jaitus 0.3.8 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {

package/src/agent/loop.js

@@ -31,7 +31,7 @@ import { loadContext, loadIgnore, CONTEXT_FILE } from '../project.js';
 import { c, out, write, spinner, glyph } from '../ui.js';
 import { discoverMcpTools } from '../mcp.js';
 import { unifiedDiff } from '../diff.js';
-import { fromResponse, fromGatewayBody } from '../errors.js';
+import { fromResponse, fromGatewayBody, JaitusError } from '../errors.js';
 
 const MAX_ITERATIONS = 1000;
 const STUCK_REPEATS = 4;
@@ -425,7 +425,12 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
       if (streamError) break;
     }
   } catch (e) {
-    if (signal?.aborted || e?.name === 'AbortError') throw e;
+    // Esc is the only abort that reads as an interruption. Any OTHER AbortError —
+    // the request timeout in api.js firing mid-body, a dropped socket — is a `timeout`
+    // JaitusError so the agent loop backs off and retries it (TRANSIENT_CODES) instead
+    // of reporting "Interrupted." for something the user never stopped.
+    if (signal?.aborted) throw e;
+    if (e?.name === 'AbortError') throw new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
     // The connection dropped mid-answer. What arrived is kept and continued from; with
     // nothing received yet, the caller retries the request instead.
     if (!blocks.size) throw e;

package/src/api.js

@@ -10,6 +10,47 @@ import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
 
 export class NotSignedIn extends Error {}
 
+// fetch() has no timeout of its own, and the gateway's worst case is minutes of
+// serial failover across provider keys — so a sick window used to pin the CLI on
+// "Working..." forever. Every call below carries its own ceiling: slow becomes a
+// `timeout` JaitusError (retryable by the agent loop, shown with a request id)
+// instead of eternity. The caller's signal (Esc) still wins: it aborts through the
+// same controller, and only a genuine user abort reads as one.
+const MESSAGES_TIMEOUT_MS = 10 * 60 * 1000; // streamed turns can legitimately run minutes
+const API_TIMEOUT_MS = 30 * 1000;           // dashboard calls are small JSON
+
+// Combine an optional caller signal with a timeout into one signal.
+// Manual combine (not AbortSignal.any): .any needs Node 20.3+, this works everywhere.
+function withTimeout(signal, ms) {
+  const ctrl = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    try { ctrl.abort(new DOMException('Request timed out', 'TimeoutError')); }
+    catch { try { ctrl.abort(); } catch { /* already gone */ } }
+  }, ms);
+  if (timer.unref) timer.unref();
+  const onAbort = () => {
+    clearTimeout(timer);
+    try { ctrl.abort(signal.reason); } catch { try { ctrl.abort(); } catch { /* already gone */ } }
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener('abort', onAbort, { once: true });
+  }
+  return {
+    signal: ctrl.signal,
+    // True only when OUR timer fired. A user abort also lands here as an AbortError,
+    // but signal.aborted is set then — never mistake Esc for a timeout.
+    timedOut: () => timedOut && !signal?.aborted,
+    cleanup: () => { clearTimeout(timer); signal?.removeEventListener?.('abort', onAbort); },
+  };
+}
+
+function timeoutError() {
+  return new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
+}
+
 // The context window the gateway last advertised, or null before it has been asked.
 let contextWindowSeen = null;
 export const advertisedContextWindow = () => contextWindowSeen;
@@ -28,45 +69,63 @@ export function createClient() {
 
     /** POST /v1/messages. Returns the raw Response so the caller can stream it. */
     async messages(body, { signal } = {}) {
+      // The timer is deliberately NOT cleared when headers arrive: a stall can happen
+      // mid-body too (headers fast, tokens never come), and only the stream reader ends
+      // that. Aborting a finished request is harmless; the timer never holds the
+      // process open (unref). 10 minutes: streamed agentic turns legitimately run long.
+      const t = withTimeout(signal, MESSAGES_TIMEOUT_MS);
       try {
         return await withAuth((token) => fetch(`${baseUrl}/v1/messages`, {
           method: 'POST',
           headers: headers(token),
           body: JSON.stringify(body),
-          signal,
+          signal: t.signal,
         }));
       } catch (cause) {
-        if (cause?.name === 'JaitusError' || cause?.name === 'AbortError') throw cause;
+        if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
         throw fromNetwork(cause);
       }
     },
 
     /** A dashboard API call, returning parsed JSON. */
     async api(pathname, init = {}) {
+      const t = withTimeout(init.signal, API_TIMEOUT_MS);
       let res;
       try {
         res = await withAuth((token) => fetch(`${baseUrl}/api${pathname}`, {
           ...init,
           headers: { ...headers(token), ...(init.headers || {}) },
+          signal: t.signal,
         }));
+        const body = await res.json().catch(() => ({}));
+        return { ok: res.ok, status: res.status, body };
       } catch (cause) {
         if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
         throw fromNetwork(cause);
+      } finally {
+        t.cleanup();
       }
-      const body = await res.json().catch(() => ({}));
-      return { ok: res.ok, status: res.status, body };
     },
 
     /** Model ids the gateway advertises. */
     async models() {
+      const t = withTimeout(undefined, API_TIMEOUT_MS);
       let res;
       try {
-        res = await withAuth((token) => fetch(`${baseUrl}/v1/models`, { headers: headers(token) }));
+        res = await withAuth((token) => fetch(`${baseUrl}/v1/models`, { headers: headers(token), signal: t.signal }));
       } catch (cause) {
+        t.cleanup();
         if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
         throw fromNetwork(cause);
       }
       const body = await res.json().catch(() => ({}));
+      t.cleanup();
       if (!res.ok) throw fromGatewayBody(res.status, body, { requestId: res.headers.get('x-request-id') || '' });
       const models = (body?.data || []).map((m) => m?.id).filter(Boolean);
       // How much conversation fits, as the gateway computed it for this account.

package/src/index.js

@@ -1181,7 +1181,8 @@ async function session({ flags }) {
       ledger.note('compacted', `The conversation was automatically summarised to free context: ${dropped} messages became one summary. Detail you are not shown above is genuinely gone — ask or re-read rather than assuming.`);
     } catch (error) {
       // Not fatal: the turn can still run, it just runs closer to the ceiling.
-      tui.notice?.(`Auto-compaction failed (${error.message}) — continuing without it. /compact retries.`, 'warn');
+      const id = isJaitusError(error) && error.requestId ? ` (request id ${error.requestId})` : '';
+      tui.notice?.(`Auto-compaction failed (${error.message}${id}) — continuing without it. /compact retries.`, 'warn');
       ledger.note('compact-failed', `Automatic context compaction failed (${error.message}); the conversation is close to the context limit.`);
     } finally {
       tui.clearStatus?.();
@@ -1830,7 +1831,11 @@ async function slashCommand(verb, args, ctx) {
         ok('Conversation compacted. Context freed.');
         try { ctx.resetContext?.(); } catch { /* header keeps last value */ }
       } catch (e) {
-        fail(`Compact failed: ${e.message}`);
+        // The request id is the only thing that ties this failure to a backend log
+        // line. fail() takes a string, so a JaitusError passed bare would shed it —
+        // and "where do I get the request id" is exactly what that produces.
+        const id = isJaitusError(e) && e.requestId ? ` (request id ${e.requestId})` : '';
+        fail(`Compact failed: ${e.message}${id}`);
       } finally {
         spin.stop();
       }