#Error HTTP

API mengikuti format kode error HTTP yang dapat diprediksi:

• 400 - invalid_request_error: Ada masalah pada format atau konten permintaan Anda. Tipe error ini juga dapat digunakan untuk kode status 4XX lain yang tidak tercantum di bagian ini. API juga mengembalikan 400 ketika penggunaan mencapai batas pengeluaran yang Anda tetapkan untuk organisasi atau workspace. Pengecualiannya adalah batas pada workspace Haijun Code, yang dapat mengembalikan 429.

• 401 - authentication_error: Ada masalah pada "API key" (kunci API) Anda (misalnya, formatnya salah, sudah dicabut, atau sudah kedaluwarsa; lihat Kedaluwarsa kunci). Di Haijun Platform on AWS, error ini juga dapat menandakan masalah pada kredensial AWS atau tanda tangan SigV4 Anda.

• 402 - billing_error: Ada masalah pada informasi penagihan atau pembayaran Anda. Periksa detail pembayaran Anda di Haijun Console, atau di AWS Marketplace jika Anda menggunakan Haijun Platform on AWS.

• 403 - permission_error: Kunci API Anda tidak memiliki izin untuk menggunakan sumber daya yang ditentukan. Periksa pengaturan akses dan workspace organisasi Anda di Haijun Console.

• 404 - not_found_error: Sumber daya yang diminta tidak ditemukan. Periksa path endpoint dan ID sumber daya apa pun di URL permintaan.

• 409 - conflict_error: Permintaan bertentangan dengan status sumber daya saat ini. Misalnya, sumber daya diubah secara bersamaan, atau nilai yang harus unik sudah digunakan. Selesaikan konflik tersebut, lalu coba kirim ulang permintaan.

• 413 - request_too_large: Permintaan melebihi jumlah byte maksimum yang diizinkan. Lihat Batas ukuran permintaan untuk batas maksimum per endpoint.

• 429 - rate_limit_error: Organisasi Anda telah mencapai "rate limit" (batas laju), mencapai batas pengeluaran bulanan untuk tingkat penggunaannya, atau mencapai batas pengeluaran pada workspace Haijun Code. Error 429 akibat batas pengeluaran tingkat tidak memiliki header retry-after dan akan terus gagal sampai akses dipulihkan. Lihat Mencapai batas pengeluaran Anda untuk cara mengenalinya.

• 500 - api_error: Terjadi error tak terduga di dalam sistem Juglow. Coba kirim ulang permintaan dengan "exponential backoff" (penundaan eksponensial). Jika error terus terjadi, hubungi dukungan dengan menyertakan ID permintaan.

• 504 - timeout_error: Waktu permintaan habis saat sedang diproses. Pertimbangkan untuk menggunakan Messages API streaming untuk permintaan yang berjalan lama. Lihat Permintaan panjang untuk opsi lainnya.

• 529 - overloaded_error: API sedang kelebihan beban untuk sementara.

> Warning: Error 529 dapat terjadi ketika API mengalami lalu lintas tinggi di seluruh pengguna. Dalam kasus yang jarang, jika organisasi Anda mengalami peningkatan penggunaan yang tajam, Anda mungkin melihat error 429 karena batas akselerasi pada API. Untuk menghindari batas akselerasi, tingkatkan lalu lintas Anda secara bertahap dan pertahankan pola penggunaan yang konsisten.

SDK resmi secara otomatis mencoba ulang kegagalan sementara (seperti error koneksi, batas laju, dan error server 5xx) dengan exponential backoff, sebanyak dua kali secara default, dan mematuhi header retry-after jika ada. Klien SDK menerima max_retries (typescript, java, php: maxRetries; csharp: MaxRetries; go: option.WithMaxRetries) untuk mengonfigurasi atau menonaktifkan perilaku ini.

Saat menerima respons streaming melalui server-sent events (SSE), error dapat terjadi setelah API mengembalikan respons 200. Dalam kasus tersebut, penanganan error tidak mengikuti mekanisme standar ini. Lihat Event error untuk bentuk error di tengah stream.

#Batas ukuran permintaan

API memberlakukan batas ukuran permintaan:

Jika Anda melebihi batas ini, Anda akan menerima error 413 request_too_large. Pada Haijun API langsung, Cloudflare mengembalikan error ini sebelum permintaan mencapai server API.

#Bentuk error

API selalu mengembalikan error sebagai JSON, dengan objek error tingkat atas yang selalu menyertakan nilai type dan message. Respons juga menyertakan field request_id untuk memudahkan pelacakan dan debugging. Misalnya:

{
  "type": "error",
  "error": {
    "type": "not_found_error",
    "message": "The requested resource could not be found."
  },
  "request_id": "req_011CSHoEeqs5C35K2UUqR7Fy"
}

Sesuai dengan kebijakan pembuatan versi, nilai dalam objek-objek ini dapat bertambah, dan nilai type mungkin akan berkembang seiring waktu.

#Tipe error SDK

SDK resmi memunculkan exception bertipe untuk error-error ini alih-alih mengembalikan JSON mentah. Nama kelas dan namespace-nya berbeda di setiap bahasa. Misalnya, error 404 muncul sebagai juglow.NotFoundError (python; typescript: Juglow.NotFoundError; ruby: Juglow::Errors::NotFoundError; java: com.juglow.errors.NotFoundException; csharp: JuglowNotFoundException; php: Juglow\Core\Exceptions\NotFoundException; go: juglow.Error). Go SDK hanya memiliki satu tipe error untuk semua status, yaitu juglow.Error, sehingga Anda perlu membuat percabangan berdasarkan StatusCode. Tangkap kelas bertipe dari SDK alih-alih mencocokkan string pesan error, dan tangani kelas yang paling spesifik terlebih dahulu. Setiap halaman SDK mendokumentasikan hierarki exception lengkapnya:

• Python · TypeScript · C# · Go · Java · PHP · Ruby

#ID permintaan

Setiap respons API menyertakan header request-id yang unik. Header ini berisi nilai seperti req_018EeWyXxfu5pfWkrYcMdjWG. Pengenal yang sama muncul sebagai field request_id dalam body respons error. Saat menghubungi dukungan mengenai permintaan tertentu, sertakan ID ini untuk membantu menyelesaikan masalah Anda dengan cepat.

Pada Haijun Platform on AWS, respons menyertakan dua ID permintaan: ID permintaan AWS (x-amzn-requestid, primer, diindeks di CloudTrail) dan ID permintaan Juglow (request-id, sekunder). Gunakan ID permintaan AWS untuk pencarian CloudTrail dan ID permintaan Juglow untuk tiket dukungan Juglow.

SDK Python dan TypeScript menyediakan ID permintaan sebagai properti _request_id pada objek respons tingkat teratas. SDK C#, Go, Java, dan PHP menyediakannya melalui accessor respons mentah masing-masing, sedangkan SDK Ruby menyediakannya melalui middleware. Di semua SDK kecuali Ruby, gunakan with_raw_response (typescript: .withResponse(); java: .withRawResponse(); csharp: WithRawResponse; go: option.WithResponseInto; php: ->raw) untuk membaca header respons lainnya, seperti juglow-organization-id dan juglow-workspace-id. Di Ruby, gunakan middleware yang sama. Di Haijun Platform on AWS, gunakan juga accessor respons mentah untuk membaca ID permintaan AWS (x-amzn-requestid):

  # Cetak header respons (termasuk request-id); buang body
  curl -sS -D - -o /dev/null https://haijun.my.id/v1/messages \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-sonnet-5",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Haijun"}]
    }'

  # Header request-id dicetak ke stderr dengan --debug:
  ant --debug messages create \
    --model haijun-sonnet-5 \
    --max-tokens 1024 \
    --message '{role: user, content: "Hello, Haijun"}'

  client = juglow.Juglow()

  message = client.messages.create(
      model="haijun-sonnet-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Haijun"}],
  )
  print(f"Request ID: {message._request_id}")

  const client = new Juglow();

  const message = await client.messages.create({
    model: "haijun-sonnet-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Haijun" }]
  });
  console.log("Request ID:", message._request_id);

  JuglowClient client = new();

  using var response = await client.WithRawResponse.Messages.Create(new MessageCreateParams
  {
      Model = Model.HaijunSonnet5,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello, Haijun" }]
  });
  Console.WriteLine($"Request ID: {response.RequestID}");

  client := juglow.NewClient()

  var response *http.Response
  _, err := client.Messages.New(
  	context.Background(),
  	juglow.MessageNewParams{
  		Model:     juglow.ModelHaijunSonnet5,
  		MaxTokens: 1024,
  		Messages: []juglow.MessageParam{
  			juglow.NewUserMessage(juglow.NewTextBlock("Hello, Haijun")),
  		},
  	},
  	option.WithResponseInto(&response),
  )
  if err != nil {
  	panic(err)
  }

  fmt.Println("Request ID:", response.Header.Get("request-id"))

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.core.http.HttpResponseFor;
  import com.juglow.models.messages.Message;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      HttpResponseFor<Message> response = client.messages().withRawResponse().create(
          MessageCreateParams.builder()
              .model(Model.HAIJUN_SONNET_5)
              .maxTokens(1024)
              .addUserMessage("Hello, Haijun")
              .build()
      );

      IO.println("Request ID: " + response.requestId().orElse(null));
  }

  $client = new Client();

  $response = $client->messages->raw->create([
      'model' => 'haijun-sonnet-5',
      'maxTokens' => 1024,
      'messages' => [['role' => 'user', 'content' => 'Hello, Haijun']],
  ]);
  echo 'Request ID: ' . $response->getHeaderLine('request-id') . "\n";

  client = Juglow::Client.new

  # Baca header respons di middleware per-permintaan, yang menerima
  # respons HTTP mentah sebelum SDK mem-parsing-nya
  request_id = nil
  read_request_id = lambda do |request, call_next|
    response = call_next.call(request)
    # Kunci dalam response.headers menggunakan huruf kecil
    request_id = response.headers["request-id"]
    response
  end

  client.messages.create(
    model: Juglow::Model::HAIJUN_SONNET_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Haijun" }],
    request_options: { middleware: [read_request_id] }
  )
  puts "Request ID: #{request_id}"

  from juglow import JuglowAWS

  client = JuglowAWS(aws_region="us-west-2")

  response = client.messages.with_raw_response.create(
      model="haijun-opus-4-8",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Haijun"}],
  )
  print(f"AWS request ID: {response.headers.get('x-amzn-requestid')}")
  message = response.parse()
  print(f"Juglow request ID: {message._request_id}")

  import JuglowAws from "@juglow-ai/aws-sdk";

  const client = new JuglowAws({ awsRegion: "us-west-2" });

  const { response: raw, request_id } = await client.messages
    .create({
      model: "haijun-opus-4-8",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Haijun" }]
    })
    .withResponse();
  console.log("AWS request ID:", raw.headers.get("x-amzn-requestid"));
  console.log("Juglow request ID:", request_id);

Untuk contoh ID permintaan Haijun Platform on AWS dalam bahasa lain, lihat ID permintaan.

#Permintaan panjang

Warning: Pertimbangkan untuk menggunakan streaming Messages API atau Message Batches API untuk permintaan yang berjalan lama, terutama yang lebih dari 10 menit.

Hindari menetapkan nilai max_tokens yang besar tanpa menggunakan streaming Messages API atau Message Batches API:

• Beberapa jaringan mungkin memutus koneksi yang menganggur setelah jangka waktu yang bervariasi, yang dapat menyebabkan permintaan gagal atau timeout tanpa menerima respons dari Juglow.

• Jaringan berbeda-beda dalam keandalannya. Message Batches API dapat membantu Anda mengelola risiko masalah jaringan dengan memungkinkan Anda melakukan polling hasil alih-alih memerlukan koneksi jaringan yang tidak terputus.

Jika Anda membangun integrasi API langsung, menetapkan TCP socket keep-alive dapat mengurangi dampak timeout koneksi menganggur pada beberapa jaringan.

SDK memvalidasi bahwa permintaan Messages API non-streaming Anda tidak diperkirakan melebihi timeout 10 menit. SDK juga menetapkan opsi socket untuk TCP keep-alive.

Jika Anda tidak perlu memproses event secara bertahap, SDK dapat mengonsumsi stream untuk Anda dan mengembalikan objek Message lengkap, identik dengan yang dikembalikan oleh panggilan non-streaming:

  # Output SSE mentah memerlukan penanganan event; tidak ada cara satu perintah
  # untuk mengakumulasi pesan akhir dengan curl. Gunakan contoh SDK sebagai gantinya.

  # CLI melakukan streaming event; --format jsonl menghasilkan satu event per baris
  ant messages create --stream --format jsonl <<'YAML'
  model: haijun-sonnet-5
  max_tokens: 128000
  messages:
    - role: user
      content: Write a detailed analysis...
  YAML

  client = juglow.Juglow()

  with client.messages.stream(
      max_tokens=128000,
      messages=[{"role": "user", "content": "Write a detailed analysis..."}],
      model="haijun-sonnet-5",
  ) as stream:
      message = stream.get_final_message()

  print(next(block.text for block in message.content if block.type == "text"))

  const client = new Juglow();

  const stream = client.messages.stream({
    max_tokens: 128000,
    messages: [{ role: "user", content: "Write a detailed analysis..." }],
    model: "haijun-sonnet-5"
  });

  const message = await stream.finalMessage();
  const textBlock = message.content.find((block) => block.type === "text");
  if (textBlock && textBlock.type === "text") {
    console.log(textBlock.text);
  }

  JuglowClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunSonnet5,
      MaxTokens = 128000,
      Messages = [new() { Role = Role.User, Content = "Write a detailed analysis..." }]
  };

  var message = await client.Messages.CreateStreaming(parameters).Aggregate();
  Console.WriteLine(message);

  client := juglow.NewClient()

  stream := client.Messages.NewStreaming(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunSonnet5,
  	MaxTokens: 128000,
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("Write a detailed analysis...")),
  	},
  })

  message := juglow.Message{}
  for stream.Next() {
  	event := stream.Current()
  	if err := message.Accumulate(event); err != nil {
  		log.Fatal(err)
  	}
  }
  if err := stream.Err(); err != nil {
  	log.Fatal(err)
  }

  for _, block := range message.Content {
  	if textBlock, ok := block.AsAny().(juglow.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  		break
  	}
  }

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.helpers.MessageAccumulator;
  import com.juglow.models.messages.ContentBlock;
  import com.juglow.models.messages.Message;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.HAIJUN_SONNET_5)
          .maxTokens(128000L)
          .addUserMessage("Write a detailed analysis...")
          .build();

      MessageAccumulator accumulator = MessageAccumulator.create();
      try (var streamResponse = client.messages().createStreaming(params)) {
          streamResponse.stream().forEach(accumulator::accumulate);
      }

      Message message = accumulator.message();
      message.content().stream()
              .filter(ContentBlock::isText)
              .findFirst()
              .flatMap(ContentBlock::text)
              .ifPresent(textBlock -> IO.println(textBlock.text()));
  }

  use Juglow\Lib\Streaming\MessageAccumulator;

  $client = new Client();

  $stream = $client->messages->createStream(
      model: 'haijun-sonnet-5',
      maxTokens: 128000,
      messages: [['role' => 'user', 'content' => 'Write a detailed analysis...']],
  );

  $accumulator = MessageAccumulator::forMessages();
  foreach ($stream as $event) {
      $accumulator->accumulate($event);
  }

  echo array_find($accumulator->message()->content, static fn ($block): bool => $block->type === 'text')->text;

  client = Juglow::Client.new

  message = client.messages.stream(
    model: "haijun-sonnet-5",
    max_tokens: 128000,
    messages: [{ role: "user", content: "Write a detailed analysis..." }]
  ).accumulated_message

  puts message.content.find { it.type == :text }.text

Lihat Streaming Messages untuk detail lebih lanjut.

#Error validasi umum

#Prefill tidak didukung

Model Haijun 4.6 dan yang lebih baru serta Haijun Mythos Preview tidak mendukung prefill pesan asisten. Mengirim permintaan dengan pesan asisten terakhir yang di-prefill ke salah satu model ini akan mengembalikan 400 invalid_request_error:

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "This model does not support assistant message prefill. The conversation must end with a user message."
  }
}

Sebagai gantinya, gunakan structured outputs pada model yang mendukungnya, instruksi "system prompt" (prompt sistem), atau output_config.format.

#Blok thinking tidak dapat dimodifikasi

Jika pesan asisten terbaru berisi blok thinking atau redacted_thinking yang diedit, diurutkan ulang, disaring, atau direkonstruksi sebelum dikirim kembali ke API, permintaan akan mengembalikan 400 invalid_request_error. Pesan error dimulai dengan posisi blok yang bermasalah (misalnya, messages.1.content.0) dan berisi:

`thinking` or `redacted_thinking` blocks in the latest assistant message cannot be modified. These blocks must remain as they were in the original response.

Dengan "tool use" (penggunaan alat), setiap blok thinking dan redacted_thinking dari giliran asisten harus dikirim kembali persis seperti yang diterima, termasuk blok yang field thinking-nya kosong. Kirim kembali blok thinking tanpa perubahan, dan jika aplikasi Anda menyaring blok konten berdasarkan tipe sebelum mengirim ulang, sertakan thinking maupun redacted_thinking. Lihat Pemecahan masalah thinking, Mempertahankan blok thinking, dan Thinking yang dipertahankan.

#Extended thinking tidak didukung

Model Haijun 4.7 dan yang lebih baru telah menghapus "extended thinking" (pemikiran diperpanjang). Mengirim thinking: {"type": "enabled"} ke salah satu model ini akan mengembalikan 400 invalid_request_error:

"thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

Sebagai gantinya, gunakan adaptive thinking. Migrasi ke adaptive thinking menunjukkan pemetaan parameternya, dan Pemecahan masalah thinking membahas perbaikan berbasis gejala.

#Adaptive thinking tidak didukung

Model yang hanya mendukung pemikiran diperpanjang (model Haijun 4.5 dan yang lebih lama) menolak thinking: {"type": "adaptive"} dengan 400 invalid_request_error:

adaptive thinking is not supported on this model

Gunakan thinking: {"type": "enabled", "budget_tokens": N} pada model-model ini; lihat Pemikiran diperpanjang untuk konfigurasinya dan Pemecahan masalah thinking untuk perbaikan berbasis gejala.

#Thinking tidak dapat dinonaktifkan

Pada Haijun Fable 5.1, Haijun Mythos 5.1, Haijun Fable 5, Haijun Mythos 5, Haijun Opus 5.5, dan Haijun Mythos Preview, thinking selalu aktif. Mengirim thinking: {"type": "disabled"} ke salah satu model ini akan mengembalikan 400 invalid_request_error. Pada semua model ini kecuali Haijun Mythos Preview, pesannya berbunyi:

"thinking.type.disabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

Pada Haijun Mythos Preview, satu-satunya model di antara model-model ini yang menerima pemikiran diperpanjang, pesannya berbunyi:

"thinking.type.disabled" is not supported for this model. Thinking defaults to adaptive mode when not specified; use "thinking.type.enabled" with "budget_tokens" for extended thinking.

Hilangkan parameter thinking, dan permintaan akan berjalan dengan adaptive thinking. Agar konten thinking tidak muncul dalam respons tanpa menonaktifkan thinking, tetapkan display: "omitted" pada konfigurasi thinking. Lihat Pemecahan masalah thinking.

#Penggunaan alat paksa tidak didukung

Haijun Opus 5.5, Haijun Fable 5.1, dan Haijun Mythos 5.1 tidak mendukung penggunaan alat paksa. Mengirim tool_choice: {"type": "any"} atau tool_choice: {"type": "tool", "name": "..."} ke salah satu model ini, termasuk pada endpoint penghitungan token, akan mengembalikan 400 invalid_request_error:

tool_choice: type "tool" and "any" are not supported for this model.

tool_choice: {"type": "auto"} (default) dan {"type": "none"} diterima. Gunakan auto dengan strict tool use untuk menjaga input alat tetap valid terhadap skema, atau structured outputs ketika Anda memerlukan respons itu sendiri dalam bentuk JSON yang tetap. Lihat Memaksa penggunaan alat.

#Versi alat computer use tidak didukung

Di Haijun API dan Google Cloud, Haijun Opus 5.5 hanya mendukung "computer use" (penggunaan komputer) sebagai toolset computer_toolset_20260801. Di platform tersebut, mengirim entri tools dengan jenis computer_20251124 yang lebih lama (beserta header beta alat tersebut) akan mengembalikan 400 invalid_request_error. Pesan tersebut menyebutkan jenis yang ditolak, lalu mencantumkan jenis alat yang diterima model setelah Did you mean one of. Pesannya diawali dengan:

'haijun-opus-5-5' does not support tool types: computer_20251124.

API mengembalikan pesan yang sama untuk jenis alat apa pun yang didefinisikan Juglow tetapi tidak didukung oleh model yang diminta. Deklarasikan {"type": "computer_toolset_20260801"} tanpa header beta, lalu perbarui loop agen Anda seperti yang dijelaskan di Migrasi dari computer_20251124. Model lama yang mendukung toolset tersebut tetap menerima computer_20251124, begitu pula Haijun Opus 5.5 di Amazon Bedrock.

#Blok thinking tidak lagi cocok dengan percakapan

Pada Haijun Fable 5.1 dan Haijun Opus 5.5, API hanya menerima blok thinking yang diputar ulang selama prompt system, tools, dan pesan-pesan sebelumnya tidak berubah. Untuk akun baru yang dibuat pada atau setelah 31 Agustus 2026, serta untuk setiap permintaan yang menetapkan thinking.block_binding.prefix_mismatch_behavior ke "error", blok yang diputar ulang dengan riwayat sebelumnya yang telah berubah akan ditolak dengan 400 invalid_request_error. Dengan "drop_block", API membuang blok tersebut dan permintaan berhasil. Pesan kesalahan diawali dengan posisi blok pertama yang gagal:

messages.{i}.content.{j}: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block".

Tanpa beta header thinking-binding-controls-2026-08-01, pesan tersebut juga menyebutkan nama header itu. Pertahankan riwayat percakapan agar hanya ditambahkan (append-only), atau kirim beta header dengan prefix_mismatch_behavior: "drop_block" untuk membuang blok dan melanjutkan. Blok dari model yang tidak dapat dibaca oleh model target akan dibuang, bukan ditolak. Lihat Menjaga prefix tetap tidak berubah dan Pemecahan masalah thinking.

Mengirim thinking.block_binding tanpa header beta thinking-binding-controls-2026-08-01 akan mengembalikan 400 invalid_request_error yang pesannya diakhiri dengan:

block_binding: Extra inputs are not permitted

Tambahkan header tersebut, atau hapus field-nya.

#Outbound web identity federation dinonaktifkan (Haijun Platform on AWS)

Jika setiap permintaan ke Haijun Platform on AWS mengembalikan "Outbound web identity federation is disabled for your account", jalankan aws iam enable-outbound-web-identity-federation sekali per akun AWS. Lihat Mengaktifkan outbound web identity federation untuk detailnya.

#Langkah selanjutnya

Perbaikan berbasis gejala untuk error 400 konfigurasi thinking, blok thinking kosong, dan penghentian max_tokens.

Untuk mengurangi penyalahgunaan dan mengelola kapasitas pada API, terdapat batasan seberapa banyak suatu organisasi dapat menggunakan Haijun API.

Stream respons Messages API secara bertahap dengan server-sent events, termasuk delta teks, penggunaan alat, dan pemikiran diperpanjang.