폴백 크레딧

A refusal carries a one-time credit token in stop_details

token=$(jq -r '.stop_details.fallback_credit_token // empty' <<<"${response}")

if [[ -n "${token}" ]]; then # Retry on the fallback model with the credit token (same body) response=$(curl --fail-with-body -sS https://api.anthropic.com/v1/messages
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: fallback-credit-2026-07-01"
-H "content-type: application/json"
-d "$(jq -n --arg token "${token}" '{ model: "claude-opus-4-8", max_tokens: 1024, messages: [{"role": "user", "content": "Hello, Claude"}], fallback_credit_token: $token }')") fi

See the SDK examples for the full rejection-handling ladder.

jq -c '{stop_reason, model}' <<<"${response}"

```bash CLI
# Initial request (may be refused)
response=$(ant beta:messages create \
  --model claude-fable-5 \
  --max-tokens 1024 \
  --message '{"role":"user","content":"Hello, Claude"}' \
  --beta fallback-credit-2026-07-01 \
  --format json)

# A refusal carries a one-time credit token in stop_details
token=$(jq -r '.stop_details.fallback_credit_token // empty' <<<"${response}")

if [[ -n "${token}" ]]; then
  # Retry on the fallback model with the credit token
  response=$(ant beta:messages create \
    --model claude-opus-4-8 \
    --max-tokens 1024 \
    --message '{"role":"user","content":"Hello, Claude"}' \
    --fallback-credit-token "${token}" \
    --beta fallback-credit-2026-07-01 \
    --format json)
fi

# See the SDK examples for the full rejection-handling ladder.
jq -c '{stop_reason, model}' <<<"${response}"

client = Anthropic()

request = {
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello, Claude"}],
}


def send(model: str, body: dict[str, object]) -> BetaMessage:
    return client.beta.messages.create(
        model=model, betas=["fallback-credit-2026-07-01"], **body
    )


response = send("claude-fable-5", request)

if (
    response.stop_reason == "refusal"
    and (details := response.stop_details)
    and (token := details.fallback_credit_token)
):
    exact_body = request | {"fallback_credit_token": token}
    # Prefer the continuation shape unless the claim is False
    if details.fallback_has_prefill_claim is not False:
        echoed = [block.model_dump() for block in response.content]
        match echoed:
            case [*_, {"type": "text"} as final_block]:
                final_block["text"] = final_block["text"].rstrip()
        attempt = exact_body | {
            "messages": [
                *request["messages"],
                {"role": "assistant", "content": echoed},
            ]
        }
    else:
        attempt = exact_body

    try:
        response = send("claude-opus-4-8", attempt)
    except BadRequestError as error:
        if "redemption temporarily unavailable" in error.message:
            raise  # Transient: retry with the token within its five-minute window
        try:
            # Fall back to the unchanged body, still with the token
            response = send("claude-opus-4-8", exact_body)
        except BadRequestError as retry_error:
            if "redemption temporarily unavailable" in retry_error.message:
                raise  # Transient: retry with the token within its five-minute window
            # The token itself was rejected: forfeit it and retry without.
            response = send("claude-opus-4-8", request)

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

const client = new Anthropic();

const request: Anthropic.Beta.MessageCreateParamsNonStreaming = {
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  betas: ["fallback-credit-2026-07-01"]
};

let response = await client.beta.messages.create(request);

if (
  response.stop_reason === "refusal" &&
  response.stop_details?.type === "refusal" &&
  response.stop_details.fallback_credit_token
) {
  const { fallback_credit_token, fallback_has_prefill_claim } = response.stop_details;
  const fallbackModel = "claude-opus-4-8";

  const exactRetry: Anthropic.Beta.MessageCreateParamsNonStreaming = {
    ...request,
    model: fallbackModel,
    fallback_credit_token
  };

  // Richest shape first, degrading on each rejection: the continuation
  // shape (unless the claim is false), the unchanged body still carrying
  // the token, and finally forfeiting the token.
  let attempt = exactRetry;
  if (fallback_has_prefill_claim !== false) {
    const finalBlock = response.content.at(-1);
    const echoed: Anthropic.Beta.BetaContentBlockParam[] =
      finalBlock?.type === "text"
        ? [
            ...response.content.slice(0, -1),
            { ...finalBlock, text: finalBlock.text.trimEnd() }
          ]
        : response.content;
    attempt = {
      ...exactRetry,
      messages: [...request.messages, { role: "assistant", content: echoed }]
    };
  }

  try {
    response = await client.beta.messages.create(attempt);
  } catch (error) {
    // Degrade only on a shape-related 400. "redemption temporarily
    // unavailable" is transient: retry the same way within the token's
    // five-minute window instead.
    if (
      !(error instanceof Anthropic.BadRequestError) ||
      error.message.includes("redemption temporarily unavailable")
    ) {
      throw error;
    }
    try {
      response = await client.beta.messages.create(exactRetry);
    } catch (retryError) {
      if (
        !(retryError instanceof Anthropic.BadRequestError) ||
        retryError.message.includes("redemption temporarily unavailable")
      ) {
        throw retryError;
      }
      response = await client.beta.messages.create({ ...request, model: fallbackModel });
    }
  }
}

const { stop_reason, model } = response;
console.log(JSON.stringify({ stop_reason, model }));

var client = new AnthropicClient();
const string beta = "fallback-credit-2026-07-01";

List<BetaMessageParam> requestMessages =
[
    new() { Role = Role.User, Content = "Hello, Claude" },
];
MessageCreateParams Request(string model) => new()
{
    Model = model,
    MaxTokens = 1024,
    Messages = requestMessages,
    Betas = [beta],
};
var response = await client.Beta.Messages.Create(Request("claude-fable-5"));

if (
    response.StopReason == BetaStopReason.Refusal
    && response.StopDetails is { FallbackCreditToken: string token } details
)
{
    var exactBody = Request("claude-opus-4-8") with { FallbackCreditToken = token };
    var attempt = exactBody;
    // Prefer the continuation shape unless the claim is false
    if (details.FallbackHasPrefillClaim is not false)
    {
        var echoed = JsonArray.Create(response.RawData["content"])!;
        if (
            echoed is [.., JsonObject lastBlock]
            && lastBlock["type"]?.GetValue<string>() is "text"
            && lastBlock["text"]?.GetValue<string>() is string text
        )
        {
            lastBlock["text"] = text.TrimEnd();
        }
        attempt = exactBody with
        {
            Messages =
            [
                .. requestMessages,
                new()
                {
                    Role = Role.Assistant,
                    Content = new BetaMessageParamContent(
                        JsonSerializer.SerializeToElement(echoed)
                    ),
                },
            ],
        };
    }
    // A transient "redemption temporarily unavailable" rejection propagates out of
    // each of the following catch filters: retry with the token within its five-minute window.
    try
    {
        response = await client.Beta.Messages.Create(attempt);
    }
    catch (AnthropicBadRequestException e)
        when (!e.Message.Contains("redemption temporarily unavailable"))
    {
        try
        {
            // Fall back to the unchanged body, still with the token
            response = await client.Beta.Messages.Create(exactBody);
        }
        catch (AnthropicBadRequestException retryError)
            when (!retryError.Message.Contains("redemption temporarily unavailable"))
        {
            // The token itself was rejected: forfeit it and retry without.
            response = await client.Beta.Messages.Create(Request("claude-opus-4-8"));
        }
    }
}

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

ctx := context.Background()
client := anthropic.NewClient()

request := anthropic.BetaMessageNewParams{
	MaxTokens: 1024,
	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaFallbackCredit2026_07_01},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude")),
	},
}

send := func(model anthropic.Model, body anthropic.BetaMessageNewParams) (*anthropic.BetaMessage, error) {
	body.Model = model
	return client.Beta.Messages.New(ctx, body)
}
// A non-transient 400 means this attempt shape or token was rejected and
// the next rung of the ladder should run. "redemption temporarily
// unavailable" is transient: surface it and retry with the token within
// its five-minute window.
canFallBack := func(err error) bool {
	apiErr, ok := errors.AsType[*anthropic.Error](err)
	return ok && apiErr.StatusCode == 400 &&
		!strings.Contains(apiErr.Error(), "redemption temporarily unavailable")
}

response, err := send(anthropic.ModelClaudeFable5, request)
if err != nil {
	log.Fatal(err)
}

if response.StopReason == anthropic.BetaStopReasonRefusal {
	details := response.StopDetails
	if token := details.FallbackCreditToken; token != "" {
		exactBody := request
		exactBody.FallbackCreditToken = anthropic.BetaMessageNewParamsFallbackCreditTokenUnion{
			OfString: anthropic.String(token),
		}
		attempt := exactBody
		// Prefer the continuation shape unless the claim is false
		if details.FallbackHasPrefillClaim || !details.JSON.FallbackHasPrefillClaim.Valid() {
			echoed := response.ToParam()
			if len(echoed.Content) > 0 {
				if text := echoed.Content[len(echoed.Content)-1].OfText; text != nil {
					text.Text = strings.TrimRightFunc(text.Text, unicode.IsSpace)
				}
			}
			attempt.Messages = append(slices.Clone(request.Messages), echoed)
		}
		response, err = send(anthropic.ModelClaudeOpus4_8, attempt)
		if err != nil && canFallBack(err) {
			// Fall back to the unchanged body, still with the token
			response, err = send(anthropic.ModelClaudeOpus4_8, exactBody)
			if err != nil && canFallBack(err) {
				// The token itself was rejected: forfeit it and retry without.
				response, err = send(anthropic.ModelClaudeOpus4_8, request)
			}
		}
		if err != nil {
			log.Fatal(err)
		}
	}
}

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

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

MessageCreateParams.Builder request() {
    return MessageCreateParams.builder()
        .maxTokens(1024L)
        .addUserMessage("Hello, Claude")
        .addBeta(AnthropicBeta.FALLBACK_CREDIT_2026_07_01);
}

BetaMessage send(Model model, MessageCreateParams.Builder body) {
    return client.beta().messages().create(body.model(model).build());
}

void main() {
    BetaMessage response = send(Model.CLAUDE_FABLE_5, request());

    if (response.stopReason().map(BetaStopReason.REFUSAL::equals).orElse(false)
            && response.stopDetails().orElse(null) instanceof BetaRefusalStopDetails details
            && details.fallbackCreditToken().orElse(null) instanceof String creditToken) {
        MessageCreateParams.Builder attempt = request().fallbackCreditToken(creditToken);
        // Prefer the continuation shape unless the claim is false
        if (details.fallbackHasPrefillClaim().orElse(true)) {
            List<BetaContentBlockParam> echoed = new ArrayList<>(
                response.content().stream().map(BetaContentBlock::toParam).toList());
            if (!echoed.isEmpty() && echoed.getLast().isText()) {
                var lastText = echoed.removeLast().asText();
                echoed.addLast(BetaContentBlockParam.ofText(
                    lastText.toBuilder().text(lastText.text().stripTrailing()).build()));
            }
            attempt.addAssistantMessageOfBetaContentBlockParams(echoed);
        }
        try {
            response = send(Model.CLAUDE_OPUS_4_8, attempt);
        } catch (BadRequestException badRequest) {
            // Transient: retry with the token within its five-minute window
            if (badRequest.getMessage().contains("redemption temporarily unavailable")) {
                throw badRequest;
            }
            try {
                // Fall back to the unchanged body, still with the token
                response = send(Model.CLAUDE_OPUS_4_8, request().fallbackCreditToken(creditToken));
            } catch (BadRequestException retryBadRequest) {
                if (retryBadRequest.getMessage().contains("redemption temporarily unavailable")) {
                    throw retryBadRequest;
                }
                // The token itself was rejected: forfeit it and retry without.
                response = send(Model.CLAUDE_OPUS_4_8, request());
            }
        }
    }

    IO.println("""
        {"stop_reason": "%s", "model": "%s"}"""
        .formatted(response.stopReason().orElseThrow(), response.model()));
}

$client = new Client();
$beta = 'fallback-credit-2026-07-01';
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];

$send = fn (string $model, array $messages, ?string $token = null) => $client->beta->messages->create(
    maxTokens: 1024,
    messages: $messages,
    model: $model,
    fallbackCreditToken: $token,
    betas: [$beta],
);
$response = $send('claude-fable-5', $messages);

$token = $response->stopReason === 'refusal'
    ? $response->stopDetails?->fallbackCreditToken
    : null;

if ($token !== null) {
    $attemptMessages = $messages;
    // Prefer the continuation shape unless the claim is false
    if ($response->stopDetails->fallbackHasPrefillClaim !== false) {
        $echoed = $response->content
            |> json_encode(...)
            |> (fn (string $json): array => json_decode($json, associative: true));
        $lastIndex = array_key_last($echoed);
        if ($lastIndex !== null && $echoed[$lastIndex]['type'] === 'text') {
            $echoed[$lastIndex]['text'] = rtrim($echoed[$lastIndex]['text']);
        }
        $attemptMessages[] = ['role' => 'assistant', 'content' => $echoed];
    }
    // Transient: retry with the token within its five-minute window
    $isTransientRedemption = fn (BadRequestException $error): bool =>
        str_contains($error->getMessage(), 'redemption temporarily unavailable');
    try {
        $response = $send('claude-opus-4-8', $attemptMessages, $token);
    } catch (BadRequestException $error) {
        if ($isTransientRedemption($error)) {
            throw $error;
        }
        try {
            // Fall back to the unchanged body, still with the token
            $response = $send('claude-opus-4-8', $messages, $token);
        } catch (BadRequestException $retryError) {
            if ($isTransientRedemption($retryError)) {
                throw $retryError;
            }
            // The token itself was rejected: forfeit it and retry without.
            $response = $send('claude-opus-4-8', $messages);
        }
    }
}

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

client = Anthropic::Client.new

request = {
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}]
}

send_message = ->(model, body) do
  client.beta.messages.create(model:, betas: ["fallback-credit-2026-07-01"], **body)
end

response = send_message.call("claude-fable-5", request)

if response in {stop_reason: :refusal,
                stop_details: {fallback_credit_token: String => credit_token} => details}
  exact_body = request.merge(fallback_credit_token: credit_token)

  # Prefer the continuation shape unless the claim is false
  attempt = if details.fallback_has_prefill_claim != false
    echoed = response.content.map(&:to_h)
    if echoed.last in {type: :text, text: String => final_text}
      echoed[-1] = echoed.last.merge(text: final_text.rstrip)
    end
    exact_body.merge(
      messages: [*request[:messages], {role: "assistant", content: echoed}]
    )
  else
    exact_body
  end

  begin
    response = send_message.call("claude-opus-4-8", attempt)
  rescue Anthropic::Errors::BadRequestError => error
    # Transient: retry with the token within its five-minute window
    raise if error.message.include?("redemption temporarily unavailable")
    begin
      # Fall back to the unchanged body, still with the token
      response = send_message.call("claude-opus-4-8", exact_body)
    rescue Anthropic::Errors::BadRequestError => error
      # Transient: retry with the token within its five-minute window
      raise if error.message.include?("redemption temporarily unavailable")
      # The token itself was rejected: forfeit it and retry without.
      response = send_message.call("claude-opus-4-8", request)
    end
  end
end

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