# Panduan penggunaan API untuk Claude

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

---

# Panduan penggunaan API untuk Claude

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

## Model

```text
Model terpintar: Claude Opus 4.6: claude-opus-4-6
Model pintar: Claude Sonnet 4.6: claude-sonnet-4-6
Untuk tugas cepat dan hemat biaya: Claude Haiku 4.5: claude-haiku-4-5-20251001
```

## Memanggil API

### Permintaan dan respons dasar

<CodeGroup>

```bash CLI
ant messages create \
  --model claude-opus-4-6 \
  --max-tokens 1024 \
  --message '{"role": "user", "content": "Hello, Claude"}'
```

```python Python
import anthropic
import os

message = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
).messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(message)
```

</CodeGroup>

```json Output
{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hello!"
    }
  ],
  "model": "claude-opus-4-6",
  "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 berasal dari Claude. Anda dapat menggunakan pesan `assistant` sintetis.

<CodeGroup>

```bash CLI
ant messages create <<'YAML'
model: claude-opus-4-6
max_tokens: 1024
messages:
  - role: user
    content: Hello, Claude
  - role: assistant
    content: Hello!
  - role: user
    content: Can you describe LLMs to me?
YAML
```

```python Python
import anthropic

message = anthropic.Anthropic().messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude"},
        {"role": "assistant", "content": "Hello!"},
        {"role": "user", "content": "Can you describe LLMs to me?"},
    ],
)
print(message)
```

</CodeGroup>

### Memasukkan kata-kata ke dalam mulut Claude

Anda dapat mengisi sebagian respons Claude di posisi terakhir daftar pesan input. Ini dapat digunakan untuk membentuk respons Claude. Contoh di bawah ini menggunakan `"max_tokens": 1` untuk mendapatkan satu jawaban pilihan ganda dari Claude.

<CodeGroup>

```bash CLI
ant messages create <<'YAML'
model: claude-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 Python
message = anthropic.Anthropic().messages.create(
    model="claude-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 ("},
    ],
)
```

</CodeGroup>

### Vision

Claude dapat membaca teks dan gambar dalam permintaan. Tipe sumber `base64` dan `url` didukung untuk gambar, bersama dengan tipe media `image/jpeg`, `image/png`, `image/gif`, dan `image/webp`.

<CodeGroup>

```bash CLI nocheck
IMAGE_URL="https://upload.wikimedia.org/wikipedia/commons/a/a7"
IMAGE_URL="$IMAGE_URL/Camponotus_flavomarginatus_ant.jpg"

# Opsi 1: Gambar yang dikodekan Base64 (awalan @ secara otomatis mengkodekan file biner sebagai base64)
curl -sSo ant.jpg "$IMAGE_URL"

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

# Opsi 2: Gambar yang direferensikan URL
ant messages create <<YAML
model: claude-opus-4-6
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 Python nocheck
import anthropic
import base64
import httpx

# Opsi 1: Gambar yang dikodekan Base64
image_url = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
image_media_type = "image/jpeg"
image_data = base64.standard_b64encode(httpx.get(image_url).content).decode("utf-8")

message = anthropic.Anthropic().messages.create(
    model="claude-opus-4-6",
    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?"},
            ],
        }
    ],
)

# Opsi 2: Gambar yang direferensikan URL
message_from_url = anthropic.Anthropic().messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {"type": "text", "text": "What is in the above image?"},
            ],
        }
    ],
)
```

</CodeGroup>

## Extended thinking

Extended thinking terkadang dapat membantu Claude dengan tugas-tugas yang sangat sulit. Ketika diaktifkan, suhu harus diatur ke 1.

Extended thinking didukung pada model-model berikut:

- Claude Opus 4.1 (`claude-opus-4-1-20250805`)
- Claude Opus 4 (`claude-opus-4-20250514`)
- Claude Sonnet 4.6 (`claude-sonnet-4-6`)
- Claude Sonnet 4.5 (`claude-sonnet-4-5-20250929`)

### Cara kerja extended thinking

Ketika extended thinking diaktifkan, Claude membuat blok konten `thinking` di mana ia mengeluarkan penalaran internalnya. Respons API akan menyertakan blok konten `thinking`, diikuti oleh blok konten `text`.

<CodeGroup>

```bash CLI
ant messages create \
  --transform content --format yaml <<'YAML'
model: claude-opus-4-6
max_tokens: 16000
thinking:
  type: enabled
  budget_tokens: 10000
messages:
  - role: user
    content: Are there an infinite number of prime numbers such that n mod 4 == 3?
YAML
```

```python Python
import anthropic

client = anthropic.Anthropic()

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

# Respons akan berisi blok thinking yang diringkas dan blok teks
for block in response.content:
    if block.type == "thinking":
        print(f"\nRingkasan thinking: {block.thinking}")
    elif block.type == "text":
        print(f"\nRespons: {block.text}")
```

</CodeGroup>

Parameter `budget_tokens` menentukan jumlah maksimum token yang diizinkan untuk digunakan Claude dalam proses penalaran internalnya. Pada model Claude 4, batas ini berlaku untuk token thinking penuh, bukan untuk output yang diringkas. Anggaran yang lebih besar dapat meningkatkan kualitas respons dengan memungkinkan analisis yang lebih menyeluruh untuk masalah yang kompleks. Satu aturan: nilai max_tokens harus lebih besar dari nilai budget_tokens agar Claude memiliki ruang untuk menulis responsnya setelah thinking selesai.

## Extended thinking dengan penggunaan alat

Extended thinking dapat digunakan bersama dengan penggunaan alat, memungkinkan Claude untuk bernalar melalui pemilihan alat dan pemrosesan hasil.

Batasan penting:

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

### Mempertahankan blok thinking

<CodeGroup>

```bash CLI nocheck
# Permintaan pertama: tangkap array konten asisten (blok thinking + tool_use,
# tanda tangan tetap utuh) sebagai JSON kompak.
ASSISTANT_CONTENT=$(ant messages create \
  --transform content --format jsonl <<'YAML'
model: claude-opus-4-6
max_tokens: 16000
thinking:
  type: enabled
  budget_tokens: 10000
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" \
  | grep -o 'toolu_[A-Za-z0-9]*')

# Permintaan kedua: teruskan blok yang ditangkap kembali tanpa perubahan sebagai pesan asisten.
# Blok thinking harus menyertai blok tool_use.
ant messages create <<YAML
model: claude-opus-4-6
max_tokens: 16000
thinking:
  type: enabled
  budget_tokens: 10000
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 Python nocheck
import anthropic

client = anthropic.Anthropic()

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 - Claude merespons dengan thinking dan permintaan alat
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    tools=[weather_tool],
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)

# Ekstrak blok thinking 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 thinking dan hasil alat
continuation = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    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",
                }
            ],
        },
    ],
)
```

</CodeGroup>

### Interleaved thinking

Extended thinking dengan penggunaan alat pada model Claude 4 mendukung interleaved thinking, yang memungkinkan Claude untuk berpikir di antara panggilan alat. Untuk mengaktifkan pada model Claude 4, 4.5, dan Sonnet 4.6, tambahkan header beta `interleaved-thinking-2025-05-14` ke permintaan API Anda.

<CodeGroup>

```bash CLI nocheck
ant beta:messages create --beta interleaved-thinking-2025-05-14 <<'YAML'
model: claude-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 Python nocheck
import anthropic

client = anthropic.Anthropic()

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="claude-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"],
)
```

</CodeGroup>

Dengan interleaved thinking dan HANYA dengan interleaved thinking (bukan extended thinking biasa), `budget_tokens` dapat melebihi parameter `max_tokens`, karena `budget_tokens` dalam kasus ini mewakili total anggaran di semua blok thinking dalam satu giliran asisten.

<Info>
  Untuk Claude Opus 4.6, interleaved thinking diaktifkan secara otomatis saat menggunakan [adaptive thinking](/docs/id/build-with-claude/adaptive-thinking) (`thinking: {type: "adaptive"}`). Tidak diperlukan header beta. Sonnet 4.6 mendukung header beta `interleaved-thinking-2025-05-14` dengan extended thinking manual dan adaptive thinking.
</Info>

## Penggunaan Alat

### Menentukan alat klien

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

| Parameter      | Deskripsi                                                                                         |
| :------------- | :-------------------------------------------------------------------------------------------------- |
| `name`         | Nama alat. Harus cocok dengan regex `^[a-zA-Z0-9_-]{1,64}$`.                                 |
| `description`  | Deskripsi teks biasa yang mendetail tentang apa yang dilakukan alat, kapan harus digunakan, dan bagaimana perilakunya. |
| `input_schema` | Objek [JSON Schema](https://json-schema.org/) 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 mendetail.** Ini adalah faktor terpenting 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 menggunakan `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 bidang `input_examples` (beta). Ini membantu Claude memahami pola input yang diharapkan. Lihat [Memberikan contoh penggunaan alat](/docs/id/agents-and-tools/tool-use/define-tools#providing-tool-use-examples) 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 Claude

### Memaksa penggunaan alat

Anda dapat memaksa Claude untuk menggunakan alat tertentu dengan menentukan alat di bidang `tool_choice`:

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

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

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

### Output JSON

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

### Chain of thought

Saat menggunakan alat, Claude sering akan menampilkan "chain of thought"-nya, yaitu penalaran langkah demi langkah yang digunakannya untuk memecah masalah dan memutuskan 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, Claude dapat menggunakan beberapa alat untuk menjawab kueri pengguna. Anda dapat menonaktifkan perilaku ini dengan mengatur `disable_parallel_tool_use=true`.

## Menangani blok konten penggunaan alat dan hasil alat

### Menangani hasil dari alat klien

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

- `id`: Pengenal unik untuk blok penggunaan alat tertentu ini.
- `name`: Nama alat yang digunakan.
- `input`: Objek yang berisi input yang diteruskan ke alat.

Ketika Anda menerima respons penggunaan alat, Anda harus:

1. Ekstrak `name`, `id`, dan `input` dari blok `tool_use`.
2. Jalankan alat aktual dalam basis kode Anda yang sesuai dengan nama alat tersebut.
3. Lanjutkan percakapan dengan mengirimkan pesan baru dengan `tool_result`:

```json
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "15 degrees"
    }
  ]
}
```

### Menangani alasan berhenti `max_tokens`

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

### Menangani alasan berhenti `pause_turn`

Saat menggunakan alat server seperti pencarian web, API mungkin mengembalikan alasan berhenti `pause_turn`. Lanjutkan percakapan dengan meneruskan respons yang dijeda kembali apa adanya dalam permintaan berikutnya.

## Memecahkan masalah kesalahan

### Kesalahan eksekusi alat

Jika alat itu sendiri melempar kesalahan selama eksekusi, kembalikan pesan kesalahan 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 percobaan penggunaan alat Claude tidak valid (misalnya parameter yang diperlukan hilang), coba permintaan lagi dengan nilai `description` yang lebih mendetail dalam definisi alat Anda.

## Streaming Pesan

Saat membuat Pesan, Anda dapat mengatur `"stream": true` untuk melakukan streaming respons secara bertahap menggunakan server-sent events (SSE).

### Streaming dengan SDK

<CodeGroup>

```bash CLI
ant messages create --stream --format jsonl \
  --model claude-opus-4-6 \
  --max-tokens 1024 \
  --message '{role: user, content: "Hello"}' \
  | while IFS= read -r event; do
      [[ $event == *'"text_delta"'* ]] || continue
      text=${event#*'"text":"'}
      printf '%b' "${text%\"*}"
    done
```

```python Python
import anthropic

client = anthropic.Anthropic()

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

</CodeGroup>

### 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.
2. Serangkaian blok konten, masing-masing dengan `content_block_start`, satu atau lebih event `content_block_delta`, dan `content_block_stop`.
3. Satu atau lebih event `message_delta`, yang menunjukkan perubahan tingkat atas pada objek `Message` akhir.
4. Event `message_stop` terakhir.

**Peringatan:** Jumlah token yang ditampilkan di bidang `usage` dari 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 adalah _string JSON parsial_:

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

#### Delta thinking

Saat menggunakan extended 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": "claude-opus-4-6", "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"}
```