minicode-ai 0.23.0 → 0.26.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -3
- package/cli/commands/config.ts +123 -0
- package/cli/setup.ts +107 -8
- package/cli/tui.ts +28 -2
- package/docs/README.md +2 -2
- package/docs/SUMMARY.md +10 -19
- package/docs/TERMINAL_CONTRACT.md +113 -28
- package/docs/architecture.md +1 -1
- package/docs/autonomous-scheduler.md +283 -2
- package/docs/choosing-mode.md +4 -4
- package/docs/concepts.md +39 -3
- package/docs/config.md +103 -5
- package/docs/environment.md +4 -0
- package/docs/getting-started.md +69 -5
- package/docs/repl.md +1 -1
- package/docs/security.md +49 -2
- package/docs/tools.md +2 -1
- package/package.json +2 -36
- package/src/app/provider-layer.ts +1 -1
- package/src/app/session.ts +187 -17
- package/src/config.ts +21 -8
- package/src/constants.ts +17 -1
- package/src/lib/net.ts +6 -15
- package/src/lib/public-http.ts +128 -0
- package/src/lib/safe-open.ts +21 -12
- package/src/memory/vector.ts +0 -31
- package/src/policy/auto-resume.ts +63 -0
- package/src/policy/compaction.ts +354 -70
- package/src/policy/context-budget.ts +4 -6
- package/src/policy/context-window-assign.ts +114 -0
- package/src/policy/context-window-catalog.ts +4 -1
- package/src/policy/context-window-presets.ts +165 -0
- package/src/policy/context-window.ts +19 -37
- package/src/policy/context.ts +11 -9
- package/src/policy/executor.ts +69 -27
- package/src/policy/microcompact.ts +76 -15
- package/src/policy/no-progress.ts +1 -1
- package/src/policy/permission.ts +5 -0
- package/src/policy/recovery-budget.ts +281 -0
- package/src/policy/scrub.ts +15 -2
- package/src/policy/step-escalation.ts +82 -0
- package/src/policy/tokenizer-registry.ts +1 -0
- package/src/policy/tool-contract.ts +11 -9
- package/src/presentation/reducer.ts +1 -0
- package/src/providers/anthropic.ts +3 -3
- package/src/providers/detect.ts +40 -7
- package/src/providers/provision.ts +23 -1
- package/src/runtime/child-execution.ts +4 -2
- package/src/runtime/execution-backend.ts +3 -0
- package/src/sandbox/os.ts +53 -9
- package/src/session/context-assembly.ts +11 -7
- package/src/session/persistence.ts +19 -3
- package/src/task/autonomous-policy.ts +7 -0
- package/src/task/graph-validate.ts +1 -1
- package/src/task/session-authority.ts +0 -5
- package/src/task/store.ts +0 -4
- package/src/tools/ask_user.ts +14 -1
- package/src/tools/bash.ts +68 -17
- package/src/tools/code_run.ts +19 -20
- package/src/tools/context.ts +10 -0
- package/src/tools/delete_file.ts +3 -2
- package/src/tools/edit.ts +5 -4
- package/src/tools/git.ts +70 -12
- package/src/tools/glob.ts +13 -5
- package/src/tools/grep.ts +26 -10
- package/src/tools/index.ts +3 -2
- package/src/tools/lsp.ts +15 -9
- package/src/tools/move_file.ts +4 -3
- package/src/tools/patch.ts +5 -4
- package/src/tools/read_file.ts +3 -2
- package/src/tools/read_image.ts +3 -2
- package/src/tools/task.ts +5 -1
- package/src/tools/todo.ts +4 -8
- package/src/tools/web_fetch.ts +13 -19
- package/src/tools/write_file.ts +4 -3
- package/src/ui/approval/prompt.ts +226 -77
- package/src/ui/assistant/simple.ts +61 -10
- package/src/ui/footer.ts +41 -29
- package/src/ui/i18n/en.ts +7 -0
- package/src/ui/i18n/id.ts +7 -0
- package/src/ui/input/prompt-engine.ts +53 -21
- package/src/ui/render/activity-group.ts +9 -0
- package/src/ui/render/activity-panel.ts +20 -2
- package/src/ui/render/ledger.ts +1 -9
- package/src/ui/render/logo.ts +0 -5
- package/src/ui/render/markdown-table.ts +0 -3
- package/src/ui/render/table-grid.ts +0 -3
- package/src/ui/render/theme.ts +31 -5
- package/src/ui/runtime/screen.ts +7 -1
- package/src/ui/screens/dialog.ts +45 -81
- package/src/ui/screens/form.ts +10 -10
- package/src/ui/screens/model-manager.ts +7 -10
- package/src/ui/screens/picker.ts +8 -11
- package/src/ui/screens/provider-manager.ts +9 -13
- package/src/ui/tui/app.ts +118 -20
- package/src/ui/tui/transcript.ts +179 -29
- package/vendor/minicore/src/core/loop.ts +20 -1
- package/vendor/minicore/src/core/session.ts +6 -0
- package/docs/P14_OPEN_WORK.md +0 -290
- package/docs/config-providers.md +0 -87
- package/docs/glossary.md +0 -39
- package/docs/quickstart.md +0 -60
- package/docs/security-model.md +0 -96
- package/docs/terminal.md +0 -91
package/src/policy/permission.ts
CHANGED
|
@@ -510,6 +510,11 @@ function buildDiffPreview(name: string, args: unknown): string | undefined {
|
|
|
510
510
|
const m = line(str(a.message), 160)
|
|
511
511
|
return m ? out(`commit ${m}`) : undefined
|
|
512
512
|
}
|
|
513
|
+
case "git_push": {
|
|
514
|
+
const remote = str(a.remote) || "origin"
|
|
515
|
+
const branch = str(a.branch) ? ` ${str(a.branch)}` : ""
|
|
516
|
+
return out(`push ${remote}${branch}`)
|
|
517
|
+
}
|
|
513
518
|
default: {
|
|
514
519
|
// Generic: name + ringkasan key=value yang dibasuh — jangan JSON mentah
|
|
515
520
|
// (struktur/token yang tak dikenal scrub bisa bocor).
|
|
@@ -0,0 +1,281 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Anggaran pemulihan bersama untuk SATU panggilan logis ke penyedia.
|
|
3
|
+
*
|
|
4
|
+
* ── Kenapa modul ini ada ────────────────────────────────────────────────────
|
|
5
|
+
* Insiden aslinya (sesi `17b6a5ff`, OBSERVATION.md T-009): satu gangguan
|
|
6
|
+
* penyedia yang berlangsung belasan detik mematikan sesi total, karena anggaran
|
|
7
|
+
* retry kernel hanya 3 percobaan (1+2+4 = 7 dtk).
|
|
8
|
+
*
|
|
9
|
+
* Perbaikan naif — "naikkan jumlah percobaan di retry, lalu tambahkan resume
|
|
10
|
+
* turn" — sudah dicoba dan salah secara struktural. Retry dan resume berada di
|
|
11
|
+
* dua lapisan berbeda, jadi biayanya BERKALI, bukan bertambah: 5 percobaan retry
|
|
12
|
+
* diulang untuk setiap resume menghasilkan 3 × 23 dtk + 13 dtk ≈ **82 detik**
|
|
13
|
+
* untuk provider yang mati permanen. Sebelum perubahan itu hanya 7 detik.
|
|
14
|
+
*
|
|
15
|
+
* Itu bukan bug angka, melainkan anti-pattern yang punya nama: *retry
|
|
16
|
+
* amplification* / *retry storm* (AWS Well-Architected REL05-BP03, "implement
|
|
17
|
+
* retries at only one level"). Setiap lapisan yang punya anggarannya sendiri
|
|
18
|
+
* mengalikan lapisan di bawahnya, dan hasilnya adalah penundaan raksasa tanpa
|
|
19
|
+
* tambahan kesembuhan.
|
|
20
|
+
*
|
|
21
|
+
* ── Yang dipakai sebagai gantinya (riset 2026) ──────────────────────────────
|
|
22
|
+
* Satu anggaran WAKTU TOTAL dipegang di puncak, dan setiap percobaan memakai
|
|
23
|
+
* sisa anggaran itu. Konsekuensinya: biaya total konstan berapa pun banyaknya
|
|
24
|
+
* lapisan yang mencoba. Ini pola "timeout budget" yang sama dipakai SDK AWS
|
|
25
|
+
* (retry quota), Google SRE, dan panduan agent-loop modern: *"a budget removes
|
|
26
|
+
* the multiplication by construction — the second attempt inherits what the
|
|
27
|
+
* first one left"*.
|
|
28
|
+
*
|
|
29
|
+
* Tiga mekanisme yang ikut dibawa dari praktik standar:
|
|
30
|
+
* 1. **Retry quota (token bucket)** — AWS standard mode. Token berkurang tiap
|
|
31
|
+
* percobaan dan pulih saat sukses. Saat habis, kita berhenti cepat alih-alih
|
|
32
|
+
* menunggu penuh untuk kegagalan yang sudah jelas tidak membaik. Inilah yang
|
|
33
|
+
* membuat provider mati total gagal dalam hitungan detik, bukan menit.
|
|
34
|
+
* 2. **Full jitter** — jeda acak pada `[0, delay]` (bukan delay pasti). Tanpa
|
|
35
|
+
* jitter, semua klien yang gagal bersamaan mencoba lagi bersamaan pula dan
|
|
36
|
+
* mengulang beban yang sama: *thundering herd* yang tertunda.
|
|
37
|
+
* 3. **`Retry-After` sebagai FLOOR, bukan target** — provider lebih tahu kapan
|
|
38
|
+
* jendelanya dibuka; kita tidak pernah menunggu lebih pendek dari itu.
|
|
39
|
+
*
|
|
40
|
+
* ── Apa yang TIDAK dilakukan ────────────────────────────────────────────────
|
|
41
|
+
* - Tidak ada penambahan jumlah percobaan tanpa batas. Anggaran waktu dan kuota
|
|
42
|
+
* token adalah dua pagar yang berbeda; keduanya wajib.
|
|
43
|
+
* - Tidak ada retry untuk kegagalan terminal (auth, request invalid, konteks
|
|
44
|
+
* kehabisan, anggaran habis). Mengulangnya tidak mengubah hasil.
|
|
45
|
+
*
|
|
46
|
+
* Modul ini MURNI (tanpa I/O, tanpa jam global) supaya kebijakan bisa diuji
|
|
47
|
+
* langsung: pemanggil memberi `nowMs`, bukan menyembunyikan `Date.now()`.
|
|
48
|
+
*/
|
|
49
|
+
|
|
50
|
+
/** Batas atas waktu yang boleh dipakai untuk memulihkan SATU panggilan logis.
|
|
51
|
+
*
|
|
52
|
+
* KENAPA 45 dtk: ini menutup gangguan penyedia yang nyata (insiden asli ~11 dtk;
|
|
53
|
+
* 529 "overloaded" Anthropic biasanya pulih dalam hitungan detik) dengan margin
|
|
54
|
+
* besar, sambil tetap jauh di bawah kesabaran user untuk perintah satu-shot dan
|
|
55
|
+
* deadline turn headless. Angka ini juga konsisten dengan praktik umum: panduan
|
|
56
|
+
* AWS menyarankan maksimum backoff 20 dtk, dan anggaran total harus beberapa kali
|
|
57
|
+
* lebih besar agar beberapa percobaan tetap masuk.
|
|
58
|
+
*/
|
|
59
|
+
export const RECOVERY_BUDGET_MS = 45_000
|
|
60
|
+
|
|
61
|
+
/** Kuota percobaan (token bucket). AWS standard mode memakai 3 percobaan total
|
|
62
|
+
* untuk satu request; kita memberi 6 slot karena satu panggilan di sini mencakup
|
|
63
|
+
* retry provider DAN resume turn (dua lapisan yang sekarang berbagi satu kuota).
|
|
64
|
+
*
|
|
65
|
+
* KENAPA tetap terbatas walau ada anggaran waktu: anggaran waktu saja akan
|
|
66
|
+
* menghabiskan 45 dtk penuh untuk provider yang mati. Kuota membuatnya berhenti
|
|
67
|
+
* cepat (≈10–15 dtk) begitu polanya jelas "gagal terus". */
|
|
68
|
+
export const RECOVERY_ATTEMPT_QUOTA = 6
|
|
69
|
+
|
|
70
|
+
/** Backoff dasar dan plafon per percobaan (ms).
|
|
71
|
+
*
|
|
72
|
+
* KENAPA 500 dan 8 dtk: AWS memakai base 50 ms untuk transient (sangat cepat
|
|
73
|
+
* karena panggilan HTTP-nya sendiri sudah cepat) dan 1 dtk untuk throttling.
|
|
74
|
+
* Panggilan LLM jauh lebih mahal dan lebih lambat, jadi base 500 ms masuk akal,
|
|
75
|
+
* dengan plafon 8 dtk yang sama dengan plafon backoff SDK Anthropic. */
|
|
76
|
+
export const RECOVERY_BASE_DELAY_MS = 500
|
|
77
|
+
export const RECOVERY_MAX_DELAY_MS = 8_000
|
|
78
|
+
|
|
79
|
+
/** Batas minimum jeda agar tidak menjadi hot loop (ms). */
|
|
80
|
+
export const RECOVERY_MIN_DELAY_MS = 50
|
|
81
|
+
|
|
82
|
+
/** Alasan berhenti — dipakai untuk pesan ke user, bukan sekadar dibuang. */
|
|
83
|
+
export type RecoveryStopReason =
|
|
84
|
+
/** Kategori/kind tidak akan membaik dengan diulang. */
|
|
85
|
+
| "not-transient"
|
|
86
|
+
/** Kuota percobaan habis (token bucket kosong). */
|
|
87
|
+
| "attempts-exhausted"
|
|
88
|
+
/** Anggaran waktu total habis. */
|
|
89
|
+
| "budget-exhausted"
|
|
90
|
+
/** User membatalkan (Ctrl+C / abort). */
|
|
91
|
+
| "user-abort"
|
|
92
|
+
/** Anggaran biaya/token model sudah habis — bukan gangguan penyedia. */
|
|
93
|
+
| "cost-budget"
|
|
94
|
+
/** Tidak ada prompt untuk dilanjutkan. */
|
|
95
|
+
| "no-prompt"
|
|
96
|
+
|
|
97
|
+
/** Kelanjutan yang diizinkan untuk sebuah kegagalan. */
|
|
98
|
+
export type RecoveryDecision =
|
|
99
|
+
| {
|
|
100
|
+
action: "retry"
|
|
101
|
+
/** Percobaan ke berapa (1-based) setelah keputusan ini dijalankan. */
|
|
102
|
+
attempt: number
|
|
103
|
+
/** Jeda sebelum percobaan itu (sudah termasuk jitter). */
|
|
104
|
+
delayMs: number
|
|
105
|
+
/** Sisa anggaran waktu setelah jeda (ms), untuk diagnostik/uji. */
|
|
106
|
+
remainingMs: number
|
|
107
|
+
}
|
|
108
|
+
| { action: "stop"; reason: RecoveryStopReason }
|
|
109
|
+
|
|
110
|
+
/** Keadaan anggaran pada satu titik waktu. */
|
|
111
|
+
export interface RecoveryState {
|
|
112
|
+
/** Waktu mulai percobaan pertama (epoch ms). */
|
|
113
|
+
startedAtMs: number
|
|
114
|
+
/** Waktu sekarang (epoch ms) — diberikan pemanggil, bukan diambil sendiri. */
|
|
115
|
+
nowMs: number
|
|
116
|
+
/** Percobaan yang SUDAH dipakai dari kuota. */
|
|
117
|
+
attemptsUsed: number
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
/** Sinyal kegagalan minimum, dipisah dari kelas error konkret agar murni. */
|
|
121
|
+
export interface FailureSignal {
|
|
122
|
+
/** Kategori provider bila kegagalannya berasal dari penyedia. */
|
|
123
|
+
category?: string
|
|
124
|
+
/** Kode kind AgentError (`max_steps_exceeded`, `aborted`, ...). */
|
|
125
|
+
kind?: string
|
|
126
|
+
/** True bila pembatalan datang dari user (bukan timeout internal). */
|
|
127
|
+
abortedByUser?: boolean
|
|
128
|
+
/** Petunjuk tunggu dari provider (`Retry-After`), ms. */
|
|
129
|
+
retryAfterMs?: number
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
/** Kategori provider yang layak dicoba ulang: gangguan di sisi penyedia/jaringan.
|
|
133
|
+
*
|
|
134
|
+
* KENAPA `rate_limit` TIDAK ikut (riset 2026): 429 punya dua wajah yang tidak
|
|
135
|
+
* bisa dibedakan dari status saja. Yang biasa membawa `Retry-After` dan sudah
|
|
136
|
+
* ditangani lapisan retry (menghormati header, 3 percobaan) — mengulanginya di
|
|
137
|
+
* sini hanya menggandakan jeda. Yang kedua permanen: spend cap Anthropic (tanpa
|
|
138
|
+
* `Retry-After`) dan `credit_balance_exhausted`/spend-limit OpenAI, yang tidak
|
|
139
|
+
* pulih walau ditunggu. 5xx — termasuk 529 "overloaded" Anthropic yang dipetakan
|
|
140
|
+
* adapter ke `server` — tidak punya sinyal itu, dan di situlah pemulihan berguna.
|
|
141
|
+
*/
|
|
142
|
+
const TRANSIENT_CATEGORIES: ReadonlySet<string> = new Set(["server", "network"])
|
|
143
|
+
|
|
144
|
+
/** Kind kegagalan yang layak diulang ketika kategori tidak terbawa.
|
|
145
|
+
*
|
|
146
|
+
* KENAPA hanya `provider`: itu penanda "kegagalannya datang dari penyedia", dan
|
|
147
|
+
* kategori di atas yang memutuskan apakah sementaranya.
|
|
148
|
+
*
|
|
149
|
+
* KENAPA `budget_exceeded` TIDAK ikut (regresi nyata yang tertangkap tes):
|
|
150
|
+
* anggaran biaya yang habis bukan kondisi sementara. Mengulang turn justru
|
|
151
|
+
* MEMBAKAR lebih banyak uang untuk melewati pagar yang sama lalu gagal di titik
|
|
152
|
+
* yang sama. Gejalanya persis itu: `budget exceeded` → jeda → `budget exceeded`,
|
|
153
|
+
* dua kali membayar penuh lewat provider, dan bagi operator tampak seperti
|
|
154
|
+
* provider rusak padahal sistem sedang menghormati pagar yang ia sendiri pasang.
|
|
155
|
+
*
|
|
156
|
+
* `aborted`, `max_turns`, auth, dan request invalid juga TIDAK. `max_steps_exceeded`
|
|
157
|
+
* punya jalur sendiri (eskalasi batas langkah); kalau ikut di sini, turn diulang
|
|
158
|
+
* SEKALIGUS batasnya dinaikkan — biaya ganda untuk satu masalah.
|
|
159
|
+
*/
|
|
160
|
+
const RETRYABLE_KINDS: ReadonlySet<string> = new Set(["provider"])
|
|
161
|
+
|
|
162
|
+
/** Kategori yang secara eksplisit TIDAK akan membaik walau diulang. Didaftarkan
|
|
163
|
+
* supaya "tidak di-retry" menjadi keputusan yang disengaja, bukan efek samping
|
|
164
|
+
* dari daftar yang tak memuatnya. */
|
|
165
|
+
const TERMINAL_CATEGORIES: ReadonlySet<string> = new Set([
|
|
166
|
+
"auth",
|
|
167
|
+
"invalid_request",
|
|
168
|
+
"context_length_exceeded",
|
|
169
|
+
])
|
|
170
|
+
|
|
171
|
+
/** Kind yang terminal untuk tujuan pemulihan. */
|
|
172
|
+
const TERMINAL_KINDS: ReadonlySet<string> = new Set([
|
|
173
|
+
"aborted",
|
|
174
|
+
"budget_exceeded",
|
|
175
|
+
"max_turns",
|
|
176
|
+
"max_steps_exceeded",
|
|
177
|
+
])
|
|
178
|
+
|
|
179
|
+
/**
|
|
180
|
+
* Apakah kegagalan ini layak untuk dicoba lagi sama sekali.
|
|
181
|
+
*
|
|
182
|
+
* Dipisah dari {@link planRecovery} supaya daftar terminal bisa diuji sendiri —
|
|
183
|
+
* kesalahan di sini adalah kesalahan diagnosis, dan diagnosis yang salah membuat
|
|
184
|
+
* semua anggaran di bawahnya sia-sia.
|
|
185
|
+
*/
|
|
186
|
+
export function isRecoverable(failure: FailureSignal): boolean {
|
|
187
|
+
if (failure.abortedByUser === true) return false
|
|
188
|
+
if (failure.kind !== undefined && TERMINAL_KINDS.has(failure.kind)) return false
|
|
189
|
+
if (failure.category !== undefined) {
|
|
190
|
+
if (TERMINAL_CATEGORIES.has(failure.category)) return false
|
|
191
|
+
return TRANSIENT_CATEGORIES.has(failure.category)
|
|
192
|
+
}
|
|
193
|
+
// Kategori tidak terbawa: pakai kind sebagai cadangan.
|
|
194
|
+
return failure.kind !== undefined && RETRYABLE_KINDS.has(failure.kind)
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
/**
|
|
198
|
+
* Full jitter: nilai acak pada `[min, delay]`.
|
|
199
|
+
*
|
|
200
|
+
* KENAPA full jitter dan bukan "delay + sedikit acak": tujuan jitter adalah
|
|
201
|
+
* memecah klien yang gagal bersamaan agar tidak mencoba bersamaan lagi. Jeda
|
|
202
|
+
* deterministik menghasilkan thundering herd yang hanya tertunda. AWS
|
|
203
|
+
* Architecture Blog: `sleep = random_between(0, min(cap, base * 2^attempt))`.
|
|
204
|
+
*
|
|
205
|
+
* `min` dinaikkan dari 0 ke {@link RECOVERY_MIN_DELAY_MS} agar percobaan pertama
|
|
206
|
+
* tidak menjadi hot retry (dan agar `Retry-After` kecil tetap dihormati sebagai
|
|
207
|
+
* floor). `random` di-inject supaya uji deterministik.
|
|
208
|
+
*/
|
|
209
|
+
export function fullJitterDelay(delayMs: number, random: () => number = Math.random): number {
|
|
210
|
+
const cap = Math.max(RECOVERY_MIN_DELAY_MS, delayMs)
|
|
211
|
+
const spread = cap - RECOVERY_MIN_DELAY_MS
|
|
212
|
+
// random() bisa bernilai 1.0 pada implementasi lain; clamp agar tidak overflow.
|
|
213
|
+
const r = Math.min(1, Math.max(0, random()))
|
|
214
|
+
return Math.round(RECOVERY_MIN_DELAY_MS + spread * r)
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
/**
|
|
218
|
+
* Jeda eksponensial untuk percobaan ke-`attempt` (1-based), dengan plafon.
|
|
219
|
+
* `retryAfterMs` (bila wajar) diperlakukan sebagai FLOOR — kita tidak pernah
|
|
220
|
+
* menunggu lebih pendek daripada yang diminta provider, karena itu berarti
|
|
221
|
+
* membakar percobaan sebelum jendelanya dibuka.
|
|
222
|
+
*/
|
|
223
|
+
export function recoveryDelay(
|
|
224
|
+
attempt: number,
|
|
225
|
+
retryAfterMs?: number,
|
|
226
|
+
random: () => number = Math.random,
|
|
227
|
+
): number {
|
|
228
|
+
const exponential = Math.min(
|
|
229
|
+
RECOVERY_BASE_DELAY_MS * 2 ** Math.max(0, attempt - 1),
|
|
230
|
+
RECOVERY_MAX_DELAY_MS,
|
|
231
|
+
)
|
|
232
|
+
const floor =
|
|
233
|
+
retryAfterMs !== undefined && Number.isFinite(retryAfterMs) && retryAfterMs > 0
|
|
234
|
+
? Math.min(retryAfterMs, RECOVERY_MAX_DELAY_MS)
|
|
235
|
+
: 0
|
|
236
|
+
const target = Math.max(exponential, floor)
|
|
237
|
+
return fullJitterDelay(target, random)
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
/**
|
|
241
|
+
* Putuskan langkah pemulihan berikutnya untuk satu panggilan logis.
|
|
242
|
+
*
|
|
243
|
+
* Urutan pemeriksaan penting dan sengaja tetap:
|
|
244
|
+
* 1. Kendali user — abort tidak pernah dilanjutkan.
|
|
245
|
+
* 2. Diagnosis — terminal berhenti sebelum menghitung anggaran apa pun.
|
|
246
|
+
* 3. Anggaran biaya model — bukan gangguan, jadi tidak boleh "dipulihkan".
|
|
247
|
+
* 4. Kuota percobaan (fail fast saat pola sudah jelas).
|
|
248
|
+
* 5. Anggaran waktu total (pagar terakhir).
|
|
249
|
+
*/
|
|
250
|
+
export function planRecovery(
|
|
251
|
+
failure: FailureSignal,
|
|
252
|
+
state: RecoveryState,
|
|
253
|
+
opts: {
|
|
254
|
+
hasPrompt: boolean
|
|
255
|
+
costBudgetExhausted?: boolean
|
|
256
|
+
/** Di-inject untuk uji deterministik. */
|
|
257
|
+
random?: () => number
|
|
258
|
+
},
|
|
259
|
+
): RecoveryDecision {
|
|
260
|
+
if (!opts.hasPrompt) return { action: "stop", reason: "no-prompt" }
|
|
261
|
+
if (failure.abortedByUser === true || failure.kind === "aborted")
|
|
262
|
+
return { action: "stop", reason: "user-abort" }
|
|
263
|
+
if (opts.costBudgetExhausted === true) return { action: "stop", reason: "cost-budget" }
|
|
264
|
+
if (!isRecoverable(failure)) return { action: "stop", reason: "not-transient" }
|
|
265
|
+
|
|
266
|
+
// Kuota dulu, lalu waktu: kuota adalah pagar yang jauh lebih murah untuk
|
|
267
|
+
// diperiksa dan mencegah 45 dtk terpakai untuk pola "gagal terus".
|
|
268
|
+
if (state.attemptsUsed >= RECOVERY_ATTEMPT_QUOTA)
|
|
269
|
+
return { action: "stop", reason: "attempts-exhausted" }
|
|
270
|
+
|
|
271
|
+
const elapsed = state.nowMs - state.startedAtMs
|
|
272
|
+
const remainingMs = RECOVERY_BUDGET_MS - elapsed
|
|
273
|
+
const attempt = state.attemptsUsed + 1
|
|
274
|
+
const delayMs = recoveryDelay(attempt, failure.retryAfterMs, opts.random)
|
|
275
|
+
// Perlu sisa untuk jeda ini DAN untuk percobaan sesudahnya. Kalau jeda saja
|
|
276
|
+
// sudah melebihi sisa anggaran, menunggu lalu mencoba lagi hanya membuat user
|
|
277
|
+
// menunggu tanpa kesempatan berhasil.
|
|
278
|
+
if (delayMs >= remainingMs) return { action: "stop", reason: "budget-exhausted" }
|
|
279
|
+
|
|
280
|
+
return { action: "retry", attempt, delayMs, remainingMs: remainingMs - delayMs }
|
|
281
|
+
}
|
package/src/policy/scrub.ts
CHANGED
|
@@ -142,9 +142,21 @@ export const SECRET_ENV_RE = new RegExp(
|
|
|
142
142
|
"i",
|
|
143
143
|
)
|
|
144
144
|
|
|
145
|
-
|
|
145
|
+
/** Kredensial git yang boleh lolos ke child HANYA di mode `unrestricted`
|
|
146
|
+
* (push/remote via token/SSH agent). Nama TETAP, bukan wildcard. */
|
|
147
|
+
const GIT_CREDENTIAL_ALLOW_RE = /^(?:GITHUB_TOKEN|GH_TOKEN|SSH_AUTH_SOCK)$/i
|
|
148
|
+
|
|
149
|
+
export function stripSecretsEnv(
|
|
150
|
+
env: NodeJS.ProcessEnv,
|
|
151
|
+
allowGitCredentials = false,
|
|
152
|
+
): NodeJS.ProcessEnv {
|
|
146
153
|
const out: NodeJS.ProcessEnv = {}
|
|
147
154
|
for (const [k, v] of Object.entries(env)) {
|
|
155
|
+
// Passthrough sempit hanya saat unrestricted (push via token/SSH agent).
|
|
156
|
+
if (allowGitCredentials && GIT_CREDENTIAL_ALLOW_RE.test(k)) {
|
|
157
|
+
out[k] = v
|
|
158
|
+
continue
|
|
159
|
+
}
|
|
148
160
|
if (SECRET_ENV_RE.test(k)) continue
|
|
149
161
|
out[k] = v
|
|
150
162
|
}
|
|
@@ -157,10 +169,11 @@ export function stripSecretsEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
|
|
|
157
169
|
export function sanitizeSpawnEnv(
|
|
158
170
|
base: NodeJS.ProcessEnv,
|
|
159
171
|
extra?: Record<string, string>,
|
|
172
|
+
allowGitCredentials = false,
|
|
160
173
|
): Record<string, string> {
|
|
161
174
|
const merged: NodeJS.ProcessEnv = { ...base, ...(extra ?? {}) }
|
|
162
175
|
const out: Record<string, string> = {}
|
|
163
|
-
for (const [k, v] of Object.entries(stripSecretsEnv(merged))) {
|
|
176
|
+
for (const [k, v] of Object.entries(stripSecretsEnv(merged, allowGitCredentials))) {
|
|
164
177
|
if (v !== undefined) out[k] = v
|
|
165
178
|
}
|
|
166
179
|
return out
|
|
@@ -0,0 +1,82 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Eskalasi adaptif batas langkah per turn.
|
|
3
|
+
*
|
|
4
|
+
* KENAPA: batas langkah adalah backstop anti-runaway, bukan anggaran kerja.
|
|
5
|
+
* Angka tunggal (dulu 50) salah di dua arah sekaligus — terlalu kecil untuk
|
|
6
|
+
* kerja nyata (pada sesi `17b6a5ff`, 4 dari 5 `turn.failed` adalah
|
|
7
|
+
* `exceeded 50 steps`), dan terlalu besar bila dipakai sebagai izin kerja
|
|
8
|
+
* tanpa batas. Solusinya bukan memilih satu angka ajaib, melainkan: mulai dari
|
|
9
|
+
* default yang waras, lalu NAIKKAN satu tangga ketika sesi terbukti mentok.
|
|
10
|
+
*
|
|
11
|
+
* KENAPA tangga, bukan "unlimited": tanpa batas atas, agent yang berputar
|
|
12
|
+
* (lihat LOOP_GUARD `READ_ONLY_THRASHING`) membakar token tanpa henti. Sesi
|
|
13
|
+
* yang sama sudah membakar ≈16,7 juta token. Tangga memberi ruang cukup
|
|
14
|
+
* sambil mempertahankan backstop yang terbatas dan dapat diramalkan.
|
|
15
|
+
*
|
|
16
|
+
* KENAPA satu tangga per kejadian: menaikkan langsung ke puncak menghapus
|
|
17
|
+
* sinyal "sesi ini memang rakus". Satu langkah per `max_steps_exceeded`
|
|
18
|
+
* membuat pertumbuhan sebanding dengan kebutuhan nyata.
|
|
19
|
+
*
|
|
20
|
+
* Modul ini murni (tanpa I/O, tanpa state global) agar bisa diuji langsung
|
|
21
|
+
* dan dipakai baik oleh sesi utama maupun sub-agent.
|
|
22
|
+
*/
|
|
23
|
+
|
|
24
|
+
/** Tangga batas langkah. 200 = default kerja nyata; 4× lipat per tangga. */
|
|
25
|
+
export const STEP_LIMIT_LADDER: readonly number[] = [200, 400, 800, 1_600, 3_200, 6_400] as const
|
|
26
|
+
|
|
27
|
+
/** Batas atas absolut. Di atas ini, "mentok langkah" bukan lagi masalah
|
|
28
|
+
* anggaran melainkan tanda agent berputar — harus berhenti, bukan naik. */
|
|
29
|
+
export const STEP_LIMIT_CEILING = 6_400
|
|
30
|
+
|
|
31
|
+
/**
|
|
32
|
+
* Batas langkah default untuk sesi utama.
|
|
33
|
+
*
|
|
34
|
+
* KENAPA 200 dan bukan 50: kerja nyata (baca, edit, jalankan tes, perbaiki)
|
|
35
|
+
* butuh ratusan langkah. 50 memaksa turn terputus di tengah tugas dan
|
|
36
|
+
* membuang langkah yang sudah dipakai.
|
|
37
|
+
*/
|
|
38
|
+
export const DEFAULT_SESSION_MAX_STEPS = 200
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* Batas langkah default untuk sub-agent.
|
|
42
|
+
*
|
|
43
|
+
* KENAPA tetap 50 sementara sesi utama 200: sub-agent berjalan PARALEL
|
|
44
|
+
* (`SUB_AGENT_POOL_SIZE`) dan tiap langkahnya memicu panggilan model sendiri.
|
|
45
|
+
* Naiknya biaya runaway di sini berlipat dengan jumlah sub-agent, sedangkan
|
|
46
|
+
* tugas sub-agent umumnya lebih sempit. Sub-agent tetap mendapat eskalasi
|
|
47
|
+
* adaptif yang sama ketika benar-benar mentok.
|
|
48
|
+
*/
|
|
49
|
+
export const DEFAULT_SUB_AGENT_MAX_STEPS = 50
|
|
50
|
+
|
|
51
|
+
/** Anak tangga berikutnya di atas `current`, atau `undefined` bila sudah di
|
|
52
|
+
* batas atas. Tidak melompat: satu langkah per kejadian. */
|
|
53
|
+
export function nextStepLadderStep(current: number): number | undefined {
|
|
54
|
+
const cur = Number.isFinite(current) && current > 0 ? current : 0
|
|
55
|
+
for (const step of STEP_LIMIT_LADDER) {
|
|
56
|
+
if (step > cur) return Math.min(step, STEP_LIMIT_CEILING)
|
|
57
|
+
}
|
|
58
|
+
return undefined
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
/**
|
|
62
|
+
* Hitung batas langkah baru setelah satu `max_steps_exceeded`.
|
|
63
|
+
*
|
|
64
|
+
* `observedSteps` = jumlah langkah yang benar-benar terpakai. Bila pengamatan
|
|
65
|
+
* sudah melampaui batas yang berlaku (mis. operator menaikkan batas manual di
|
|
66
|
+
* tengah jalan), naik dari pengamatan — bukan dari batas lama — supaya
|
|
67
|
+
* tangganya tidak "melewati" kebutuhan nyata.
|
|
68
|
+
*
|
|
69
|
+
* Mengembalikan `undefined` bila tidak ada kenaikan yang sah (sudah di puncak,
|
|
70
|
+
* atau hasilnya tidak lebih besar dari batas sekarang). Pemanggil WAJIB
|
|
71
|
+
* memperlakukan `undefined` sebagai "hentikan, jangan ulang" — bukan sebagai
|
|
72
|
+
* izin melanjutkan tanpa batas.
|
|
73
|
+
*/
|
|
74
|
+
export function nextStepLimit(currentLimit: number, observedSteps: number): number | undefined {
|
|
75
|
+
const base = Number.isFinite(currentLimit) && currentLimit > 0 ? Math.floor(currentLimit) : 0
|
|
76
|
+
const observed =
|
|
77
|
+
Number.isFinite(observedSteps) && observedSteps > 0 ? Math.floor(observedSteps) : 0
|
|
78
|
+
const from = Math.max(base, observed)
|
|
79
|
+
const next = nextStepLadderStep(from)
|
|
80
|
+
if (next === undefined || next <= base) return undefined
|
|
81
|
+
return next
|
|
82
|
+
}
|
|
@@ -72,6 +72,7 @@ export function getCachedTokenizer(modelId: string): BpeTokenizer | null {
|
|
|
72
72
|
* + fire-and-forget: gagal jaringan = null (fallback estimator densitas/usage).
|
|
73
73
|
*/
|
|
74
74
|
export async function loadTokenizer(modelId: string): Promise<BpeTokenizer | null> {
|
|
75
|
+
if (!tokenizersEnabled()) return null
|
|
75
76
|
const cached = getCachedTokenizer(modelId)
|
|
76
77
|
if (cached) return cached
|
|
77
78
|
const repo = findTokenizerRepo(modelId)
|
|
@@ -422,6 +422,17 @@ export const TOOL_CONTRACTS: readonly ToolContractMetadata[] = [
|
|
|
422
422
|
idempotent: false,
|
|
423
423
|
journalMutation: true,
|
|
424
424
|
}),
|
|
425
|
+
C({
|
|
426
|
+
name: "git_push",
|
|
427
|
+
sideEffectTier: "EXTERNAL_IRREVERSIBLE",
|
|
428
|
+
concurrencyClass: "exclusive",
|
|
429
|
+
gatedByDefault: true,
|
|
430
|
+
allowedInExplore: false,
|
|
431
|
+
allowedInAutonomous: false,
|
|
432
|
+
allowedInReadonly: false,
|
|
433
|
+
idempotent: false,
|
|
434
|
+
journalMutation: true,
|
|
435
|
+
}),
|
|
425
436
|
C({
|
|
426
437
|
name: "delegate_task",
|
|
427
438
|
sideEffectTier: "EXTERNAL_IRREVERSIBLE",
|
|
@@ -494,9 +505,6 @@ const BY_NAME: ReadonlyMap<string, ToolContractMetadata> = new Map(
|
|
|
494
505
|
TOOL_CONTRACTS.map((c) => [c.name, c]),
|
|
495
506
|
)
|
|
496
507
|
|
|
497
|
-
/** Nama tool yang dikenal registry ini (bukan tool MCP bertitik). */
|
|
498
|
-
export const TOOL_CONTRACT_NAMES: readonly string[] = TOOL_CONTRACTS.map((c) => c.name)
|
|
499
|
-
|
|
500
508
|
/**
|
|
501
509
|
* Kontrak efektif untuk satu nama tool.
|
|
502
510
|
*
|
|
@@ -595,9 +603,3 @@ export function classifyContractTool(name: string): "mutation" | "none" | "unkno
|
|
|
595
603
|
if (c === undefined) return "unknown"
|
|
596
604
|
return c.journalMutation ? "mutation" : "none"
|
|
597
605
|
}
|
|
598
|
-
|
|
599
|
-
/** True bila tool mengubah apa pun (bukan PURE_READ). */
|
|
600
|
-
export function isSideEffectingTool(name: string): boolean {
|
|
601
|
-
const c = contractForTool(name)
|
|
602
|
-
return c === undefined ? true : c.sideEffectTier !== "PURE_READ"
|
|
603
|
-
}
|
|
@@ -68,10 +68,10 @@ export function createAnthropicProvider(config: AnthropicConfig): ModelProvider
|
|
|
68
68
|
.replace(/\/+$/, "")
|
|
69
69
|
.replace(/\/v1$/, "")
|
|
70
70
|
const endpoint = `${baseUrl}/v1/messages`
|
|
71
|
-
//
|
|
72
|
-
|
|
71
|
+
// Presedensi: env > metadata `/models` > default aktif (undefined = aktif).
|
|
72
|
+
|
|
73
73
|
const enableCache =
|
|
74
|
-
|
|
74
|
+
process.env.MINICODE_PROMPT_CACHE !== "0" && config.enablePromptCaching !== false
|
|
75
75
|
|
|
76
76
|
// brand `kind` dipakai router agar tahu konten Uint8Array ditangani native
|
|
77
77
|
const provider: ModelProvider & { kind: "anthropic" } = {
|
package/src/providers/detect.ts
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { createHash } from "node:crypto"
|
|
1
2
|
import { LIMITS } from "../constants.ts"
|
|
2
3
|
|
|
3
4
|
export interface DetectedModel {
|
|
@@ -13,6 +14,8 @@ export interface DetectedModel {
|
|
|
13
14
|
/** Batas output model (`max_output_tokens`) bila dilaporkan. Dipakai sebagai
|
|
14
15
|
* reserve output proporsional, bukan angka tetap. */
|
|
15
16
|
maxOutputTokens?: number
|
|
17
|
+
/** Dukungan cache yang dilaporkan endpoint (Fase 7.1); `undefined` = tak disebut. */
|
|
18
|
+
promptCaching?: boolean
|
|
16
19
|
}
|
|
17
20
|
|
|
18
21
|
export interface DetectResult {
|
|
@@ -30,9 +33,7 @@ export interface DetectResult {
|
|
|
30
33
|
authFailed: boolean
|
|
31
34
|
}
|
|
32
35
|
|
|
33
|
-
//
|
|
34
|
-
// perlu re-deteksi network tiap kali. Key = url tanpa apiKey (secrets tidak
|
|
35
|
-
// pernah disimpan atau di-log).
|
|
36
|
+
// Scope cached metadata to endpoint and credential; never store plaintext keys.
|
|
36
37
|
const cache = new Map<string, { at: number; result: DetectResult }>()
|
|
37
38
|
const CACHE_TTL_MS = 30 * 60 * 1000
|
|
38
39
|
|
|
@@ -40,8 +41,14 @@ export function clearDetectCache(): void {
|
|
|
40
41
|
cache.clear()
|
|
41
42
|
}
|
|
42
43
|
|
|
43
|
-
export function cacheKey(baseUrl: string): string {
|
|
44
|
-
|
|
44
|
+
export function cacheKey(baseUrl: string, apiKey = ""): string {
|
|
45
|
+
let normalized = baseUrl.replace(/\/+$/, "")
|
|
46
|
+
try {
|
|
47
|
+
normalized = new URL(normalized).href.replace(/\/+$/, "")
|
|
48
|
+
} catch {
|
|
49
|
+
// Invalid URLs are handled by the fetch path; preserve their case here.
|
|
50
|
+
}
|
|
51
|
+
return `${normalized}#${createHash("sha256").update(apiKey).digest("hex")}`
|
|
45
52
|
}
|
|
46
53
|
|
|
47
54
|
function hybridHeaders(apiKey: string): Record<string, string>[] {
|
|
@@ -81,6 +88,26 @@ const OUTPUT_FIELD_ALIASES = [
|
|
|
81
88
|
"output_token_limit",
|
|
82
89
|
] as const
|
|
83
90
|
|
|
91
|
+
/** Field penanda dukungan cache (boolean, atau objek = ya). */
|
|
92
|
+
const CACHE_FIELD_ALIASES = [
|
|
93
|
+
"prompt_caching",
|
|
94
|
+
"prompt_cache",
|
|
95
|
+
"supports_prompt_caching",
|
|
96
|
+
"supports_cache",
|
|
97
|
+
"cache_control",
|
|
98
|
+
] as const
|
|
99
|
+
|
|
100
|
+
/** `undefined` (tak disebut) harus beda dari `false` (menolak) — tri-state. */
|
|
101
|
+
function extractCacheSupport(obj: Record<string, unknown>): boolean | undefined {
|
|
102
|
+
for (const key of CACHE_FIELD_ALIASES) {
|
|
103
|
+
if (!(key in obj)) continue
|
|
104
|
+
const v = obj[key]
|
|
105
|
+
if (typeof v === "boolean") return v
|
|
106
|
+
return v !== null && v !== undefined && v !== "" && v !== 0
|
|
107
|
+
}
|
|
108
|
+
return undefined
|
|
109
|
+
}
|
|
110
|
+
|
|
84
111
|
function positiveInt(value: unknown): number | undefined {
|
|
85
112
|
if (typeof value !== "number" || !Number.isFinite(value)) return undefined
|
|
86
113
|
const n = Math.floor(value)
|
|
@@ -106,6 +133,7 @@ function pickField(obj: Record<string, unknown>, aliases: readonly string[]): nu
|
|
|
106
133
|
export function extractModelCapacity(entry: unknown): {
|
|
107
134
|
contextLength?: number
|
|
108
135
|
maxOutputTokens?: number
|
|
136
|
+
promptCaching?: boolean
|
|
109
137
|
} {
|
|
110
138
|
if (!entry || typeof entry !== "object") return {}
|
|
111
139
|
const obj = entry as Record<string, unknown>
|
|
@@ -122,9 +150,13 @@ export function extractModelCapacity(entry: unknown): {
|
|
|
122
150
|
const maxOutputTokens =
|
|
123
151
|
pickField(obj, OUTPUT_FIELD_ALIASES) ??
|
|
124
152
|
(nested ? pickField(nested, OUTPUT_FIELD_ALIASES) : undefined)
|
|
153
|
+
// Level atas menang; `top_provider` hanya fallback.
|
|
154
|
+
const promptCaching =
|
|
155
|
+
extractCacheSupport(obj) ?? (nested ? extractCacheSupport(nested) : undefined)
|
|
125
156
|
return {
|
|
126
157
|
...(contextLength !== undefined ? { contextLength } : {}),
|
|
127
158
|
...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
|
|
159
|
+
...(promptCaching !== undefined ? { promptCaching } : {}),
|
|
128
160
|
}
|
|
129
161
|
}
|
|
130
162
|
|
|
@@ -198,12 +230,13 @@ export async function detectModels(
|
|
|
198
230
|
signal?: AbortSignal,
|
|
199
231
|
): Promise<DetectResult> {
|
|
200
232
|
// serve dari cache bila masih segar (anti request redundant dalam 30 menit)
|
|
201
|
-
const key = cacheKey(baseUrl)
|
|
233
|
+
const key = cacheKey(baseUrl, apiKey)
|
|
202
234
|
const hit = cache.get(key)
|
|
203
235
|
if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.result
|
|
204
236
|
|
|
205
237
|
// CAP global — jangan pernah biarkan user menunggu lama pada gateway offline
|
|
206
|
-
const
|
|
238
|
+
const timeout = AbortSignal.timeout(LIMITS.DETECT_GLOBAL_TIMEOUT_MS)
|
|
239
|
+
const sig = signal ? AbortSignal.any([signal, timeout]) : timeout
|
|
207
240
|
let everContacted = false
|
|
208
241
|
let everAuthFailed = false
|
|
209
242
|
for (const h of hybridHeaders(apiKey)) {
|
|
@@ -70,6 +70,14 @@ export async function saveProvider(
|
|
|
70
70
|
...(entry.contextWindows === undefined && previous.contextWindows
|
|
71
71
|
? { contextWindows: previous.contextWindows }
|
|
72
72
|
: {}),
|
|
73
|
+
// Sumber harus ikut diselamatkan bersama nilainya. Tanpa ini, entri
|
|
74
|
+
// yang ditulis tanpa `contextWindows` (mis. hasil `sync`) kehilangan
|
|
75
|
+
// label `user` sementara angkanya dipertahankan — nilai operator lalu
|
|
76
|
+
// dianggap milik endpoint dan boleh ditimpa pada sync berikutnya,
|
|
77
|
+
// yaitu persis hal yang label itu ada untuk mencegahnya.
|
|
78
|
+
...(entry.contextWindowSources === undefined && previous.contextWindowSources
|
|
79
|
+
? { contextWindowSources: previous.contextWindowSources }
|
|
80
|
+
: {}),
|
|
73
81
|
}
|
|
74
82
|
} else cfg.providers.push(entry)
|
|
75
83
|
await writeConfigAtomic(path, cfg)
|
|
@@ -123,7 +131,10 @@ export function deriveProviderId(baseUrl: string, existingIds: string[], id?: st
|
|
|
123
131
|
export function mergeDiscoveredCapacity(
|
|
124
132
|
previous: ProviderEntry | undefined,
|
|
125
133
|
detected: DetectResult,
|
|
126
|
-
): Pick<
|
|
134
|
+
): Pick<
|
|
135
|
+
ProviderEntry,
|
|
136
|
+
"contextWindows" | "contextWindowSources" | "maxOutputTokens" | "enablePromptCaching"
|
|
137
|
+
> {
|
|
127
138
|
const metadata = detected.modelMetadata
|
|
128
139
|
if (!metadata || Object.keys(metadata).length === 0) return {}
|
|
129
140
|
const prevWindows = previous?.contextWindows ?? {}
|
|
@@ -160,10 +171,21 @@ export function mergeDiscoveredCapacity(
|
|
|
160
171
|
if (live.size > 0 && !live.has(model)) continue
|
|
161
172
|
if (maxOut[model] === undefined) maxOut[model] = tokens
|
|
162
173
|
}
|
|
174
|
+
// Fase 7.1: satu model mendukung = provider mendukung; false bila semua menolak.
|
|
175
|
+
let caching: boolean | undefined
|
|
176
|
+
for (const meta of Object.values(metadata)) {
|
|
177
|
+
if (meta.promptCaching === true) {
|
|
178
|
+
caching = true
|
|
179
|
+
break
|
|
180
|
+
}
|
|
181
|
+
if (meta.promptCaching === false) caching ??= false
|
|
182
|
+
}
|
|
183
|
+
|
|
163
184
|
return {
|
|
164
185
|
...(Object.keys(windows).length > 0 ? { contextWindows: windows } : {}),
|
|
165
186
|
...(Object.keys(sources).length > 0 ? { contextWindowSources: sources } : {}),
|
|
166
187
|
...(Object.keys(maxOut).length > 0 ? { maxOutputTokens: maxOut } : {}),
|
|
188
|
+
...(caching !== undefined ? { enablePromptCaching: caching } : {}),
|
|
167
189
|
}
|
|
168
190
|
}
|
|
169
191
|
|
|
@@ -106,9 +106,11 @@ export interface ChildAdmission {
|
|
|
106
106
|
}
|
|
107
107
|
|
|
108
108
|
function modeStepCap(mode: ChildMode): number {
|
|
109
|
-
// Evidence: SUB_AGENT_BUDGET_EXPLORE/PLAN + hard-cap
|
|
109
|
+
// Evidence: SUB_AGENT_BUDGET_EXPLORE/PLAN + hard-cap SUB_AGENT_MAX_STEPS (task.ts).
|
|
110
|
+
// [T-008] Memakai cap sub-agent SENDIRI, bukan DEFAULT_MAX_STEPS sesi utama:
|
|
111
|
+
// cap delegasi tidak boleh ikut naik saat default sesi utama berubah.
|
|
110
112
|
const cap = mode === "explore" ? LIMITS.SUB_AGENT_BUDGET_EXPLORE : LIMITS.SUB_AGENT_BUDGET_PLAN
|
|
111
|
-
return Math.min(cap, LIMITS.
|
|
113
|
+
return Math.min(cap, LIMITS.SUB_AGENT_MAX_STEPS)
|
|
112
114
|
}
|
|
113
115
|
|
|
114
116
|
/**
|