minicode-ai 0.25.0 → 0.27.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.
Files changed (56) hide show
  1. package/README.md +3 -1
  2. package/cli/commands/config.ts +123 -0
  3. package/cli/commands.ts +23 -2
  4. package/cli/context-command-run.ts +159 -0
  5. package/cli/context-command.ts +87 -0
  6. package/cli/index.ts +48 -0
  7. package/cli/setup.ts +107 -8
  8. package/cli/tui.ts +8 -9
  9. package/docs/TERMINAL_CONTRACT.md +32 -1
  10. package/docs/config.md +29 -1
  11. package/docs/environment.md +3 -1
  12. package/docs/getting-started.md +11 -3
  13. package/docs/repl.md +1 -0
  14. package/package.json +1 -1
  15. package/src/app/session.ts +187 -17
  16. package/src/config.ts +19 -8
  17. package/src/constants.ts +33 -4
  18. package/src/lib/net.ts +6 -15
  19. package/src/lib/public-http.ts +128 -0
  20. package/src/policy/auto-resume.ts +63 -0
  21. package/src/policy/compaction.ts +354 -70
  22. package/src/policy/context-budget.ts +4 -6
  23. package/src/policy/context-window-assign.ts +114 -0
  24. package/src/policy/context-window-catalog.ts +4 -1
  25. package/src/policy/context-window-presets.ts +165 -0
  26. package/src/policy/context-window.ts +105 -4
  27. package/src/policy/context.ts +27 -10
  28. package/src/policy/executor.ts +69 -27
  29. package/src/policy/microcompact.ts +76 -15
  30. package/src/policy/recovery-budget.ts +281 -0
  31. package/src/policy/step-escalation.ts +82 -0
  32. package/src/policy/tokenizer-registry.ts +1 -0
  33. package/src/providers/detect.ts +13 -7
  34. package/src/providers/guards.ts +41 -2
  35. package/src/providers/provision.ts +8 -4
  36. package/src/repo/repomap.ts +180 -23
  37. package/src/runtime/child-execution.ts +4 -2
  38. package/src/runtime/execution-backend.ts +3 -0
  39. package/src/sandbox/os.ts +53 -9
  40. package/src/session/context-assembly.ts +11 -7
  41. package/src/session/persistence.ts +19 -3
  42. package/src/tools/bash.ts +12 -9
  43. package/src/tools/code_run.ts +19 -20
  44. package/src/tools/task.ts +4 -1
  45. package/src/tools/web_fetch.ts +13 -19
  46. package/src/ui/assistant/simple.ts +61 -10
  47. package/src/ui/i18n/en.ts +15 -0
  48. package/src/ui/i18n/id.ts +15 -0
  49. package/src/ui/input/prompt-engine.ts +53 -21
  50. package/src/ui/render/activity-group.ts +8 -0
  51. package/src/ui/render/activity-panel.ts +20 -2
  52. package/src/ui/screens/model-manager.ts +6 -1
  53. package/src/ui/tui/app.ts +26 -11
  54. package/src/ui/tui/transcript.ts +175 -29
  55. package/vendor/minicore/src/core/loop.ts +20 -1
  56. package/vendor/minicore/src/core/session.ts +6 -0
@@ -1,4 +1,5 @@
1
1
  import type { Message } from "#minicore/core/types.ts"
2
+ import { classifyContractTool, TOOL_CONTRACTS } from "./tool-contract.ts"
2
3
 
3
4
  /**
4
5
  * Microcompact — pangkas ISI hasil tool lama jadi sentinel pendek: tanpa
@@ -18,26 +19,79 @@ import type { Message } from "#minicore/core/types.ts"
18
19
  * mendominasi, (c) bukan di tengah batch tool yang belum selesai.
19
20
  */
20
21
 
21
- /** Tool yang hasilnya DAPAT dipulihkan (dibaca ulang kapan saja). Tool
22
- * kontrol-sesi (`todo`, `memory`) SENGAJA tidak masuk: isinya keadaan yang tak
23
- * bisa direkonstruksi dari filesystem — memangkasnya menghapus kebenaran. */
24
- export const MICROCOMPACT_RECOVERABLE_TOOLS: ReadonlySet<string> = new Set([
25
- "read_file",
26
- "grep",
27
- "glob",
28
- "bash",
29
- "bash_output",
30
- "code_run",
31
- "web_fetch",
32
- "web_search",
33
- "list_dir",
34
- "view_file",
22
+ /**
23
+ * Tool yang isinya adalah KEBENARAN yang tak dapat direkonstruksi: hasilnya
24
+ * keadaan sesi (rencana, memori, hasil tugas), bukan observasi filesystem.
25
+ * Memangkasnya membuat model kehilangan fakta tanpa cara memulihkannya.
26
+ *
27
+ * Diletakkan SEBELUM daftar turunan di bawah: `const` bersifat TDZ, jadi
28
+ * membacanya dari initializer yang lebih awal akan melempar ReferenceError.
29
+ */
30
+ const MICROCOMPACT_NEVER_TRIM: ReadonlySet<string> = new Set([
31
+ "todo_read",
32
+ "todo_write",
33
+ "write_memory",
34
+ "read_memory",
35
+ "forget_memory",
36
+ "submit_result",
37
+ "ask_user",
35
38
  ])
36
39
 
40
+ /**
41
+ * Tool yang hasilnya boleh dipangkas meskipun TIDAK `PURE_READ`.
42
+ *
43
+ * KENAPA ada: `bash`/`code_run` bertier `LOCAL_ENV_MUTATION` (bisa menulis
44
+ * berkas), jadi tidak bisa dimasukkan lewat predikat baca-murni. Tetapi
45
+ * keduanya penyumbang token TERBESAR di lapangan; mengeluarkannya berarti
46
+ * konteks tak pernah menyusut justru di bagian yang paling gemuk. Mereka aman
47
+ * dipangkas karena sentinel-nya memakai varian "JANGAN jalankan ulang" — model
48
+ * diberi tahu untuk memverifikasi state, bukan mengulang efek sampingnya.
49
+ */
50
+ const MICROCOMPACT_TRIMMABLE_MUTATORS: ReadonlySet<string> = new Set(["bash", "code_run"])
51
+
52
+ /** Tool yang hasilnya DAPAT dipulihkan (dibaca ulang kapan saja). Tool
53
+ * bisa direkonstruksi dari filesystem — memangkasnya menghapus kebenaran.
54
+ *
55
+ * [Perbaikan microcompact] Daftar ini DITURUNKAN dari kontrak tool, bukan
56
+ * diketik manual. Daftar manual sebelumnya menyimpang dua arah sekaligus: memuat
57
+ * tool yang TIDAK PERNAH ADA (`list_dir`, `view_file`) dan melewatkan tool baca
58
+ * nyata yang outputnya besar (`git_diff` sampai 500k karakter, `git_log`,
59
+ * `read_image`, `lsp_diagnostics`). Itu berarti hasil terbesar di sesi tidak
60
+ * pernah bisa dipangkas; sekarang himpunan ini mengikuti registry yang sama
61
+ * dengan jurnal dan permission.
62
+ *
63
+ * Kriteria: tier `PURE_READ` ATAU baca jaringan yang `allowedInReadonly` ATAU
64
+ * pemutasi yang hasilnya dominan (`bash`, `code_run`), DAN BUKAN tool
65
+ * kontrol-sesi (yang keadaannya tak dapat direkonstruksi). */
66
+ export const MICROCOMPACT_RECOVERABLE_TOOLS: ReadonlySet<string> = new Set(
67
+ TOOL_CONTRACTS.filter(
68
+ (c) =>
69
+ !MICROCOMPACT_NEVER_TRIM.has(c.name) &&
70
+ (MICROCOMPACT_TRIMMABLE_MUTATORS.has(c.name) ||
71
+ (c.journalMutation === false && (c.sideEffectTier === "PURE_READ" || c.allowedInReadonly))),
72
+ ).map((c) => c.name),
73
+ )
74
+
37
75
  /** Awalan sentinel. Stabil supaya bisa dikenali ulang (idempoten) dan supaya
38
76
  * model tahu isinya dipangkas, bukan kosong. */
39
77
  export const MICROCOMPACT_SENTINEL_PREFIX = "[hasil tool lama dipangkas"
40
78
 
79
+ /**
80
+ * Apakah mengulang tool ini berbahaya?
81
+ *
82
+ * KENAPA ini ada: sentinel menyuruh model "jalankan ulang tool ini", instruksi
83
+ * yang BENAR untuk tool baca (idempoten, hasilnya bisa dipulihkan) tetapi
84
+ * SALAH untuk tool yang memutasi. `bash` ada di daftar recoverable karena ia
85
+ * penyumbang token terbesar, padahal isinya bisa `rm`, migrasi, atau tulis file:
86
+ * mengulangnya menduplikasi efek samping. `unknown` diperlakukan sama dengan
87
+ * `mutation` (fail-closed) — tool yang lupa didaftarkan tidak boleh dianggap
88
+ * aman untuk diulang.
89
+ */
90
+ function replayIsUnsafe(toolName: string | undefined): boolean {
91
+ if (toolName === undefined) return true
92
+ return classifyContractTool(toolName) !== "none"
93
+ }
94
+
41
95
  export interface MicrocompactOptions {
42
96
  /** Hasil tool TERBARU yang dipertahankan utuh. Default 5. */
43
97
  keepRecent?: number
@@ -145,7 +199,14 @@ export function applyMicrocompact(
145
199
  const m = messages[idx] as Extract<Message, { role: "tool" }>
146
200
  const original = contentText(m.content)
147
201
  const wasError = m.isError === true
148
- const sentinel = `${MICROCOMPACT_SENTINEL_PREFIX}: ${m.name} ${original.length} char${wasError ? ", gagal" : ""}. Jalankan ulang tool ini bila isinya masih dibutuhkan.]`
202
+ // Dua teks berbeda untuk dua situasi berbeda. Tool baca: aman diulang.
203
+ // Tool bermutasi: JANGAN diulang — verifikasi dulu, karena mengulang bisa
204
+ // menduplikasi efek (`rm`, tulis file, migrasi). Tanpa pemisahan ini model
205
+ // menerima instruksi berbahaya hanya karena hasilnya panjang.
206
+ const hint = replayIsUnsafe(m.name)
207
+ ? `JANGAN jalankan ulang${wasError ? " (panggilan ini sudah gagal)" : ""}: tool ini dapat mengubah state (berkas/lingkungan), mengulangnya bisa menduplikasi efek. Verifikasi state lebih dulu (mis. baca berkas/hasil) sebelum mengulang.`
208
+ : "Jalankan ulang tool ini bila isinya masih dibutuhkan."
209
+ const sentinel = `${MICROCOMPACT_SENTINEL_PREFIX}: ${m.name} ${original.length} char${wasError ? ", gagal" : ""}. ${hint}]`
149
210
  // Hemat = token asli - token sentinel (sentinel tetap memakan token).
150
211
  const saving = opts.estimateTokens(original) - opts.estimateTokens(sentinel)
151
212
  out[idx] = { ...m, content: sentinel }
@@ -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
+ }
@@ -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)
@@ -1,3 +1,4 @@
1
+ import { createHash } from "node:crypto"
1
2
  import { LIMITS } from "../constants.ts"
2
3
 
3
4
  export interface DetectedModel {
@@ -32,9 +33,7 @@ export interface DetectResult {
32
33
  authFailed: boolean
33
34
  }
34
35
 
35
- // Cache in-memory per baseUrl (30 menit) — /sync yang sering dipanggil tidak
36
- // perlu re-deteksi network tiap kali. Key = url tanpa apiKey (secrets tidak
37
- // pernah disimpan atau di-log).
36
+ // Scope cached metadata to endpoint and credential; never store plaintext keys.
38
37
  const cache = new Map<string, { at: number; result: DetectResult }>()
39
38
  const CACHE_TTL_MS = 30 * 60 * 1000
40
39
 
@@ -42,8 +41,14 @@ export function clearDetectCache(): void {
42
41
  cache.clear()
43
42
  }
44
43
 
45
- export function cacheKey(baseUrl: string): string {
46
- return baseUrl.replace(/\/+$/, "").toLowerCase()
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")}`
47
52
  }
48
53
 
49
54
  function hybridHeaders(apiKey: string): Record<string, string>[] {
@@ -225,12 +230,13 @@ export async function detectModels(
225
230
  signal?: AbortSignal,
226
231
  ): Promise<DetectResult> {
227
232
  // serve dari cache bila masih segar (anti request redundant dalam 30 menit)
228
- const key = cacheKey(baseUrl)
233
+ const key = cacheKey(baseUrl, apiKey)
229
234
  const hit = cache.get(key)
230
235
  if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.result
231
236
 
232
237
  // CAP global — jangan pernah biarkan user menunggu lama pada gateway offline
233
- const sig = signal ?? AbortSignal.timeout(LIMITS.DETECT_GLOBAL_TIMEOUT_MS)
238
+ const timeout = AbortSignal.timeout(LIMITS.DETECT_GLOBAL_TIMEOUT_MS)
239
+ const sig = signal ? AbortSignal.any([signal, timeout]) : timeout
234
240
  let everContacted = false
235
241
  let everAuthFailed = false
236
242
  for (const h of hybridHeaders(apiKey)) {
@@ -19,6 +19,8 @@ export function withStreamGuards(
19
19
  provider: ModelProvider,
20
20
  opts: {
21
21
  timeoutMs?: number
22
+ /** Batas diam (tanpa byte) sebelum request dianggap mati. 0 = nonaktif. */
23
+ idleTimeoutMs?: number
22
24
  maxTextChars?: number
23
25
  maxReasonChars?: number
24
26
  maxToolArgBytes?: number
@@ -32,6 +34,11 @@ export function withStreamGuards(
32
34
  configuredTimeout > 0
33
35
  ? Math.min(LIMITS.MAX_TIMER_DELAY_MS, Math.max(1, Math.floor(configuredTimeout)))
34
36
  : LIMITS.PROVIDER_REQUEST_TIMEOUT_MS
37
+ const configuredIdle = opts.idleTimeoutMs
38
+ const idleTimeoutMs =
39
+ typeof configuredIdle === "number" && Number.isFinite(configuredIdle) && configuredIdle >= 0
40
+ ? Math.min(LIMITS.MAX_TIMER_DELAY_MS, Math.floor(configuredIdle))
41
+ : LIMITS.PROVIDER_IDLE_TIMEOUT_MS
35
42
  const maxTextChars = opts.maxTextChars ?? LIMITS.PROVIDER_TEXT_MAX_CHARS
36
43
  // Reasoning = bukan bagian jawaban; cap agresif (2MB logis ≈ 500k token —
37
44
  // jauh di atas reasoning sah mana pun, jauh di bawah OOM).
@@ -67,6 +74,28 @@ export function withStreamGuards(
67
74
  timedOut = true
68
75
  ctl.abort(new Error(`provider request timed out after ${timeoutMs}ms`))
69
76
  }, timeoutMs)
77
+ // Timeout DIAM (audit freeze 2026-11-16): timer total di atas membiarkan
78
+ // provider yang tak pernah mengirim byte menahan turn sampai 5 menit —
79
+ // user tak bisa membedakannya dari hang. Timer ini di-reset setiap ada
80
+ // frame masuk, jadi hanya koneksi yang benar-benar berhenti bicara yang
81
+ // dipotong; stream panjang (reasoning, output besar) tidak tersentuh.
82
+ const idleMs = idleTimeoutMs > 0 ? idleTimeoutMs : 0
83
+ let idleFired = false
84
+ let idleTimer: ReturnType<typeof setTimeout> | undefined
85
+ const armIdle = () => {
86
+ if (!idleMs) return
87
+ if (idleTimer) clearTimeout(idleTimer)
88
+ idleTimer = setTimeout(() => {
89
+ idleFired = true
90
+ ctl.abort(new Error(`provider sent nothing for ${idleMs}ms (connection stalled)`))
91
+ }, idleMs)
92
+ }
93
+ armIdle()
94
+ const stopTimers = () => {
95
+ clearTimeout(timer)
96
+ if (idleTimer) clearTimeout(idleTimer)
97
+ idleTimer = undefined
98
+ }
70
99
  let textChars = 0
71
100
  let reasonChars = 0
72
101
  let toolArgumentBytes = 0
@@ -81,6 +110,8 @@ export function withStreamGuards(
81
110
  while (true) {
82
111
  const next = await nextOrAbort(iterator, ctl.signal)
83
112
  if (next.done) break
113
+ // Ada frame masuk = koneksi masih hidup; jadwal diam dimulai ulang.
114
+ armIdle()
84
115
  const ev = next.value
85
116
  if (
86
117
  finishReason !== undefined &&
@@ -186,14 +217,22 @@ export function withStreamGuards(
186
217
  invalidated = true
187
218
  yield attemptEvent("invalidated", {
188
219
  hadVisibleOutput,
189
- reason: timedOut ? "timeout" : "stream-error",
220
+ reason: timedOut ? "timeout" : idleFired ? "stalled" : "stream-error",
190
221
  })
191
222
  }
192
223
  if (timedOut)
193
224
  throw new ProviderError("server", `provider request timed out after ${timeoutMs}ms`)
225
+ // Diam total = kegagalan sisi server yang bisa diulang, bukan abort user.
226
+ // Diklasifikasikan "server" supaya jalur pemulihan bersama (anggaran
227
+ // T-009) yang menanganinya, dengan pesan yang menyebut SEBABNYA.
228
+ if (idleFired)
229
+ throw new ProviderError(
230
+ "server",
231
+ `provider sent nothing for ${idleTimeoutMs}ms (connection stalled)`,
232
+ )
194
233
  throw e
195
234
  } finally {
196
- clearTimeout(timer)
235
+ stopTimers()
197
236
  signal.removeEventListener("abort", onParentAbort)
198
237
  if (!ctl.signal.aborted && finishReason !== "stop" && finishReason !== "tool_calls") {
199
238
  ctl.abort(new DOMException("Provider stream closed", "AbortError"))
@@ -64,12 +64,16 @@ export async function saveProvider(
64
64
  }
65
65
  const idx = cfg.providers.findIndex((p) => p.id === entry.id)
66
66
  if (idx >= 0) {
67
- const previous = cfg.providers[idx]!
68
67
  cfg.providers[idx] = {
69
68
  ...entry,
70
- ...(entry.contextWindows === undefined && previous.contextWindows
71
- ? { contextWindows: previous.contextWindows }
72
- : {}),
69
+ // Entri baru menang MUTLAK atas nilai lama: `saveProvider` menulis apa
70
+ // yang diberikan pemanggil. Sengaja tanpa "selamatkan nilai lama bila
71
+ // entry tidak punya field ini" — versi lama melakukan itu dan membuat
72
+ // `auto` (hapus jendela) mustahil: `assignContextWindow` sengaja MENGHAPUS
73
+ // kunci, dan penyelamatan di sini membangkitkannya lagi sehingga perintah
74
+ // "kembali ke otomatis" sukses di layar tapi tak berefek di config.
75
+ // Pemanggil yang memang ingin mempertahankan nilai lama (mis. `sync`)
76
+ // sudah membacanya sendiri lewat `loadConfig` sebelum menyusun entry.
73
77
  }
74
78
  } else cfg.providers.push(entry)
75
79
  await writeConfigAtomic(path, cfg)