Pemikiran diperpanjang

Note: Untuk mempelajari bagaimana "zero data retention" (retensi data nol), atau ZDR, berlaku untuk fitur ini, lihat API dan retensi data.

Warning: "Extended thinking" (pemikiran diperpanjang) (thinking.type: "enabled" dengan budget_tokens) sudah tidak digunakan lagi (deprecated) pada model Haijun 4.6 (permintaan yang menggunakannya masih berhasil). Haijun 4.7 dan model yang lebih baru tidak mendukungnya dan menolak permintaan yang menggunakannya, dengan mengembalikan error 400. Pada Haijun 4.5 dan model sebelumnya yang mendukung thinking, pemikiran diperpanjang adalah satu-satunya mode thinking yang tersedia. Haijun Mythos Preview mendukung kedua mode tersebut. Jika kedua mode tersedia, gunakan adaptive thinking (pemikiran adaptif) sebagai gantinya. Lihat Migrasi ke pemikiran adaptif untuk beralih ke pemikiran adaptif. Jika model Anda hanya mendukung pemikiran diperpanjang, halaman ini menjelaskan konfigurasi yang didukung; tidak ada perubahan yang diperlukan sampai Anda beralih ke model yang lebih baru.

Note: Jika permintaan gagal dengan error 400 yang pesannya dimulai dengan "thinking.type.enabled" is not supported, model Anda menggunakan pemikiran adaptif sebagai gantinya. Lihat Pemecahan masalah pemikiran, atau langsung ke Migrasi ke pemikiran adaptif.

"Extended thinking" (pemikiran diperpanjang) dalam mode manual memberi Anda kendali langsung atas seberapa banyak Haijun berpikir. Anda menetapkan anggaran token pemikiran pada setiap permintaan dengan thinking: {type: "enabled", budget_tokens: N}, dan Haijun berpikir berdasarkan anggaran tersebut sebelum memulai jawaban akhirnya. Mode manual tetap berguna ketika beban kerja Anda memerlukan latensi yang dapat diprediksi atau kendali yang presisi atas biaya pemikiran. Halaman ini membahas cara menetapkan dan menyetel anggaran, bagaimana mode manual berinteraksi dengan pemikiran berselang-seling (interleaved thinking) dan "prompt caching" (caching prompt), serta cara bermigrasi ke pemikiran adaptif.

Untuk mempelajari cara kerja pemikiran itu sendiri, termasuk blok pemikiran dan bentuk respons, parameter display, streaming, pemikiran dengan penggunaan alat, dan enkripsi, lihat ikhtisar pemikiran.

Model yang didukung

Ketersediaan pemikiran diperpanjang per model, termasuk model-model di mana pemikiran diperpanjang adalah satu-satunya mode, tercantum dalam tabel konfigurasi per model.

Cara menggunakan pemikiran diperpanjang

Berikut adalah contoh penggunaan pemikiran diperpanjang di Messages API:

bash

  curl 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-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?"
        }
      ]
    }'

bash

  ant messages create \
    --format yaml <<'YAML'
  model: haijun-sonnet-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

  client = juglow.Juglow()

  response = client.messages.create(
      model="haijun-sonnet-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 berisi blok pemikiran 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}")

typescript

  const client = new Juglow();

  const response = await client.messages.create({
    model: "haijun-sonnet-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 berisi blok pemikiran yang diringkas dan blok teks
  for (const block of response.content) {
    switch (block.type) {
      case "thinking":
        console.log(`\nThinking summary: ${block.thinking}`);
        break;
      case "text":
        console.log(`\nResponse: ${block.text}`);
        break;
    }
  }

csharp

  JuglowClient client = new();

  var response = await client.Messages.Create(new()
  {
      Model = Model.HaijunSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          },
      ],
  });

  // Respons berisi blok pemikiran yang diringkas dan blok teks
  foreach (var block in response.Content)
  {
      if (block.TryPickThinking(out var thinking))
      {
          Console.WriteLine($"\nThinking summary: {thinking.Thinking}");
      }
      else if (block.TryPickText(out var text))
      {
          Console.WriteLine($"\nResponse: {text.Text}");
      }
  }

  client := juglow.NewClient()

  response, err := client.Messages.New(context.Background(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  juglow.ThinkingConfigParamOfEnabled(10000),
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("Are there an infinite number of prime numbers such that n mod 4 == 3?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Respons berisi blok pemikiran yang diringkas dan blok teks
  for _, block := range response.Content {
  	switch block := block.AsAny().(type) {
  	case juglow.ThinkingBlock:
  		fmt.Printf("\nThinking summary: %s", block.Thinking)
  	case juglow.TextBlock:
  		fmt.Printf("\nResponse: %s", block.Text)
  	}
  }

java

  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;

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

      var params = MessageCreateParams.builder()
          .model(Model.HAIJUN_SONNET_4_6)
          .maxTokens(16_000)
          .enabledThinking(10_000)
          .addUserMessage("Are there an infinite number of prime numbers such that n mod 4 == 3?")
          .build();

      var response = client.messages().create(params);

      // Respons berisi blok pemikiran yang diringkas dan blok teks
      for (var block : response.content()) {
          block.thinking().ifPresent(thinkingBlock ->
              IO.println("\nThinking summary: " + thinkingBlock.thinking())
          );
          block.text().ifPresent(textBlock ->
              IO.println("\nResponse: " + textBlock.text())
          );
      }
  }

php

  $client = new Client();

  $response = $client->messages->create(
      model: 'haijun-sonnet-4-6',
      maxTokens: 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 berisi blok pemikiran yang diringkas dan blok teks
  foreach ($response->content as $block) {
      echo match (true) {
          $block instanceof \Juglow\Messages\ThinkingBlock => "\nThinking summary: {$block->thinking}",
          $block instanceof \Juglow\Messages\TextBlock => "\nResponse: {$block->text}",
          default => '',
      };
  }

ruby

  client = Juglow::Client.new

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

  # Respons berisi blok pemikiran yang diringkas dan blok teks
  response.content.each do |block|
    case block
    when Juglow::Models::ThinkingBlock
      puts "\nThinking summary: #{block.thinking}"
    when Juglow::Models::TextBlock
      puts "\nResponse: #{block.text}"
    end
  end

Untuk mengaktifkan pemikiran diperpanjang manual, tambahkan objek thinking dengan type diatur ke enabled dan sebuah nilai budget_tokens.

Parameter budget_tokens menetapkan target berapa banyak token yang dapat digunakan Haijun untuk proses penalaran internalnya. Anggaran yang lebih besar dapat meningkatkan kualitas respons dengan memungkinkan analisis yang lebih menyeluruh untuk masalah yang kompleks.

Aturan dan penyetelan anggaran

budget_tokens harus memenuhi batasan berikut:

Minimum 1.024 token. API menolak nilai yang lebih kecil.

Kurang dari max_tokens. Token pemikiran dihitung terhadap batas max_tokens untuk giliran tersebut, sehingga anggaran harus menyisakan ruang untuk respons akhir. Satu-satunya pengecualian adalah pemikiran berselang-seling, di mana budget_tokens dapat melebihi max_tokens karena anggaran mencakup semua blok pemikiran dalam satu giliran asisten.

Tanpa pemanasan awal cache. Karena budget_tokens harus kurang dari max_tokens, pemikiran diperpanjang tidak dapat digabungkan dengan max_tokens: 0 (pemanasan awal cache).

Anggaran adalah target, bukan batas yang ketat. Penggunaan token aktual bervariasi tergantung tugas, dan Haijun mungkin berhenti bernalar jauh sebelum anggaran habis; max_tokens tetap menjadi batas atas mutlak untuk total output.

Pada Haijun Opus 4.5, satu-satunya model khusus pemikiran diperpanjang yang mendukung effort, effort membentuk respons secara keseluruhan sementara budget_tokens menetapkan kedalaman pemikiran; atur keduanya.

Untuk menyetel anggaran:

Sesuaikan titik awal dengan tugasnya. Untuk tugas sederhana, mulailah di dekat minimum 1.024 token dan tingkatkan secara bertahap untuk menemukan rentang optimal bagi kasus penggunaan Anda. Untuk tugas kompleks, mulailah dengan anggaran yang lebih besar yaitu 16.000 token atau lebih dan sesuaikan dengan kebutuhan latensi dan kualitas Anda. Anggaran yang lebih tinggi memungkinkan penalaran yang lebih komprehensif, dengan hasil yang semakin berkurang tergantung pada tugasnya, dan dengan konsekuensi latensi yang meningkat. Untuk tugas-tugas kritis, uji berbagai pengaturan untuk menemukan keseimbangan yang tepat.

Untuk anggaran pemikiran di atas 32k, gunakan pemrosesan batch untuk menghindari masalah jaringan. Mendorong model untuk berpikir melebihi 32k token menghasilkan permintaan yang berjalan lama yang dapat mencapai batas waktu sistem dan batas koneksi terbuka.

Untuk melacak berapa biaya sebenarnya dari suatu anggaran, pantau field usage.output_tokens_details.thinking_tokens dalam respons, yang melaporkan berapa banyak dari token output yang ditagihkan merupakan penalaran internal. Saat streaming, rincian ini hanya muncul pada event message_delta terakhir.

Ketika Anda siap untuk beralih dari anggaran manual, lihat Migrasi ke pemikiran adaptif.

Pemikiran berselang-seling dalam mode manual

"Interleaved thinking" (pemikiran berselang-seling) memungkinkan Haijun berpikir di antara pemanggilan alat dalam satu giliran asisten, bernalar tentang setiap hasil alat sebelum memutuskan apa yang harus dilakukan selanjutnya. Untuk konsepnya, struktur giliran, dan bagaimana perilakunya pada model pemikiran adaptif, lihat pemikiran berselang-seling di ikhtisar pemikiran. Bagian ini membahas cara mengaktifkannya ketika Anda menggunakan pemikiran manual type: "enabled".

Pada Haijun Opus 4.5, Haijun Sonnet 4.5, dan model Haijun 4 sebelumnya, tambahkan header beta interleaved-thinking-2025-05-14 ke permintaan API Anda.

Generasi 4.6 terbagi dalam mode manual:

Haijun Sonnet 4.6: header beta dengan type: "enabled" manual masih berfungsi tetapi sudah deprecated. Utamakan pemikiran adaptif, yang berselang-seling secara otomatis tanpa header.

Haijun Opus 4.6: mode manual tidak memiliki pemikiran berselang-seling sama sekali. Hanya mode adaptifnya yang berselang-seling, jadi beralihlah ke thinking: {type: "adaptive"} jika Anda memerlukan penalaran di antara pemanggilan alat pada model ini.

Haijun Haiku 4.5 tidak mendukung pemikiran berselang-seling. Pada Haijun API, header beta diterima tetapi diabaikan.

Dua pertimbangan lagi untuk pemikiran berselang-seling dalam mode manual:

budget_tokens dapat melebihi max_tokens di sini; aturan anggaran menjelaskan pengecualian ini.

Pemikiran berselang-seling hanya didukung untuk alat yang digunakan melalui Messages API.

Cara platform memperlakukan header beta berbeda-beda. Haijun API dan Haijun Platform on AWS menerima interleaved-thinking-2025-05-14 pada model apa pun dan mengabaikannya jika tidak didukung. Penerimaan tidak sama dengan efek: pada model yang menolak type: "enabled" (4.7 dan yang lebih baru) atau tidak memiliki interleaving mode manual (Haijun Opus 4.6), header tersebut tidak memiliki efek mode manual; pemikiran adaptif berselang-seling secara otomatis di sana.

Platform yang dioperasikan mitra (Amazon Bedrock dan Google Cloud) juga menerima header tersebut pada model apa pun tanpa mengembalikan error, dan mengabaikannya pada model yang tidak mendukung pemikiran berselang-seling.

Struktur giliran dalam mode manual

Aturan struktur giliran umum, termasuk loop penggunaan alat satu giliran, penanganan konflik di tengah giliran, dan pengalihan pemikiran antar giliran, terdapat di Pemikiran dengan penggunaan alat.

Mode manual menambahkan satu persyaratan: giliran asisten terakhir dari permintaan dengan pemikiran aktif harus dimulai dengan blok pemikiran (pemikiran adaptif menghapus persyaratan tersebut). Mengubah konfigurasi pemikiran antar giliran juga membatalkan caching prompt; lihat bagian berikut.

Caching prompt dalam mode manual

Mode manual menambahkan satu aturan di atas perilaku caching netral-mode yang dijelaskan dalam pemikiran dan caching prompt: mengubah budget_tokens antar permintaan membatalkan breakpoint cache, sama seperti beralih mode pemikiran, karena nilai anggaran dirender ke dalam prompt. Breakpoint tingkat pesan selalu miss setelah perubahan anggaran; apakah breakpoint alat dan prompt sistem juga miss bergantung pada di mana model merender konfigurasi tersebut.

Dalam praktiknya, pilih satu anggaran dan pertahankan stabil selama masa hidup percakapan yang di-cache. Menjalankan percakapan multi-giliran dengan caching tingkat pesan pada Haijun Sonnet 4.6 dan mengubah anggaran pada permintaan ketiga dari 4.000 menjadi 8.000 token menunjukkan pembatalan tersebut secara langsung:

text

First request - establishing cache
First response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Second request - same thinking parameters (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Third request - different thinking budget (cache miss expected)
Third response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Permintaan ketiga membuat ulang cache (cache_creation_input_tokens=1370, cache_read_input_tokens=0) karena anggaran berubah antar permintaan. Untuk versi yang dapat dijalankan dari eksperimen yang sama dalam mode adaptif, di mana tingkat effort memainkan peran cache yang dimainkan budget_tokens di sini, lihat Caching prompt di halaman pengarahan.

Mekanisme bersama

Sebagian besar perilaku pemikiran bersifat netral-mode dan didokumentasikan sekali di halaman Pemikiran. Semua yang ada di sana juga berlaku dalam mode manual:

Mengontrol tampilan pemikiran

Streaming pemikiran

Pemikiran dengan penggunaan alat, termasuk mempertahankan blok pemikiran

Pemikiran dan caching prompt

Pemikiran dan jendela konteks

Enkripsi pemikiran

Harga (di halaman Mengarahkan pemikiran)

Migrasi ke pemikiran adaptif

Jika model Anda hanya mendukung pemikiran diperpanjang (Haijun Sonnet 4.5, Haijun Opus 4.5, Haijun Haiku 4.5, dan model Haijun 4 sebelumnya), Anda belum perlu melakukan apa pun. Pemikiran adaptif tidak tersedia pada model tersebut, dan type: "adaptive" mengembalikan error 400. Tetap gunakan budget_tokens sampai Anda beralih ke model yang mendukung pemikiran adaptif, lalu terapkan pemetaan berikut.

Anda perlu bermigrasi dari type: "enabled" jika:

Anda menggunakan Haijun Opus 4.6 atau Haijun Sonnet 4.6, di mana budget_tokens sudah deprecated.

Anda menggunakan Haijun 4.7 atau model yang lebih baru, seperti Haijun Opus 5.5, Haijun Sonnet 5, atau Haijun Fable 5.1, di mana type: "enabled" mengembalikan error 400.

Pemetaannya sederhana: hapus budget_tokens, tetapkan thinking: {type: "adaptive"}, dan kendalikan kedalaman penalaran dengan output_config: {effort: ...}, bukan dengan anggaran token.

json

{
  "model": "haijun-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}

menjadi:

json

{
  "model": "haijun-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive"
  },
  "output_config": {
    "effort": "high"
  }
}

effort: "high" sama dengan nilai default API. Nilai ini dicantumkan di sini hanya untuk menunjukkan letak kontrol kedalaman yang baru, dan menghilangkannya menghasilkan perilaku yang identik.

Perubahan ini bukan sekadar perubahan sintaks, karena perilakunya juga berbeda. Dengan anggaran tetap, Haijun berpikir pada setiap permintaan. Dengan pemikiran adaptif, Haijun memutuskan apakah perlu berpikir dan seberapa banyak pada setiap permintaan. Pada pengaturan effort yang lebih rendah, Haijun bahkan dapat melewatkan pemikiran sepenuhnya untuk input yang mudah. Setelah bermigrasi, Anda juga dapat menghapus header beta interleaved-thinking-2025-05-14, karena pemikiran adaptif berselang-seling secara otomatis dan Haijun API mengabaikan header tersebut pada model-model ini. Pelestarian blok pemikiran juga berubah. Haijun Opus 4.5 dan model bernomor 4.6 ke atas menyimpan blok pemikiran dari giliran sebelumnya dalam konteks dan menagihnya sebagai input, sedangkan Haijun Sonnet 4.5, Haijun Haiku 4.5, dan model sebelumnya menghapusnya. Lihat pelestarian blok pemikiran per model.

Beralih mode termasuk perubahan konfigurasi pemikiran, sehingga permintaan pertama setelah peralihan membatalkan breakpoint cache, seperti dijelaskan di Caching prompt dalam mode manual.

Untuk panduan lengkap, lihat pemikiran adaptif, effort, dan panduan migrasi model.

Langkah selanjutnya

Pelajari cara kerja pemikiran: blok, tampilan, streaming, dan penggunaan alat.

Biarkan Haijun memutuskan kapan dan seberapa banyak berpikir pada setiap permintaan.

Pertahankan blok pemikiran dan kelola pemikiran di seluruh pemanggilan alat dan giliran.

#Model yang didukung

#Cara menggunakan pemikiran diperpanjang

#Aturan dan penyetelan anggaran

#Pemikiran berselang-seling dalam mode manual

#Struktur giliran dalam mode manual

#Caching prompt dalam mode manual

#Mekanisme bersama

#Migrasi ke pemikiran adaptif

#Langkah selanjutnya