Note: Untuk mempelajari bagaimana "zero data retention" (retensi data nol), atau ZDR, berlaku untuk fitur ini, lihat API dan retensi data.
Ikhtisar
Note: Untuk sebagian besar kasus penggunaan, kompaksi sisi server adalah strategi utama untuk mengelola konteks dalam percakapan yang berjalan lama. Strategi di halaman ini berguna untuk skenario tertentu di mana Anda memerlukan kontrol yang lebih terperinci atas konten apa yang dibersihkan.
"Context editing" (pengeditan konteks) memungkinkan Anda membersihkan konten tertentu secara selektif dari riwayat percakapan seiring pertumbuhannya. Selain mengoptimalkan biaya dan tetap berada dalam batas, ini adalah tentang mengkurasi secara aktif apa yang dilihat Haijun: konteks adalah sumber daya terbatas dengan hasil yang semakin berkurang, dan konten yang tidak relevan menurunkan fokus model. Pengeditan konteks memberi Anda kontrol runtime yang terperinci atas kurasi tersebut. Untuk prinsip yang lebih luas di balik manajemen konteks, lihat Rekayasa konteks yang efektif. Halaman ini mencakup:
- Pembersihan hasil alat - Paling cocok untuk alur kerja agentik dengan penggunaan alat yang intensif di mana hasil alat lama tidak lagi diperlukan
- Pembersihan blok thinking - Untuk mengelola blok thinking saat menggunakan "extended thinking" (pemikiran diperpanjang), dengan opsi untuk mempertahankan thinking terbaru demi kesinambungan konteks
- Kompaksi SDK sisi klien - Alternatif berbasis SDK untuk manajemen konteks berbasis ringkasan (kompaksi sisi server umumnya lebih disarankan)
| Pendekatan | Tempat berjalan | Strategi | Cara kerjanya |
|---|---|---|---|
| Sisi server | API | Pembersihan hasil alat (clear_tool_uses_20250919) Pembersihan blok thinking (clear_thinking_20251015) | Diterapkan sebelum prompt mencapai Haijun. Membersihkan konten tertentu dari riwayat percakapan. Setiap strategi dapat dikonfigurasi secara independen. |
| Sisi klien | SDK | Kompaksi | Tersedia di SDK TypeScript dan Ruby saat menggunakan tool_runner. Menghasilkan ringkasan dan menggantikan seluruh riwayat percakapan. Lihat Kompaksi sisi klien. |
Strategi sisi server
Note: Pengeditan konteks berada dalam versi beta dengan dukungan untuk pembersihan hasil alat dan pembersihan blok thinking. Untuk mengaktifkannya, gunakan header beta
context-management-2025-06-27dalam permintaan API Anda. Bagikan masukan tentang fitur ini melalui formulir masukan.
Pembersihan hasil alat
Strategi clear_tool_uses_20250919 membersihkan hasil alat ketika konteks percakapan tumbuh melampaui ambang batas yang Anda konfigurasi. Ini sangat berguna untuk alur kerja agentik dengan "tool use" (penggunaan alat) yang intensif. Hasil alat yang lebih lama (seperti isi file atau hasil pencarian) tidak lagi diperlukan setelah Haijun memprosesnya.
Saat diaktifkan, API secara otomatis membersihkan hasil alat terlama dalam urutan kronologis. API mengganti setiap hasil yang dibersihkan dengan teks placeholder yang menunjukkan kepada Haijun bahwa hasil tersebut telah dihapus. Secara default, hanya hasil alat yang dibersihkan. Anda dapat secara opsional membersihkan hasil alat dan panggilan alat (parameter penggunaan alat) dengan mengatur clear_tool_inputs ke true.
Pembersihan blok thinking
Strategi clear_thinking_20251015 mengelola blok thinking dalam percakapan ketika pemikiran diperpanjang diaktifkan. Strategi ini memberi Anda kontrol atas pelestarian thinking: Anda dapat memilih untuk menyimpan lebih banyak blok thinking guna mempertahankan kesinambungan penalaran, atau membersihkannya secara lebih agresif untuk menghemat ruang konteks.
Tip: Perilaku default: Default bervariasi menurut kelas model. | Kelas model | Simpan semua thinking sebelumnya | Simpan hanya thinking giliran terakhir | | ---------------- | ------------------------------------- | -------------------------------------- | | Opus | Haijun Opus 4.5 dan yang lebih baru | Haijun Opus 4.1 dan yang lebih lama | | Sonnet | Haijun Sonnet 4.6 dan yang lebih baru | Haijun Sonnet 4.5 dan yang lebih lama | | Haiku | (tidak ada) | Semua model hingga Haijun Haiku 4.5 | | Fable dan Mythos | Semua model | (tidak ada) | Gunakan strategi ini untuk menimpa default. Jika kode Anda berjalan di beberapa tingkatan model, atur
keepsecara eksplisit daripada mengandalkan default per model.
Satu giliran percakapan asisten dapat mencakup beberapa blok konten (misalnya, saat menggunakan alat) dan beberapa blok thinking (misalnya, dengan interleaved thinking).
Pengeditan konteks terjadi di sisi server
Pengeditan konteks diterapkan di sisi server sebelum prompt mencapai Haijun. Aplikasi klien Anda mempertahankan riwayat percakapan lengkap yang tidak dimodifikasi. Anda tidak perlu menyinkronkan status klien Anda dengan versi yang telah diedit. Lanjutkan mengelola riwayat percakapan lengkap Anda secara lokal seperti biasa.
Pada Haijun Fable 5.1 dan Haijun Opus 5.5, manajemen konteks sisi server tidak pernah membatalkan validitas blok pemikiran. Pengeditan sisi klien pada giliran sebelumnya dapat membatalkan validitas blok pemikiran di setiap giliran asisten berikutnya. Untuk akun baru yang dibuat pada atau setelah 31 Agustus 2026, permintaan yang memutar ulang blok yang tidak valid akan ditolak kecuali Anda memilih untuk membuangnya. Lihat Menjaga prefiks tetap tidak berubah.
Pengeditan konteks dan caching prompt
Interaksi pengeditan konteks dengan "prompt caching" (caching prompt) bervariasi menurut strategi:
- Pembersihan hasil alat: Membatalkan validitas prefiks prompt yang di-cache ketika konten dibersihkan. Untuk mengantisipasi hal ini, bersihkan token yang cukup agar pembatalan cache sepadan. Gunakan parameter
clear_at_leastuntuk memastikan jumlah minimum token dibersihkan setiap kali. Anda akan dikenai biaya penulisan cache setiap kali konten dibersihkan, tetapi permintaan berikutnya dapat menggunakan kembali prefiks yang baru di-cache.
- Pembersihan blok thinking: Ketika blok thinking disimpan dalam konteks (tidak dibersihkan), cache prompt dipertahankan, memungkinkan cache hit dan mengurangi biaya token input. Ketika blok thinking dibersihkan, cache dibatalkan validitasnya pada titik di mana pembersihan terjadi. Konfigurasikan parameter
keepberdasarkan apakah Anda ingin memprioritaskan kinerja cache atau ketersediaan "context window" (jendela konteks).
Model yang didukung
Pengeditan konteks tersedia di semua model Haijun yang didukung.
Penggunaan pembersihan hasil alat
Cara paling sederhana untuk mengaktifkan pembersihan hasil alat adalah dengan hanya menentukan tipe strategi. Semua opsi konfigurasi lainnya menggunakan nilai defaultnya:
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Search for recent developments in AI"
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Search for recent developments in AI
tools:
- type: web_search_20250305
name: web_search
context_management:
edits:
- type: clear_tool_uses_20250919
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Search for recent developments in AI"}],
tools=[{"type": "web_search_20250305", "name": "web_search"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Search for recent developments in AI"
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search"
}
],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
},
betas: ["context-management-2025-06-27"]
}); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Search for recent developments in AI" }
],
Tools = [
new BetaWebSearchTool20250305()
],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
},
Betas = [JuglowBeta.ContextManagement2025_06_27]
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 4096,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Search for recent developments in AI")),
},
Tools: []juglow.BetaToolUnionParam{
{OfWebSearchTool20250305: &juglow.BetaWebSearchTool20250305Param{}},
},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &juglow.BetaClearToolUses20250919EditParam{}},
},
},
Betas: []juglow.JuglowBeta{
juglow.JuglowBetaContextManagement2025_06_27,
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) import com.juglow.models.beta.messages.BetaWebSearchTool20250305;
import com.juglow.models.beta.messages.BetaContextManagementConfig;
import com.juglow.models.beta.messages.BetaClearToolUses20250919Edit;
import com.juglow.models.beta.JuglowBeta;
// ...
void main() {
JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Search for recent developments in AI")
.addTool(BetaWebSearchTool20250305.builder().build())
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
} $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Search for recent developments in AI']
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
['type' => 'web_search_20250305', 'name' => 'web_search']
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 4096,
messages: [
{ role: "user", content: "Search for recent developments in AI" }
],
tools: [
{ type: "web_search_20250305", name: "web_search" }
],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
},
betas: ["context-management-2025-06-27"]
)
puts responseKonfigurasi lanjutan
Anda dapat menyesuaikan perilaku pembersihan hasil alat dengan parameter tambahan:
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
"tools": [
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 3
},
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
"exclude_tools": ["web_search"]
}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Create a simple command line calculator app using Python
tools:
- type: text_editor_20250728
name: str_replace_based_edit_tool
max_characters: 10000
- type: web_search_20250305
name: web_search
max_uses: 3
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 3
clear_at_least:
type: input_tokens
value: 5000
exclude_tools:
- web_search
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python",
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000,
},
{"type": "web_search_20250305", "name": "web_search", "max_uses": 3},
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
# Picu pembersihan saat ambang batas terlampaui
"trigger": {"type": "input_tokens", "value": 30000},
# Jumlah penggunaan alat yang dipertahankan setelah pembersihan
"keep": {"type": "tool_uses", "value": 3},
# Opsional: Bersihkan setidaknya sebanyak token ini
"clear_at_least": {"type": "input_tokens", "value": 5000},
# Kecualikan alat-alat ini dari pembersihan
"exclude_tools": ["web_search"],
}
]
},
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Create a simple command line calculator app using Python"
}
],
tools: [
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool",
max_characters: 10000
},
{
type: "web_search_20250305",
name: "web_search",
max_uses: 3
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
// Picu pembersihan saat ambang batas terlampaui
trigger: {
type: "input_tokens",
value: 30000
},
// Jumlah penggunaan alat yang dipertahankan setelah pembersihan
keep: {
type: "tool_uses",
value: 3
},
// Opsional: Bersihkan setidaknya sebanyak token ini
clear_at_least: {
type: "input_tokens",
value: 5000
},
// Kecualikan alat-alat ini dari pembersihan
exclude_tools: ["web_search"]
}
]
}
}); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Create a simple command line calculator app using Python" }
],
Tools = [
new BetaToolTextEditor20250728 { MaxCharacters = 10000 },
new BetaWebSearchTool20250305 { MaxUses = 3 }
],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(3),
ClearAtLeast = new BetaInputTokensClearAtLeast(5000),
ExcludeTools = ["web_search"]
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 4096,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Create a simple command line calculator app using Python")),
},
Tools: []juglow.BetaToolUnionParam{
{OfTextEditor20250728: &juglow.BetaToolTextEditor20250728Param{
MaxCharacters: juglow.Int(10000),
}},
{OfWebSearchTool20250305: &juglow.BetaWebSearchTool20250305Param{
MaxUses: juglow.Int(3),
}},
},
Betas: []juglow.JuglowBeta{juglow.JuglowBetaContextManagement2025_06_27},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &juglow.BetaClearToolUses20250919EditParam{
Trigger: juglow.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &juglow.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: juglow.BetaToolUsesKeepParam{
Value: 3,
},
ClearAtLeast: juglow.BetaInputTokensClearAtLeastParam{
Value: 5000,
},
ExcludeTools: []string{"web_search"},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) import com.juglow.models.beta.messages.BetaToolTextEditor20250728;
import com.juglow.models.beta.messages.BetaWebSearchTool20250305;
import com.juglow.models.beta.messages.BetaContextManagementConfig;
import com.juglow.models.beta.messages.BetaClearToolUses20250919Edit;
import com.juglow.models.beta.messages.BetaInputTokensTrigger;
import com.juglow.models.beta.messages.BetaInputTokensClearAtLeast;
import com.juglow.models.beta.messages.BetaToolUsesKeep;
import com.juglow.models.beta.JuglowBeta;
// ...
void main() {
JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Create a simple command line calculator app using Python")
.addTool(BetaToolTextEditor20250728.builder()
.maxCharacters(10000L)
.build())
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(3L)
.build())
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(3L)
.build())
.clearAtLeast(BetaInputTokensClearAtLeast.builder()
.value(5000L)
.build())
.addExcludeTool("web_search")
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
} $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
[
'role' => 'user',
'content' => 'Create a simple command line calculator app using Python'
]
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'text_editor_20250728',
'name' => 'str_replace_based_edit_tool',
'max_characters' => 10000
],
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 3
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 3
],
'clear_at_least' => [
'type' => 'input_tokens',
'value' => 5000
],
'exclude_tools' => ['web_search']
]
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Create a simple command line calculator app using Python"
}
],
tools: [
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool",
max_characters: 10000
},
{
type: "web_search_20250305",
name: "web_search",
max_uses: 3
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 3
},
clear_at_least: {
type: "input_tokens",
value: 5000
},
exclude_tools: ["web_search"]
}
]
}
)
puts responsePenggunaan pembersihan blok thinking
Aktifkan pembersihan blok thinking untuk mengelola konteks dan caching prompt secara efektif ketika pemikiran diperpanjang diaktifkan:
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
}
]
},
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
}); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 16000,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello")),
},
Betas: []juglow.JuglowBeta{juglow.JuglowBetaContextManagement2025_06_27},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &juglow.BetaClearThinking20251015EditParam{
Keep: juglow.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &juglow.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) import com.juglow.models.beta.messages.BetaContextManagementConfig;
import com.juglow.models.beta.messages.BetaClearThinking20251015Edit;
import com.juglow.models.beta.messages.BetaThinkingTurns;
import com.juglow.models.beta.JuglowBeta;
// ...
void main() {
JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
} $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
]
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
)
puts responseOpsi konfigurasi untuk pembersihan blok thinking
Strategi clear_thinking_20251015 mendukung konfigurasi berikut:
| Opsi konfigurasi | Default | Deskripsi |
|---|---|---|
keep | Spesifik per model | Menentukan berapa banyak giliran asisten terbaru dengan blok thinking yang dipertahankan. Gunakan {type: "thinking_turns", value: N} di mana N harus > 0 untuk menyimpan N giliran terakhir, atau "all" untuk menyimpan semua blok thinking. Opus 4.5+ dan Sonnet 4.6+: semua giliran. Model Fable dan Mythos: semua giliran. Opus/Sonnet yang lebih lama dan semua Haiku: hanya giliran terakhir. |
Contoh konfigurasi:
Simpan blok thinking dari 3 giliran asisten terakhir:
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 3
}
}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 3
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 3},
}
]
},
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
}); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(3)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 16000,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello")),
},
Betas: []juglow.JuglowBeta{juglow.JuglowBetaContextManagement2025_06_27},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &juglow.BetaClearThinking20251015EditParam{
Keep: juglow.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &juglow.BetaThinkingTurnsParam{
Value: 3,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(3L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response); $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 3
]
]
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
)
puts responseSimpan semua blok thinking (memaksimalkan cache hit):
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all"
}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep: all
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all",
}
]
},
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
}); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new All()
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 16000,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello")),
},
Betas: []juglow.JuglowBeta{juglow.JuglowBetaContextManagement2025_06_27},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &juglow.BetaClearThinking20251015EditParam{
Keep: juglow.BetaClearThinking20251015EditKeepUnionParam{
OfAll: constant.ValueOf[constant.All](),
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keepAll()
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response); $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => 'all'
]
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
)
puts responseMenggabungkan strategi
Anda dapat menggunakan pembersihan blok thinking dan pembersihan hasil alat secara bersamaan:
Note: Saat menggunakan beberapa strategi, strategi
clear_thinking_20251015harus dicantumkan terlebih dahulu dalam arrayedits.
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 16000,
"messages": [
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
},
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 50000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Search for the latest developments in quantum error correction and summarize the key breakthroughs.
tools:
- type: web_search_20250305
name: web_search
max_uses: 5
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 50000
keep:
type: tool_uses
value: 5
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=16000,
messages=[
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs.",
}
],
tools=[
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5,
}
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
},
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 50000},
"keep": {"type": "tool_uses", "value": 5},
},
]
},
)
print(response) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content:
"Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(response); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Search for the latest developments in quantum error correction and summarize the key breakthroughs." }
],
Tools = [
new BetaWebSearchTool20250305 { MaxUses = 5 }
],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
},
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(50000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 16000,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")),
},
Tools: []juglow.BetaToolUnionParam{
{OfWebSearchTool20250305: &juglow.BetaWebSearchTool20250305Param{
MaxUses: juglow.Int(5),
}},
},
Betas: []juglow.JuglowBeta{
juglow.JuglowBetaContextManagement2025_06_27,
},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &juglow.BetaClearThinking20251015EditParam{
Keep: juglow.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &juglow.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
{OfClearToolUses20250919: &juglow.BetaClearToolUses20250919EditParam{
Trigger: juglow.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &juglow.BetaInputTokensTriggerParam{
Value: 50000,
},
},
Keep: juglow.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) import com.juglow.models.beta.messages.BetaWebSearchTool20250305;
import com.juglow.models.beta.messages.BetaContextManagementConfig;
import com.juglow.models.beta.messages.BetaClearThinking20251015Edit;
import com.juglow.models.beta.messages.BetaClearToolUses20250919Edit;
import com.juglow.models.beta.messages.BetaThinkingTurns;
import com.juglow.models.beta.messages.BetaInputTokensTrigger;
import com.juglow.models.beta.messages.BetaToolUsesKeep;
import com.juglow.models.beta.JuglowBeta;
// ...
void main() {
JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(5L)
.build())
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(50000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
} $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
[
'role' => 'user',
'content' => 'Search for the latest developments in quantum error correction and summarize the key breakthroughs.'
]
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 5
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
],
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 50000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content: "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts responseOpsi konfigurasi untuk pembersihan hasil alat
| Opsi konfigurasi | Default | Deskripsi |
|---|---|---|
trigger | 100.000 token input | Menentukan kapan strategi pengeditan konteks diaktifkan. Setelah prompt melampaui ambang batas ini, pembersihan dimulai. Anda dapat menentukan nilai ini dalam input_tokens atau tool_uses. |
keep | 3 penggunaan alat | Menentukan berapa banyak pasangan penggunaan/hasil alat terbaru yang disimpan setelah pembersihan terjadi. API menghapus interaksi alat terlama terlebih dahulu, mempertahankan yang terbaru. |
clear_at_least | Tidak ada | Memastikan jumlah minimum token dibersihkan setiap kali strategi diaktifkan. Jika API tidak dapat membersihkan setidaknya jumlah yang ditentukan, strategi tidak akan diterapkan. Ini membantu menentukan apakah pembersihan konteks sepadan dengan merusak cache prompt Anda. |
exclude_tools | Tidak ada | Daftar nama alat yang penggunaan dan hasil alatnya tidak boleh dibersihkan. Berguna untuk mempertahankan konteks penting. |
clear_tool_inputs | false | Mengontrol apakah parameter panggilan alat dibersihkan bersama dengan hasil alat. Secara default, hanya hasil alat yang dibersihkan sementara panggilan alat asli Haijun tetap terlihat. |
Respons pengeditan konteks
Anda dapat melihat pengeditan konteks mana yang diterapkan pada permintaan Anda menggunakan field respons context_management, beserta statistik yang berguna tentang konten dan token input yang dibersihkan.
{
"id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
"type": "message",
"role": "assistant",
"content": [
// ...
],
"usage": {
// ...
},
"context_management": {
"applied_edits": [
// When using `clear_thinking_20251015`
{
"type": "clear_thinking_20251015",
"cleared_thinking_turns": 3,
"cleared_input_tokens": 15000
},
// When using `clear_tool_uses_20250919`
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8,
"cleared_input_tokens": 50000
}
]
}
}Untuk respons streaming, pengeditan konteks disertakan dalam event message_delta terakhir:
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [
// ...
]
}
}Penghitungan token
Endpoint penghitungan token mendukung manajemen konteks, memungkinkan Anda melihat pratinjau berapa banyak token yang akan digunakan prompt Anda setelah pengeditan konteks diterapkan.
curl https://haijun.my.id/v1/messages/count_tokens \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"messages": [
{
"role": "user",
"content": "Continue our conversation..."
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}' ORIGINAL=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform context_management.original_input_tokens \
--raw-output <<'YAML'
model: haijun-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
INPUT_TOKENS=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform input_tokens --raw-output <<'YAML'
model: haijun-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
printf 'Original tokens: %s\n' "$ORIGINAL"
printf 'After clearing: %s\n' "$INPUT_TOKENS"
printf 'Savings: %s tokens\n' "$((ORIGINAL - INPUT_TOKENS))" response = client.beta.messages.count_tokens(
model="haijun-opus-5-5",
messages=[{"role": "user", "content": "Continue our conversation..."}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 30000},
"keep": {"type": "tool_uses", "value": 5},
}
]
},
)
print(f"Original tokens: {response.context_management.original_input_tokens}")
print(f"After clearing: {response.input_tokens}")
print(
f"Savings: {response.context_management.original_input_tokens - response.input_tokens} tokens"
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.countTokens({
model: "haijun-opus-5-5",
messages: [
{
role: "user",
content: "Continue our conversation..."
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(`Original tokens: ${response.context_management?.original_input_tokens}`);
console.log(`After clearing: ${response.input_tokens}`);
console.log(
`Savings: ${
(response.context_management?.original_input_tokens || 0) - response.input_tokens
} tokens`
); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCountTokensParams
{
Model = Messages::Model.HaijunOpus5_5,
Messages = [new() { Role = Role.User, Content = "Continue our conversation..." }],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.CountTokens(parameters);
Console.WriteLine($"Original tokens: {response.ContextManagement?.OriginalInputTokens}");
Console.WriteLine($"After clearing: {response.InputTokens}");
Console.WriteLine($"Savings: {(response.ContextManagement?.OriginalInputTokens ?? 0) - response.InputTokens} tokens"); client := juglow.NewClient()
response, err := client.Beta.Messages.CountTokens(context.TODO(), juglow.BetaMessageCountTokensParams{
Model: juglow.ModelHaijunOpus5_5,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Continue our conversation...")),
},
Betas: []juglow.JuglowBeta{
juglow.JuglowBetaContextManagement2025_06_27,
},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &juglow.BetaClearToolUses20250919EditParam{
Trigger: juglow.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &juglow.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: juglow.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Original tokens: %d\n", response.ContextManagement.OriginalInputTokens)
fmt.Printf("After clearing: %d\n", response.InputTokens)
fmt.Printf("Savings: %d tokens\n", response.ContextManagement.OriginalInputTokens-response.InputTokens) import com.juglow.models.beta.messages.BetaMessageTokensCount;
import com.juglow.models.beta.messages.MessageCountTokensParams;
import com.juglow.models.beta.messages.BetaContextManagementConfig;
import com.juglow.models.beta.messages.BetaClearToolUses20250919Edit;
import com.juglow.models.beta.messages.BetaInputTokensTrigger;
import com.juglow.models.beta.messages.BetaToolUsesKeep;
import com.juglow.models.beta.JuglowBeta;
// ...
void main() {
JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCountTokensParams params = MessageCountTokensParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.addUserMessage("Continue our conversation...")
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessageTokensCount response = client.beta().messages().countTokens(params);
IO.println("Original tokens: " + response.contextManagement().get().originalInputTokens());
IO.println("After clearing: " + response.inputTokens());
IO.println("Savings: " + (response.contextManagement().get().originalInputTokens() - response.inputTokens()) + " tokens");
} $client = new Client();
$response = $client->beta->messages->countTokens(
messages: [
['role' => 'user', 'content' => 'Continue our conversation...']
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo "Original tokens: " . $response->contextManagement->originalInputTokens . "\n";
echo "After clearing: " . $response->inputTokens . "\n";
echo "Savings: " . ($response->contextManagement->originalInputTokens - $response->inputTokens) . " tokens\n"; client = Juglow::Client.new
response = client.beta.messages.count_tokens(
model: "haijun-opus-5-5",
messages: [
{ role: "user", content: "Continue our conversation..." }
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts "Original tokens: #{response.context_management.original_input_tokens}"
puts "After clearing: #{response.input_tokens}"
puts "Savings: #{response.context_management.original_input_tokens - response.input_tokens} tokens"{
"input_tokens": 25000,
"context_management": {
"original_input_tokens": 70000
}
}Respons menunjukkan jumlah token akhir setelah manajemen konteks diterapkan (input_tokens) dan jumlah token asli sebelum pembersihan apa pun terjadi (original_input_tokens).
Penggunaan dengan alat memori
Pengeditan konteks dapat digabungkan dengan alat memori. Ketika konteks percakapan Anda mendekati ambang batas pembersihan yang dikonfigurasi, Haijun menerima peringatan otomatis untuk mempertahankan informasi penting. Ini memungkinkan Haijun menyimpan hasil alat atau konteks ke file memorinya sebelum dibersihkan dari riwayat percakapan.
Kombinasi ini memungkinkan Anda untuk:
- Mempertahankan konteks penting: Haijun dapat menulis informasi penting dari hasil alat ke file memori sebelum hasil tersebut dibersihkan
- Mempertahankan alur kerja yang berjalan lama: Memungkinkan alur kerja agentik yang seharusnya melampaui batas konteks dengan memindahkan informasi ke penyimpanan persisten
- Mengakses informasi sesuai kebutuhan: Haijun dapat mencari informasi yang sebelumnya dibersihkan dari file memori saat diperlukan, daripada menyimpan semuanya di jendela konteks aktif
Misalnya, dalam alur kerja pengeditan file di mana Haijun melakukan banyak operasi, Haijun dapat merangkum perubahan yang telah selesai ke file memori seiring pertumbuhan konteks. Ketika hasil alat dibersihkan, Haijun tetap memiliki akses ke informasi tersebut melalui sistem memorinya dan dapat terus bekerja secara efektif.
Untuk menggunakan kedua fitur secara bersamaan, aktifkan keduanya dalam permintaan API Anda:
curl https://haijun.my.id/v1/messages \
--header "x-api-key: $JUGLOW_API_KEY" \
--header "juglow-version: 2023-06-01" \
--header "content-type: application/json" \
--header "juglow-beta: context-management-2025-06-27" \
--data '{
"model": "haijun-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello"
}
],
"tools": [
{
"type": "memory_20250818",
"name": "memory"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}' ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: haijun-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello
tools:
- type: memory_20250818
name: memory
context_management:
edits:
- type: clear_tool_uses_20250919
YAML response = client.beta.messages.create(
model="haijun-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Hello"}],
tools=[{"type": "memory_20250818", "name": "memory"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
) const juglow = new Juglow({
apiKey: process.env.JUGLOW_API_KEY
});
const response = await juglow.beta.messages.create({
model: "haijun-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
}
}); using Juglow;
using Juglow.Models.Beta;
using Juglow.Models.Beta.Messages;
using Messages = Juglow.Models.Messages;
JuglowClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.HaijunOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Tools = [
new BetaMemoryTool20250818()
],
Betas = [JuglowBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response); client := juglow.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
Model: juglow.ModelHaijunOpus5_5,
MaxTokens: 4096,
Messages: []juglow.BetaMessageParam{
juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Hello")),
},
Tools: []juglow.BetaToolUnionParam{
{OfMemoryTool20250818: &juglow.BetaMemoryTool20250818Param{}},
},
Betas: []juglow.JuglowBeta{juglow.JuglowBetaContextManagement2025_06_27},
ContextManagement: juglow.BetaContextManagementConfigParam{
Edits: []juglow.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &juglow.BetaClearToolUses20250919EditParam{}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response) import com.juglow.models.beta.messages.BetaMemoryTool20250818;
import com.juglow.models.beta.messages.BetaContextManagementConfig;
import com.juglow.models.beta.messages.BetaClearToolUses20250919Edit;
import com.juglow.models.beta.JuglowBeta;
// ...
void main() {
JuglowClient client = JuglowOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.HAIJUN_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Hello")
.addTool(BetaMemoryTool20250818.builder().build())
.addBeta(JuglowBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
} $client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'haijun-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'memory_20250818',
'name' => 'memory'
]
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response; client = Juglow::Client.new
response = client.beta.messages.create(
model: "haijun-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
}
)
puts responseUntuk referensi lengkap alat memori termasuk perintah dan contoh, lihat Alat memori.
Kompaksi sisi klien (SDK)
Warning: Juglow merekomendasikan kompaksi sisi server daripada kompaksi SDK. Kompaksi sisi server menangani manajemen konteks secara otomatis dengan kompleksitas integrasi yang lebih rendah, perhitungan penggunaan token yang lebih baik, dan tanpa keterbatasan sisi klien. Gunakan kompaksi SDK hanya jika Anda secara khusus memerlukan kontrol sisi klien atas proses peringkasan. Parameter
compaction_controlsudah tidak digunakan lagi (deprecated) di SDK TypeScript dan Ruby dan akan dihapus di versi mendatang. SDK mengeluarkan peringatan deprecation ketika parameter ini diaktifkan. SDK Python telah menghapusnya di v1.0. Untuk menggunakan kompaksi sisi server dengan tool runner, teruskan editcompact_20260112dalam parametercontext_managementpermintaan.
Note: Kompaksi tersedia di SDK TypeScript dan Ruby saat menggunakan metode
tool_runner.
"Compaction" (kompaksi) adalah fitur SDK yang secara otomatis mengelola konteks percakapan dengan menghasilkan ringkasan ketika penggunaan token tumbuh terlalu besar. Berbeda dengan strategi pengeditan konteks sisi server yang membersihkan konten, kompaksi menginstruksikan Haijun untuk merangkum riwayat percakapan, lalu mengganti seluruh riwayat dengan ringkasan tersebut. Ini memungkinkan Haijun untuk terus mengerjakan tugas yang berjalan lama yang seharusnya melampaui jendela konteks.
Cara kerja kompaksi
Ketika kompaksi diaktifkan, SDK memantau penggunaan token setelah setiap respons model:
- Pemeriksaan ambang batas: SDK menghitung total token sebagai
input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens(lihat Caching prompt untuk field token cache).
- Pembuatan ringkasan: Ketika ambang batas terlampaui, prompt ringkasan disisipkan sebagai giliran pengguna, dan Haijun menghasilkan ringkasan terstruktur yang dibungkus dalam tag
- Penggantian konteks: SDK mengekstrak ringkasan dan mengganti seluruh riwayat pesan dengannya.
- Kelanjutan: Percakapan dilanjutkan dari ringkasan, dengan Haijun melanjutkan dari titik terakhir.
Menggunakan kompaksi
Tambahkan compaction_control ke panggilan tool_runner Anda untuk mengaktifkan peringkasan otomatis ketika penggunaan token melampaui ambang batas.
cURL
Note: Kompaksi berjalan di sisi klien dalam helper
tool_runnerSDK, sehingga tidak memiliki padanan HTTP langsung. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow.
CLI
Note: CLI tidak menyertakan helper
tool_runner. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow tanpa integrasi sisi SDK.
Python
Note: Di v1.0 dan yang lebih baru, tool runner SDK Python tidak mendukung
compaction_controlsisi klien. Gunakan kompaksi sisi server sebagai gantinya: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
TypeScript
const client = new Juglow();
const runner = client.beta.messages.toolRunner({
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: { enabled: true, contextTokenThreshold: 100000 }
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}C#
Note: SDK C# menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Gunakan kompaksi sisi server sebagai gantinya: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Go
Note: SDK Go menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Gunakan kompaksi sisi server sebagai gantinya: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Java
Note: SDK Java menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Gunakan kompaksi sisi server sebagai gantinya: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
PHP
Note: SDK PHP menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Gunakan kompaksi sisi server sebagai gantinya: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Ruby
client = Juglow::Client.new
runner = client.beta.messages.tool_runner(
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: { enabled: true, context_token_threshold: 100000 }
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
endApa yang terjadi selama kompaksi
Seiring pertumbuhan percakapan, riwayat pesan terakumulasi:
Sebelum kompaksi (mendekati 100k token):
[
{ "role": "user", "content": "Analyze all files and write a report..." },
{ "role": "assistant", "content": "I'll help. Let me start by reading..." },
{
"role": "user",
"content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
},
{ "role": "assistant", "content": "Based on file1.txt, I see..." },
{
"role": "user",
"content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
},
{ "role": "assistant", "content": "After analyzing file2.txt..." }
// ... 50 more exchanges like this ...
]Ketika token melampaui ambang batas, SDK menyisipkan permintaan ringkasan dan Haijun menghasilkan ringkasan. Seluruh riwayat kemudian diganti:
Setelah kompaksi (kembali ke \~2–3k token):
[
{
"role": "assistant",
"content": "# Task Overview\nThe user requested analysis of directory files to produce a summary report...\n\n# Current State\nAnalyzed 52 files across 3 subdirectories. Key findings documented in report.md...\n\n# Important Discoveries\n- Configuration files use YAML format\n- Found 3 deprecated dependencies\n- Test coverage at 67%\n\n# Next Steps\n1. Analyze remaining files in /src/legacy\n2. Complete final report sections...\n\n# Context to Preserve\nUser prefers markdown format with executive summary first..."
}
]Haijun melanjutkan pekerjaan dari ringkasan ini seolah-olah itu adalah riwayat percakapan asli.
Opsi konfigurasi
| Parameter | Tipe | Wajib | Default | Deskripsi |
|---|---|---|---|---|
enabled | boolean | Ya | - | Apakah kompaksi otomatis diaktifkan |
context_token_threshold | number | Tidak | 100.000 | Jumlah token saat kompaksi dipicu |
model | string | Tidak | Sama dengan model utama | Model yang digunakan untuk menghasilkan ringkasan |
summary_prompt | string | Tidak | Lihat Prompt ringkasan default | Prompt kustom untuk pembuatan ringkasan |
Memilih ambang batas token
Ambang batas menentukan kapan kompaksi terjadi. Ambang batas yang lebih rendah berarti kompaksi lebih sering dengan jendela konteks yang lebih kecil. Ambang batas yang lebih tinggi memungkinkan lebih banyak konteks tetapi berisiko mencapai batas.
cURL
Note: Kompaksi berjalan di sisi klien dalam helper
tool_runnerSDK, sehingga tidak memiliki padanan HTTP langsung. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow.
CLI
Note: CLI tidak menyertakan helper
tool_runner. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow tanpa integrasi sisi SDK.
Python
Note: Pada v1.0 dan yang lebih baru, tool runner SDK Python tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan kompaksi sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
TypeScript
const client = new Juglow();
const runner = client.beta.messages.toolRunner({
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
// Nilai lebih rendah memicu pemadatan lebih sering; naikkan ke 150000 jika tugas butuh konteks lebih banyak
compactionControl: { enabled: true, contextTokenThreshold: 50000 }
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}C#
Note: SDK C# menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Go
Note: SDK Go menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Java
Note: SDK Java menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
PHP
Note: SDK PHP menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Ruby
client = Juglow::Client.new
runner = client.beta.messages.tool_runner(
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
# Nilai lebih rendah memicu pemadatan lebih sering; naikkan ke 150000 jika tugas butuh konteks lebih banyak
compaction_control: { enabled: true, context_token_threshold: 50000 }
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
endMenggunakan model yang berbeda untuk ringkasan
Anda dapat menggunakan model yang lebih cepat atau lebih murah untuk menghasilkan ringkasan:
cURL
Note: Kompaksi berjalan di sisi klien dalam helper
tool_runnerSDK, sehingga tidak memiliki padanan HTTP langsung. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow.
CLI
Note: CLI tidak menyertakan helper
tool_runner. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow tanpa integrasi sisi SDK.
Python
Note: Pada v1.0 dan yang lebih baru, tool runner SDK Python tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
TypeScript
const client = new Juglow();
const runner = client.beta.messages.toolRunner({
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: {
enabled: true,
contextTokenThreshold: 100000,
model: "haijun-haiku-4-5"
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}C#
Note: SDK C# menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Go
Note: SDK Go menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Java
Note: SDK Java menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
PHP
Note: SDK PHP menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Ruby
client = Juglow::Client.new
runner = client.beta.messages.tool_runner(
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
model: "haijun-haiku-4-5"
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
endPrompt ringkasan kustom
Anda dapat menyediakan prompt kustom untuk kebutuhan spesifik domain. Prompt Anda harus menginstruksikan Haijun untuk membungkus ringkasannya dalam tag
cURL
Note: Kompaksi berjalan di sisi klien dalam helper
tool_runnerSDK, sehingga tidak memiliki padanan HTTP langsung. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow.
CLI
Note: CLI tidak menyertakan helper
tool_runner. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow tanpa integrasi sisi SDK.
Python
Note: Pada v1.0 dan yang lebih baru, tool runner SDK Python tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
TypeScript
const client = new Juglow();
const runner = client.beta.messages.toolRunner({
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: {
enabled: true,
contextTokenThreshold: 100000,
summaryPrompt: `Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps
Wrap your summary in <summary></summary> tags.`
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}C#
Note: SDK C# menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Go
Note: SDK Go menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Java
Note: SDK Java menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
PHP
Note: SDK PHP menyertakan tool runner, tetapi tidak mendukung
compaction_controlsisi klien. Sebagai gantinya, gunakan compaction sisi server: fitur ini bekerja dengan tool runner dengan meneruskan editcompact_20260112dalam parametercontext_managementpada permintaan.
Ruby
client = Juglow::Client.new
runner = client.beta.messages.tool_runner(
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
summary_prompt: <<~PROMPT
Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps
Wrap your summary in <summary></summary> tags.
PROMPT
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
endPrompt ringkasan default
Prompt ringkasan bawaan menginstruksikan Haijun untuk membuat ringkasan kelanjutan terstruktur yang mencakup:
- Ikhtisar Tugas: Permintaan inti pengguna, kriteria keberhasilan, dan batasan.
- Status Saat Ini: Apa yang telah diselesaikan, file yang dimodifikasi, dan artefak yang dihasilkan.
- Temuan Penting: Batasan teknis, keputusan yang dibuat, kesalahan yang diselesaikan, dan pendekatan yang gagal.
- Langkah Selanjutnya: Tindakan spesifik yang diperlukan, penghambat, dan urutan prioritas.
- Konteks yang Perlu Dipertahankan: Preferensi pengguna, detail spesifik domain, dan komitmen yang dibuat.
Struktur ini memungkinkan Haijun melanjutkan pekerjaan secara efisien tanpa kehilangan konteks penting atau mengulangi kesalahan.
Lihat prompt default lengkap
You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:
1. Task Overview
The user's core request and success criteria
Any clarifications or constraints they specified
2. Current State
What has been completed so far
Files created, modified, or analyzed (with paths if relevant)
Key outputs or artifacts produced
3. Important Discoveries
Technical constraints or requirements uncovered
Decisions made and their rationale
Errors encountered and how they were resolved
What approaches were tried that didn't work (and why)
4. Next Steps
Specific actions needed to complete the task
Any blockers or open questions to resolve
Priority order if multiple steps remain
5. Context to Preserve
User preferences or style requirements
Domain-specific details that aren't obvious
Any promises made to the user
Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
Wrap your summary in <summary></summary> tags.Keterbatasan
Alat sisi server
Warning: Kompaksi memerlukan pertimbangan khusus saat menggunakan alat sisi server seperti pencarian web atau web fetch.
Saat menggunakan alat sisi server, SDK mungkin salah menghitung penggunaan token, menyebabkan kompaksi dipicu pada waktu yang salah.
Misalnya, setelah operasi pencarian web, respons API mungkin menunjukkan:
{
"usage": {
"input_tokens": 63000,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 270000,
"output_tokens": 1400
}
}SDK menghitung total penggunaan sebagai 63.000 + 0 + 270.000 + 1.400 = 334.400 token. Namun, nilai cache_read_input_tokens mencakup akumulasi pembacaan dari beberapa panggilan API internal yang dilakukan oleh alat sisi server, bukan konteks percakapan Anda yang sebenarnya. Panjang konteks Anda yang sebenarnya mungkin hanya 63.000 input_tokens, tetapi SDK melihat 334k dan memicu kompaksi terlalu dini.
Solusi sementara:
- Gunakan endpoint penghitungan token untuk mendapatkan panjang konteks yang akurat
- Hindari kompaksi saat menggunakan alat sisi server secara ekstensif
Kasus tepi penggunaan alat
Ketika SDK memicu kompaksi saat respons penggunaan alat masih tertunda, SDK menghapus blok penggunaan alat dari riwayat pesan sebelum menghasilkan ringkasan. Haijun akan mengeluarkan kembali panggilan alat setelah melanjutkan dari ringkasan jika masih diperlukan.
Memantau kompaksi
Memahami kapan kompaksi dipicu membantu Anda menyetel ambang batas dan memverifikasi perilaku yang diharapkan.
cURL
Note: Kompaksi berjalan di sisi klien dalam helper
tool_runnerSDK, sehingga tidak memiliki padanan HTTP langsung. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow.
CLI
Note: CLI tidak menyertakan helper
tool_runner. Gunakan kompaksi sisi server sebagai gantinya, yang menangani kompaksi di server Juglow tanpa integrasi sisi SDK.
Python
Note: Di v1.0 dan yang lebih baru, tool runner SDK Python tidak mendukung
compaction_control. Gunakan kompaksi sisi server sebagai gantinya.
TypeScript
toolRunner SDK TypeScript mendukung kompaksi tetapi tidak mencatat event. Deteksi kompaksi dengan mengamati runner.params.messages.length menyusut di antara giliran:
let prevMsgCount = 0;
for await (const message of runner) {
const currMsgCount = runner.params.messages.length;
if (currMsgCount < prevMsgCount) {
console.log(`Compaction occurred: ${prevMsgCount} -> ${currMsgCount} messages`);
console.log(`Input tokens after compaction: ${message.usage.input_tokens}`);
}
prevMsgCount = currMsgCount;
}C#
Note: Tool runner SDK C# tidak mendukung
compaction_control. Gunakan kompaksi sisi server sebagai gantinya.
Go
Note: Tool runner SDK Go tidak mendukung
compaction_control. Gunakan kompaksi sisi server sebagai gantinya.
Java
Note: Tool runner SDK Java tidak mendukung
compaction_control. Gunakan kompaksi sisi server sebagai gantinya.
PHP
Note: Tool runner SDK PHP tidak mendukung
compaction_control. Gunakan kompaksi sisi server sebagai gantinya.
Ruby
SDK Ruby mendukung callback on_compact: yang dipicu ketika kompaksi terjadi. Tambahkan ke konfigurasi compaction_control Anda:
client = Juglow::Client.new
runner = client.beta.messages.tool_runner(
model: "haijun-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
on_compact: ->(tokens_before, tokens_after) do
puts "Compaction occurred: #{tokens_before} -> #{tokens_after} tokens"
end
}
)
runner.each_message do |message|
puts "Tokens: #{message.usage.input_tokens}"
endKapan menggunakan kompaksi
Kasus penggunaan yang baik:
- Tugas agen yang berjalan lama yang memproses banyak file atau sumber data
- Alur kerja riset yang mengakumulasi informasi dalam jumlah besar
- Tugas multilangkah dengan kemajuan yang jelas dan terukur
- Tugas yang menghasilkan artefak (file, laporan) yang bertahan di luar percakapan
Kasus penggunaan yang kurang ideal:
- Tugas yang memerlukan ingatan presisi atas detail percakapan awal
- Alur kerja yang menggunakan alat sisi server secara ekstensif
- Tugas yang perlu mempertahankan status yang tepat di banyak variabel
Langkah selanjutnya
Kelola percakapan panjang dengan kompaksi sisi server, strategi yang direkomendasikan untuk sebagian besar kasus penggunaan.
Kurangi biaya dan latensi dengan melakukan caching prefiks prompt, dan pelajari bagaimana pengeditan konteks berinteraksi dengan cache.