agen-vektor 0.3.18 → 0.3.20

package/dist/agent/loop.js

@@ -238,22 +238,53 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
         callbacks.onStatus?.(iterations === 1 ? 'Thinking' : 'Thinking…');
         let result;
         try {
-            result = await (0, provider_1.withRetry)(doCall, {
-                retries: config.maxRetries,
-                signal,
-                onRetry: (attempt, err, waitMs) => {
-                    // Surface the silent retry loop: without this the user stares at a
-                    // frozen spinner for 1s+2s+4s while the gateway flakes.
-                    // friendlyApiError keeps provider bodies (JSON, stack-ish text) out
-                    // of the status bar — the raw dump leaked internals and pushed the
-                    // timer/mode labels off the row.
-                    callbacks.onStatus?.(`Retrying ${attempt}/${config.maxRetries} — ${(0, provider_1.friendlyApiError)(err)}, waiting ${Math.round(waitMs / 1000)}s`);
-                    // A partially-streamed reply from the FAILED attempt must not leak
-                    // into the UI or the next attempt's reasoning accumulator.
-                    lastReasoning = '';
-                    callbacks.onRetryReset?.();
-                },
-            });
+            // ANTI-COOLDOWN UX (2026-09-09): a 429 from the shared free gateway is
+            // absorbed INVISIBLY. withRetry deliberately does not ladder-retry 429;
+            // this grace loop owns rate-limit pacing: it honors the gateway's
+            // retryAfter (capped), waits quietly, and retries — the user only ever
+            // sees the status line, never an error, as long as the total budget
+            // (~120s) lasts. Only a persistently rate-limited key beyond that
+            // budget surfaces the calm "Provider busy" message. resultHistory
+            // covers the FIRST 429 round-trip too: a failure after a success is a
+            // transient gateway flap, not a dead shared key.
+            const graceDeadline = Date.now() + 120_000;
+            for (;;) {
+                try {
+                    result = await (0, provider_1.withRetry)(doCall, {
+                        retries: config.maxRetries,
+                        signal,
+                        onRetry: (attempt, err, waitMs) => {
+                            // Surface the silent retry loop: without this the user stares at a
+                            // frozen spinner for 1s+2s+4s while the gateway flakes.
+                            // friendlyApiError keeps provider bodies (JSON, stack-ish text) out
+                            // of the status bar — the raw dump leaked internals and pushed the
+                            // timer/mode labels off the row.
+                            callbacks.onStatus?.(`Retrying ${attempt}/${config.maxRetries} — ${(0, provider_1.friendlyApiError)(err)}, waiting ${Math.round(waitMs / 1000)}s`);
+                            // A partially-streamed reply from the FAILED attempt must not leak
+                            // into the UI or the next attempt's reasoning accumulator.
+                            lastReasoning = '';
+                            callbacks.onRetryReset?.();
+                        },
+                    });
+                    break;
+                }
+                catch (err) {
+                    if (err instanceof provider_1.ProviderError &&
+                        err.status === 429 &&
+                        !signal?.aborted &&
+                        Date.now() < graceDeadline) {
+                        const waitMs = Math.min(Math.max(err.retryAfterMs ?? 30_000, 5_000), Math.max(graceDeadline - Date.now(), 1_000));
+                        callbacks.onStatus?.(`Provider busy — retrying in ${Math.round(waitMs / 1000)}s`);
+                        lastReasoning = '';
+                        callbacks.onRetryReset?.();
+                        await new Promise((r) => setTimeout(r, waitMs));
+                        if (signal?.aborted)
+                            throw new Error('aborted');
+                        continue;
+                    }
+                    throw err;
+                }
+            }
         }
         catch (err) {
             if (err.name === 'AbortError' || err.message === 'aborted') {
@@ -270,9 +301,9 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             }
             if (err instanceof provider_1.ProviderError && err.status === 429) {
                 callbacks.onError?.(new Error('Rate limited (429) by the provider.'));
-                callbacks.onStatus?.('Rate limited');
+                callbacks.onStatus?.('Provider busy');
                 stopped = true;
-                finalContent = '! Rate limited by the provider. Wait a moment and try again.';
+                finalContent = '! Provider busy — automatically retried for ~2 minutes. Try sending your message again.';
                 break;
             }
             callbacks.onError?.(err);

package/dist/providers/anthropic.js

@@ -132,7 +132,7 @@ class AnthropicProvider {
             if (!res.ok) {
                 const detail = safeJson(text);
                 const errObj = (detail && detail.error);
-                throw new provider_1.ProviderError(errObj?.message || `HTTP ${res.status}: ${text.slice(0, 300)}`, res.status, res.status >= 500 || res.status === 429);
+                throw new provider_1.ProviderError(errObj?.message || `HTTP ${res.status}: ${text.slice(0, 300)}`, res.status, res.status >= 500 || res.status === 429, (0, provider_1.parseRetryAfterMs)(res, text));
             }
             return safeJson(text) || {};
         }

package/dist/providers/openai-compat.js

@@ -305,7 +305,7 @@ class OpenAICompatProvider {
                 const detail = safeJson(text);
                 const errObj = (detail && detail.error);
                 const msg = errObj?.message || text.slice(0, 300);
-                throw new provider_1.ProviderError(msg, res.status, res.status >= 500 || res.status === 429);
+                throw new provider_1.ProviderError(msg, res.status, res.status >= 500 || res.status === 429, (0, provider_1.parseRetryAfterMs)(res, text));
             }
             return safeJson(text) || {};
         }
@@ -376,7 +376,7 @@ class OpenAICompatProvider {
                 const text = await res.text().catch(() => '');
                 const detail = safeJson(text);
                 const errObj = (detail && detail.error);
-                throw new provider_1.ProviderError(errObj?.message || `HTTP ${res.status}: ${text.slice(0, 200)}`, res.status, res.status >= 500 || res.status === 429);
+                throw new provider_1.ProviderError(errObj?.message || `HTTP ${res.status}: ${text.slice(0, 200)}`, res.status, res.status >= 500 || res.status === 429, (0, provider_1.parseRetryAfterMs)(res, text));
             }
             const reader = res.body.getReader();
             const decoder = new TextDecoder();

package/dist/providers/provider.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderError = void 0;
 exports.mergeStreamDelta = mergeStreamDelta;
 exports.friendlyApiError = friendlyApiError;
+exports.parseRetryAfterMs = parseRetryAfterMs;
 exports.withRetry = withRetry;
 /**
  * Idempotent merge of a streamed delta into the reply content so far.
@@ -43,7 +44,11 @@ function mergeStreamDelta(existing, delta) {
 class ProviderError extends Error {
     status;
     retryable;
-    constructor(message, status, retryable = false) {
+    retryAfterMs;
+    constructor(message, status, retryable = false, 
+    /** Server-advised wait before retrying (ms) — from Retry-After / retryAfter.
+     *  withRetry uses it instead of the plain 1s/2s/4s ladder for 429s. */
+    retryAfterMs) {
         super(message
             // Upstream error bodies are often PRETTY-PRINTED JSON — the raw
             // text carries real newlines (e.g. `HTTP 429: {\n  "error": …}`).
@@ -57,6 +62,7 @@ class ProviderError extends Error {
             .trim());
         this.status = status;
         this.retryable = retryable;
+        this.retryAfterMs = retryAfterMs;
         this.name = 'ProviderError';
     }
 }
@@ -107,6 +113,37 @@ function friendlyApiError(err) {
     const text = cleaned || noJson || raw;
     return text.length > 64 ? `${text.slice(0, 63)}…` : text;
 }
+/**
+ * Server-advised retry delay for 429s, in ms (0 when absent). Sources, in
+ * order: the standard `Retry-After` header (delta-seconds or HTTP-date) and
+ * the VectorHead gateway's JSON body field `retryAfter` (seconds). Keeps
+ * client retries aligned with the gateway breaker instead of burning the
+ * 1s/2s/4s ladder against a still-parked shared key.
+ */
+function parseRetryAfterMs(res, bodyText) {
+    const cap = 60_000;
+    const ra = res.headers.get('retry-after');
+    if (ra) {
+        const secs = Number(ra);
+        if (Number.isFinite(secs) && secs >= 0)
+            return Math.min(secs * 1000, cap);
+        const at = Date.parse(ra);
+        if (Number.isFinite(at))
+            return Math.max(0, Math.min(at - Date.now(), cap));
+    }
+    if (bodyText) {
+        try {
+            const j = JSON.parse(bodyText);
+            const secs = typeof j.retryAfter === 'number' ? j.retryAfter : Number(j.retryAfter);
+            if (Number.isFinite(secs) && secs >= 0)
+                return Math.min(secs * 1000, cap);
+        }
+        catch {
+            /* body not JSON — header-only */
+        }
+    }
+    return 0;
+}
 /** Simple retry wrapper for provider calls. */
 async function withRetry(fn, { retries = 3, delayMs = 1000, signal, 
 /** Called before each wait so the UI can show "retrying…" instead of a
@@ -135,6 +172,12 @@ onRetry, } = {}) {
                     : true;
             if (!retryable || attempt > retries)
                 throw err;
+            // 429 is NEVER retried by the plain ladder: the agent loop owns
+            // rate-limit pacing (grace retries honoring retryAfterMs). Ladder
+            // retries here would burn attempts against a parked shared key and
+            // delay the calm “Provider busy — retrying” UX.
+            if (err instanceof ProviderError && err.status === 429)
+                throw err;
             const wait = delayMs * Math.pow(2, attempt - 1);
             onRetry?.(attempt, err, wait);
             await new Promise((r) => setTimeout(r, wait));

package/dist/tools/shell.js

@@ -7,39 +7,94 @@ exports.createShellTool = createShellTool;
  * Every command is classified by the command policy and gated by permissions.
  */
 const node_child_process_1 = require("node:child_process");
+// After the shell itself exits, wait this long for the stdio pipes to drain
+// (normal commands flush and close within milliseconds) before giving up.
+// A command that ORPHANS a child holding the pipes (background job, server,
+// watcher …) would otherwise keep the tool — and the whole agent loop —
+// hanging until the grandchild dies ("sering nyangkut di shell", 2026-09-10).
+const ORPHAN_GRACE_MS = 500;
 function runShell(command, cwd, opts = {}) {
     return new Promise((resolve) => {
         const timeoutMs = opts.timeoutMs || 120_000;
+        // Own process group (detached) → the timeout / orphan guard can kill the
+        // whole tree (shell AND grandchildren), same policy as background.ts.
         const child = (0, node_child_process_1.spawn)(command, {
             cwd,
             shell: '/bin/sh',
             env: { ...process.env, ...opts.env },
             stdio: ['ignore', 'pipe', 'pipe'],
+            detached: true,
         });
         let stdout = '';
         let stderr = '';
         let timedOut = false;
+        let settled = false;
+        let graceTimer = null;
+        const killTree = () => {
+            if (child.pid != null) {
+                try {
+                    process.kill(-child.pid, 'SIGKILL'); // detached spawn ⇒ own process group
+                }
+                catch {
+                    /* group already gone */
+                }
+            }
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* already gone */
+            }
+        };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            resolve({ stdout, stderr, exitCode: code, timedOut });
+        };
         const timer = setTimeout(() => {
             timedOut = true;
-            child.kill('SIGKILL');
+            killTree(); // was: child.kill() only — orphaned children kept the pipe open and the promise hanging past the timeout
+            // 'exit' fires once the shell dies and resolves immediately.
         }, timeoutMs);
         child.stdout.on('data', (d) => {
             stdout += d.toString();
             if (stdout.length > 2_000_000)
-                child.kill('SIGKILL');
+                killTree();
         });
         child.stderr.on('data', (d) => {
             stderr += d.toString();
             if (stderr.length > 2_000_000)
-                child.kill('SIGKILL');
+                killTree();
+        });
+        // 'exit' = the shell itself died; 'close' = shell AND stdio pipes closed.
+        // Resolve on whichever happens first with a small grace window after
+        // 'exit': a normal command flushes and closes well inside the window, so
+        // full output still arrives — but an orphaned grandchild holding the
+        // pipes can no longer hang the tool past it.
+        child.on('exit', (code) => {
+            if (timedOut) {
+                finish(code);
+                return;
+            }
+            if (graceTimer)
+                return;
+            graceTimer = setTimeout(() => {
+                killTree(); // stop the orphan so its output stops too
+                finish(code);
+            }, ORPHAN_GRACE_MS);
         });
         child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ stdout, stderr, exitCode: code, timedOut });
+            finish(code);
         });
         child.on('error', (e) => {
-            clearTimeout(timer);
-            resolve({ stdout, stderr: `spawn error: ${e.message}`, exitCode: -1, timedOut });
+            // set stderr BEFORE finish — the resolved object snapshots these strings
+            if (!stdout && !stderr)
+                stderr = `spawn error: ${e.message}`;
+            finish(-1);
         });
     });
 }
@@ -52,7 +107,7 @@ function createShellTool() {
     return {
         definition: {
             name: 'shell',
-            description: 'Run a shell command in the project directory. The command is classified for safety; risky commands require permission. Use for building, testing, installing, git, or any command execution. Long output is truncated. For git commits prefer the dedicated `git` tool and follow its commit-attribution guidance.',
+            description: 'Run a shell command in the project directory. The command is classified for safety; risky commands require permission. Use for building, testing, installing, git, or any command execution. Long output is truncated. Commands that keep running (dev servers, watchers, polling loops) must use run_in_background instead — a foreground shell is killed after its timeout. For git commits prefer the dedicated `git` tool and follow its commit-attribution guidance.',
             parameters: {
                 type: 'object',
                 properties: {

package/dist/tui/app.js

@@ -1804,11 +1804,12 @@ class App {
                 // never shows gateway internals.
                 let errorContent = `! ${(0, provider_1.friendlyApiError)(err)}`;
                 if (exhausted && this.agent.config.provider === free_tier_1.FREE_PROVIDER_ID) {
-                    // TIDAK ada kuota perangkat di tier free (dihapus dari gateway).
-                    // Error quota di sini = cooldown key GATEWAY (akun bersama), bukan
-                    // kesalahan user — jangan menuduh kuota habis.
+                    // ANTI-COOLDOWN UX (2026-09-09): loop sudah meng-absorpsi 429 dgn
+                    // grace retry ~2 menit — pesan ini hanya muncul kalau gateway benar-
+                    // benar masih ramai SETELAH itu. Copy-nya tenang & pasif (penerimaan,
+                    // bukan dinding instruksi BYOK); otomatis coba lagi adalah default.
                     errorContent =
-                        '! Key gateway VectorHead Free sedang cooldown sebentar (dipakai akun bersama) — coba lagi beberapa menit, atau ganti model via /model, atau pakai API key sendiri via /connect (BYOK).';
+                        '! Provider sedang ramai (akun gratis dipakai bersama). Percobaan berikutnya berjalan otomatis — tidak perlu mengatur apa pun.';
                 }
                 this.messages.push({ kind: 'error', content: errorContent, ts: Date.now() });
                 this.scrollToLatest();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agen-vektor",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "VectorHead (agen-vektor) — AI Coding Agent CLI/TUI for Linux & Termux. Multi-provider, tool calling, session, permission system.",
   "type": "commonjs",
   "bin": {