jaitus 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "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",
     "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/index.js

@@ -792,9 +792,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 +1133,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 +2064,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;