jaitus 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/source-sanity.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js",
+    "test": "node tests/source-sanity.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/continuation.js && node tests/context-budget.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/agent/loop.js

@@ -31,6 +31,23 @@ import { fromResponse, fromGatewayBody } from '../errors.js';
 
 const MAX_ITERATIONS = 40;
 
+// Room for a long answer or a large file in one reply. The models behind Jaitus reason
+// before they answer, and that reasoning is spent from the same budget — at 8192 a long
+// answer, or any file of a few hundred lines, was cut off partway.
+export const MAX_OUTPUT_TOKENS = 32000;
+
+// A reply that stopped before it finished — the output limit, or a connection dropped
+// somewhere between the provider and here — is continued, not presented as the answer.
+// Bounded, so a model that never finishes cannot loop on the user's allowance.
+export const MAX_CONTINUATIONS = 4;
+export const CONTINUE_NOTE = 'Your previous reply was cut off before it finished (an output limit or a dropped connection). '
+  + 'Continue from exactly where it stopped: do not repeat or summarise what you already wrote, and do not mention this note. '
+  + 'If you were in the middle of a tool call, make that call again in full.';
+
+// A request that failed before anything arrived (a network blip) is tried again this
+// many times before it is reported.
+const NETWORK_RETRIES = 2;
+
 /** opencode tool icon per tool, muted when done. ASCII twins included. */
 const TOOL_MARKS = {
   run_command: ['$', '$'], read_file: ['→', '>'], read_image: ['→', '>'],
@@ -145,7 +162,7 @@ ${project}
 async function streamTurn({ client, messages, model, system, tools, onText, onToolStart, signal }) {
   const res = await client.messages({
     model,
-    max_tokens: 8192,
+    max_tokens: MAX_OUTPUT_TOKENS,
     system: system || SYSTEM_PROMPT,
     tools,
     messages,
@@ -158,6 +175,10 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
   // Blocks are keyed by the index the stream gives them, because they interleave.
   const blocks = new Map();
   let stopReason = null;
+  // Whether the stream ended the way a finished message ends. A stream that just stops
+  // — no message_stop, no stop reason — was cut, and used to be taken as a complete,
+  // silent answer: the "it stops midway for no reason" bug.
+  let sawStop = false;
   const usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
   // Usage can arrive at the START of a stream (Anthropic-format providers) or only at
   // the END, in message_delta (OpenAI-format providers, translated by the gateway —
@@ -208,6 +229,9 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
         if (event.delta?.stop_reason) stopReason = event.delta.stop_reason;
         takeUsage(event.usage);
         break;
+      case 'message_stop':
+        sawStop = true;
+        break;
       default:
         break;
     }
@@ -222,21 +246,31 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
   // independently would corrupt it. The decoder holds the partial bytes until complete.
   const decoder = new TextDecoder();
 
-  for await (const chunk of res.body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    const frames = buffer.split('\n\n');
-    buffer = frames.pop() || '';
-    for (const frame of frames) {
-      for (const line of frame.split('\n')) {
-        if (!line.startsWith('data:')) continue;
-        const raw = line.slice(5).trim();
-        if (!raw || raw === '[DONE]') continue;
-        try { handle(JSON.parse(raw)); } catch { /* keepalive or partial */ }
+  let cut = false;
+  try {
+    for await (const chunk of res.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const frames = buffer.split('\n\n');
+      buffer = frames.pop() || '';
+      for (const frame of frames) {
+        for (const line of frame.split('\n')) {
+          if (!line.startsWith('data:')) continue;
+          const raw = line.slice(5).trim();
+          if (!raw || raw === '[DONE]') continue;
+          try { handle(JSON.parse(raw)); } catch { /* keepalive or partial */ }
+        }
       }
+      if (streamError) break;
     }
-    if (streamError) break;
+  } catch (e) {
+    if (signal?.aborted || e?.name === 'AbortError') throw e;
+    // 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;
+    cut = true;
   }
   if (streamError) throw streamError;
+  if (cut || (!sawStop && !stopReason)) stopReason = 'cut';
 
   const content = [...blocks.entries()]
     .sort((a, b) => a[0] - b[0])
@@ -285,6 +319,12 @@ export async function runAgent({
     ...Object.fromEntries(mcp.map((tool) => [tool.name, tool])),
   };
 
+  let continuations = 0;
+  let networkRetries = 0;
+  // True while the previous reply is being continued: its text is still on screen as
+  // one live message, and the continuation must extend it rather than start another.
+  let continuing = false;
+
   for (let iteration = 0; iteration < maxIterations; iteration++) {
     let streamed = false;
     const spin = tui ? { stop: () => {}, update: () => {} } : (silent ? { stop: () => {}, update: () => {} } : spinner(glyph('Working…', 'Working...')));
@@ -323,6 +363,15 @@ export async function runAgent({
       spin.stop();
       // Esc during streaming: stop mid-sentence, keep what landed, don't treat it
       // as an error. The partial text is already on screen.
+      // A network failure before anything arrived: try again, briefly, before reporting.
+      // Anything the gateway itself refused (a limit, a sign-in problem) has a status and
+      // is reported at once — retrying it would only repeat the refusal.
+      if (!(signal?.aborted || e?.name === 'AbortError') && !e?.status && networkRetries < NETWORK_RETRIES) {
+        networkRetries += 1;
+        await new Promise((r) => setTimeout(r, 800 * networkRetries));
+        iteration -= 1;
+        continue;
+      }
       if (signal?.aborted || e?.name === 'AbortError') {
         if (tui) tui.flushStream();
         if (streamed && !silent) out('');
@@ -334,8 +383,16 @@ export async function runAgent({
       throw e;
     }
     spin.stop();
-    if (tui) tui.flushStream();
-    if (streamed) { if (tui) tui.printStream('\n'); else if (!silent && !onText) out(''); }
+    networkRetries = 0;
+    const incomplete = turn.stopReason === 'max_tokens' || turn.stopReason === 'cut';
+    // A tool call cut off halfway has JSON that is not whole; it is dropped and the model
+    // is asked to make it again.
+    if (incomplete) turn.content = turn.content.filter((b) => b.type !== 'tool_use' || b.input?.__parse_error === undefined);
+    const willContinue = incomplete && continuations < MAX_CONTINUATIONS && !turn.content.some((b) => b.type === 'tool_use');
+    if (!willContinue) {
+      if (tui) tui.flushStream();
+      if (streamed || continuing) { if (tui) tui.printStream('\n'); else if (!silent && !onText) out(''); }
+    }
 
     totals.input += turn.usage.input_tokens || 0;
     totals.cached += (turn.usage.cache_read_input_tokens || 0) + (turn.usage.cache_creation_input_tokens || 0);
@@ -346,6 +403,24 @@ export async function runAgent({
     // appeared; now it moves after every step of the turn.
     tui?.setTurnTokens?.(totals.input + totals.cached + totals.output);
 
+    if (willContinue) {
+      continuations += 1;
+      continuing = true;
+      const text = turn.content.filter((b) => b.type === 'text');
+      if (text.length) messages.push({ role: 'assistant', content: text });
+      messages.push({ role: 'user', content: [{ type: 'text', text: CONTINUE_NOTE }] });
+      onEvent?.({ type: 'continued', reason: turn.stopReason, count: continuations });
+      continue;
+    }
+    continuing = false;
+    if (incomplete && !turn.content.some((b) => b.type === 'tool_use')) {
+      // Still unfinished after every continuation: say so, rather than let a partial
+      // answer pass as a whole one.
+      const why = 'The reply was still unfinished after several continuations. Ask for the rest, or narrow the request.';
+      if (tui?.notice) tui.notice(why, 'warn');
+      else if (!silent) out(c.yellow(`  ${why}`));
+    }
+
     // Append the assistant turn verbatim — tool_use blocks and all.
     messages.push({ role: 'assistant', content: turn.content });
     onEvent?.({ type: 'assistant_turn', content: turn.content, usage: turn.usage, iteration });

package/src/api.js

@@ -10,6 +10,10 @@ import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
 
 export class NotSignedIn extends Error {}
 
+// The context window the gateway last advertised, or null before it has been asked.
+let contextWindowSeen = null;
+export const advertisedContextWindow = () => contextWindowSeen;
+
 export function createClient() {
   const { baseUrl } = endpoints();
   if (!signedIn()) throw new NotSignedIn('Not signed in. Run `jaitus login` first.');
@@ -63,6 +67,9 @@ export function createClient() {
       const body = await res.json().catch(() => ({}));
       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.
+      const ctx = (body?.data || []).map((m) => Number(m?.context_window)).find((n) => n > 0);
+      if (ctx) contextWindowSeen = ctx;
       // An empty list is a service fault, not something the user can fix — and naming
       // the gateway's model map to them would be naming our internals.
       if (!models.length) throw new JaitusError({ code: 'unavailable', status: 502 });

package/src/index.js

@@ -9,7 +9,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { spawn, spawnSync } from 'node:child_process';
-import { createClient, NotSignedIn } from './api.js';
+import { createClient, NotSignedIn, advertisedContextWindow } from './api.js';
 import { fromResponse, isJaitusError } from './errors.js';
 import { signedIn } from './session.js';
 import {
@@ -300,10 +300,18 @@ function gitBranch(cwd) {
   }
 }
 
-// Used only to fill the context meter. The real ceiling is the model's, which the
-// gateway does not advertise; this is the conservative floor of what any model it
-// serves accepts, so the bar reads "getting full" before anything actually breaks.
-const CONTEXT_BUDGET = 180_000;
+// How much conversation a session carries before it is compacted. The gateway works it
+// out from the providers' real limits and the admin's cap, and advertises it on its
+// model list; this floor is only used until that answer arrives, or if it never does.
+const CONTEXT_FALLBACK = 128_000;
+let CONTEXT_BUDGET = CONTEXT_FALLBACK;
+async function loadContextBudget(client) {
+  try {
+    if (!advertisedContextWindow()) await client.models();
+    CONTEXT_BUDGET = advertisedContextWindow() || CONTEXT_FALLBACK;
+  } catch { /* keep the floor */ }
+  return CONTEXT_BUDGET;
+}
 
 // Compact at this fraction of the budget. Low enough that the summarisation request
 // itself still fits comfortably, high enough that a normal session never sees it.
@@ -548,6 +556,7 @@ async function session({ flags }) {
   let [model, device] = await Promise.all([
     resolveModel(client, flags.model),
     probeDevice({}).catch(() => ({ vt: !!process.stdout.isTTY, sixel: false })),
+    loadContextBudget(client),
   ]);
   // Degrade on EVIDENCE, not on silence.
   //
@@ -792,9 +801,11 @@ async function session({ flags }) {
         spent.turns += 1;
         // opencode assistant metadata: ▣ Mode · model · duration.
         const secs = ((Date.now() - turnStarted) / 1000).toFixed(1);
-        const posture = permissions.mode === 'plan' ? 'Read-only'
+        // The same words the header uses for the mode. "Off" on its own read as though
+        // something was broken; it meant approvals were off.
+        const posture = permissions.mode === 'plan' ? 'Plan'
           : permissions.mode === 'acceptEdits' ? 'Auto-edit'
-          : permissions.mode === 'bypassPermissions' ? 'Off' : 'Ask';
+          : permissions.mode === 'bypassPermissions' ? 'Bypass' : 'Ask';
         const meta = `  ${c.brand(glyph('▣', '*'))} ${posture} ${c.dim(`· ${model} · ${secs}s`)}`;
         if (tui) tui.print(meta);
         else out(meta);
@@ -1131,7 +1142,7 @@ async function session({ flags }) {
     const { columns: termColumns } = await import('./ui.js');
     const approval = permissions.mode === 'plan' ? 'read-only'
       : permissions.mode === 'acceptEdits' ? 'auto-edit'
-      : permissions.mode === 'bypassPermissions' ? 'off' : 'ask';
+      : permissions.mode === 'bypassPermissions' ? 'bypass' : 'ask';
     for (const line of renderClassicOpen({
       version: VERSION, model, approval, cwd: flags.cwd,
       account: creds?.user?.email ? `${creds.user.email}${creds.user.isPaid ? '' : ' (free plan)'}` : null,
@@ -2062,7 +2073,7 @@ async function slashCommand(verb, args, ctx) {
       // Session header on demand, codex-style.
       const modeApproval = ctx.permissions.mode === 'plan' ? 'read-only'
         : ctx.permissions.mode === 'acceptEdits' ? 'auto-edit'
-        : ctx.permissions.mode === 'bypassPermissions' ? 'off' : 'ask';
+        : ctx.permissions.mode === 'bypassPermissions' ? 'bypass' : 'ask';
       ctx.tui.print(`  ${c.dim(`jaitus v${VERSION}`)}`);
       ctx.tui.print(`  ${c.dim(`model ${ctx.model} · approval ${modeApproval} · ${ctx.flags.cwd}`)}`);
       return null;