Haijun Platform Docs
EN

Panduan ini dirancang untuk memberikan Haijun dasar-dasar penggunaan Haijun API. Panduan ini memberikan penjelasan dan contoh ID model/Messages API dasar, penggunaan alat, streaming, thinking, dan tidak ada yang lain.

Model

text
Recommended default for most work, including complex agentic coding: Haijun Opus 5.5: haijun-opus-5-5
Step up for the hardest long-running agentic and research tasks, at 2.5x Haijun Opus 5.5 pricing: Haijun Fable 5.1: haijun-fable-5-1
Previous Opus model: Haijun Opus 5: haijun-opus-5
Smart model: Haijun Sonnet 5: haijun-sonnet-5
For fast, cost-effective tasks: Haijun Haiku 4.5: haijun-haiku-4-5-20251001

Memanggil API

Permintaan dan respons dasar

bash
  ant messages create \
    --model haijun-opus-5-5 \
    --max-tokens 1024 \
    --message '{"role": "user", "content": "Hello, Haijun"}'
python
  import juglow

  message = juglow.Juglow().messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Haijun"}],
  )
  print(message)
json
{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hello!"
    }
  ],
  "model": "haijun-opus-5-5",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 12,
    "output_tokens": 6
  }
}

Beberapa giliran percakapan

Messages API bersifat stateless, yang berarti Anda selalu mengirimkan riwayat percakapan lengkap ke API. Anda dapat menggunakan pola ini untuk membangun percakapan dari waktu ke waktu. Giliran percakapan sebelumnya tidak harus benar-benar berasal dari Haijun. Anda dapat menggunakan pesan assistant sintetis.

bash
  ant messages create <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content: Hello, Haijun
    - role: assistant
      content: Hello!
    - role: user
      content: Can you describe LLMs to me?
  YAML
python
  import juglow

  message = juglow.Juglow().messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {"role": "user", "content": "Hello, Haijun"},
          {"role": "assistant", "content": "Hello!"},
          {"role": "user", "content": "Can you describe LLMs to me?"},
      ],
  )
  print(message)

Mengisi awal respons Haijun

Anda dapat mengisi awal (prefill) sebagian respons Haijun pada posisi terakhir dari daftar pesan input. Gunakan teknik ini untuk membentuk respons Haijun. Contoh berikut menggunakan "max_tokens": 1 untuk mendapatkan satu jawaban pilihan ganda dari Haijun.

Note: Model Haijun 4.6 dan yang lebih baru serta Haijun Mythos Preview tidak mendukung prefill pesan assistant; permintaan ke model-model tersebut harus diakhiri dengan pesan user. Contoh di bawah ini menggunakan model yang mendukung prefill.

bash
  ant messages create <<'YAML'
  model: haijun-sonnet-4-5
  max_tokens: 1
  messages:
    - role: user
      content: "What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae"
    - role: assistant
      content: "The answer is ("
  YAML
python
  import juglow

  message = juglow.Juglow().messages.create(
      model="haijun-sonnet-4-5",
      max_tokens=1,
      messages=[
          {
              "role": "user",
              "content": "What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae",
          },
          {"role": "assistant", "content": "The answer is ("},
      ],
  )
  print(message.content[0].text)

Vision

Haijun dapat membaca teks maupun gambar dalam permintaan. Tipe sumber base64 dan url keduanya didukung untuk gambar, beserta tipe media image/jpeg, image/png, image/gif, dan image/webp.

bash
  IMAGE_URL="/docs/images/vision-example.jpg"

  # Opsi 1: Gambar yang di-encode Base64 (prefiks @ otomatis meng-encode file biner sebagai base64)
  curl -sSo vision-example.jpg "$IMAGE_URL"

  ant messages create <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: base64
            media_type: image/jpeg
            data: "@./vision-example.jpg"
        - type: text
          text: What is in the above image?
  YAML

  # Opsi 2: Gambar yang dirujuk melalui URL
  ant messages create <<YAML
  model: haijun-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: url
            url: $IMAGE_URL
        - type: text
          text: What is in the above image?
  YAML
python
  import juglow
  import base64
  import httpx2

  # Opsi 1: Gambar yang dienkode Base64
  image_url = "/docs/images/vision-example.jpg"
  image_media_type = "image/jpeg"
  image_data = base64.standard_b64encode(httpx2.get(image_url).content).decode("utf-8")

  message = juglow.Juglow().messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": image_media_type,
                          "data": image_data,
                      },
                  },
                  {"type": "text", "text": "What is in the above image?"},
              ],
          }
      ],
  )
  print(next(block.text for block in message.content if block.type == "text"))

  # Opsi 2: Gambar yang dirujuk melalui URL
  message_from_url = juglow.Juglow().messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {
                          "type": "url",
                          "url": "/docs/images/vision-example.jpg",
                      },
                  },
                  {"type": "text", "text": "What is in the above image?"},
              ],
          }
      ],
  )
  print(next(block.text for block in message_from_url.content if block.type == "text"))

Thinking

Thinking terkadang dapat membantu Haijun dalam tugas yang sangat sulit. Mekanisme saat ini adalah adaptive thinking (pemikiran adaptif) (thinking: {"type": "adaptive"}): Haijun memutuskan kapan dan seberapa banyak harus berpikir, dan Anda mengarahkan kedalaman pemikiran dengan parameter effort alih-alih anggaran token. Adaptive thinking didukung pada model Haijun 4.6 dan yang lebih baru serta Haijun Mythos Preview. Pada model Haijun 5 dan Haijun Mythos Preview, thinking aktif secara default ketika parameter thinking dihilangkan.

Temperature harus diatur ke 1 (atau dibiarkan tidak diatur) setiap kali thinking diaktifkan, pada semua model. Pada model Haijun 4.7 dan yang lebih baru serta Haijun Mythos Preview, temperature sudah tidak digunakan lagi (deprecated) dan hanya nilai default-nya yang diterima, bahkan ketika thinking nonaktif.

Thinking didukung pada model-model berikut:

  • Haijun Opus 5.5 (haijun-opus-5-5, hanya adaptive thinking, selalu aktif)
  • Haijun Opus 5 (haijun-opus-5, hanya adaptive thinking, aktif secara default)
  • Haijun Sonnet 5 (haijun-sonnet-5, hanya adaptive thinking, aktif secara default)
  • Haijun Opus 4.8 (haijun-opus-4-8, hanya adaptive thinking)
  • Haijun Opus 4.7 (haijun-opus-4-7, hanya adaptive thinking)
  • Haijun Opus 4.6 (haijun-opus-4-6, adaptive thinking atau manual thinking lama)
  • Haijun Sonnet 4.6 (haijun-sonnet-4-6, adaptive thinking atau manual thinking lama)
  • Haijun Opus 4.5 (haijun-opus-4-5-20251101, hanya manual thinking lama)
  • Haijun Sonnet 4.5 (haijun-sonnet-4-5-20250929, hanya manual thinking lama)
  • Haijun Haiku 4.5 (haijun-haiku-4-5-20251001, hanya manual thinking lama)

Note: Pada model Haijun 4.7 dan yang lebih baru, "extended thinking" (pemikiran diperpanjang) manual (type: enabled dengan nilai budget_tokens) tidak didukung dan mengembalikan error 400. Gunakan adaptive thinking (type: adaptive) sebagai gantinya.

Cara kerja thinking

Ketika thinking aktif, Haijun membuat blok konten thinking tempat ia mengeluarkan penalaran internalnya. Respons API menyertakan blok konten thinking, diikuti oleh blok konten text.

bash
  ant messages create --transform content --format yaml <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
    display: summarized
  messages:
    - role: user
      content: Are there an infinite number of prime numbers such that n mod 4 == 3?
  YAML
python
  import juglow

  client = juglow.Juglow()

  response = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive", "display": "summarized"},
      messages=[
          {
              "role": "user",
              "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          }
      ],
  )

  # Respons berisi blok thinking yang diringkas dan blok teks
  for block in response.content:
      match block.type:
          case "thinking":
              print(f"\nThinking summary: {block.thinking}")
          case "text":
              print(f"\nResponse: {block.text}")

Pemikiran diperpanjang manual (thinking: {"type": "enabled", "budget_tokens": N}) adalah mekanisme lama. Mekanisme ini hanya berfungsi pada model Haijun 4 hingga 4.6 yang mendukung thinking; model Haijun 4.7 dan yang lebih baru menolak type: enabled dengan error 400 dan menggunakan adaptive thinking sebagai gantinya. Dengan pemikiran diperpanjang manual, budget_tokens menetapkan jumlah maksimum token yang boleh digunakan Haijun untuk proses penalaran internalnya; batas ini berlaku untuk token thinking penuh, bukan untuk output yang diringkas. Kecuali Anda menggunakan interleaved thinking, budget_tokens harus lebih kecil dari max_tokens agar Haijun memiliki ruang untuk menulis responsnya setelah thinking selesai.

Thinking dengan penggunaan alat

Thinking dapat digunakan bersama "tool use" (penggunaan alat), memungkinkan Haijun untuk bernalar dalam pemilihan alat dan pemrosesan hasil.

Batasan penting:

  1. Batasan pilihan alat: Hanya mendukung tool_choice: {"type": "auto"} (default) atau tool_choice: {"type": "none"}.
  1. Mempertahankan blok thinking: Selama penggunaan alat, Anda harus mengirimkan kembali blok thinking ke API untuk pesan assistant terakhir.

Mempertahankan blok thinking

bash
  # Permintaan pertama: tangkap array konten assistant (blok thinking + tool_use,
  # dengan signature utuh) sebagai JSON ringkas.
  ASSISTANT_CONTENT=$(ant messages create \
    --transform content --format jsonl <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
    display: summarized
  tools:
    - name: get_weather
      description: Get the current weather for a location.
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city name.
        required: [location]
  messages:
    - role: user
      content: "What's the weather in Paris?"
  YAML
  )

  TOOL_USE_ID=$(printf '%s' "$ASSISTANT_CONTENT" \
    | jq -r '.[] | select(.type == "tool_use") | .id')

  # Permintaan kedua: kirim kembali blok yang ditangkap tanpa diubah sebagai pesan
  # assistant. Blok thinking harus menyertai blok tool_use.
  ant messages create <<YAML
  model: haijun-opus-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
    display: summarized
  tools:
    - name: get_weather
      description: Get the current weather for a location.
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city name.
        required: [location]
  messages:
    - role: user
      content: "What's the weather in Paris?"
    - role: assistant
      content: $ASSISTANT_CONTENT
    - role: user
      content:
        - type: tool_result
          tool_use_id: $TOOL_USE_ID
          content: "Current temperature: 72°F"
  YAML
python
  import juglow

  client = juglow.Juglow()

  weather_tool = {
      "name": "get_weather",
      "description": "Get the current weather for a location.",
      "input_schema": {
          "type": "object",
          "properties": {"location": {"type": "string", "description": "The city name."}},
          "required": ["location"],
      },
  }

  weather_data = {"temperature": 72}

  # Permintaan pertama - Haijun merespons dengan pemikiran dan permintaan alat
  response = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive", "display": "summarized"},
      tools=[weather_tool],
      messages=[{"role": "user", "content": "What's the weather in Paris?"}],
  )

  # Ekstrak blok pemikiran dan blok penggunaan alat
  thinking_block = next(
      (block for block in response.content if block.type == "thinking"), None
  )
  tool_use_block = next(
      (block for block in response.content if block.type == "tool_use"), None
  )

  # Permintaan kedua - Sertakan blok pemikiran dan hasil alat
  continuation = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive", "display": "summarized"},
      tools=[weather_tool],
      messages=[
          {"role": "user", "content": "What's the weather in Paris?"},
          # Perhatikan bahwa thinking_block diteruskan bersama dengan tool_use_block
          {"role": "assistant", "content": [thinking_block, tool_use_block]},
          {
              "role": "user",
              "content": [
                  {
                      "type": "tool_result",
                      "tool_use_id": tool_use_block.id,
                      "content": f"Current temperature: {weather_data['temperature']}°F",
                  }
              ],
          },
      ],
  )

  for block in continuation.content:
      if block.type == "text":
          print(block.text)

Interleaved thinking

"Interleaved thinking" (pemikiran berselang-seling) memungkinkan Haijun untuk berpikir di antara pemanggilan alat, bernalar tentang hasil alat sebelum memutuskan langkah berikutnya.

Note: Pada model dengan adaptive thinking (thinking: {type: "adaptive"}), interleaved thinking diaktifkan secara otomatis. Tidak diperlukan header beta. Sonnet 4.6 mendukung header beta interleaved-thinking-2025-05-14 dengan pemikiran diperpanjang manual maupun adaptive thinking.

Pada model lama yang menggunakan pemikiran diperpanjang manual (model Haijun 4, 4.5, dan Sonnet 4.6), aktifkan interleaved thinking dengan menambahkan header beta interleaved-thinking-2025-05-14 ke permintaan API Anda:

bash
  ant beta:messages create --beta interleaved-thinking-2025-05-14 <<'YAML'
  model: haijun-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  tools:
    - name: calculator
      description: Perform arithmetic calculations.
      input_schema:
        type: object
        properties:
          expression:
            type: string
            description: The math expression to evaluate.
        required:
          - expression
    - name: database_query
      description: Query the product database.
      input_schema:
        type: object
        properties:
          query:
            type: string
            description: The database query.
        required:
          - query
  messages:
    - role: user
      content: "What's the total revenue if we sold 150 units of product A at $50 each?"
  YAML
python
  import juglow

  client = juglow.Juglow()

  calculator_tool = {
      "name": "calculator",
      "description": "Perform arithmetic calculations.",
      "input_schema": {
          "type": "object",
          "properties": {
              "expression": {
                  "type": "string",
                  "description": "The math expression to evaluate.",
              }
          },
          "required": ["expression"],
      },
  }

  database_tool = {
      "name": "database_query",
      "description": "Query the product database.",
      "input_schema": {
          "type": "object",
          "properties": {
              "query": {"type": "string", "description": "The database query."}
          },
          "required": ["query"],
      },
  }

  response = client.beta.messages.create(
      model="haijun-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      tools=[calculator_tool, database_tool],
      messages=[
          {
              "role": "user",
              "content": "What's the total revenue if we sold 150 units of product A at $50 each?",
          }
      ],
      betas=["interleaved-thinking-2025-05-14"],
  )

  for block in response.content:
      match block.type:
          case "thinking":
              print(f"Thinking: {block.thinking}")
          case "tool_use":
              print(f"Tool call: {block.name}({block.input})")
          case "text":
              print(f"Response: {block.text}")

Dengan interleaved thinking dan HANYA dengan interleaved thinking (bukan pemikiran diperpanjang manual biasa), budget_tokens dapat melebihi parameter max_tokens, karena budget_tokens dalam hal ini mewakili total anggaran di seluruh blok thinking dalam satu giliran assistant.

Penggunaan alat

Menentukan alat klien

Alat klien ditentukan dalam parameter tingkat atas tools pada permintaan API. Setiap definisi alat mencakup:

ParameterDeskripsi
nameNama alat. Harus cocok dengan regex ^[a-zA-Z0-9_-]{1,128}$.
descriptionDeskripsi teks biasa yang terperinci tentang apa yang dilakukan alat, kapan alat harus digunakan, dan bagaimana perilakunya.
input_schemaObjek JSON Schema yang mendefinisikan parameter yang diharapkan untuk alat.
json
{
  "name": "get_weather",
  "description": "Get the current weather in a given location",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "The city and state, e.g. San Francisco, CA"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "The unit of temperature, either 'celsius' or 'fahrenheit'"
      }
    },
    "required": ["location"]
  }
}

Praktik terbaik untuk definisi alat

Berikan deskripsi yang sangat terperinci. Ini adalah faktor yang paling penting dalam kinerja alat. Deskripsi Anda harus menjelaskan setiap detail tentang alat, termasuk:

  • Apa yang dilakukan alat
  • Kapan harus digunakan (dan kapan tidak)
  • Apa arti setiap parameter dan bagaimana pengaruhnya terhadap perilaku alat
  • Peringatan atau batasan penting apa pun

Pertimbangkan penggunaan input_examples untuk alat yang kompleks. Untuk alat dengan objek bersarang, parameter opsional, atau input yang sensitif terhadap format, Anda dapat memberikan contoh konkret menggunakan field input_examples (beta). Ini membantu Haijun memahami pola input yang diharapkan. Lihat Memberikan contoh penggunaan alat untuk detailnya.

Contoh deskripsi alat yang baik:

json
{
  "name": "get_stock_price",
  "description": "Retrieves the current stock price for a given ticker symbol. The ticker symbol must be a valid symbol for a publicly traded company on a major US stock exchange like NYSE or NASDAQ. The tool will return the latest trade price in USD. It should be used when the user asks about the current or most recent price of a specific stock. It will not provide any other information about the stock or company.",
  "input_schema": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string",
        "description": "The stock ticker symbol, e.g. AAPL for Apple Inc."
      }
    },
    "required": ["ticker"]
  }
}

Mengontrol output Haijun

Memaksa penggunaan alat

Anda dapat memaksa Haijun untuk menggunakan alat tertentu dengan menentukan alat tersebut di field tool_choice:

python
tool_choice = {"type": "tool", "name": "get_weather"}

Saat bekerja dengan parameter tool_choice, ada empat opsi yang mungkin:

  • auto memungkinkan Haijun menentukan apakah akan memanggil alat yang disediakan atau tidak (default).
  • any memberi tahu Haijun bahwa ia harus menggunakan salah satu alat yang disediakan.
  • tool memaksa Haijun untuk selalu menggunakan alat tertentu.
  • none mencegah Haijun menggunakan alat apa pun.

Pada Haijun Opus 5.5, Haijun Fable 5.1, dan Haijun Mythos 5.1, any dan tool mengembalikan error 400. Biarkan tool_choice pada auto dan atur "strict": true pada definisi alat untuk menjamin bahwa setiap panggilan yang dilakukan Haijun sesuai dengan input_schema alat tersebut. Lihat Penggunaan alat strict.

Output JSON

Alat tidak harus berupa fungsi klien. Anda dapat menggunakan alat kapan pun Anda ingin model mengembalikan output JSON yang mengikuti skema yang disediakan.

Chain of thought

Saat menggunakan alat, Haijun sering menunjukkan "chain of thought" (rantai pemikiran)-nya, yaitu penalaran langkah demi langkah yang digunakannya untuk memecah masalah dan menentukan alat mana yang akan digunakan.

json
{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "<thinking>To answer this question, I will: 1. Use the get_weather tool to get the current weather in San Francisco. 2. Use the get_time tool to get the current time in the America/Los_Angeles timezone, which covers San Francisco, CA.</thinking>"
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lq9",
      "name": "get_weather",
      "input": { "location": "San Francisco, CA" }
    }
  ]
}

Penggunaan alat paralel

Secara default, Haijun dapat menggunakan beberapa alat untuk menjawab kueri pengguna. Anda dapat menonaktifkan perilaku ini dengan mengatur disable_parallel_tool_use=true.

Menangani blok konten tool use dan tool result

Menangani hasil dari alat klien

Respons memiliki stop_reason berupa tool_use dan satu atau lebih blok konten tool_use yang mencakup:

  • id: Pengidentifikasi unik untuk blok penggunaan alat ini.
  • name: Nama alat yang digunakan.
  • input: Objek yang berisi input yang dikirimkan ke alat.

Ketika Anda menerima respons penggunaan alat, Anda harus:

  1. Mengekstrak name, id, dan input dari blok tool_use.
  1. Menjalankan alat yang sebenarnya di basis kode Anda yang sesuai dengan nama alat tersebut.
  1. Melanjutkan percakapan dengan mengirim pesan baru berisi tool_result:
json
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "15 degrees"
    }
  ]
}

Menangani stop reason max_tokens

Jika respons Haijun terpotong karena mencapai batas max_tokens selama penggunaan alat, coba ulang permintaan dengan nilai max_tokens yang lebih tinggi.

Menangani stop reason pause_turn

Saat menggunakan alat server seperti web search, API dapat mengembalikan stop reason pause_turn. Lanjutkan percakapan dengan mengirimkan kembali respons yang dijeda apa adanya dalam permintaan berikutnya.

Memecahkan masalah error

Error eksekusi alat

Jika alat itu sendiri melemparkan error selama eksekusi, kembalikan pesan error dengan "is_error": true:

json
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "ConnectionError: the weather service API is not available (HTTP 500)",
      "is_error": true
    }
  ]
}

Nama alat tidak valid

Jika upaya Haijun menggunakan alat tidak valid (misalnya, parameter wajib tidak ada), coba permintaan lagi dengan nilai description yang lebih terperinci dalam definisi alat Anda.

Streaming pesan

Saat membuat Message, Anda dapat mengatur "stream": true untuk melakukan streaming respons secara bertahap menggunakan "server-sent events" (event yang dikirim server), atau SSE.

Streaming dengan SDK

bash
  ant messages create --stream --format jsonl \
    --model haijun-opus-5-5 \
    --max-tokens 1024 \
    --message '{role: user, content: "Hello"}' \
    | jq -rj 'select(.delta.type? == "text_delta") | .delta.text'
python
  import juglow

  client = juglow.Juglow()

  with client.messages.stream(
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello"}],
      model="haijun-opus-5-5",
  ) as stream:
      for text in stream.text_stream:
          print(text, end="", flush=True)

Tipe event

Setiap server-sent event menyertakan tipe event bernama dan data JSON terkait. Setiap stream menggunakan alur event berikut:

  1. message_start: berisi objek Message dengan content kosong.
  1. Serangkaian blok konten, masing-masing dengan content_block_start, satu atau lebih event content_block_delta, dan content_block_stop.
  1. Satu atau lebih event message_delta, yang menunjukkan perubahan tingkat atas pada objek Message akhir.
  1. Event message_stop terakhir.

Peringatan: Jumlah token yang ditampilkan di field usage pada event message_delta bersifat kumulatif.

Tipe delta blok konten

Delta teks

json
{
  "type": "content_block_delta",
  "index": 0,
  "delta": { "type": "text_delta", "text": "Hello frien" }
}

Delta JSON input

Untuk blok konten tool_use, delta berupa string JSON parsial:

json
{"type": "content_block_delta","index": 1,"delta": {"type": "input_json_delta","partial_json": "{\"location\": \"San Fra"}}}

Delta thinking

Saat menggunakan thinking dengan streaming:

json
{
  "type": "content_block_delta",
  "index": 0,
  "delta": {
    "type": "thinking_delta",
    "thinking": "Let me solve this step by step..."
  }
}

Contoh permintaan streaming dasar

sse
event: message_start
data: {"type": "message_start", "message": {"id": "msg_1nZdL29xx5MUA1yADyHTEsnR8uuvGzszyY", "type": "message", "role": "assistant", "content": [], "model": "haijun-opus-5-5", "stop_reason": null, "stop_sequence": null, "usage": {"input_tokens": 25, "output_tokens": 1}}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "Hello"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "!"}}

event: content_block_stop
data: {"type": "content_block_stop", "index": 0}

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence":null}, "usage": {"output_tokens": 15}}

event: message_stop
data: {"type": "message_stop"}
On this page
ModelMemanggil APIPermintaan dan respons dasarBeberapa giliran percakapanMengisi awal respons HaijunVisionThinkingCara kerja thinkingThinking dengan penggunaan alatMempertahankan blok thinkingInterleaved thinkingPenggunaan alatMenentukan alat klienPraktik terbaik untuk definisi alatMengontrol output HaijunMemaksa penggunaan alatOutput JSONChain of thoughtPenggunaan alat paralelMenangani blok konten tool use dan tool resultMenangani hasil dari alat klienMenangani stop reason max_tokensMenangani stop reason pause_turnMemecahkan masalah errorError eksekusi alatNama alat tidak validStreaming pesanStreaming dengan SDKTipe eventTipe delta blok kontenDelta teksDelta JSON inputDelta thinkingContoh permintaan streaming dasar