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: server-side-fallback-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-fable-5",
      "max_tokens": 1024,
      "fallbacks": "default",
      "messages": [{"role": "user", "content": "Hello, Haijun"}]
    }'

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

  client = Juglow()

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

  const client = new Juglow();

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

  JuglowClient client = new();

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

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

  client := juglow.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), juglow.BetaMessageNewParams{
  	Model:     juglow.ModelHaijunFable5,
  	MaxTokens: 1024,
  	Messages: []juglow.BetaMessageParam{
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello, Haijun")),
  	},
  	Fallbacks: juglow.BetaFallbacksParamOfDefault(),
  	Betas:     []juglow.JuglowBeta{juglow.JuglowBetaServerSideFallback2026_07_01},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Println(response.Model)

  JuglowClient client = JuglowOkHttpClient.fromEnv();

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

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

  $client = new Client();

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

  echo $response->model, PHP_EOL;

  client = Juglow::Client.new

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

  puts response.model

{
  "id": "msg_01XFUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "model": "haijun-fable-5",
  "content": [],
  "stop_reason": "refusal",
  "stop_details": {
    "type": "refusal",
    "category": "cyber",
    "explanation": "This request was declined because it could enable cyber harm."
  },
  "usage": {
    "input_tokens": 412,
    "output_tokens": 0
  }
}

  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: server-side-fallback-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-fable-5",
      "max_tokens": 1024,
      "fallbacks": "default",
      "messages": [{"role": "user", "content": "Hello, Haijun"}]
    }' |
    jq -c '{
      stop_reason,
      model,
      # Entri fallback_message di usage.iterations berarti model fallback dijalankan;
      # pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
      served_by_fallback: (
        any(.usage.iterations[]?; .type == "fallback_message")
        and .stop_reason != "refusal"
      )
    }'

  ant beta:messages create \
    --model haijun-fable-5 \
    --max-tokens 1024 \
    --message '{"role":"user","content":"Hello, Haijun"}' \
    --fallbacks default \
    --beta server-side-fallback-2026-07-01 \
    --format json |
    jq -c '{
      stop_reason,
      model,
      # Entri fallback_message di usage.iterations berarti model fallback dijalankan;
      # pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
      served_by_fallback: (
        any(.usage.iterations[]?; .type == "fallback_message")
        and .stop_reason != "refusal"
      )
    }'

  client = Juglow()

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

  # Entri fallback_message dalam usage.iterations berarti model fallback dijalankan;
  # pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
  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 Juglow();

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

  // Entri fallback_message di usage.iterations berarti model fallback dijalankan;
  // pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
  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
    })
  );

  JuglowClient client = new();

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

  // Entri fallback_message di usage.iterations berarti model fallback dijalankan;
  // pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
  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 := juglow.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), juglow.BetaMessageNewParams{
  	Model:     juglow.ModelHaijunFable5,
  	MaxTokens: 1024,
  	Messages: []juglow.BetaMessageParam{
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello, Haijun")),
  	},
  	Fallbacks: juglow.BetaFallbacksParamOfDefault(),
  	Betas:     []juglow.JuglowBeta{juglow.JuglowBetaServerSideFallback2026_07_01},
  })
  if err != nil {
  	panic(err)
  }

  // Entri fallback_message di usage.iterations berarti model fallback dijalankan;
  // pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
  fallbackRan := slices.ContainsFunc(
  	response.Usage.Iterations,
  	func(iteration juglow.BetaIterationsUsageItemUnion) bool {
  		_, isFallback := iteration.AsAny().(juglow.BetaFallbackMessageIterationUsage)
  		return isFallback
  	},
  )
  servedByFallback := fallbackRan && response.StopReason != juglow.BetaStopReasonRefusal

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

  JuglowClient client = JuglowOkHttpClient.fromEnv();

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

  // Entri usage fallback_message berarti model fallback yang menghasilkan
  // respons; stop reason refusal berarti tidak ada model yang melayaninya.
  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, Haijun']],
      model: 'haijun-fable-5',
      fallbacks: 'default',
      betas: ['server-side-fallback-2026-07-01'],
  );

  // Entri fallback_message di usage.iterations berarti model fallback dijalankan;
  // pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
  $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 = Juglow::Client.new

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

  # Entri fallback_message di usage.iterations berarti model fallback dijalankan;
  # pasangkan dengan stop_reason untuk memastikan fallback yang melayani respons.
  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:})

  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: server-side-fallback-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-fable-5",
      "max_tokens": 1024,
      "fallbacks": [{"model": "haijun-opus-4-8"}],
      "messages": [{"role": "user", "content": "Hello, Haijun"}]
    }'

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

  client = Juglow()

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

  const client = new Juglow();

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

  JuglowClient client = new();

  BetaMessage response = await client.Beta.Messages.Create(
      new()
      {
          Model = Messages::Model.HaijunFable5,
          MaxTokens = 1024,
          Messages = [new() { Content = "Hello, Haijun", Role = Role.User }],
          Fallbacks = new([new(Messages::Model.HaijunOpus4_8)]),
          Betas = [JuglowBeta.ServerSideFallback2026_07_01],
      }
  );

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

  client := juglow.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), juglow.BetaMessageNewParams{
  	Model:     juglow.ModelHaijunFable5,
  	MaxTokens: 1024,
  	Messages: []juglow.BetaMessageParam{
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello, Haijun")),
  	},
  	Fallbacks: juglow.BetaFallbacksParamUnion{
  		OfBetaFallbackArray: []juglow.BetaFallbackParam{{Model: juglow.ModelHaijunOpus4_8}},
  	},
  	Betas: []juglow.JuglowBeta{juglow.JuglowBetaServerSideFallback2026_07_01},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Println(response.Model)

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
      .model(Model.HAIJUN_FABLE_5)
      .maxTokens(1024L)
      .addUserMessage("Hello, Haijun")
      .fallbacksOfFallbackParams(List.of(BetaFallbackParam.builder()
          .model(Model.HAIJUN_OPUS_4_8)
          .build()))
      .addBeta(JuglowBeta.SERVER_SIDE_FALLBACK_2026_07_01)
      .build());

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

  $client = new Client();

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

  echo $response->model, PHP_EOL;

  client = Juglow::Client.new

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

  puts response.model

{
  "id": "msg_01XFUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "model": "haijun-opus-4-8",
  "content": [
    {
      "type": "fallback",
      "from": { "model": "haijun-fable-5" },
      "to": { "model": "haijun-opus-4-8" }
    },
    { "type": "text", "text": "Hi! How can I help you today?" }
  ],
  "stop_reason": "end_turn",
  "stop_details": null,
  "usage": {
    "input_tokens": 412,
    "output_tokens": 264,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0,
    "iterations": [
      {
        "type": "message",
        "model": "haijun-fable-5",
        "input_tokens": 535,
        "output_tokens": 0,
        "cache_read_input_tokens": 0,
        "cache_creation_input_tokens": 0
      },
      {
        "type": "fallback_message",
        "model": "haijun-opus-4-8",
        "input_tokens": 412,
        "output_tokens": 264,
        "cache_read_input_tokens": 0,
        "cache_creation_input_tokens": 0
      }
    ]
  }
}

  # Middleware refusal-fallback adalah fitur SDK. Lihat
  # bagian fallback sisi server untuk pendekatan permintaan tunggal yang setara,
  # atau halaman kredit fallback untuk pola retry HTTP mentah.

  # Middleware refusal-fallback adalah fitur SDK. Lihat
  # bagian fallback sisi server untuk pendekatan permintaan tunggal yang setara,
  # atau halaman kredit fallback untuk pola percobaan ulang HTTP mentah.

  from juglow import Juglow, BetaFallbackState, BetaRefusalFallbackMiddleware

  # Saat terjadi penolakan, middleware mencoba ulang pada model fallback yang terdaftar dan
  # secara otomatis mengirim header beta fallback-credit pada setiap permintaan yang ditanganinya.
  client = Juglow(
      middleware=[BetaRefusalFallbackMiddleware([{"model": "haijun-opus-4-8"}])],
  )

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

  # Streaming: saat terjadi penolakan, middleware mencoba ulang pada model fallback dan
  # menyambungkan event-nya ke stream yang sedang terbuka.
  with (
      state,
      client.beta.messages.stream(
          max_tokens=1024,
          model="haijun-fable-5",
          messages=[{"role": "user", "content": "Hello, Haijun"}],
      ) 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: menggunakan kembali state menjaga percakapan tetap terpatok.
  with state:
      message = client.beta.messages.create(
          max_tokens=1024,
          model="haijun-fable-5",
          messages=[{"role": "user", "content": "Hello, Haijun"}],
      )
  print(f"served by: {message.model}")

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

  // Saat terjadi penolakan, middleware mencoba ulang pada model fallback yang tercantum dan
  // secara otomatis mengirim header beta fallback-credit pada setiap permintaan yang ditanganinya.
  const client = new Juglow({
    middleware: [betaRefusalFallbackMiddleware([{ model: "haijun-opus-4-8" }])]
  });

  // Bagikan satu state di seluruh percakapan agar permintaan lanjutan tetap
  // terikat pada model yang menerima.
  const fallbackState = new BetaFallbackState();

  // Streaming: saat terjadi penolakan, middleware mencoba ulang pada model fallback dan
  // menyambungkan event-nya ke stream yang terbuka.
  const stream = client.beta.messages
    .stream(
      {
        max_tokens: 1024,
        model: "haijun-fable-5",
        messages: [{ role: "user", content: "Hello, Haijun" }]
      },
      { fallbackState }
    )
    .on("text", (text) => process.stdout.write(text));

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

  // Non-streaming: menggunakan kembali state menjaga percakapan tetap terikat.
  const message = await client.beta.messages.create(
    {
      max_tokens: 1024,
      model: "haijun-fable-5",
      messages: [{ role: "user", content: "Hello, Haijun" }]
    },
    { fallbackState }
  );
  console.log("served by:", message.model);

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

  // Saat terjadi penolakan, handler mencoba ulang pada model fallback yang terdaftar dan
  // secara otomatis mengirim header beta fallback-credit pada setiap permintaan yang ditanganinya.
  JuglowClient client = new()
  {
      Handlers =
      [
          new BetaRefusalFallbackHandler { Fallbacks = [new(Messages::Model.HaijunOpus4_8)] },
      ],
  };

  // Menyematkan permintaan lanjutan yang berbagi state ini ke model yang menerima.
  BetaFallbackState fallbackState = BetaFallbackState.Create();

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

  // Streaming: jika stream berakhir dengan penolakan, handler menyambungkan event
  // model fallback ke stream yang masih terbuka.
  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: menggunakan ulang state menjaga percakapan tetap tersemat pada model yang menerima.
  using (fallbackState.Use())
  {
      BetaMessage message = await client.Beta.Messages.Create(parameters);
      Console.WriteLine($"served by: {message.Model.Raw()}");
  }

  import (
  // ...
  	"github.com/juglows/juglow-sdk-go/lib/betafallback"
  // ...
  )

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

  	// Middleware mencoba ulang permintaan yang ditolak pada setiap model fallback secara
  	// bergiliran, dan otomatis mengikutsertakan permintaan ke beta fallback-credit.
  	client := juglow.NewClient(
  		option.WithMiddleware(betafallback.BetaRefusalFallbackMiddleware(
  			[]juglow.BetaFallbackParam{{Model: juglow.ModelHaijunOpus4_8}},
  		)),
  	)

  	// Satu state per percakapan: permintaan yang berbagi state tetap terikat pada
  	// model yang menerima, sehingga tindak lanjut tak pernah menanyai ulang model yang menolak.
  	state := &betafallback.BetaFallbackState{}
  	conversation := betafallback.WithBetaFallbackState(state)

  	params := juglow.BetaMessageNewParams{
  		MaxTokens: 1024,
  		Model:     juglow.ModelHaijunFable5,
  		Messages: []juglow.BetaMessageParam{
  			juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello, Haijun")),
  		},
  	}

  	// Streaming: saat ada penolakan, middleware mencoba ulang di tempat, menyambungkan
  	// event model fallback ke stream yang terbuka sebagai satu pesan berkelanjutan.
  	stream := client.Beta.Messages.NewStreaming(ctx, params, conversation)
  	defer stream.Close()
  	var streamed juglow.BetaMessage
  	for stream.Next() {
  		event := stream.Current()
  		if err := streamed.Accumulate(event); err != nil {
  			panic(err)
  		}
  		switch eventVariant := event.AsAny().(type) {
  		case juglow.BetaRawContentBlockDeltaEvent:
  			if textDelta, ok := eventVariant.Delta.AsAny().(juglow.BetaTextDelta); ok {
  				fmt.Print(textDelta.Text)
  			}
  		}
  	}
  	if err := stream.Err(); err != nil {
  		panic(err)
  	}
  	fmt.Println("\nserved by:", streamed.Model)

  	// Non-streaming: state bersama mengikat tindak lanjut ini ke model yang
  	// melayani giliran yang di-stream.
  	message, err := client.Beta.Messages.New(ctx, params, conversation)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println("served by:", message.Model)
  }

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.core.RequestOptions;
  import com.juglow.core.http.StreamResponse;
  import com.juglow.helpers.BetaFallbackState;
  import com.juglow.helpers.BetaMessageAccumulator;
  import com.juglow.helpers.BetaRefusalFallbackInterceptor;
  import com.juglow.models.beta.messages.BetaMessage;
  import com.juglow.models.beta.messages.BetaRawMessageStreamEvent;
  import com.juglow.models.beta.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;

  void main() {
      // Interceptor mencoba ulang permintaan yang ditolak pada model fallback. Secara otomatis
      // menambahkan header beta fallback-credit ke setiap permintaan yang ditanganinya.
      JuglowClient client = JuglowOkHttpClient.builder()
          .fromEnv()
          .addInterceptor(BetaRefusalFallbackInterceptor.builder()
              .addFallback(Model.HAIJUN_OPUS_4_8)
              .build())
          .build();

      // Bagikan satu state di seluruh permintaan agar tindak lanjut tetap terikat pada model yang menerima.
      BetaFallbackState state = BetaFallbackState.create();

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

      // Streaming: saat penolakan, event model fallback disambungkan ke stream yang terbuka.
      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: menggunakan kembali state yang sama menjaga percakapan tetap terikat.
      BetaMessage message = client.beta()
          .messages()
          .create(params, RequestOptions.builder().fallbackState(state).build());
      IO.println("served by: " + message.model().asString());
  }

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

  // Konfigurasikan rantai fallback sekali saja. Saat terjadi penolakan, middleware mencoba ulang
  // permintaan ke bawah rantai dan mengirim header beta fallback-credit untuk Anda.
  $client = new Client(
      requestOptions: [
          'middleware' => [new RefusalFallbackMiddleware([['model' => 'haijun-opus-4-8']])],
      ],
  );

  // Bagikan satu state di seluruh percakapan agar permintaan lanjutan tetap terikat
  // pada model yang menerima.
  $state = new BetaFallbackState();

  // Streaming: saat terjadi penolakan, middleware menyambungkan event model fallback
  // ke stream yang masih terbuka. Model pada accumulator adalah model yang melayani.
  $stream = $client->beta->messages->createStream(
      model: 'haijun-fable-5',
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello, Haijun']],
      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: middleware yang sama. Menggunakan ulang state menjaga percakapan
  // tetap terikat pada model yang menerima.
  $message = $client->beta->messages->create(
      model: 'haijun-fable-5',
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello, Haijun']],
      requestOptions: ['fallbackState' => $state],
  );
  echo "served by: {$message->model}\n";

  # Saat terjadi penolakan, middleware mencoba ulang permintaan ke bawah rantai fallback.
  # Middleware mengirim header beta fallback-credit pada setiap permintaan yang ditanganinya.
  client = Juglow::Client.new(
    middleware: [Juglow::BetaRefusalFallbackMiddleware.new([{model: "haijun-opus-4-8"}])]
  )

  # Bagikan satu state di seluruh percakapan agar permintaan lanjutan tetap
  # terikat pada model yang menerima.
  state = Juglow::BetaFallbackState.new

  # Streaming: saat terjadi penolakan, middleware menyambungkan event dari model fallback
  # ke stream yang masih terbuka.
  stream = client.beta.messages.stream(
    model: "haijun-fable-5",
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Haijun"}],
    request_options: {fallback_state: state}
  )
  stream.text.each { print it }
  puts "\nserved by: #{stream.accumulated_message.model}"

  # Non-streaming: menggunakan ulang state menjaga percakapan tetap terikat pada model yang menerima.
  message = client.beta.messages.create(
    model: "haijun-fable-5",
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Haijun"}],
    request_options: {fallback_state: state}
  )
  puts "served by: #{message.model}"