压实

随着对话增长，聊天历史的令牌计数可能超过模型上下文窗口或推高成本。压缩策略可减少聊天历史记录的大小，同时保留重要上下文，因此代理可以在长时间运行的交互中继续运行。

重要

压缩框架目前是实验性的。若要使用它，需要添加 #pragma warning disable MAAI001。

重要

压缩框架目前在 Python 中是实验性的。从 agent_framework中导入压缩类型。

Go 支持通过 agent/compaction 包压缩。将压缩策略注册为一种 agent.ContextProvider ，以便在每次运行之前压缩会话历史记录。

为什么压缩很重要

每次调用 LLM 都包括完整的对话历史记录。不压缩：

令牌限制 - 对话最终超过模型的上下文窗口，导致错误。
成本 - 较大的提示消耗更多令牌，增加 API 成本。
延迟 - 更多的输入令牌意味着响应时间变慢。

压缩通过选择性地删除、折叠或汇总对话的较旧部分来解决这些问题。

核心概念

适用性：仅限内存型历史记录代理程序

压缩仅适用于在内存中管理其自己的聊天历史记录的代理。依赖服务托管上下文或对话状态的智能体无法从压缩中受益，因为服务已经处理了上下文管理。服务托管代理的示例包括：

Foundry 代理 - 上下文由 Microsoft Foundry 服务并行管理。
启用了存储的响应 API （默认值） - 聊天状态由 OpenAI 服务存储和管理。
Copilot Studio 代理 - 聊天上下文由 Copilot Studio 服务维护。

对于这些代理类型，配置压缩策略不起作用。仅当代理维护自己的内存中消息列表，并在每次调用时将完整历史记录传递给模型时，压缩才相关。

MessageIndex 上的压缩操作 - 一个将平面消息列表分组为称为 MessageGroup 实例的原子单元的结构化视图。每个组跟踪其消息计数、字节计数和估计令牌计数。

消息组

一个 MessageGroup 表示必须一起保留或删除的逻辑相关消息。例如，包含工具调用的助手消息及其相应的工具结果消息形成一个原子组，删除其中一个而不删除另一个就会导致 LLM API 错误。

每个组都有一个 MessageGroupKind：

种类	说明
`System`	一个或多个系统消息。在压缩期间始终保留。
`User`	启动新轮次的单个用户消息。
`AssistantText`	纯助理文本响应（无工具调用）。
`ToolCall`	带有工具调用和相应工具结果消息的助理消息，被视为原子单元。
`Summary`	汇总压缩生成的简化消息。

Triggers

CompactionTrigger 是一个委托，根据当前 MessageIndex 指标评估是否应进行压缩：

public delegate bool CompactionTrigger(MessageIndex index);

该 CompactionTriggers 类提供常见的工厂方法：

Trigger	在以下情况下触发
`CompactionTriggers.Always`	每次（无条件）。
`CompactionTriggers.Never`	从不（禁用压缩）。
`CompactionTriggers.TokensExceed(maxTokens)`	包含的标识符计数超过阈值。
`CompactionTriggers.MessagesExceed(maxMessages)`	包含的消息数超过阈值。
`CompactionTriggers.TurnsExceed(maxTurns)`	包含的用户轮次数超过阈值。
`CompactionTriggers.GroupsExceed(maxGroups)`	包含的组计数超过阈值。
`CompactionTriggers.HasToolCalls()`	至少有一个非排除的工具调用组存在。

将触发器与CompactionTriggers.All(...)（逻辑 AND）或CompactionTriggers.Any(...)（逻辑 OR）组合在一起。

// Compact only when there are tool calls AND tokens exceed 2000
CompactionTrigger trigger = CompactionTriggers.All(
    CompactionTriggers.HasToolCalls(),
    CompactionTriggers.TokensExceed(2000));

触发器与目标

每个策略都有两个谓词：

触发器 — 控制压缩何时开始。如果触发器返回 false，则完全跳过该策略。
目标 —— 控制压缩 停止时机。策略以增量方式排除组，并在每个步骤后重新评估目标，一旦目标返回 true，就会停止。

如果未指定目标，它将默认为触发器的反函数 — 一旦触发器条件不再触发，压缩就会停止。

压缩操作在 Message 对象的平面列表上进行。消息用轻量级组元数据注释，策略在原地改变这些注释，标记组为排除，然后消息列表被投影到模型。

消息组

消息分组为原子单元。为每个组分配一个 GroupKind：

种类	说明
`system`	系统消息。在压缩期间始终保留。
`user`	单个用户消息。
`assistant_text`	纯助理文本响应（无函数调用）。
`tool_call`	具有函数调用的助手消息加上相应的工具结果消息，被视为原子单元。

压缩策略

CompactionStrategy 是一个协议 - 任何 async 可调用对象，接受 list[Message] 并原地改变它，在改变任何内容时返回 True：

class CompactionStrategy(Protocol):
    async def __call__(self, messages: list[Message]) -> bool: ...

分词器

令牌感知策略接受 TokenizerProtocol 实现。内置 CharacterEstimatorTokenizer 使用 4 个字符每令牌的启发式：

from agent_framework import CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

当需要特定模型编码的准确令牌计数时，传递自定义分词器。

压缩作为上下文提供程序运行。策略可以在每次运行之前检查会话历史记录，并减少较旧的消息组，同时保留最新的上下文。

Go 包包括策略类型，例如 ToolResultStrategy、SlidingWindowStrategy 和 PipelineStrategy，以及触发器辅助函数，例如 MessagesExceed 和 TurnsExceed。

压缩策略

所有策略都继承自抽象 CompactionStrategy 基类。每个策略都会保留系统消息，并尊重一个 MinimumPreserved 可保护最新非系统组免受删除的底层。

压缩策略是从 agent_framework中导入的。

压缩策略是从 github.com/microsoft/agent-framework-go/agent/compaction中导入的。

TruncationCompactionStrategy

TruncationStrategy

最直接的方法：在满足目标条件之前删除最早的非系统消息组。

尊重原子组边界（工具调用和结果消息一起删除）。
最适合硬令牌预算后备。

MinimumPreserved 默认为 32。

// Drop oldest groups when tokens exceed 32K, keeping at least 10 recent groups
TruncationCompactionStrategy truncation = new(
    trigger: CompactionTriggers.TokensExceed(0x8000),
    minimumPreserved: 10);

当提供 tokenizer 时，指标是令牌计数；否则是包含的消息计数。
preserve_system 默认为 True。

from agent_framework import CharacterEstimatorTokenizer, TruncationStrategy

# Exclude oldest groups when tokens exceed 32 000, trimming to 16 000
truncation = TruncationStrategy(
    max_n=32_000,
    compact_to=16_000,
    tokenizer=CharacterEstimatorTokenizer(),
)

SlidingWindowCompactionStrategy

SlidingWindowStrategy（滑动窗口策略）

删除较旧的聊天内容以仅保留最近的交换窗口，尊重逻辑对话单元而不是任意消息计数。系统消息将在整个过程中保留。

最适合可预测地限制对话长度。

移除最旧的用户轮次及其关联响应组，在逻辑轮次边界上操作，而不是单个组。

轮次从用户消息开始，并包括所有后续助理和工具呼叫组，直到下一个用户消息。
MinimumPreserved 默认为 1 （至少保留最新的非系统组）。

// Keep only the last 4 user turns
SlidingWindowCompactionStrategy slidingWindow = new(
    trigger: CompactionTriggers.TurnsExceed(4));

仅保留最新的 keep_last_groups 非系统组，不包括较旧的所有内容。

preserve_system 默认为 True。

from agent_framework import SlidingWindowStrategy

# Keep only the last 20 non-system groups
sliding_window = SlidingWindowStrategy(keep_last_groups=20)

ToolResultCompactionStrategy

将旧的工具调用组合并为紧凑的摘要消息，保留可读的跟踪，而没有完整的消息开销。

不更改用户消息或普通助手回应。
作为第一遍策略，回收来自冗长工具结果的空间是最好的。

将多消息工具呼叫组（助理呼叫 + 工具结果）替换为简短摘要，例如 [Tool calls: get_weather, search_docs]。
MinimumPreserved 默认为 2，确保当前轮次的工具交互保持可见。

// Collapse old tool results when tokens exceed 512
ToolResultCompactionStrategy toolCompaction = new(
    trigger: CompactionTriggers.TokensExceed(0x200));

折叠成紧凑的摘要消息，例如 [Tool results: get_weather: sunny, 18°C]。
最新的 keep_last_tool_call_groups 工具调用组保持不变。

from agent_framework import ToolResultCompactionStrategy

# Collapse all but the newest tool-call group
tool_result = ToolResultCompactionStrategy(keep_last_tool_call_groups=1)

SummarizationCompactionStrategy

总结策略

使用 LLM 来汇总对话的较旧部分，并将其替换为单个摘要消息。

默认提示会保留关键事实、决策、用户首选项和工具调用结果。
需要单独的 LLM 客户端进行汇总 - 建议使用更小、更快的模型。
最适合保留会话上下文，同时显著减少令牌计数。
可以提供自定义摘要提示。

保护系统消息和最新的 MinimumPreserved 非系统组（默认值： 4）。
使用摘要提示将旧消息发送到单独的 IChatClient 环境，然后将摘要作为 MessageGroupKind.Summary 组插入。

// Summarize older messages when tokens exceed 1280, keeping the last 4 groups
SummarizationCompactionStrategy summarization = new(
    chatClient: summarizerChatClient,
    trigger: CompactionTriggers.TokensExceed(0x500),
    minimumPreserved: 4);

可以提供自定义摘要提示：

SummarizationCompactionStrategy summarization = new(
    chatClient: summarizerChatClient,
    trigger: CompactionTriggers.TokensExceed(0x500),
    summarizationPrompt: "Summarize the key decisions and user preferences only.");

当包含的非系统消息数超过 target_count + threshold 时触发。
保留靠近 target_count 的近期消息，但以消息组边界为界；对符合摘要器输入预算的最旧完整消息组进行摘要。
需要客户端 SupportsChatGetResponse 。
默认情况下，将摘要器提示和对话记录限制为估算的 8,000 个令牌。它选择完整的邮件组，因此永远不会拆分组以适应预算。
设置max_summary_input_tokens=None可禁用摘要器输入限制；如果需要特定于模型的令牌计数，请传递tokenizer=。如果没有任何完整的分组符合条件，则会跳过汇总，现有历史记录将保持不变。
包括摘要生成器脚本中的函数和 MCP 工具名称、参数、结果、异常、调用 ID 和审批决策，以便摘要可以保留工具轨迹。

重要

信任摘要生成器客户端，就像主模型一样。工具参数和结果可以包含敏感数据，并将 SummarizationStrategy 这些详细信息发送到摘要生成器。

from agent_framework import SummarizationStrategy

# Summarize when non-system message count exceeds 6, retaining the 4 newest
summarization = SummarizationStrategy(
    client=summarizer_client,
    target_count=4,
    threshold=2,
)

提供自定义摘要提示：

summarization = SummarizationStrategy(
    client=summarizer_client,
    target_count=4,
    prompt="Summarize the key decisions and user preferences only.",
)

独立于保留历史记录目标控制摘要器请求预算：

from agent_framework import CharacterEstimatorTokenizer, SummarizationStrategy

summarization = SummarizationStrategy(
    client=summarizer_client,
    target_count=4,
    threshold=2,
    max_summary_input_tokens=16_000,
    tokenizer=CharacterEstimatorTokenizer(),
)

PipelineCompactionStrategy

将多个策略组合成顺序管道。每个策略都基于上一个策略的结果进行操作，实现从柔和到强势的分层压缩。

管道自身的触发器是 CompactionTriggers.Always - 每个子策略独立评估自己的触发器。
策略按顺序执行，因此将最温柔的策略放在第一位。

PipelineCompactionStrategy pipeline = new(
    new ToolResultCompactionStrategy(CompactionTriggers.TokensExceed(0x200)),
    new SummarizationCompactionStrategy(summarizerChatClient, CompactionTriggers.TokensExceed(0x500)),
    new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(4)),
    new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(0x8000)));

此管线：

折叠旧的工具结果（温和）。
总结较旧的对话内容（适度）。
仅保留最后 4 个用户轮次（激进）。
如果仍超出预算，丢弃最旧的组（紧急后备）。

SelectiveToolCallCompactionStrategy

完全排除较旧的工具调用组，只保留最后 keep_last_tool_call_groups一个。

不处理用户或纯助手消息。
当工具聊天占据令牌使用且不需要完整工具历史时最好。

from agent_framework import SelectiveToolCallCompactionStrategy

# Keep only the most recent tool-call group
selective_tool = SelectiveToolCallCompactionStrategy(keep_last_tool_call_groups=1)

TokenBudgetComposedStrategy

将多个策略组合到由令牌预算驱动的顺序流程中。每个子策略按顺序执行，一旦预算得到满足，就会提前终止。如果仅策略无法达到目标，则内置的回退机制将排除最旧的一组。

策略按顺序执行;首先放置最温和的策略。
early_stop=True （默认值）在满足令牌预算后立即停止。

from agent_framework import (
    CharacterEstimatorTokenizer,
    SelectiveToolCallCompactionStrategy,
    SlidingWindowStrategy,
    SummarizationStrategy,
    TokenBudgetComposedStrategy,
    ToolResultCompactionStrategy,
)

tokenizer = CharacterEstimatorTokenizer()

pipeline = TokenBudgetComposedStrategy(
    token_budget=16_000,
    tokenizer=tokenizer,
    strategies=[
        ToolResultCompactionStrategy(keep_last_tool_call_groups=1),
        SummarizationStrategy(client=summarizer_client, target_count=4, threshold=2),
        SlidingWindowStrategy(keep_last_groups=20),
    ],
)

此管线：

折叠旧的工具结果（温和）。
总结较旧的对话内容（适度）。
只保留最后 20 个组（咄咄逼人）。
如果仍超出预算，回退到最早优先排除（紧急后备）。

在智能体中使用压缩

将压缩策略包装在一个 CompactionProvider 中，并将其注册为一个 AIContextProvider。将单个策略或 PipelineCompactionStrategy 传递给构造函数。

注册在生成器 API 上

在 ChatClientBuilder上使用 UseAIContextProviders注册提供程序。提供者在工具调用循环内运行，在每次调用 LLM 之前压缩消息。

IChatClient agentChatClient = openAIClient.GetChatClient(deploymentName).AsIChatClient();
IChatClient summarizerChatClient = openAIClient.GetChatClient(deploymentName).AsIChatClient();

PipelineCompactionStrategy compactionPipeline =
    new(
        new ToolResultCompactionStrategy(CompactionTriggers.TokensExceed(0x200)),
        new SummarizationCompactionStrategy(summarizerChatClient, CompactionTriggers.TokensExceed(0x500)),
        new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(4)),
        new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(0x8000)));

AIAgent agent =
    agentChatClient
        .AsBuilder()
        .UseAIContextProviders(new CompactionProvider(compactionPipeline))
        .BuildAIAgent(
            new ChatClientAgentOptions
            {
                Name = "ShoppingAssistant",
                ChatOptions = new()
                {
                    Instructions = "You are a helpful shopping assistant.",
                    Tools = [AIFunctionFactory.Create(LookupPrice)],
                },
            });

AgentSession session = await agent.CreateSessionAsync();
Console.WriteLine(await agent.RunAsync("What's the price of a laptop?", session));

Tip

对摘要聊天客户端使用更小、更便宜的模型 gpt-4o-mini来使成本降低，同时使摘要质量得以保持。

如果只需要一个策略，请直接将其传递给 CompactionProvider，而无需将其包装在 PipelineCompactionStrategy 中：

agentChatClient
    .AsBuilder()
    .UseAIContextProviders(new CompactionProvider(
        new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(20))))
    .BuildAIAgent(...);

通过 `ChatClientAgentOptions` 注册

还可以直接在ChatClientAgentOptions.AIContextProviders上指定提供程序。

AIAgent agent = agentChatClient
    .AsBuilder()
    .BuildAIAgent(new ChatClientAgentOptions
    {
        AIContextProviders = [new CompactionProvider(compactionPipeline)]
    });

注释

通过 ChatClientAgentOptions 注册时，CompactionProvider 在工具调用循环中不会参与。代理级上下文提供程序在存储聊天历史记录之前运行，因此使用CompactionProvider时，生成ChatHistoryProvider的任何综合摘要消息都可以成为持久历史记录的一部分。要仅压缩飞行中的请求上下文，同时保留原始存储的历史记录，请通过 UseAIContextProviders(...) 在 ChatClientBuilder 上注册提供程序。

在 `CompactionProvider` 和 `IChatReducer` 之间进行选择

CompactionProvider 和 IChatReducer 都会减少发送给模型的消息。它们在聊天生命周期的不同点运行，并不同方式影响历史记录。

使用 UseAIContextProviders(...)在 ChatClientBuilder 上注册 CompactionProvider 时，它仅压缩正在传输给模型的消息。存储的对话 ChatHistoryProvider 历史记录保持不变。

相比之下，在 InMemoryChatHistoryProvider 上配置的 IChatReducer 会减少由历史记录提供程序本身管理的历史记录数量。如果还希望绑定内存中保留的对话历史记录，请使用此方法。

InMemoryChatHistoryProvider 可以在以下任一事件上运行化简器：

BeforeMessagesRetrieval （默认值）在将存储的历史记录提供给代理之前会减少该历史记录。
AfterMessageAdded 在添加每个请求/响应对后，都会缩减已存储的历史记录。

事件控制归约何时发生；IChatReducer 实现控制消息如何被归约。

相比之下，CompactionStrategy 提供其自己的 CompactionTrigger，并对保留工具调用/结果配对的消息组进行操作。

在各抽象层之间进行适配

适配器允许你在任一集成点使用现有实现。根据你想要运行缩减操作的位置来选择适配器。

若要使用 CompactionStrategy 进行持久的内存中历史记录缩减，请将其改造为 IChatReducer：

CompactionStrategy strategy =
    new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(20));

InMemoryChatHistoryProviderOptions historyOptions = new()
{
    ChatReducer = strategy.AsChatReducer(),
    ReducerTriggerEvent =
        InMemoryChatHistoryProviderOptions.ChatReducerTriggerEvent.BeforeMessagesRetrieval
};

InMemoryChatHistoryProvider historyProvider = new(historyOptions);

若要在压缩管道中使用现有的 IChatReducer，或用于运行期间的请求压缩，请将其调整为 CompactionStrategy：

IChatReducer existingReducer = /* your Microsoft.Extensions.AI reducer */;

CompactionStrategy strategy = new ChatReducerCompactionStrategy(
    existingReducer,
    CompactionTriggers.TokensExceed(4000));

CompactionProvider provider = new(strategy);

避免使用 AsChatReducer() 将策略转换为 IChatReducer，然后立即使用 ChatReducerCompactionStrategy 包装该归约器。这种来回转换不会增加任何能力；应直接在适当的集成点使用原始策略。

专用压缩

CompactionProvider.CompactAsync 将策略应用于没有活动代理会话的任意消息列表：

IEnumerable<ChatMessage> compacted = await CompactionProvider.CompactAsync(
    new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(8000)),
    existingMessages);

直接在 Agent 上配置所选的压缩策略和分词器。代理级值会替代基础聊天客户端上配置的默认值，单个 agent.run(...) 调用可以再次替代这两个值。

向代理注册

from agent_framework import (
    Agent,
    CharacterEstimatorTokenizer,
    SlidingWindowStrategy,
    SummarizationStrategy,
    TokenBudgetComposedStrategy,
    ToolResultCompactionStrategy,
    TruncationStrategy,
)

tokenizer = CharacterEstimatorTokenizer()

strategy = TokenBudgetComposedStrategy(
    token_budget=16_000,
    tokenizer=tokenizer,
    strategies=[
        ToolResultCompactionStrategy(keep_last_tool_call_groups=1),
        SummarizationStrategy(client=summarizer_client, target_count=4, threshold=2),
        SlidingWindowStrategy(keep_last_groups=20),
    ],
)

agent = Agent(
    client=client,
    name="ShoppingAssistant",
    instructions="You are a helpful shopping assistant.",
    compaction_strategy=strategy,
    tokenizer=tokenizer,
)

session = agent.create_session()
print(await agent.run("What's the price of a laptop?", session=session))

Tip

对摘要客户端使用更小、更便宜的模型 gpt-4o-mini来降低成本，同时保持摘要质量。

如果只需要一个策略，请直接传递它：

agent = Agent(
    client=client,
    compaction_strategy=SlidingWindowStrategy(keep_last_groups=20),
    tokenizer=CharacterEstimatorTokenizer(),
)

为单次运行覆盖压缩设置

当某个请求需要不同的策略时，将 compaction_strategy 和 tokenizer 传递给 agent.run(...)：

response = await agent.run(
    "Summarize the rollout risks.",
    compaction_strategy=TruncationStrategy(max_n=8_000, compact_to=4_000),
    tokenizer=tokenizer,
)

专用压缩

apply_compaction 将策略应用于活动代理会话外部的任意消息列表：

from agent_framework import apply_compaction, TruncationStrategy, CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

compacted = await apply_compaction(
    messages,
    strategy=TruncationStrategy(
        max_n=8_000,
        compact_to=4_000,
        tokenizer=tokenizer,
    ),
    tokenizer=tokenizer,
)

创建压缩上下文提供程序并将其添加到代理的上下文提供程序：

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/agent/compaction"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
)

compactionProvider := compaction.NewContextProvider(compaction.ContextProviderConfig{
    Strategy: &compaction.PipelineStrategy{
        Strategies: []compaction.Strategy{
            &compaction.ToolResultStrategy{
                Trigger:                compaction.MessagesExceed(7),
                MinimumPreservedGroups: 4,
            },
            &compaction.SlidingWindowStrategy{
                Trigger:               compaction.TurnsExceed(4),
                MinimumPreservedTurns: 4,
            },
        },
    },
})

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Config: agent.Config{
        ContextProviders: []agent.ContextProvider{compactionProvider},
    },
})

Tip

请参阅压实管道示例，获取完整的可运行示例。

将压缩与工具套件代理结合使用

上述手动设置可以完全控制压缩提供程序的运行位置。工具套件代理会将压缩接入每次服务调用的历史记录管道，使较长的工具调用循环能够在模型调用之间执行压缩。

压缩默认处于关闭状态。同时设置 HarnessAgentOptions.MaxContextWindowTokens 和 MaxOutputTokens 以创建默认 ContextWindowCompactionStrategy，或者设置 CompactionStrategy 以提供你自己的策略。

HarnessAgent agent = chatClient.AsHarnessAgent(new HarnessAgentOptions
{
    MaxContextWindowTokens = 128_000,
    MaxOutputTokens = 16_384,
});

工具套件会在函数调用循环中的每次模型调用前运行解析得到的策略。如果工具套件还创建默认InMemoryChatHistoryProvider，则会使用该策略的聊天记录缩减器配置此提供程序。自定义ChatHistoryProvider会按提供的配置使用。 DisableCompaction = true会覆盖令牌设置和CompactionStrategy；启用或禁用压缩时，MaxOutputTokens仍会设置ChatOptions.MaxOutputTokens。

chatClient.AsHarnessAgent(options) 和 new HarnessAgent(chatClient, options) 使用相同的 HarnessAgentOptions。

压缩默认处于关闭状态，除非同时设置了 max_context_window_tokens 和 max_output_tokens，或者提供了自定义阶段策略。

agent = create_harness_agent(
    client,
    max_context_window_tokens=128_000,
    max_output_tokens=16_384,
)

使用令牌设置时，工具套件会在两个阶段重复使用同一个ContextWindowCompactionStrategy：前置阶段在工具循环内的每次模型调用前运行，后置阶段则在运行后压缩已持久化的历史记录。使用before_compaction_strategy或after_compaction_strategy独立覆盖任一阶段；设置tokenizer=以使用自定义分词器，设置history_provider=以使用其他历史记录存储，或设置disable_compaction=True以禁用这两个阶段。 max_output_tokens 还提供默认 max_tokens 聊天选项。

Harness 代理目前在 Go SDK 中不可用。手动注册压缩上下文提供程序，如上所示。

选择策略

策略	攻击性	保留上下文	需要 LLM	最适用于
`ToolResultCompactionStrategy`	低	高 - 仅折叠工具结果	No	从冗长的工具输出中回收空间
`SummarizationCompactionStrategy`	Medium	中 - 将历史记录替换为摘要	Yes	上下文重要的长对话
`SlidingWindowCompactionStrategy`	高	低 - 丢弃整个轮次	No	硬轮次计数限制
`TruncationCompactionStrategy`	高	低 - 丢弃最旧的组	No	紧急令牌预算后备
`PipelineCompactionStrategy`	可配置性	取决于子策略	视情况而定	具有多种备选机制的分层压缩

策略	攻击性	保留上下文	需要 LLM	最适用于
`ToolResultCompactionStrategy`	低	高级 - 将工具结果折叠为摘要信息	No	从冗长的工具输出中回收空间
`SelectiveToolCallCompactionStrategy`	低-中	中等—完全排除旧的工具调用组	No	不再需要结果时删除工具历史记录
`SummarizationStrategy`	Medium	中 - 将历史记录替换为摘要	Yes	上下文重要的长对话
`SlidingWindowStrategy`	高	低 - 丢弃最旧的组	No	固定组数量限制
`TruncationStrategy`	高	低 - 丢弃最旧的组	No	紧急消息或令牌预算后备
`TokenBudgetComposedStrategy`	可配置性	取决于子策略	视情况而定	具有令牌预算目标和多个后备的分层压缩

策略	攻击性	保留上下文	需要 LLM	最适用于
`ToolResultStrategy`	低	高 - 折叠详细的工具结果	No	从冗长的工具输出中回收空间
`SlidingWindowStrategy`	高	低 - 保留最近的轮次	No	硬轮次计数限制
`PipelineStrategy`	可配置性	取决于子策略	视情况而定	具有多种备选机制的分层压缩

后续步骤

中间件

深入了解

上下文提供程序

反馈

此页面是否有帮助？

Last updated on 2026-09-18

压 实

为什么压缩很重要

核心概念

适用性：仅限内存型历史记录代理程序

消息组

Triggers

触发器与目标

消息组

压缩策略

分词器

压缩策略

TruncationCompactionStrategy

TruncationStrategy

SlidingWindowCompactionStrategy

SlidingWindowStrategy（滑动窗口策略）

ToolResultCompactionStrategy

SummarizationCompactionStrategy

总结策略

PipelineCompactionStrategy

SelectiveToolCallCompactionStrategy

TokenBudgetComposedStrategy

在智能体中使用压缩

注册在生成器 API 上

通过 ChatClientAgentOptions 注册

在 CompactionProvider 和 IChatReducer 之间进行选择

在各抽象层之间进行适配

专用压缩

向代理注册

为单次运行覆盖压缩设置

专用压缩

将压缩与工具套件代理结合使用

选择策略

后续步骤

深入了解

反馈

其他资源

压实

通过 `ChatClientAgentOptions` 注册

在 `CompactionProvider` 和 `IChatReducer` 之间进行选择