ucode-agent 1.47.0 → 1.49.0

package/src/core/provider.js

@@ -137,6 +137,21 @@ export function fallbackFor(id, tried = new Set()) {
 /** Seconds to wait on successive rate limits that come with no retry-after. */
 const RATE_LIMIT_BACKOFF = [5, 10, 20];
 
+/**
+ * How long a stream may go without a single chunk before it counts as frozen.
+ *
+ * A free endpoint can accept a request and then send nothing at all, and the
+ * only thing that used to end that was the five-minute request timeout — five
+ * minutes of a spinner, then the same again on the retry. Reasoning streams
+ * as it is produced, so even the slowest thinker sends something well inside
+ * a minute; silence for that long means nobody is working on the reply.
+ */
+export const stallLimit = () => Number(process.env.UCODE_STALL_MS) || 60_000;
+
+/** Freezes in a row before ucode stops asking and says to switch models. */
+export const MAX_STALLS = 3;
+let stalls = 0;
+
 let current = process.env.UCODE_MODEL || DEFAULT_MODEL;
 let client = null;
 
@@ -622,16 +637,34 @@ export async function ask(messages, tools = [], opts = {}) {
 
   for (let attempt = 1; attempt <= attempts; attempt++) {
     try {
-      if (opts.onText) return await streamed(request, callOpts, id);
+      if (opts.onText) {
+        const reply = await streamed(request, callOpts, id);
+        stalls = 0;
+        return reply;
+      }
       const { data, response } = await connection().chat.completions
         .create(request, { signal: opts.signal })
         .withResponse();
       noteLimits(response?.headers);
+      stalls = 0;
       return normalize(data, id);
     } catch (err) {
       noteLimits(err?.headers);
       problem = explain(err, id);
 
+      // Retrying a model that keeps freezing only repeats the wait. After a
+      // few in a row, say so and hand the choice back.
+      if (problem.detail?.stalled && ++stalls >= MAX_STALLS) {
+        stalls = 0;
+        throw new Failure({
+          kind: 'stalled',
+          attempted: `asking ${modelName(id)} for a reply`,
+          failed: `${modelName(id)} froze ${MAX_STALLS} times in a row — it took the request and then sent nothing.`,
+          fix: 'Its free endpoint is struggling right now. Run /model and pick another one; North Mini Code answers soonest.',
+          cause: problem,
+        });
+      }
+
       // A per-minute limit is a wait, not a failure. Sit it out rather than
       // making the user retype their message. Free endpoints often refuse
       // without saying how long to wait, so when there is no retry-after the
@@ -656,6 +689,7 @@ export async function ask(messages, tools = [], opts = {}) {
         problem.kind === 'server' || problem.kind === 'network' || problem.kind === 'timeout';
       if (!worthRetrying || attempt === attempts || opts.signal?.aborted) break;
       if (printed > 0) break; // half an answer is on screen; do not print it twice
+      if (problem.detail?.handed) break; // its first tool calls are already running
 
       // A stalled provider needs longer to come back than a dropped socket
       // does, and the wait is narrated so a slow turn never looks like a hang.
@@ -675,13 +709,17 @@ export async function ask(messages, tools = [], opts = {}) {
 
 /** Collect a streamed reply, handing deltas out as they land. */
 async function streamed(request, opts, id) {
-  const { data: stream, response } = await connection().chat.completions
-    .create(
-      { ...request, stream: true, stream_options: { include_usage: true } },
-      { signal: opts.signal }
-    )
-    .withResponse();
-  noteLimits(response?.headers);
+  // A watchdog of its own, so a frozen stream can be ended without it looking
+  // like the user pressed stop.
+  const quiet = new AbortController();
+  const stop = () => quiet.abort();
+  opts.signal?.addEventListener('abort', stop, { once: true });
+  let stalled = false;
+  let timer;
+  const alive = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => { stalled = true; quiet.abort(); }, stallLimit());
+  };
 
   let text = '';
   let reasoning = '';
@@ -691,57 +729,82 @@ async function streamed(request, opts, id) {
   const handed = new Set();
   let highest = -1;
 
-  for await (const chunk of stream) {
-    if (opts.signal?.aborted) break;
-    if (chunk.usage) usage = chunk.usage;
-
-    const choice = chunk.choices?.[0];
-    if (!choice) continue;
-    if (choice.finish_reason) finishReason = choice.finish_reason;
-    const delta = choice.delta ?? {};
-
-    // Reasoning arrives on a separate channel: `reasoning` on OpenRouter,
-    // `reasoning_content` on some upstreams.
-    const thinking = delta.reasoning ?? delta.reasoning_content;
-    if (thinking) {
-      reasoning += thinking;
-      opts.onThinking?.(thinking);
-    }
+  try {
+    alive();
+    const { data: stream, response } = await connection().chat.completions
+      .create(
+        { ...request, stream: true, stream_options: { include_usage: true } },
+        { signal: quiet.signal }
+      )
+      .withResponse();
+    noteLimits(response?.headers);
+
+    for await (const chunk of stream) {
+      alive();
+      if (opts.signal?.aborted) break;
+      if (chunk.usage) usage = chunk.usage;
+
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      if (choice.finish_reason) finishReason = choice.finish_reason;
+      const delta = choice.delta ?? {};
+
+      // Reasoning arrives on a separate channel: `reasoning` on OpenRouter,
+      // `reasoning_content` on some upstreams.
+      const thinking = delta.reasoning ?? delta.reasoning_content;
+      if (thinking) {
+        reasoning += thinking;
+        opts.onThinking?.(thinking);
+      }
 
-    if (delta.content) {
-      text += delta.content;
-      opts.onText(delta.content);
-    }
+      if (delta.content) {
+        text += delta.content;
+        opts.onText(delta.content);
+      }
 
-    // A tool call's name and arguments arrive across several chunks, keyed by
-    // index, so they are stitched back together here.
-    for (const call of delta.tool_calls ?? []) {
-      // Calls arrive one after another, so the first chunk of call N means
-      // every call before it is complete. Those are handed over at once, and
-      // the caller can start running them while the rest are still being
-      // written — the reply streaming and the tools working overlap.
-      if (opts.onToolCall && call.index > highest) {
-        for (const [index, slot] of partial) {
-          if (index < call.index && !handed.has(index)) {
-            handed.add(index);
-            opts.onToolCall(readCall({ id: slot.id || `call_${index}`, name: slot.name, raw: slot.args }));
+      // A tool call's name and arguments arrive across several chunks, keyed by
+      // index, so they are stitched back together here.
+      for (const call of delta.tool_calls ?? []) {
+        // Calls arrive one after another, so the first chunk of call N means
+        // every call before it is complete. Those are handed over at once, and
+        // the caller can start running them while the rest are still being
+        // written — the reply streaming and the tools working overlap.
+        if (opts.onToolCall && call.index > highest) {
+          for (const [index, slot] of partial) {
+            if (index < call.index && !handed.has(index)) {
+              handed.add(index);
+              opts.onToolCall(readCall({ id: slot.id || `call_${index}`, name: slot.name, raw: slot.args }));
+            }
           }
+          highest = call.index;
         }
-        highest = call.index;
-      }
 
-      const slot = partial.get(call.index) ?? { id: '', name: '', args: '' };
-      if (call.id) slot.id = call.id;
-      if (call.function?.name) slot.name += call.function.name;
-      if (call.function?.arguments) slot.args += call.function.arguments;
-      partial.set(call.index, slot);
-
-      // A whole app arrives as one enormous arguments string that takes a
-      // minute or two to write. Handing it over as it grows is what lets the
-      // caller say which file is being written right now, instead of showing
-      // a spinner that has meant nothing for ninety seconds.
-      if (call.function?.arguments) opts.onToolArgs?.({ index: call.index, name: slot.name, args: slot.args });
+        const slot = partial.get(call.index) ?? { id: '', name: '', args: '' };
+        if (call.id) slot.id = call.id;
+        if (call.function?.name) slot.name += call.function.name;
+        if (call.function?.arguments) slot.args += call.function.arguments;
+        partial.set(call.index, slot);
+
+        // A whole app arrives as one enormous arguments string that takes a
+        // minute or two to write. Handing it over as it grows is what lets the
+        // caller say which file is being written right now, instead of showing
+        // a spinner that has meant nothing for ninety seconds.
+        if (call.function?.arguments) opts.onToolArgs?.({ index: call.index, name: slot.name, args: slot.args });
+      }
     }
+  } catch (err) {
+    if (!stalled || opts.signal?.aborted) throw err;
+    throw new Failure({
+      kind: 'timeout',
+      attempted: `asking ${modelName(id)} for a reply`,
+      failed: `${modelName(id)} went silent for ${Math.round(stallLimit() / 1000)}s, so ucode stopped waiting.`,
+      fix: 'ucode asks again by itself. If it keeps freezing, /model to North Mini Code.',
+      detail: { stalled: true, handed: handed.size },
+      cause: err,
+    });
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener('abort', stop);
   }
 
   const toolCalls = [];

package/src/tools/browser.js

@@ -188,7 +188,11 @@ export function forgetReviews() {
 const PROBE_TEXT = 'ucode check';
 
 /** Did anything at all happen on the page? */
-const moved = (a, b) => a.nodes !== b.nodes || a.text !== b.text || a.stored !== b.stored;
+// The markup itself, not its length: a timer going 25:00 -> 24:59, a counter
+// going 0 -> 1 or a task ticked off by a class change keeps every length the
+// same, and was reported as "NOTHING HAPPENS" — a false accusation the model
+// then "fixed" by rewriting script that worked.
+const moved = (a, b) => a.nodes !== b.nodes || a.html !== b.html || a.stored !== b.stored;
 
 /**
  * Use the app, rather than only looking at it.
@@ -218,6 +222,7 @@ async function useTheApp(page) {
   const snapshot = () => page.evaluate(() => ({
     nodes: document.body.querySelectorAll('*').length,
     text: document.body.innerText.replace(/\s+/g, ' ').trim().length,
+    html: document.body.innerHTML,
     stored: (() => { try { return JSON.stringify(localStorage).length; } catch { return 0; } })(),
   }));
 
@@ -326,7 +331,7 @@ export async function withStaticServer(dir, fn) {
   }
 }
 
-export async function lookAtApp({ url, paths = ['/'] }) {
+export async function lookAtApp({ url, paths = ['/'], review: withReview = true }) {
   const base = String(url ?? '').trim().replace(/\/+$/, '');
   if (!LOCAL.test(`${base}/`)) {
     throw new ToolFailure({
@@ -355,6 +360,10 @@ export async function lookAtApp({ url, paths = ['/'] }) {
     const errors = [];
     const failed = [];
     page.on('console', (m) => {
+      // The browser asks for /favicon.ico on its own. A page without one is
+      // not broken, and counting that 404 sent every plain-html build round
+      // a fix loop it did not need.
+      if (/\/favicon\.ico$/i.test(m.location()?.url ?? '')) return;
       if (m.type() === 'error' && !/devtools|download the react/i.test(m.text())) errors.push(m.text().slice(0, 200));
     });
     page.on('pageerror', (e) => errors.push(`uncaught: ${String(e.message).slice(0, 200)}`));
@@ -513,7 +522,7 @@ export async function lookAtApp({ url, paths = ['/'] }) {
   // error overlay is a minute spent on nothing.
   let critique = '';
   const state = reviews.get(base) ?? { done: false, tries: 0 };
-  if (!broken && !state.done && state.tries < 2 && toReview.length) {
+  if (withReview && !broken && !state.done && state.tries < 2 && toReview.length) {
     state.tries++;
     reviews.set(base, state);
     try {
@@ -530,7 +539,7 @@ export async function lookAtApp({ url, paths = ['/'] }) {
     critique ? `## Visual review\n${critique}` : '',
     '',
     problems
-      ? 'Fix the problems above, then look again to confirm.'
+      ? 'Fix the problems above - only those; leave everything that works as it is.'
       : state.done && critique
         ? 'The automatic checks found nothing. Weigh the visual review, fix what is worth fixing - ' +
           'the next look re-runs only the fast checks.'

package/src/tools/index.js

@@ -12,7 +12,7 @@ import { addBlock, BLOCK_NAMES, PLAIN_BLOCK_NAMES, ALL_BLOCK_NAMES } from './blo
 import { typeOf } from './types.js';
 import { runCommand, runCommands } from './shell.js';
 import { webSearch } from './web.js';
-import { createApp, TEMPLATE_NAMES, TEMPLATE_NOTES } from './scaffold.js';
+import { createApp, normaliseFiles, TEMPLATE_NAMES, TEMPLATE_NOTES } from './scaffold.js';
 import { deploy } from './deploy.js';
 import { clip, READ_LINES } from './shared.js';
 
@@ -702,13 +702,15 @@ export function describe(name, args = {}) {
       return `Running ${args.commands?.length ?? 0} commands together`;
     case 'deploy':
       return `Deploying ${clip(args.folder || '.', 30)} to Vercel`;
-    case 'create_app':
+    case 'create_app': {
+      const files = normaliseFiles(args.files).length;
       // Say which starter it actually is. Hardcoding one of them meant a plain
       // HTML app announced itself as Next.js, which is a line that is simply
       // untrue on screen while the opposite happens on disk.
       return `Creating ${clip(args.name || args.folder, 30)} from the ` +
         `${args.template === 'next-shadcn' ? 'Next.js' : 'HTML'} starter` +
-        `${args.files?.length ? ` with ${args.files.length} file${args.files.length === 1 ? '' : 's'}` : ''}`;
+        `${files ? ` with ${files} file${files === 1 ? '' : 's'}` : ''}`;
+    }
     case 'look_at_app':
       return `Looking at ${clip(args.url, 40)} on a phone and a desktop`;
     case 'web_search':

package/src/tools/scaffold.js

@@ -48,7 +48,7 @@ const SHOW_BACK = { 'plain-html': ['index.html', 'styles.css', 'app.js'] };
  * something adjacent. Each of those, refused, is a round trip spent being
  * told what could have been read — so they are all read.
  */
-function normaliseFiles(files) {
+export function normaliseFiles(files) {
   let value = files;
   if (typeof value === 'string') {
     try { value = JSON.parse(value); } catch { return []; }