거부와 폴백

ant beta:messages create \
  --model claude-fable-5 \
  --max-tokens 1024 \
  --message '{"role":"user","content":"Hello, Claude"}' \
  --fallbacks default \
  --beta server-side-fallback-2026-07-01

client = Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    fallbacks="default",
    betas=["server-side-fallback-2026-07-01"],
)
print(response.model)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  fallbacks: "default",
  betas: ["server-side-fallback-2026-07-01"]
});
console.log(response.model);

AnthropicClient client = new();

BetaMessage response = await client.Beta.Messages.Create(
    new()
    {
        Model = Messages::Model.ClaudeFable5,
        MaxTokens = 1024,
        Messages = [new() { Content = "Hello, Claude", Role = Role.User }],
        Fallbacks = new Default(),
        Betas = [AnthropicBeta.ServerSideFallback2026_07_01],
    }
);

Console.WriteLine(response.Model.Raw());

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeFable5,
	MaxTokens: 1024,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude")),
	},
	Fallbacks: anthropic.BetaFallbacksParamOfDefault(),
	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaServerSideFallback2026_07_01},
})
if err != nil {
	panic(err)
}

fmt.Println(response.Model)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
    .model(Model.CLAUDE_FABLE_5)
    .maxTokens(1024L)
    .addUserMessage("Hello, Claude")
    .fallbacksDefault()
    .addBeta(AnthropicBeta.SERVER_SIDE_FALLBACK_2026_07_01)
    .build());

IO.println(response.model().asString());

$client = new Client();

$response = $client->beta->messages->create(
    model: 'claude-fable-5',
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello, Claude']],
    fallbacks: 'default',
    betas: ['server-side-fallback-2026-07-01'],
);

echo $response->model, PHP_EOL;

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  fallbacks: :default,
  betas: ["server-side-fallback-2026-07-01"]
)

puts response.model

ant beta:messages create \
  --model claude-fable-5 \
  --max-tokens 1024 \
  --message '{"role":"user","content":"Hello, Claude"}' \
  --fallbacks default \
  --beta server-side-fallback-2026-07-01 \
  --format json |
  jq -c '{
    stop_reason,
    model,
    # A fallback_message entry in usage.iterations means a fallback model ran;
    # pair it with stop_reason to confirm the fallback served the response.
    served_by_fallback: (
      any(.usage.iterations[]?; .type == "fallback_message")
      and .stop_reason != "refusal"
    )
  }'

client = Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    fallbacks="default",
    betas=["server-side-fallback-2026-07-01"],
)

# A fallback_message entry in usage.iterations means a fallback model ran;
# pair it with stop_reason to confirm the fallback served the response.
fallback_ran = any(
    iteration.type == "fallback_message"
    for iteration in response.usage.iterations or []
)
served_by_fallback = fallback_ran and response.stop_reason != "refusal"

print(
    json.dumps(
        {
            "stop_reason": response.stop_reason,
            "model": response.model,
            "served_by_fallback": served_by_fallback,
        }
    )
)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  fallbacks: "default",
  betas: ["server-side-fallback-2026-07-01"]
});

// A fallback_message entry in usage.iterations means a fallback model ran;
// pair it with stop_reason to confirm the fallback served the response.
const { stop_reason, model, usage } = response;
const servedByFallback =
  (usage.iterations ?? []).some((entry) => entry.type === "fallback_message") &&
  stop_reason !== "refusal";

console.log(
  JSON.stringify({
    stop_reason,
    model,
    served_by_fallback: servedByFallback
  })
);

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(
    new()
    {
        Model = Messages::Model.ClaudeFable5,
        MaxTokens = 1024,
        Messages =
        [
            new() { Content = "Hello, Claude", Role = Role.User },
        ],
        Fallbacks = new Default(),
        Betas = [AnthropicBeta.ServerSideFallback2026_07_01],
    }
);

// A fallback_message entry in usage.iterations means a fallback model ran;
// pair it with stop_reason to confirm the fallback served the response.
bool fallbackRan = (response.Usage.Iterations ?? []).Any(iteration =>
    iteration.TryPickBetaFallbackMessageIterationUsage(out _)
);
bool servedByFallback =
    fallbackRan && response.StopReason?.Value() != BetaStopReason.Refusal;

Console.WriteLine(
    JsonSerializer.Serialize(
        new
        {
            stop_reason = response.StopReason?.Raw(),
            model = response.Model.Raw(),
            served_by_fallback = servedByFallback,
        }
    )
);

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeFable5,
	MaxTokens: 1024,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude")),
	},
	Fallbacks: anthropic.BetaFallbacksParamOfDefault(),
	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaServerSideFallback2026_07_01},
})
if err != nil {
	panic(err)
}

// A fallback_message entry in usage.iterations means a fallback model ran;
// pair it with stop_reason to confirm the fallback served the response.
fallbackRan := slices.ContainsFunc(
	response.Usage.Iterations,
	func(iteration anthropic.BetaIterationsUsageItemUnion) bool {
		_, isFallback := iteration.AsAny().(anthropic.BetaFallbackMessageIterationUsage)
		return isFallback
	},
)
servedByFallback := fallbackRan && response.StopReason != anthropic.BetaStopReasonRefusal

summary, err := json.Marshal(struct {
	StopReason       anthropic.BetaStopReason `json:"stop_reason"`
	Model            anthropic.Model          `json:"model"`
	ServedByFallback bool                     `json:"served_by_fallback"`
}{response.StopReason, response.Model, servedByFallback})
if err != nil {
	panic(err)
}
fmt.Println(string(summary))

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

BetaMessage response = client.beta().messages().create(
    MessageCreateParams.builder()
        .model(Model.CLAUDE_FABLE_5)
        .maxTokens(1024L)
        .addUserMessage("Hello, Claude")
        .fallbacksDefault()
        .addBeta(AnthropicBeta.SERVER_SIDE_FALLBACK_2026_07_01)
        .build()
);

// A fallback_message usage entry means a fallback model produced the
// response; a refusal stop reason means no model served it.
List<BetaUsage.Iteration> iterations =
    response.usage().iterations().orElse(List.of());
boolean servedByFallback =
    iterations.stream().anyMatch(BetaUsage.Iteration::isFallbackMessage)
        && response.stopReason().filter(BetaStopReason.REFUSAL::equals).isEmpty();

IO.println("""
    {"stop_reason":"%s","model":"%s","served_by_fallback":%b}\
    """.formatted(
        response.stopReason().map(BetaStopReason::asString).orElse("null"),
        response.model().asString(),
        servedByFallback));

$client = new Client();

$response = $client->beta->messages->create(
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello, Claude']],
    model: 'claude-fable-5',
    fallbacks: 'default',
    betas: ['server-side-fallback-2026-07-01'],
);

// A fallback_message entry in usage.iterations means a fallback model ran;
// pair it with stop_reason to confirm the fallback served the response.
$iterations = $response->usage->iterations ?? [];
$servedByFallback = array_any($iterations, fn($entry) => $entry->type === 'fallback_message')
    && $response->stopReason !== 'refusal';

echo json_encode([
    'stop_reason' => $response->stopReason,
    'model' => $response->model,
    'served_by_fallback' => $servedByFallback,
]), PHP_EOL;

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  fallbacks: :default,
  betas: ["server-side-fallback-2026-07-01"]
)

# A fallback_message entry in usage.iterations means a fallback model ran;
# pair it with stop_reason to confirm the fallback served the response.
iterations = response.usage.iterations || []
served_by_fallback = iterations.any? { it.type == :fallback_message } &&
  response.stop_reason != :refusal

stop_reason = response.stop_reason
model = response.model
puts JSON.generate({stop_reason:, model:, served_by_fallback:})

ant beta:messages create \
  --model claude-fable-5 \
  --max-tokens 1024 \
  --message '{"role":"user","content":"Hello, Claude"}' \
  --fallbacks '[{"model":"claude-opus-4-8"}]' \
  --beta server-side-fallback-2026-07-01

client = Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    fallbacks=[{"model": "claude-opus-4-8"}],
    betas=["server-side-fallback-2026-07-01"],
)
print(response.model)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  fallbacks: [{ model: "claude-opus-4-8" }],
  betas: ["server-side-fallback-2026-07-01"]
});
console.log(response.model);

AnthropicClient client = new();

BetaMessage response = await client.Beta.Messages.Create(
    new()
    {
        Model = Messages::Model.ClaudeFable5,
        MaxTokens = 1024,
        Messages = [new() { Content = "Hello, Claude", Role = Role.User }],
        Fallbacks = new([new(Messages::Model.ClaudeOpus4_8)]),
        Betas = [AnthropicBeta.ServerSideFallback2026_07_01],
    }
);

Console.WriteLine(response.Model.Raw());

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeFable5,
	MaxTokens: 1024,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude")),
	},
	Fallbacks: anthropic.BetaFallbacksParamUnion{
		OfBetaFallbackArray: []anthropic.BetaFallbackParam{{Model: anthropic.ModelClaudeOpus4_8}},
	},
	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaServerSideFallback2026_07_01},
})
if err != nil {
	panic(err)
}

fmt.Println(response.Model)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
    .model(Model.CLAUDE_FABLE_5)
    .maxTokens(1024L)
    .addUserMessage("Hello, Claude")
    .fallbacksOfFallbackParams(List.of(BetaFallbackParam.builder()
        .model(Model.CLAUDE_OPUS_4_8)
        .build()))
    .addBeta(AnthropicBeta.SERVER_SIDE_FALLBACK_2026_07_01)
    .build());

IO.println(response.model().asString());

$client = new Client();

$response = $client->beta->messages->create(
    model: 'claude-fable-5',
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello, Claude']],
    fallbacks: [['model' => 'claude-opus-4-8']],
    betas: ['server-side-fallback-2026-07-01'],
);

echo $response->model, PHP_EOL;

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  fallbacks: [{model: "claude-opus-4-8"}],
  betas: ["server-side-fallback-2026-07-01"]
)

puts response.model

# The refusal-fallback middleware is an SDK feature. See the
# server-side fallback section for the equivalent single-request approach,
# or the fallback credit page for the raw HTTP retry pattern.

from anthropic import Anthropic, BetaFallbackState, BetaRefusalFallbackMiddleware

# On a refusal, the middleware retries on the listed fallback model and
# automatically sends the fallback-credit beta header on every request it handles.
client = Anthropic(
    middleware=[BetaRefusalFallbackMiddleware([{"model": "claude-opus-4-8"}])],
)

state = BetaFallbackState()  # pins follow-ups to the model that accepted

# Streaming: on a refusal the middleware retries on the fallback model and
# splices its events onto the open stream.
with (
    state,
    client.beta.messages.stream(
        max_tokens=1024,
        model="claude-fable-5",
        messages=[{"role": "user", "content": "Hello, Claude"}],
    ) as stream,
):
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final_message = stream.get_final_message()
print(f"\nserved by: {final_message.model}")

# Non-streaming: reusing the state keeps the conversation pinned.
with state:
    message = client.beta.messages.create(
        max_tokens=1024,
        model="claude-fable-5",
        messages=[{"role": "user", "content": "Hello, Claude"}],
    )
print(f"served by: {message.model}")

import { BetaFallbackState, betaRefusalFallbackMiddleware } from "@anthropic-ai/sdk";

// On a refusal, the middleware retries on the listed fallback model and
// automatically sends the fallback-credit beta header on every request it handles.
const client = new Anthropic({
  middleware: [betaRefusalFallbackMiddleware([{ model: "claude-opus-4-8" }])]
});

// Share one state across the conversation so follow-up requests stay
// pinned to the model that accepted.
const fallbackState = new BetaFallbackState();

// Streaming: on a refusal the middleware retries on the fallback model and
// splices its events onto the open stream.
const stream = client.beta.messages
  .stream(
    {
      max_tokens: 1024,
      model: "claude-fable-5",
      messages: [{ role: "user", content: "Hello, Claude" }]
    },
    { fallbackState }
  )
  .on("text", (text) => process.stdout.write(text));

const finalMessage = await stream.finalMessage();
console.log("\nserved by:", finalMessage.model);

// Non-streaming: reusing the state keeps the conversation pinned.
const message = await client.beta.messages.create(
  {
    max_tokens: 1024,
    model: "claude-fable-5",
    messages: [{ role: "user", content: "Hello, Claude" }]
  },
  { fallbackState }
);
console.log("served by:", message.model);

using Anthropic;
using Anthropic.Helpers;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

// On a refusal, the handler retries on the listed fallback model and
// automatically sends the fallback-credit beta header on every request it handles.
AnthropicClient client = new()
{
    Handlers =
    [
        new BetaRefusalFallbackHandler { Fallbacks = [new(Messages::Model.ClaudeOpus4_8)] },
    ],
};

// Pins follow-up requests sharing this state to the model that accepted.
BetaFallbackState fallbackState = BetaFallbackState.Create();

MessageCreateParams parameters = new()
{
    Model = Messages::Model.ClaudeFable5,
    MaxTokens = 1024,
    Messages = [new() { Content = "Hello, Claude", Role = Role.User }],
};

// Streaming: if the stream ends in a refusal, the handler splices the fallback
// model's events onto the still-open stream.
BetaMessageContentAggregator aggregator = new();
using (fallbackState.Use())
{
    var responseUpdates = client.Beta.Messages.CreateStreaming(parameters);
    await foreach (BetaRawMessageStreamEvent rawEvent in responseUpdates.CollectAsync(aggregator))
    {
        if (
            rawEvent.TryPickContentBlockDelta(out var deltaEvent)
            && deltaEvent.Delta.TryPickText(out var textDelta)
        )
        {
            Console.Write(textDelta.Text);
        }
    }
}
BetaMessage streamedMessage = aggregator.Message();
Console.WriteLine($"\nserved by: {streamedMessage.Model.Raw()}");

// Non-streaming: reusing the state keeps the conversation pinned to the model that accepted.
using (fallbackState.Use())
{
    BetaMessage message = await client.Beta.Messages.Create(parameters);
    Console.WriteLine($"served by: {message.Model.Raw()}");
}

import (
// ...
	"github.com/anthropics/anthropic-sdk-go/lib/betafallback"
// ...
)

func main() {
	ctx := context.Background()

	// The middleware retries a refused request on each fallback model in
	// turn, and opts requests into the fallback-credit beta automatically.
	client := anthropic.NewClient(
		option.WithMiddleware(betafallback.BetaRefusalFallbackMiddleware(
			[]anthropic.BetaFallbackParam{{Model: anthropic.ModelClaudeOpus4_8}},
		)),
	)

	// One state per conversation: requests sharing it stay pinned to the
	// model that accepted, so a follow-up never re-asks a model that refused.
	state := &betafallback.BetaFallbackState{}
	conversation := betafallback.WithBetaFallbackState(state)

	params := anthropic.BetaMessageNewParams{
		MaxTokens: 1024,
		Model:     anthropic.ModelClaudeFable5,
		Messages: []anthropic.BetaMessageParam{
			anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude")),
		},
	}

	// Streaming: on a refusal the middleware retries in place, splicing the
	// fallback model's events onto the open stream as one continuous message.
	stream := client.Beta.Messages.NewStreaming(ctx, params, conversation)
	defer stream.Close()
	var streamed anthropic.BetaMessage
	for stream.Next() {
		event := stream.Current()
		if err := streamed.Accumulate(event); err != nil {
			panic(err)
		}
		switch eventVariant := event.AsAny().(type) {
		case anthropic.BetaRawContentBlockDeltaEvent:
			if textDelta, ok := eventVariant.Delta.AsAny().(anthropic.BetaTextDelta); ok {
				fmt.Print(textDelta.Text)
			}
		}
	}
	if err := stream.Err(); err != nil {
		panic(err)
	}
	fmt.Println("\nserved by:", streamed.Model)

	// Non-streaming: the shared state pins this follow-up to the model that
	// served the streamed turn.
	message, err := client.Beta.Messages.New(ctx, params, conversation)
	if err != nil {
		panic(err)
	}
	fmt.Println("served by:", message.Model)
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.RequestOptions;
import com.anthropic.core.http.StreamResponse;
import com.anthropic.helpers.BetaFallbackState;
import com.anthropic.helpers.BetaMessageAccumulator;
import com.anthropic.helpers.BetaRefusalFallbackInterceptor;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaRawMessageStreamEvent;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;

void main() {
    // The interceptor retries refused requests on the fallback model. It automatically
    // adds the fallback-credit beta header to every request it handles.
    AnthropicClient client = AnthropicOkHttpClient.builder()
        .fromEnv()
        .addInterceptor(BetaRefusalFallbackInterceptor.builder()
            .addFallback(Model.CLAUDE_OPUS_4_8)
            .build())
        .build();

    // Share one state across requests so follow-ups stay pinned to the model that accepted.
    BetaFallbackState state = BetaFallbackState.create();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_FABLE_5)
        .maxTokens(1024)
        .addUserMessage("Hello, Claude")
        .build();

    // Streaming: on a refusal, the fallback model's events are spliced onto the open stream.
    BetaMessageAccumulator accumulator = BetaMessageAccumulator.create();
    try (StreamResponse<BetaRawMessageStreamEvent> streamResponse = client.beta()
            .messages()
            .createStreaming(params, RequestOptions.builder().fallbackState(state).build())) {
        streamResponse.stream()
            .peek(accumulator::accumulate)
            .forEach(event -> event.contentBlockDelta()
                .flatMap(deltaEvent -> deltaEvent.delta().text())
                .ifPresent(textDelta -> IO.print(textDelta.text())));
    }
    IO.println("\nserved by: " + accumulator.message().model().asString());

    // Non-streaming: reusing the same state keeps the conversation pinned.
    BetaMessage message = client.beta()
        .messages()
        .create(params, RequestOptions.builder().fallbackState(state).build());
    IO.println("served by: " + message.model().asString());
}

use Anthropic\Beta\Messages\BetaRawContentBlockDeltaEvent;
use Anthropic\Beta\Messages\BetaTextDelta;
use Anthropic\Client;
use Anthropic\Lib\Middleware\BetaFallbackState;
use Anthropic\Lib\Middleware\RefusalFallbackMiddleware;
use Anthropic\Lib\Streaming\MessageAccumulator;

// Configure the fallback chain once. On a refusal, the middleware retries the
// request down the chain and sends the fallback-credit beta header for you.
$client = new Client(
    requestOptions: [
        'middleware' => [new RefusalFallbackMiddleware([['model' => 'claude-opus-4-8']])],
    ],
);

// Share one state across the conversation so follow-up requests stay pinned
// to the model that accepted.
$state = new BetaFallbackState();

// Streaming: on a refusal the middleware splices the fallback model's events
// onto the still-open stream. The accumulator's model is the serving model.
$stream = $client->beta->messages->createStream(
    model: 'claude-fable-5',
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello, Claude']],
    requestOptions: ['fallbackState' => $state],
);
$accumulator = MessageAccumulator::forBetaMessages();
foreach ($stream as $event) {
    $accumulator->accumulate($event);
    if ($event instanceof BetaRawContentBlockDeltaEvent
        && $event->delta instanceof BetaTextDelta) {
        echo $event->delta->text;
    }
}
echo "\nserved by: {$accumulator->message()->model}\n";

// Non-streaming: same middleware. Reusing the state keeps the conversation
// pinned to the model that accepted.
$message = $client->beta->messages->create(
    model: 'claude-fable-5',
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello, Claude']],
    requestOptions: ['fallbackState' => $state],
);
echo "served by: {$message->model}\n";

# On a refusal, the middleware retries the request down the fallback chain.
# It sends the fallback-credit beta header on every request it handles.
client = Anthropic::Client.new(
  middleware: [Anthropic::BetaRefusalFallbackMiddleware.new([{model: "claude-opus-4-8"}])]
)

# Share one state across the conversation so follow-up requests stay
# pinned to the model that accepted.
state = Anthropic::BetaFallbackState.new

# Streaming: on a refusal the middleware splices the fallback model's
# events onto the still-open stream.
stream = client.beta.messages.stream(
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  request_options: {fallback_state: state}
)
stream.text.each { print it }
puts "\nserved by: #{stream.accumulated_message.model}"

# Non-streaming: reusing the state keeps the conversation pinned to the model that accepted.
message = client.beta.messages.create(
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  request_options: {fallback_state: state}
)
puts "served by: #{message.model}"