AI 原生开放教材

外观

Anthropic 平台文档（英文全量）官方文档·英文原文 ↗原件 ↓仓库 ↗

Parameters ​

ParameterTypeDefaultDescription
typestringRequiredMust be "compact_20260112"
triggerobject\{"type": "input_tokens", "value": 150000\}When to trigger compaction. input_tokens is the only supported trigger type. value must be at least 50,000 tokens.
pause_after_compactionbooleanfalseWhether to pause after generating the compaction summary
instructionsstringnullCustom summarization prompt. Completely replaces the default prompt when provided.

Trigger configuration ​

Configure when compaction triggers using the trigger parameter:

bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: compact-2026-01-12" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ],
    "context_management": {
      "edits": [
        {
          "type": "compact_20260112",
          "trigger": {
            "type": "input_tokens",
            "value": 150000
          }
        }
      ]
    }
  }'
bash
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5
max_tokens: 4096
messages:
  - role: user
    content: Hello, Claude
context_management:
  edits:
    - type: compact_20260112
      trigger:
        type: input_tokens
        value: 150000
YAML
python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-5",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "trigger": {"type": "input_tokens", "value": 150000},
            }
        ]
    },
)
typescript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
  { role: "user", content: "Hello, Claude" }
];

const response = await client.beta.messages.create({
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        trigger: {
          type: "input_tokens",
          value: 150000
        }
      }
    ]
  }
});
csharp
AnthropicClient client = new();
List<BetaMessageParam> messages = [new() { Role = Role.User, Content = "Hello" }];

var parameters = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Betas = ["compact-2026-01-12"],
    Messages = messages,
    ContextManagement = new BetaContextManagementConfig
    {
        Edits = [new BetaCompact20260112Edit
        {
            Trigger = new BetaInputTokensTrigger(150000)
        }]
    }
};

var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);
go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 4096,
	Messages:  messages,
	ContextManagement: anthropic.BetaContextManagementConfigParam{
		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
			{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
				Trigger: anthropic.BetaInputTokensTriggerParam{Value: 150000},
			}},
		},
	},
	Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)
java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        MessageCreateParams params = MessageCreateParams.builder()
            .model("claude-opus-5")
            .maxTokens(4096L)
            .addBeta("compact-2026-01-12")
            .addUserMessage("Hello, Claude")
            .contextManagement(BetaContextManagementConfig.builder()
                .addEdit(BetaCompact20260112Edit.builder()
                    .trigger(BetaInputTokensTrigger.builder()
                        .value(150000L)
                        .build())
                    .build())
                .build())
            .build();

        BetaMessage response = client.beta().messages().create(params);
        System.out.println(response);
php
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];

$message = $client->beta->messages->create(
    maxTokens: 4096,
    messages: $messages,
    model: 'claude-opus-5',
    betas: ['compact-2026-01-12'],
    contextManagement: [
        'edits' => [
            [
                'type' => 'compact_20260112',
                'trigger' => [
                    'type' => 'input_tokens',
                    'value' => 150000
                ]
            ]
        ]
    ]
);

echo $message;
ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]

response = client.beta.messages.create(
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages: messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        trigger: {
          type: "input_tokens",
          value: 150000
        }
      }
    ]
  }
)
puts response

Custom summarization instructions ​

The default summarization prompt varies by model. Each default instructs Claude to write a summary inside <summary></summary> tags with the information needed to continue the task in a future context window. For example, some models use the following prompt:

text
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a <summary></summary> block.

You can provide custom instructions through the instructions parameter. Custom instructions don't supplement the default prompt. They replace it completely:

bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: compact-2026-01-12" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ],
    "context_management": {
      "edits": [
        {
          "type": "compact_20260112",
          "instructions": "Focus on preserving code snippets, variable names, and technical decisions."
        }
      ]
    }
  }'
bash
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5
max_tokens: 4096
messages:
  - role: user
    content: Hello, Claude
context_management:
  edits:
    - type: compact_20260112
      instructions: >-
        Focus on preserving code snippets, variable names, and
        technical decisions.
YAML
python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-5",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "instructions": "Focus on preserving code snippets, variable names, and technical decisions.",
            }
        ]
    },
)
typescript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
  { role: "user", content: "Hello, Claude" }
];

const response = await client.beta.messages.create({
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        instructions:
          "Focus on preserving code snippets, variable names, and technical decisions."
      }
    ]
  }
});
csharp
AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Betas = ["compact-2026-01-12"],
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Messages =
    [
        new BetaMessageParam { Role = Role.User, Content = "Help me build a Python web scraper" },
        new BetaMessageParam { Role = Role.Assistant, Content = "I'll help you build a web scraper..." },
        new BetaMessageParam { Role = Role.User, Content = "Add support for JavaScript-rendered pages" }
    ],
    ContextManagement = new BetaContextManagementConfig
    {
        Edits = [new BetaCompact20260112Edit
        {
            Instructions = "Focus on preserving code snippets, variable names, and technical decisions."
        }]
    }
};

var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);
go
client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 4096,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a Python web scraper")),
		{Role: anthropic.BetaMessageParamRoleAssistant, Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("I'll help you build a web scraper...")}},
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Add support for JavaScript-rendered pages")),
	},
	ContextManagement: anthropic.BetaContextManagementConfigParam{
		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
			{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
				Instructions: anthropic.String("Focus on preserving code snippets, variable names, and technical decisions."),
			}},
		},
	},
	Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)
java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        MessageCreateParams params = MessageCreateParams.builder()
            .addBeta("compact-2026-01-12")
            .model("claude-opus-5")
            .maxTokens(4096L)
            .addUserMessage("Help me build a Python web scraper")
            .addAssistantMessage("I'll help you build a web scraper...")
            .addUserMessage("Add support for JavaScript-rendered pages")
            .contextManagement(BetaContextManagementConfig.builder()
                .addEdit(BetaCompact20260112Edit.builder()
                    .instructions("Focus on preserving code snippets, variable names, and technical decisions.")
                    .build())
                .build())
            .build();

        BetaMessage response = client.beta().messages().create(params);
        System.out.println(response);
php
$client = new Client();

$response = $client->beta->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Help me build a Python web scraper'],
        ['role' => 'assistant', 'content' => "I'll help you build a web scraper..."],
        ['role' => 'user', 'content' => 'Add support for JavaScript-rendered pages']
    ],
    model: 'claude-opus-5',
    betas: ['compact-2026-01-12'],
    contextManagement: [
        'edits' => [
            [
                'type' => 'compact_20260112',
                'instructions' => 'Focus on preserving code snippets, variable names, and technical decisions.'
            ]
        ]
    ]
);

echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
ruby
client = Anthropic::Client.new

response = client.beta.messages.create(
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Help me build a Python web scraper" },
    { role: "assistant", content: "I'll help you build a web scraper..." },
    { role: "user", content: "Add support for JavaScript-rendered pages" }
  ],
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        instructions:
          "Focus on preserving code snippets, variable names, and technical decisions."
      }
    ]
  }
)

puts response

On Claude Fable 5.1 and Claude Mythos 5.1, a request with custom instructions summarizes from the visible conversation only: earlier thinking blocks are not part of the summarizer's input.

Pausing after compaction ​

Use pause_after_compaction to pause the API after generating the compaction summary. This allows you to add additional content blocks (such as preserving recent messages or specific instruction-oriented messages) before the API continues with the response.

When enabled, the API returns a message with the compaction stop reason after generating the compaction block:

bash
# pause_after_compaction stops the response right after the compaction
# summary so you can adjust the messages before continuing. The continue
# step doesn't translate well to a one-off shell command; see the SDK tabs
# for the full pause-and-continue flow. Single paused request:
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: compact-2026-01-12" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ],
    "context_management": {
      "edits": [
        {
          "type": "compact_20260112",
          "pause_after_compaction": true
        }
      ]
    }
  }'
bash
# pause_after_compaction stops the response right after the compaction
# summary so you can adjust the messages before continuing. The continue
# step doesn't translate well to a one-off CLI command; see the SDK tabs
# for the full pause-and-continue flow. Single paused request:
ant beta:messages create --beta compact-2026-01-12 --format jsonl <<'YAML'
model: claude-opus-5
max_tokens: 4096
messages:
  - role: user
    content: Hello, Claude
context_management:
  edits:
    - type: compact_20260112
      pause_after_compaction: true
YAML
python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-5",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [{"type": "compact_20260112", "pause_after_compaction": True}]
    },
)

# Check if compaction triggered a pause
if response.stop_reason == "compaction":
    # Response contains only the compaction block
    messages.append({"role": "assistant", "content": response.content})

    # Continue the request
    response = client.beta.messages.create(
        betas=["compact-2026-01-12"],
        model="claude-opus-5",
        max_tokens=4096,
        messages=messages,
        context_management={"edits": [{"type": "compact_20260112"}]},
    )
typescript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
  { role: "user", content: "Hello, Claude" }
];

let response = await client.beta.messages.create({
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        pause_after_compaction: true
      }
    ]
  }
});

// Check if compaction triggered a pause
if (response.stop_reason === "compaction") {
  // Response contains only the compaction block
  messages.push({
    role: "assistant",
    content: response.content
  });

  // Continue the request
  response = await client.beta.messages.create({
    betas: ["compact-2026-01-12"],
    model: "claude-opus-5",
    max_tokens: 4096,
    messages,
    context_management: {
      edits: [{ type: "compact_20260112" }]
    }
  });
}
csharp
var client = new AnthropicClient();
var messages = new List<BetaMessageParam>
{
    new() { Role = Role.User, Content = "Hello, Claude" }
};

var parameters = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Betas = ["compact-2026-01-12"],
    Messages = messages,
    ContextManagement = new BetaContextManagementConfig
    {
        Edits = [new BetaCompact20260112Edit
        {
            PauseAfterCompaction = true
        }]
    }
};

var response = await client.Beta.Messages.Create(parameters);

if (response.StopReason == BetaStopReason.Compaction)
{
    messages.Add(new BetaMessageParam
    {
        Role = Role.Assistant,
        Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
    });

    parameters = new()
    {
        Model = "claude-opus-5",
        MaxTokens = 4096,
        Betas = ["compact-2026-01-12"],
        Messages = messages,
        ContextManagement = new BetaContextManagementConfig
        {
            Edits = [new BetaCompact20260112Edit()]
        }
    };

    response = await client.Beta.Messages.Create(parameters);
}

Console.WriteLine(response);
go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}

compactEdit := anthropic.BetaContextManagementConfigParam{
	Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
		{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
			PauseAfterCompaction: anthropic.Bool(true),
		}},
	},
}

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:             anthropic.ModelClaudeOpus5,
	MaxTokens:         4096,
	Messages:          messages,
	ContextManagement: compactEdit,
	Betas:             []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
	log.Fatal(err)
}

if response.StopReason == "compaction" {
	messages = append(messages, response.ToParam())

	response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
		Model:     anthropic.ModelClaudeOpus5,
		MaxTokens: 4096,
		Messages:  messages,
		ContextManagement: anthropic.BetaContextManagementConfigParam{
			Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
				{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
			},
		},
		Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
	})
	if err != nil {
		log.Fatal(err)
	}
}

fmt.Println(response)
java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        MessageCreateParams params = MessageCreateParams.builder()
            .model("claude-opus-5")
            .maxTokens(4096L)
            .addBeta("compact-2026-01-12")
            .addUserMessage("Help me build a website")
            .contextManagement(BetaContextManagementConfig.builder()
                .addEdit(BetaCompact20260112Edit.builder()
                    .pauseAfterCompaction(true)
                    .build())
                .build())
            .build();

        BetaMessage response = client.beta().messages().create(params);

        // Check if compaction triggered a pause
        if (response.stopReason().isPresent()
                && response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
            // Append the compaction block and continue the request
            // by building a new request with the compacted context
            MessageCreateParams continueParams = MessageCreateParams.builder()
                .model("claude-opus-5")
                .maxTokens(4096L)
                .addBeta("compact-2026-01-12")
                .addUserMessage("Help me build a website")
                .addMessage(response)
                .contextManagement(BetaContextManagementConfig.builder()
                    .addEdit(BetaCompact20260112Edit.builder().build())
                    .build())
                .build();

            response = client.beta().messages().create(continueParams);
        }

        System.out.println(response);
php
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];

$response = $client->beta->messages->create(
    maxTokens: 4096,
    messages: $messages,
    model: 'claude-opus-5',
    betas: ['compact-2026-01-12'],
    contextManagement: [
        'edits' => [
            [
                'type' => 'compact_20260112',
                'pause_after_compaction' => true
            ]
        ]
    ]
);

if ($response->stopReason === 'compaction') {
    $messages[] = [
        'role' => 'assistant',
        'content' => $response->content
    ];

    $response = $client->beta->messages->create(
        maxTokens: 4096,
        messages: $messages,
        model: 'claude-opus-5',
        betas: ['compact-2026-01-12'],
        contextManagement: [
            'edits' => [
                ['type' => 'compact_20260112']
            ]
        ]
    );
}

echo $response;
ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]

response = client.beta.messages.create(
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages: messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        pause_after_compaction: true
      }
    ]
  }
)

if response.stop_reason == :compaction
  messages << { role: "assistant", content: response.content }

  response = client.beta.messages.create(
    betas: ["compact-2026-01-12"],
    model: "claude-opus-5",
    max_tokens: 4096,
    messages: messages,
    context_management: {
      edits: [{ type: "compact_20260112" }]
    }
  )
end

puts response

Enforcing a total token budget ​

When a model works on long tasks with many tool-use iterations, total token consumption can grow significantly. You can combine pause_after_compaction with a compaction counter to estimate cumulative usage and gracefully wrap up the task once a budget is reached.

This example appears in the SDK languages only: its value is the budget-tracking logic around the request. The raw request combines the trigger from Trigger configuration with pause_after_compaction from Pausing after compaction.

python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
TRIGGER_THRESHOLD = 100_000
TOTAL_TOKEN_BUDGET = 3_000_000
n_compactions = 0

response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-5",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "trigger": {"type": "input_tokens", "value": TRIGGER_THRESHOLD},
                "pause_after_compaction": True,
            }
        ]
    },
)

if response.stop_reason == "compaction":
    n_compactions += 1
    messages.append({"role": "assistant", "content": response.content})

    # Estimate total tokens consumed; prompt wrap-up if over budget
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append(
            {
                "role": "user",
                "content": "Please wrap up your current work and summarize the final state.",
            }
        )
typescript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
  { role: "user", content: "Hello, Claude" }
];
const TRIGGER_THRESHOLD = 100_000;
const TOTAL_TOKEN_BUDGET = 3_000_000;
let compactionCount = 0;

const response = await client.beta.messages.create({
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD },
        pause_after_compaction: true
      }
    ]
  }
});

if (response.stop_reason === "compaction") {
  compactionCount += 1;
  messages.push({ role: "assistant", content: response.content });

  // Estimate total tokens consumed; prompt wrap-up if over budget
  if (compactionCount * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET) {
    messages.push({
      role: "user",
      content: "Please wrap up your current work and summarize the final state."
    });
  }
}
csharp
AnthropicClient client = new();
List<BetaMessageParam> messages = [new() { Role = Role.User, Content = "Hello, Claude" }];

const int TriggerThreshold = 100_000;
const int TotalTokenBudget = 3_000_000;
int compactionCount = 0;

var response = await client.Beta.Messages.Create(new()
{
    Betas = ["compact-2026-01-12"],
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Messages = messages,
    ContextManagement = new BetaContextManagementConfig
    {
        Edits = [new BetaCompact20260112Edit
        {
            Trigger = new BetaInputTokensTrigger(TriggerThreshold),
            PauseAfterCompaction = true
        }]
    }
});

if (response.StopReason == BetaStopReason.Compaction)
{
    compactionCount += 1;
    messages.Add(new()
    {
        Role = Role.Assistant,
        Content = response.Content.Select(b => new BetaContentBlockParam(b.Json)).ToList()
    });

    // Estimate total tokens consumed; prompt wrap-up if over budget
    if (compactionCount * TriggerThreshold >= TotalTokenBudget)
    {
        messages.Add(new()
        {
            Role = Role.User,
            Content = "Please wrap up your current work and summarize the final state."
        });
    }
}

Console.WriteLine(response);
go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}

const triggerThreshold = 100_000
const totalTokenBudget = 3_000_000
compactionCount := 0

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 4096,
	Messages:  messages,
	ContextManagement: anthropic.BetaContextManagementConfigParam{
		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
			{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
				Trigger:              anthropic.BetaInputTokensTriggerParam{Value: triggerThreshold},
				PauseAfterCompaction: anthropic.Bool(true),
			}},
		},
	},
	Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
	log.Fatal(err)
}

if response.StopReason == "compaction" {
	compactionCount++
	messages = append(messages, response.ToParam())

	// Estimate total tokens consumed; prompt wrap-up if over budget
	if compactionCount*triggerThreshold >= totalTokenBudget {
		messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Please wrap up your current work and summarize the final state.")))
	}
}

fmt.Println(response)
java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        long triggerThreshold = 100_000;
        long totalTokenBudget = 3_000_000;
        int compactionCount = 0;

        List<BetaMessageParam> messages = new ArrayList<>();
        messages.add(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.USER)
            .content("Hello, Claude")
            .build());

        MessageCreateParams params = MessageCreateParams.builder()
            .addBeta("compact-2026-01-12")
            .model("claude-opus-5")
            .maxTokens(4096L)
            .messages(messages)
            .contextManagement(BetaContextManagementConfig.builder()
                .addEdit(BetaCompact20260112Edit.builder()
                    .trigger(BetaInputTokensTrigger.builder()
                        .value(triggerThreshold)
                        .build())
                    .pauseAfterCompaction(true)
                    .build())
                .build())
            .build();

        BetaMessage response = client.beta().messages().create(params);

        if (response.stopReason().isPresent()
                && response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
            compactionCount += 1;
            messages.add(response.toParam());

            // Estimate total tokens consumed; prompt wrap-up if over budget
            if (compactionCount * triggerThreshold >= totalTokenBudget) {
                messages.add(BetaMessageParam.builder()
                    .role(BetaMessageParam.Role.USER)
                    .content("Please wrap up your current work and summarize the final state.")
                    .build());
            }
        }

        System.out.println(response);
php
$client = new Client();

$triggerThreshold = 100_000;
$totalTokenBudget = 3_000_000;
$compactionCount = 0;

$messages = [['role' => 'user', 'content' => 'Hello, Claude']];

$response = $client->beta->messages->create(
    maxTokens: 4096,
    messages: $messages,
    model: 'claude-opus-5',
    betas: ['compact-2026-01-12'],
    contextManagement: [
        'edits' => [
            [
                'type' => 'compact_20260112',
                'trigger' => ['type' => 'input_tokens', 'value' => $triggerThreshold],
                'pause_after_compaction' => true
            ]
        ]
    ]
);

if ($response->stopReason === 'compaction') {
    $compactionCount += 1;
    $messages[] = ['role' => 'assistant', 'content' => $response->content];

    // Estimate total tokens consumed; prompt wrap-up if over budget
    if ($compactionCount * $triggerThreshold >= $totalTokenBudget) {
        $messages[] = [
            'role' => 'user',
            'content' => 'Please wrap up your current work and summarize the final state.'
        ];
    }
}
ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
TRIGGER_THRESHOLD = 100_000
TOTAL_TOKEN_BUDGET = 3_000_000
compaction_count = 0

response = client.beta.messages.create(
  betas: ["compact-2026-01-12"],
  model: "claude-opus-5",
  max_tokens: 4096,
  messages: messages,
  context_management: {
    edits: [
      {
        type: "compact_20260112",
        trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD },
        pause_after_compaction: true
      }
    ]
  }
)

if response.stop_reason == :compaction
  compaction_count += 1
  messages << { role: "assistant", content: response.content }

  # Estimate total tokens consumed; prompt wrap-up if over budget
  if compaction_count * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET
    messages << {
      role: "user",
      content: "Please wrap up your current work and summarize the final state."
    }
  end
end