# Permintaan awal (mungkin ditolak)
  response=$(curl --fail-with-body -sS https://haijun.my.id/v1/messages \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: fallback-credit-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-fable-5",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Haijun"}]
    }')

  # Penolakan membawa token kredit sekali pakai di stop_details
  token=$(jq -r '.stop_details.fallback_credit_token // empty' <<<"${response}")

  if [[ -n "${token}" ]]; then
    # Coba lagi pada model cadangan dengan token kredit (body yang sama)
    response=$(curl --fail-with-body -sS https://haijun.my.id/v1/messages \
      -H "x-api-key: $JUGLOW_API_KEY" \
      -H "juglow-version: 2023-06-01" \
      -H "juglow-beta: fallback-credit-2026-07-01" \
      -H "content-type: application/json" \
      -d "$(jq -n --arg token "${token}" '{
        model: "haijun-opus-4-8",
        max_tokens: 1024,
        messages: [{"role": "user", "content": "Hello, Haijun"}],
        fallback_credit_token: $token
      }')")
  fi

  # Lihat contoh SDK untuk tangga penanganan penolakan yang lengkap.
  jq -c '{stop_reason, model}' <<<"${response}"

  # Permintaan awal (mungkin ditolak)
  response=$(ant beta:messages create \
    --model haijun-fable-5 \
    --max-tokens 1024 \
    --message '{"role":"user","content":"Hello, Haijun"}' \
    --beta fallback-credit-2026-07-01 \
    --format json)

  # Penolakan membawa token kredit sekali pakai di stop_details
  token=$(jq -r '.stop_details.fallback_credit_token // empty' <<<"${response}")

  if [[ -n "${token}" ]]; then
    # Coba lagi pada model cadangan dengan token kredit
    response=$(ant beta:messages create \
      --model haijun-opus-4-8 \
      --max-tokens 1024 \
      --message '{"role":"user","content":"Hello, Haijun"}' \
      --fallback-credit-token "${token}" \
      --beta fallback-credit-2026-07-01 \
      --format json)
  fi

  # Lihat contoh SDK untuk tahapan penanganan penolakan yang lengkap.
  jq -c '{stop_reason, model}' <<<"${response}"

  client = Juglow()

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

  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("haijun-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}
      # Utamakan bentuk continuation kecuali claim bernilai 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("haijun-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:
              # Kembali ke body yang tidak diubah, tetap dengan token
              response = send("haijun-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
              # Token itu sendiri ditolak: lepaskan dan coba lagi tanpanya.
              response = send("haijun-opus-4-8", request)

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

  const client = new Juglow();

  const request: Juglow.Beta.MessageCreateParamsNonStreaming = {
    model: "haijun-fable-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Haijun" }],
    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 = "haijun-opus-4-8";

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

    // Bentuk terkaya lebih dulu, menurun pada setiap penolakan: bentuk
    // continuation (kecuali klaimnya salah), body tak berubah yang masih membawa
    // token, dan terakhir melepaskan token.
    let attempt = exactRetry;
    if (fallback_has_prefill_claim !== false) {
      const finalBlock = response.content.at(-1);
      const echoed: Juglow.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) {
      // Turunkan hanya pada 400 terkait bentuk. "redemption temporarily
      // unavailable" bersifat sementara: coba lagi dengan cara yang sama dalam
      // jendela lima menit token tersebut.
      if (
        !(error instanceof Juglow.BadRequestError) ||
        error.message.includes("redemption temporarily unavailable")
      ) {
        throw error;
      }
      try {
        response = await client.beta.messages.create(exactRetry);
      } catch (retryError) {
        if (
          !(retryError instanceof Juglow.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 JuglowClient();
  const string beta = "fallback-credit-2026-07-01";

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

  if (
      response.StopReason == BetaStopReason.Refusal
      && response.StopDetails is { FallbackCreditToken: string token } details
  )
  {
      var exactBody = Request("haijun-opus-4-8") with { FallbackCreditToken = token };
      var attempt = exactBody;
      // Utamakan bentuk kelanjutan kecuali klaimnya salah
      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)
                      ),
                  },
              ],
          };
      }
      // Penolakan sementara "redemption temporarily unavailable" diteruskan keluar dari
      // setiap filter catch berikut: coba lagi dengan token dalam jendela lima menitnya.
      try
      {
          response = await client.Beta.Messages.Create(attempt);
      }
      catch (JuglowBadRequestException e)
          when (!e.Message.Contains("redemption temporarily unavailable"))
      {
          try
          {
              // Kembali ke body yang tidak diubah, tetap dengan token
              response = await client.Beta.Messages.Create(exactBody);
          }
          catch (JuglowBadRequestException retryError)
              when (!retryError.Message.Contains("redemption temporarily unavailable"))
          {
              // Token itu sendiri ditolak: lepaskan dan coba lagi tanpanya.
              response = await client.Beta.Messages.Create(Request("haijun-opus-4-8"));
          }
      }
  }

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

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

  request := juglow.BetaMessageNewParams{
  	MaxTokens: 1024,
  	Betas:     []juglow.JuglowBeta{juglow.JuglowBetaFallbackCredit2026_07_01},
  	Messages: []juglow.BetaMessageParam{
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello, Haijun")),
  	},
  }

  send := func(model juglow.Model, body juglow.BetaMessageNewParams) (*juglow.BetaMessage, error) {
  	body.Model = model
  	return client.Beta.Messages.New(ctx, body)
  }
  // 400 yang tidak sementara berarti bentuk percobaan atau token ini ditolak dan
  // anak tangga berikutnya harus dijalankan. "redemption temporarily
  // unavailable" bersifat sementara: tampilkan dan coba lagi dengan token dalam
  // jendela lima menitnya.
  canFallBack := func(err error) bool {
  	apiErr, ok := errors.AsType[*juglow.Error](err)
  	return ok && apiErr.StatusCode == 400 &&
  		!strings.Contains(apiErr.Error(), "redemption temporarily unavailable")
  }

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

  if response.StopReason == juglow.BetaStopReasonRefusal {
  	details := response.StopDetails
  	if token := details.FallbackCreditToken; token != "" {
  		exactBody := request
  		exactBody.FallbackCreditToken = juglow.BetaMessageNewParamsFallbackCreditTokenUnion{
  			OfString: juglow.String(token),
  		}
  		attempt := exactBody
  		// Utamakan bentuk lanjutan kecuali klaimnya salah
  		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(juglow.ModelHaijunOpus4_8, attempt)
  		if err != nil && canFallBack(err) {
  			// Kembali ke body yang tidak diubah, tetap dengan token
  			response, err = send(juglow.ModelHaijunOpus4_8, exactBody)
  			if err != nil && canFallBack(err) {
  				// Token itu sendiri ditolak: lepaskan dan coba lagi tanpanya.
  				response, err = send(juglow.ModelHaijunOpus4_8, request)
  			}
  		}
  		if err != nil {
  			log.Fatal(err)
  		}
  	}
  }

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

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  MessageCreateParams.Builder request() {
      return MessageCreateParams.builder()
          .maxTokens(1024L)
          .addUserMessage("Hello, Haijun")
          .addBeta(JuglowBeta.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.HAIJUN_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);
          // Utamakan bentuk lanjutan kecuali klaimnya salah
          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.HAIJUN_OPUS_4_8, attempt);
          } catch (BadRequestException badRequest) {
              // Sementara: coba lagi dengan token dalam jendela lima menitnya
              if (badRequest.getMessage().contains("redemption temporarily unavailable")) {
                  throw badRequest;
              }
              try {
                  // Kembali ke body yang tidak diubah, tetap dengan token
                  response = send(Model.HAIJUN_OPUS_4_8, request().fallbackCreditToken(creditToken));
              } catch (BadRequestException retryBadRequest) {
                  if (retryBadRequest.getMessage().contains("redemption temporarily unavailable")) {
                      throw retryBadRequest;
                  }
                  // Token itu sendiri ditolak: lepaskan dan coba lagi tanpanya.
                  response = send(Model.HAIJUN_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, Haijun']];

  $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('haijun-fable-5', $messages);

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

  if ($token !== null) {
      $attemptMessages = $messages;
      // Utamakan bentuk lanjutan kecuali klaimnya salah
      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];
      }
      // Sementara: coba lagi dengan token dalam jendela lima menitnya
      $isTransientRedemption = fn (BadRequestException $error): bool =>
          str_contains($error->getMessage(), 'redemption temporarily unavailable');
      try {
          $response = $send('haijun-opus-4-8', $attemptMessages, $token);
      } catch (BadRequestException $error) {
          if ($isTransientRedemption($error)) {
              throw $error;
          }
          try {
              // Kembali ke body yang tidak diubah, tetap dengan token
              $response = $send('haijun-opus-4-8', $messages, $token);
          } catch (BadRequestException $retryError) {
              if ($isTransientRedemption($retryError)) {
                  throw $retryError;
              }
              // Token itu sendiri ditolak: lepaskan dan coba lagi tanpanya.
              $response = $send('haijun-opus-4-8', $messages);
          }
      }
  }

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

  client = Juglow::Client.new

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

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

  response = send_message.call("haijun-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)

    # Utamakan bentuk lanjutan kecuali klaimnya salah
    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("haijun-opus-4-8", attempt)
    rescue Juglow::Errors::BadRequestError => error
      # Sementara: coba lagi dengan token dalam jendela lima menitnya
      raise if error.message.include?("redemption temporarily unavailable")
      begin
        # Kembali ke body yang tidak diubah, tetap dengan token
        response = send_message.call("haijun-opus-4-8", exact_body)
      rescue Juglow::Errors::BadRequestError => error
        # Sementara: coba lagi dengan token dalam jendela lima menitnya
        raise if error.message.include?("redemption temporarily unavailable")
        # Token itu sendiri ditolak: lepaskan dan coba lagi tanpanya.
        response = send_message.call("haijun-opus-4-8", request)
      end
    end
  end

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