보존된 사고

ant beta:messages create --beta thinking-binding-controls-2026-08-01 \
  --format yaml <<'YAML'
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
  block_binding:
    prefix_mismatch_behavior: drop_block
messages:
  - role: user
    content: What is the greatest common divisor of 1071 and 462?
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "block_binding": {"prefix_mismatch_behavior": "drop_block"},
    },
    messages=[
        {
            "role": "user",
            "content": "What is the greatest common divisor of 1071 and 462?",
        }
    ],
    betas=["thinking-binding-controls-2026-08-01"],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

print(f"Input transformations: {len(response.input_transformations or [])}")

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-fable-5-1",
  max_tokens: 16000,
  thinking: {
    type: "adaptive",
    block_binding: { prefix_mismatch_behavior: "drop_block" }
  },
  messages: [
    { role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
  ],
  betas: ["thinking-binding-controls-2026-08-01"]
});

for (const block of response.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}
console.log(`Input transformations: ${response.input_transformations?.length ?? 0}`);

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(
    new()
    {
        Model = "claude-fable-5-1",
        MaxTokens = 16000,
        Thinking = new BetaThinkingConfigAdaptive
        {
            BlockBinding = new()
            {
                PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
            },
        },
        Messages =
        [
            new()
            {
                Role = Role.User,
                Content = "What is the greatest common divisor of 1071 and 462?",
            },
        ],
        Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
    }
);

foreach (var block in response.Content)
{
    if (block.TryPickText(out var textBlock))
    {
        Console.WriteLine(textBlock.Text);
    }
}

Console.WriteLine($"Input transformations: {response.InputTransformations?.Count ?? 0}");

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     "claude-fable-5-1",
	MaxTokens: 16000,
	Thinking: anthropic.BetaThinkingConfigParamUnion{
		OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
			BlockBinding: anthropic.BetaThinkingBlockBindingParam{
				PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
			},
		},
	},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What is the greatest common divisor of 1071 and 462?")),
	},
	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
})
if err != nil {
	log.Fatal(err)
}

for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}
fmt.Printf("Input transformations: %d\n", len(response.InputTransformations))

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-fable-5-1")
        .maxTokens(16000L)
        .addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01)
        .thinking(BetaThinkingConfigAdaptive.builder()
            .blockBinding(BetaThinkingBlockBinding.builder()
                .prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
                .build())
            .build())
        .addUserMessage("What is the greatest common divisor of 1071 and 462?")
        .build();

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

    response.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
    IO.println("Input transformations: "
        + response.inputTransformations().map(List::size).orElse(0));
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
use Anthropic\Client;

$client = new Client();

$response = $client->beta->messages->create(
    model: 'claude-fable-5-1',
    maxTokens: 16000,
    thinking: BetaThinkingConfigAdaptive::with(
        blockBinding: BetaThinkingBlockBinding::with(
            prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
        ),
    ),
    messages: [
        ['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?'],
    ],
    betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
);

foreach ($response->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

echo 'Input transformations: ', count($response->inputTransformations ?? []), PHP_EOL;

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-fable-5-1",
  max_tokens: 16_000,
  thinking: {
    type: "adaptive",
    block_binding: {prefix_mismatch_behavior: "drop_block"}
  },
  messages: [
    {role: "user", content: "What is the greatest common divisor of 1071 and 462?"}
  ],
  betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]
)

response.content.each do |block|
  puts block.text if block.type == :text
end

puts "Input transformations: #{response.input_transformations&.length || 0}"

FIRST=$(curl -s https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: thinking-binding-controls-2026-08-01"
-d '{ "model": "claude-fable-5-1", "max_tokens": 16000, "thinking": { "type": "adaptive", "block_binding": { "prefix_mismatch_behavior": "drop_block" } }, "messages": [ { "role": "user", "content": "How many positive integers below 500 have exactly 6 positive divisors?" } ] }') echo "$FIRST" | jq -r "$COUNTS"

Turn 2: the assistant turn goes back exactly as returned, then the next user message

MESSAGES=$(jq -n --argjson first "$FIRST" '[ { role: "user", content: "How many positive integers below 500 have exactly 6 positive divisors?" }, { role: "assistant", content: $first.content }, { role: "user", content: "How many of those are odd?" } ]')

jq -n --argjson messages "$MESSAGES" '{ model: "claude-fable-5-1", max_tokens: 16000, thinking: { type: "adaptive", block_binding: { prefix_mismatch_behavior: "drop_block" } }, messages: $messages }' | curl -s https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: thinking-binding-controls-2026-08-01"
-d @- | jq -r "$COUNTS"

```bash CLI
# Counts the thinking blocks in a response and the blocks the API dropped
COUNTS='"thinking blocks: \([.content[] | select(.type == "thinking")] | length), " +
  "dropped: \(.input_transformations | length)"'

FIRST=$(ant beta:messages create --beta thinking-binding-controls-2026-08-01 \
  --format json <<'YAML'
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
  block_binding:
    prefix_mismatch_behavior: drop_block
messages:
  - role: user
    content: How many positive integers below 500 have exactly 6 positive divisors?
YAML
)
echo "$FIRST" | jq -r "$COUNTS"

# Turn 2: the assistant turn goes back exactly as returned, then the next user message
ant beta:messages create --beta thinking-binding-controls-2026-08-01 \
  --format json <<YAML | jq -r "$COUNTS"
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
  block_binding:
    prefix_mismatch_behavior: drop_block
messages:
  - role: user
    content: How many positive integers below 500 have exactly 6 positive divisors?
  - role: assistant
    content: $(echo "$FIRST" | jq -c .content)
  - role: user
    content: How many of those are odd?
YAML

client = anthropic.Anthropic()

user_turns = [
    "How many positive integers below 500 have exactly 6 positive divisors?",
    "How many of those are odd?",
]

# messages grows across turns: each assistant turn goes back exactly as returned
messages = []
for user_turn in user_turns:
    messages.append({"role": "user", "content": user_turn})
    response = client.beta.messages.create(
        model="claude-fable-5-1",
        max_tokens=16000,
        thinking={
            "type": "adaptive",
            "block_binding": {"prefix_mismatch_behavior": "drop_block"},
        },
        messages=messages,
        betas=["thinking-binding-controls-2026-08-01"],
    )
    messages.append({"role": "assistant", "content": response.content})
    thinking_blocks = sum(block.type == "thinking" for block in response.content)
    dropped = len(response.input_transformations or [])
    print(f"thinking blocks: {thinking_blocks}, dropped: {dropped}")

const client = new Anthropic();

const userTurns = [
  "How many positive integers below 500 have exactly 6 positive divisors?",
  "How many of those are odd?"
];

// messages grows across turns: each assistant turn goes back exactly as returned
const messages: Anthropic.Beta.BetaMessageParam[] = [];
for (const userTurn of userTurns) {
  messages.push({ role: "user", content: userTurn });
  const response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 16000,
    thinking: {
      type: "adaptive",
      block_binding: { prefix_mismatch_behavior: "drop_block" }
    },
    messages,
    betas: ["thinking-binding-controls-2026-08-01"]
  });
  messages.push({ role: "assistant", content: response.content });
  const thinkingBlocks = response.content.filter((block) => block.type === "thinking");
  const dropped = response.input_transformations ?? [];
  console.log(`thinking blocks: ${thinkingBlocks.length}, dropped: ${dropped.length}`);
}

AnthropicClient client = new();

string[] userTurns =
[
    "How many positive integers below 500 have exactly 6 positive divisors?",
    "How many of those are odd?",
];

// messages grows across turns: each assistant turn goes back exactly as returned
List<BetaMessageParam> messages = [];
foreach (var userTurn in userTurns)
{
    messages.Add(new() { Role = Role.User, Content = userTurn });
    var response = await client.Beta.Messages.Create(
        new()
        {
            Model = "claude-fable-5-1",
            MaxTokens = 16000,
            Thinking = new BetaThinkingConfigAdaptive
            {
                BlockBinding = new()
                {
                    PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
                },
            },
            Messages = messages,
            Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
        }
    );
    messages.Add(new()
    {
        Role = Role.Assistant,
        Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
    });
    var thinkingBlocks = response.Content.Count(block => block.TryPickThinking(out _));
    var dropped = response.InputTransformations?.Count ?? 0;
    Console.WriteLine($"thinking blocks: {thinkingBlocks}, dropped: {dropped}");
}

client := anthropic.NewClient()

userTurns := []string{
	"How many positive integers below 500 have exactly 6 positive divisors?",
	"How many of those are odd?",
}

// messages grows across turns: each assistant turn goes back exactly as returned
messages := []anthropic.BetaMessageParam{}
for _, userTurn := range userTurns {
	messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userTurn)))
	response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
		Model:     "claude-fable-5-1",
		MaxTokens: 16000,
		Thinking: anthropic.BetaThinkingConfigParamUnion{
			OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
				BlockBinding: anthropic.BetaThinkingBlockBindingParam{
					PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
				},
			},
		},
		Messages: messages,
		Betas:    []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
	})
	if err != nil {
		log.Fatal(err)
	}
	messages = append(messages, response.ToParam())
	thinkingBlocks := 0
	for _, block := range response.Content {
		if block.Type == "thinking" {
			thinkingBlocks++
		}
	}
	fmt.Printf("thinking blocks: %d, dropped: %d\n", thinkingBlocks, len(response.InputTransformations))
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    List<String> userTurns = List.of(
        "How many positive integers below 500 have exactly 6 positive divisors?",
        "How many of those are odd?");

    // The builder's message list grows across turns: each assistant turn goes back exactly as returned
    MessageCreateParams.Builder conversation = MessageCreateParams.builder()
        .model("claude-fable-5-1")
        .maxTokens(16000L)
        .thinking(BetaThinkingConfigAdaptive.builder()
            .blockBinding(BetaThinkingBlockBinding.builder()
                .prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
                .build())
            .build())
        .addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01);

    for (String userTurn : userTurns) {
        conversation.addUserMessage(userTurn);
        BetaMessage response = client.beta().messages().create(conversation.build());
        conversation.addMessage(response);
        long thinkingBlocks = response.content().stream()
            .filter(BetaContentBlock::isThinking)
            .count();
        int dropped = response.inputTransformations().map(List::size).orElse(0);
        IO.println("thinking blocks: " + thinkingBlocks + ", dropped: " + dropped);
    }
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
use Anthropic\Client;

$client = new Client();

$userTurns = [
    'How many positive integers below 500 have exactly 6 positive divisors?',
    'How many of those are odd?',
];

// $messages grows across turns: each assistant turn goes back exactly as returned
$messages = [];
foreach ($userTurns as $userTurn) {
    $messages[] = ['role' => 'user', 'content' => $userTurn];
    $response = $client->beta->messages->create(
        model: 'claude-fable-5-1',
        maxTokens: 16000,
        thinking: BetaThinkingConfigAdaptive::with(
            blockBinding: BetaThinkingBlockBinding::with(
                prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
            ),
        ),
        messages: $messages,
        betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
    );
    $messages[] = ['role' => 'assistant', 'content' => $response->content];
    $thinkingBlocks = array_filter($response->content, fn ($block) => $block->type === 'thinking');
    $dropped = $response->inputTransformations ?? [];
    echo 'thinking blocks: ', count($thinkingBlocks), ', dropped: ', count($dropped), PHP_EOL;
}

client = Anthropic::Client.new

user_turns = [
  "How many positive integers below 500 have exactly 6 positive divisors?",
  "How many of those are odd?"
]

# messages grows across turns: each assistant turn goes back exactly as returned
messages = []
user_turns.each do |user_turn|
  messages << {role: "user", content: user_turn}
  response = client.beta.messages.create(
    model: "claude-fable-5-1",
    max_tokens: 16_000,
    thinking: {
      type: "adaptive",
      block_binding: {prefix_mismatch_behavior: "drop_block"}
    },
    messages: messages,
    betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]
  )
  messages << {role: "assistant", content: response.content}
  thinking_blocks = response.content.count { |block| block.type == :thinking }
  dropped = (response.input_transformations || []).length
  puts "thinking blocks: #{thinking_blocks}, dropped: #{dropped}"
end

FIRST=$(curl -s https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: thinking-binding-controls-2026-08-01"
-d '{ "model": "claude-fable-5-1", "max_tokens": 16000, "thinking": { "type": "adaptive" }, "messages": [ { "role": "user", "content": "How many positive integers below 500 have exactly 6 positive divisors?" } ] }') echo "$FIRST" | jq -r "$COUNTS"

Turn 2: the assistant turn goes back exactly as returned, then the next user message

MESSAGES=$(jq -n --argjson first "$FIRST" '[ { role: "user", content: "How many positive integers below 500 have exactly 6 positive divisors?" }, { role: "assistant", content: $first.content }, { role: "user", content: "How many of those are odd?" } ]')

SECOND=$(jq -n --argjson messages "$MESSAGES" '{ model: "claude-fable-5-1", max_tokens: 16000, thinking: { type: "adaptive" }, messages: $messages }' | curl -s https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: thinking-binding-controls-2026-08-01"
-d @-) echo "$SECOND" | jq -r "$COUNTS"

Turn 3: only this request adds a system prompt, which changes the prefix on purpose

jq -n --argjson messages "$MESSAGES" --argjson second "$SECOND" '{ model: "claude-fable-5-1", max_tokens: 16000, thinking: { type: "adaptive" }, system: "Answer briefly.", messages: ($messages + [ { role: "assistant", content: $second.content }, { role: "user", content: "And how many of the odd ones are below 100?" } ]) }' | curl -s https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: thinking-binding-controls-2026-08-01"
-d @- | jq -r "$COUNTS"

```bash CLI
# Counts the thinking blocks in a response and the blocks that failed the prefix check
COUNTS='"thinking blocks: \([.content[] | select(.type == "thinking")] | length), " +
  "flagged: \([.input_transformations[] |
    select(.type == "thinking_mismatch_allowed")] | length)"'

FIRST=$(ant beta:messages create --beta thinking-binding-controls-2026-08-01 \
  --format json <<'YAML'
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
messages:
  - role: user
    content: How many positive integers below 500 have exactly 6 positive divisors?
YAML
)
echo "$FIRST" | jq -r "$COUNTS"

# Turn 2: the assistant turn goes back exactly as returned, then the next user message
SECOND=$(ant beta:messages create --beta thinking-binding-controls-2026-08-01 \
  --format json <<YAML
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
messages:
  - role: user
    content: How many positive integers below 500 have exactly 6 positive divisors?
  - role: assistant
    content: $(echo "$FIRST" | jq -c .content)
  - role: user
    content: How many of those are odd?
YAML
)
echo "$SECOND" | jq -r "$COUNTS"

# Turn 3: only this request adds a system prompt, which changes the prefix on purpose
ant beta:messages create --beta thinking-binding-controls-2026-08-01 \
  --format json <<YAML | jq -r "$COUNTS"
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
system: Answer briefly.
messages:
  - role: user
    content: How many positive integers below 500 have exactly 6 positive divisors?
  - role: assistant
    content: $(echo "$FIRST" | jq -c .content)
  - role: user
    content: How many of those are odd?
  - role: assistant
    content: $(echo "$SECOND" | jq -c .content)
  - role: user
    content: And how many of the odd ones are below 100?
YAML

client = anthropic.Anthropic()

user_turns = [
    "How many positive integers below 500 have exactly 6 positive divisors?",
    "How many of those are odd?",
    "And how many of the odd ones are below 100?",
]

# messages grows across turns: each assistant turn goes back exactly as returned
messages = []
for turn, user_turn in enumerate(user_turns, start=1):
    messages.append({"role": "user", "content": user_turn})
    response = client.beta.messages.create(
        model="claude-fable-5-1",
        max_tokens=16000,
        thinking={"type": "adaptive"},
        # Only the last request adds a system prompt, which changes the prefix on purpose
        system="Answer briefly." if turn == len(user_turns) else anthropic.omit,
        messages=messages,
        betas=["thinking-binding-controls-2026-08-01"],
    )
    messages.append({"role": "assistant", "content": response.content})
    thinking_blocks = sum(block.type == "thinking" for block in response.content)
    flagged = sum(
        transformation.type == "thinking_mismatch_allowed"
        for transformation in response.input_transformations or []
    )
    print(f"thinking blocks: {thinking_blocks}, flagged: {flagged}")

const client = new Anthropic();

const userTurns = [
  "How many positive integers below 500 have exactly 6 positive divisors?",
  "How many of those are odd?",
  "And how many of the odd ones are below 100?"
];

// messages grows across turns: each assistant turn goes back exactly as returned
const messages: Anthropic.Beta.BetaMessageParam[] = [];
for (const [turnIndex, userTurn] of userTurns.entries()) {
  messages.push({ role: "user", content: userTurn });
  const response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    // Only the last request adds a system prompt, which changes the prefix on purpose
    system: turnIndex === userTurns.length - 1 ? "Answer briefly." : undefined,
    messages,
    betas: ["thinking-binding-controls-2026-08-01"]
  });
  messages.push({ role: "assistant", content: response.content });
  const thinkingBlocks = response.content.filter((block) => block.type === "thinking");
  const flagged = (response.input_transformations ?? []).filter(
    (transformation) => transformation.type === "thinking_mismatch_allowed"
  );
  console.log(`thinking blocks: ${thinkingBlocks.length}, flagged: ${flagged.length}`);
}

AnthropicClient client = new();

string[] userTurns =
[
    "How many positive integers below 500 have exactly 6 positive divisors?",
    "How many of those are odd?",
    "And how many of the odd ones are below 100?",
];

// messages grows across turns: each assistant turn goes back exactly as returned
List<BetaMessageParam> messages = [];
for (var turnIndex = 0; turnIndex < userTurns.Length; turnIndex++)
{
    messages.Add(new() { Role = Role.User, Content = userTurns[turnIndex] });
    var response = await client.Beta.Messages.Create(
        new()
        {
            Model = "claude-fable-5-1",
            MaxTokens = 16000,
            Thinking = new BetaThinkingConfigAdaptive(),
            // Only the last request adds a system prompt, which changes the prefix on purpose
            System = turnIndex == userTurns.Length - 1 ? new("Answer briefly.") : null,
            Messages = messages,
            Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
        }
    );
    messages.Add(new()
    {
        Role = Role.Assistant,
        Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
    });
    var thinkingBlocks = response.Content.Count(block => block.TryPickThinking(out _));
    var flagged = response.InputTransformations?.Count(transformation =>
        transformation.TryPickThinkingMismatchAllowed(out _)
    ) ?? 0;
    Console.WriteLine($"thinking blocks: {thinkingBlocks}, flagged: {flagged}");
}

client := anthropic.NewClient()

userTurns := []string{
	"How many positive integers below 500 have exactly 6 positive divisors?",
	"How many of those are odd?",
	"And how many of the odd ones are below 100?",
}

// messages grows across turns: each assistant turn goes back exactly as returned
messages := []anthropic.BetaMessageParam{}
for i, userTurn := range userTurns {
	messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userTurn)))
	// Only the last request adds a system prompt, which changes the prefix on purpose
	var system []anthropic.BetaTextBlockParam
	if i == len(userTurns)-1 {
		system = []anthropic.BetaTextBlockParam{{Text: "Answer briefly."}}
	}
	response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
		Model:     "claude-fable-5-1",
		MaxTokens: 16000,
		Thinking: anthropic.BetaThinkingConfigParamUnion{
			OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{},
		},
		System:   system,
		Messages: messages,
		Betas:    []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
	})
	if err != nil {
		log.Fatal(err)
	}
	messages = append(messages, response.ToParam())
	thinkingBlocks := 0
	for _, block := range response.Content {
		if block.Type == "thinking" {
			thinkingBlocks++
		}
	}
	flagged := 0
	for _, transformation := range response.InputTransformations {
		if transformation.Type == "thinking_mismatch_allowed" {
			flagged++
		}
	}
	fmt.Printf("thinking blocks: %d, flagged: %d\n", thinkingBlocks, flagged)
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaInputTransformation;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    List<String> userTurns = List.of(
        "How many positive integers below 500 have exactly 6 positive divisors?",
        "How many of those are odd?",
        "And how many of the odd ones are below 100?");

    // The builder's message list grows across turns: each assistant turn goes back exactly as returned
    MessageCreateParams.Builder conversation = MessageCreateParams.builder()
        .model("claude-fable-5-1")
        .maxTokens(16000L)
        .thinking(BetaThinkingConfigAdaptive.builder().build())
        .addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01);

    for (int turnIndex = 0; turnIndex < userTurns.size(); turnIndex++) {
        if (turnIndex == userTurns.size() - 1) {
            // Only the last request adds a system prompt, which changes the prefix on purpose
            conversation.system("Answer briefly.");
        }
        conversation.addUserMessage(userTurns.get(turnIndex));
        BetaMessage response = client.beta().messages().create(conversation.build());
        conversation.addMessage(response);
        long thinkingBlocks = response.content().stream()
            .filter(BetaContentBlock::isThinking)
            .count();
        long flagged = response.inputTransformations().stream()
            .flatMap(List::stream)
            .filter(BetaInputTransformation::isThinkingMismatchAllowed)
            .count();
        IO.println("thinking blocks: " + thinkingBlocks + ", flagged: " + flagged);
    }
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingMismatchAllowedInputTransformation;
use Anthropic\Client;

$client = new Client();

$userTurns = [
    'How many positive integers below 500 have exactly 6 positive divisors?',
    'How many of those are odd?',
    'And how many of the odd ones are below 100?',
];

// $messages grows across turns: each assistant turn goes back exactly as returned
$messages = [];
foreach ($userTurns as $turnIndex => $userTurn) {
    $messages[] = ['role' => 'user', 'content' => $userTurn];
    $response = $client->beta->messages->create(
        model: 'claude-fable-5-1',
        maxTokens: 16000,
        thinking: BetaThinkingConfigAdaptive::with(),
        // Only the last request adds a system prompt, which changes the prefix on purpose
        system: $turnIndex === array_key_last($userTurns) ? 'Answer briefly.' : null,
        messages: $messages,
        betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
    );
    $messages[] = ['role' => 'assistant', 'content' => $response->content];
    $thinkingBlocks = array_filter($response->content, fn ($block) => $block->type === 'thinking');
    $flagged = array_filter(
        $response->inputTransformations ?? [],
        fn ($transformation) => $transformation instanceof BetaThinkingMismatchAllowedInputTransformation,
    );
    echo 'thinking blocks: ', count($thinkingBlocks), ', flagged: ', count($flagged), PHP_EOL;
}

client = Anthropic::Client.new

user_turns = [
  "How many positive integers below 500 have exactly 6 positive divisors?",
  "How many of those are odd?",
  "And how many of the odd ones are below 100?"
]

# messages grows across turns: each assistant turn goes back exactly as returned
messages = []
user_turns.each_with_index do |user_turn, turn_index|
  messages << {role: "user", content: user_turn}
  # Only the last request adds a system prompt, which changes the prefix on purpose
  system_param = (turn_index == user_turns.length - 1) ? {system_: "Answer briefly."} : {}
  response = client.beta.messages.create(
    model: "claude-fable-5-1",
    max_tokens: 16_000,
    thinking: {type: "adaptive"},
    messages: messages,
    betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
    **system_param
  )
  messages << {role: "assistant", content: response.content}
  thinking_blocks = response.content.count { |block| block.type == :thinking }
  flagged = (response.input_transformations || []).count do |transformation|
    transformation.type == :thinking_mismatch_allowed
  end
  puts "thinking blocks: #{thinking_blocks}, flagged: #{flagged}"
end

ant beta:messages create --beta thinking-binding-controls-2026-08-01 <<YAML
model: claude-fable-5-1
max_tokens: 16000
thinking:
  type: adaptive
  block_binding:
    prefix_mismatch_behavior: drop_block
messages: $COMPACTED_MESSAGES
YAML

client = anthropic.Anthropic()

# compacted_messages: the summary message, then the kept turns as returned
response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "block_binding": {"prefix_mismatch_behavior": "drop_block"},
    },
    messages=compacted_messages,
    betas=["thinking-binding-controls-2026-08-01"],
)

print(response.input_transformations)

const client = new Anthropic();

// compactedMessages: the summary message, then the kept turns as returned
const response = await client.beta.messages.create({
  model: "claude-fable-5-1",
  max_tokens: 16000,
  thinking: {
    type: "adaptive",
    block_binding: { prefix_mismatch_behavior: "drop_block" }
  },
  messages: compactedMessages,
  betas: ["thinking-binding-controls-2026-08-01"]
});

console.log(response.input_transformations);

AnthropicClient client = new();

// compactedMessages: the summary message, then the kept turns as returned
var response = await client.Beta.Messages.Create(
    new()
    {
        Model = "claude-fable-5-1",
        MaxTokens = 16000,
        Thinking = new BetaThinkingConfigAdaptive
        {
            BlockBinding = new()
            {
                PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
            },
        },
        Messages = compactedMessages,
        Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
    }
);

Console.WriteLine(response.InputTransformations?.Count ?? 0);

client := anthropic.NewClient()

// compactedMessages: the summary message, then the kept turns as returned
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     "claude-fable-5-1",
	MaxTokens: 16000,
	Thinking: anthropic.BetaThinkingConfigParamUnion{
		OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
			BlockBinding: anthropic.BetaThinkingBlockBindingParam{
				PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
			},
		},
	},
	Messages: compactedMessages,
	Betas:    []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(len(response.InputTransformations))

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    // compactedMessages: the summary message, then the kept turns as returned
    MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-fable-5-1")
        .maxTokens(16000L)
        .thinking(BetaThinkingConfigAdaptive.builder()
            .blockBinding(BetaThinkingBlockBinding.builder()
                .prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
                .build())
            .build())
        .messages(compactedMessages)
        .addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01)
        .build();

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

    IO.println(response.inputTransformations());
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
use Anthropic\Client;

$client = new Client();

// $compactedMessages: the summary message, then the kept turns as returned
$response = $client->beta->messages->create(
    model: 'claude-fable-5-1',
    maxTokens: 16000,
    thinking: BetaThinkingConfigAdaptive::with(
        blockBinding: BetaThinkingBlockBinding::with(
            prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
        ),
    ),
    messages: $compactedMessages,
    betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
);

var_dump($response->inputTransformations);

client = Anthropic::Client.new

# compacted_messages: the summary message, then the kept turns as returned
response = client.beta.messages.create(
  model: "claude-fable-5-1",
  max_tokens: 16_000,
  thinking: {
    type: "adaptive",
    block_binding: {prefix_mismatch_behavior: "drop_block"}
  },
  messages: compacted_messages,
  betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]
)

puts response.input_transformations