ucode-agent 1.51.0 → 1.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.51.0",
+  "version": "1.53.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA, Cohere, Nex AGI, DeepSeek and Qwen models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/loop.js

@@ -306,6 +306,9 @@ export function lean(messages, keep = 3) {
   });
 }
 
+/** Tools that write whole files, whose sizes are remembered for the turn. */
+const WHOLE_WRITES = new Set(['write_file', 'batch_write', 'create_app']);
+
 function trace(event) {
   if (!TRACE_FILE) return;
   try { appendFileSync(TRACE_FILE, `${JSON.stringify({ at: Date.now(), ...event })}
@@ -1189,6 +1192,7 @@ export class Agent {
     this.reads = new Map();
     this.declines = 0;
     this.apps = [];
+    this.wrote = new Map();
     forgetReviews(); // a new request: its apps get a fresh design review
     setRequest(input); // create_app checks this before choosing a starter
     const images = await this.attachImages(input);
@@ -1776,6 +1780,7 @@ export class Agent {
     // goes on the same line, the way a change carries its two numbers.
     // Which app folders this turn actually made, so a second one can be
     // refused before it is built and any leftovers can be counted at the end.
+    if (WHOLE_WRITES.has(call.name)) for (const f of this.writesOf(call)) this.wrote?.set(f.abs, f.size);
     if (call.name === 'create_app' && call.args?.folder) {
       const made = path.resolve(this.cwd, String(call.args.folder));
       if (!(this.apps ??= []).includes(made)) this.apps.push(made);
@@ -1857,6 +1862,21 @@ export class Agent {
     return err.kind === 'bad_args';
   }
 
+  /** The files a whole-file write names, resolved the way the tool will resolve them. */
+  writesOf(call) {
+    const a = call.args ?? {};
+    const list = call.name === 'write_file' ? [{ path: a.path, content: a.content }] : normaliseFiles(a.files);
+    const home = call.name === 'create_app' && a.folder ? path.resolve(this.cwd, String(a.folder)) : null;
+    return list
+      .filter((f) => typeof f?.path === 'string' && typeof f?.content === 'string')
+      .map((f) => {
+        let abs = path.resolve(this.cwd, f.path);
+        const rel = home ? path.relative(home, abs) : '';
+        if (home && (rel.startsWith('..') || path.isAbsolute(rel))) abs = path.resolve(home, f.path.replace(/^[./\\]+/, ''));
+        return { abs, size: f.content.length, path: f.path };
+      });
+  }
+
   async dispatch(call) {
     // The model emitted arguments that were not valid JSON. Hand the parser's
     // own complaint straight back so it can correct itself next step.
@@ -1883,6 +1903,21 @@ export class Agent {
       });
     }
 
+    // A read of "index.html" right after create_app put it in tasker/. The
+    // model named the file that way, so it looks for it that way: DeepSeek got
+    // three not-founds and wrote the whole app again. A missing path that
+    // exists inside the one app made this turn is read from there.
+    if ((call.name === 'read_files' || call.name === 'read_file') && this.apps?.length === 1) {
+      const home = this.apps[0];
+      const inApp = (p) => {
+        if (typeof p !== 'string' || existsSync(path.resolve(this.cwd, p))) return p;
+        const there = path.resolve(home, p.replace(/^[./\\]+/, ''));
+        return existsSync(there) ? path.relative(this.cwd, there) : p;
+      };
+      if (call.name === 'read_file') call.args.path = inApp(call.args.path);
+      else if (Array.isArray(call.args?.paths)) call.args.paths = call.args.paths.map(inApp);
+    }
+
     // Reading the same unchanged file over and over.
     //
     // A traced build of a one-page app spent 53 of its 80 tool calls on
@@ -1924,6 +1959,23 @@ export class Agent {
       const files = args.files;
       const none = files == null || files === ''
         || (Array.isArray(files) ? !files.length : typeof files === 'object' && !Object.keys(files).length);
+      // Its files already written this turn, and create_app called over them
+      // again. DeepSeek does this to "verify" — and twice the second version
+      // was the broken one. The first stands; changes go through edit_file.
+      const written = [...(this.wrote?.keys() ?? [])].some((f) => {
+        const rel = path.relative(made, f);
+        return !rel.startsWith('..') && !path.isAbsolute(rel);
+      });
+      if (written && path.resolve(this.cwd, String(args.folder)) === made) {
+        const show = path.relative(this.cwd, made) || '.';
+        throw new ToolFailure({
+          kind: 'already_made',
+          attempted: `creating ${show} again`,
+          failed: `${show} was already created and written this turn; nothing was changed.`,
+          fix: 'The app is on disk as you wrote it. To check it, read it with read_files. To fix '
+            + 'something in it, use edit_file on that part. Do not call create_app again.',
+        });
+      }
       if (none && path.resolve(this.cwd, String(args.folder)) === made) {
         const show = path.relative(this.cwd, made) || '.';
         throw new ToolFailure({
@@ -1936,6 +1988,24 @@ export class Agent {
       }
     }
 
+    // A file written this turn, about to be replaced by a sliver of itself.
+    // DeepSeek built a 13.6 KB tasker, then "verified" it by writing it again
+    // as 24 bytes, and the app was gone. Checking a file is a read.
+    if (WHOLE_WRITES.has(call.name) && this.wrote?.size) {
+      for (const f of this.writesOf(call)) {
+        const had = this.wrote.get(f.abs);
+        if (had >= 2000 && f.size < had / 4) {
+          throw new ToolFailure({
+            kind: 'would_shrink',
+            attempted: `writing ${f.path}`,
+            failed: `You wrote ${f.path} earlier this turn (${had} characters), and this would replace it with ${f.size}.`,
+            fix: 'Nothing was written. To check a file, read it with read_files; do not write it again. '
+              + 'To change part of it, use edit_file.',
+          });
+        }
+      }
+    }
+
     // Starting a second app instead of fixing the first.
     //
     // A traced build hit a problem in todo/, abandoned it and made todo-fixed/

package/src/core/provider.js

@@ -94,6 +94,10 @@ export const MODELS = {
   'deepseek/deepseek-v4-flash-0731:free': {
     name: 'DeepSeek V4 Flash',
     context: 1_048_576,
+    // Left to itself it thinks for minutes before every step — over two
+    // minutes of nothing on screen before its first word. Low effort answers
+    // in seconds and still plans the build.
+    reasoning: { effort: 'low' },
     note: 'fast DeepSeek coder, 1M context — on trial',
   },
   'qwen/qwen3.8-27b:free': {
@@ -162,6 +166,9 @@ 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;
+
+/** How long a reply may go quiet once it has started writing a tool call. */
+const writingLimit = () => Number(process.env.UCODE_STALL_MS) || 600_000;
 let stalls = 0;
 
 let current = process.env.UCODE_MODEL || DEFAULT_MODEL;
@@ -632,7 +639,8 @@ export async function ask(messages, tools = [], opts = {}) {
   }
   if (opts.temperature !== undefined) request.temperature = opts.temperature;
   if (opts.maxOutputTokens) request.max_tokens = opts.maxOutputTokens;
-  if (opts.reasoning) request.reasoning = opts.reasoning;
+  const reasoning = opts.reasoning ?? MODELS[id]?.reasoning;
+  if (reasoning) request.reasoning = reasoning;
 
   // A side call (the design review) passes fewer: it is better skipped than
   // waited on through a string of rate-limit pauses.
@@ -728,9 +736,22 @@ async function streamed(request, opts, id) {
   opts.signal?.addEventListener('abort', stop, { once: true });
   let stalled = false;
   let timer;
+  const frozen = (cause) => new Failure({
+    kind: 'timeout',
+    attempted: `asking ${modelName(id)} for a reply`,
+    failed: `${modelName(id)} went silent for too long, 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,
+  });
+  // Once a tool call has begun, the silence may be the call being written.
+  // DeepSeek's free upstream holds a create_app back until the whole app is
+  // done — two or three quiet minutes — and a one-minute watchdog killed every
+  // build it started. So a call in progress gets ten minutes instead.
   const alive = () => {
     clearTimeout(timer);
-    timer = setTimeout(() => { stalled = true; quiet.abort(); }, stallLimit());
+    const limit = partial.size ? writingLimit() : stallLimit();
+    timer = setTimeout(() => { stalled = true; quiet.abort(); }, limit);
   };
 
   let text = '';
@@ -806,18 +827,15 @@ async function streamed(request, opts, id) {
     }
   } 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,
-    });
+    throw frozen(err);
   } finally {
     clearTimeout(timer);
     opts.signal?.removeEventListener('abort', stop);
   }
+  // The watchdog's abort can also end the stream quietly instead of throwing.
+  // Carrying on from there ran a half-written create_app: JSON repair closed
+  // it with no files, and five minutes of app were saved as an empty starter.
+  if (stalled && !opts.signal?.aborted) throw frozen();
 
   const toolCalls = [];
   for (const [index, slot] of partial) {

package/src/tools/index.js

@@ -3,6 +3,7 @@
  * line the user reads while each one runs.
  */
 
+import { jsonrepair } from 'jsonrepair';
 import { ToolFailure } from '../core/failure.js';
 import { readFile, readFiles, writeFile, batchWrite, editFile, multiEdit, editFiles } from './files.js';
 import { listDir, glob, grep } from './search.js';
@@ -573,6 +574,12 @@ export const FILE_WRITES = new Set(['write_file', 'batch_write', 'edit_file', 'm
  */
 const LENIENT = new Set(['create_app.files']);
 
+/** Names models use for an argument that the schema calls something else. */
+const ALIASES = {
+  path: ['file', 'filename', 'file_path', 'filepath'],
+  content: ['contents', 'text', 'code', 'body'],
+};
+
 function check(name, args) {
   const schema = tools.find((t) => t.name === name).parameters;
   const problems = [];
@@ -584,6 +591,14 @@ function check(name, args) {
   // One file named as "path" where the tool takes a list called "paths".
   // DeepSeek did it to four read_files at once, a whole round trip spent being
   // told a plural it could simply have been given.
+  // The same argument under a neighbouring name: write_file sent "file"
+  // instead of "path" cost DeepSeek two and a half minutes to be told so.
+  for (const [key, others] of Object.entries(ALIASES)) {
+    if (!schema.properties[key] || args[key] != null) continue;
+    const other = others.find((o) => args[o] != null && !schema.properties[o]);
+    if (other) { args[key] = args[other]; delete args[other]; }
+  }
+
   for (const key of schema.required ?? []) {
     const one = key.endsWith('s') ? key.slice(0, -1) : '';
     if (args[key] == null && one && !schema.properties[one] && args[one] != null
@@ -619,7 +634,15 @@ function check(name, args) {
         const parsed = JSON.parse(value);
         const kind = Array.isArray(parsed) ? 'array' : typeof parsed;
         if (kind === wanted || LENIENT.has(`${name}.${key}`)) { args[key] = parsed; actual = kind; }
-      } catch { /* not JSON either — the message below is the right answer */ }
+      } catch {
+        // Nearly JSON: DeepSeek sent a whole app's files this way and was
+        // told only that a string is not an array. Repair it before refusing.
+        try {
+          const parsed = JSON.parse(jsonrepair(value));
+          const kind = Array.isArray(parsed) ? 'array' : typeof parsed;
+          if (kind === wanted) { args[key] = parsed; actual = kind; }
+        } catch { /* not JSON either — the message below is the right answer */ }
+      }
     }
 
     // A list of files written as a { path: contents } map. The tool reads it

package/src/tools/scaffold.js

@@ -431,6 +431,18 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // The app's own files, written in this same call. Two round trips become
   // one, and round trips are nearly all of the time a build takes.
   // Next.js only: paths that have missed src/ are corrected before they land.
+  // Paths are relative to the project root, but a model will name a file
+  // "index.html" meaning the app's own. DeepSeek did: its tasker went to the
+  // project root and the starter was left in tasker/ as the app. A path that
+  // is not already under the folder is put under it.
+  const home = resolveIn(folder, 'create_app', 'folder').abs;
+  for (const f of given) {
+    const abs = resolveIn(f.path, 'create_app', 'files').abs;
+    const rel = path.relative(home, abs);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+      f.path = path.join(String(folder), String(f.path).replace(/^[./\\]+/, ''));
+    }
+  }
   const placed = template === 'next-shadcn' ? placeForNext(given, path.basename(target.abs)) : { files: given, moved: [] };
   const mine = placed.files;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
@@ -442,11 +454,15 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // back — and only the ones this call did not already write over. A read is
   // another round trip to learn what ucode already knows.
   const starter = [];
+  const leftover = [];
   for (const rel of SHOW_BACK[template] ?? []) {
     const abs = path.join(target.abs, rel);
     if (written.has(abs)) continue;
     const text = await fs.readFile(abs, 'utf8').catch(() => null);
-    if (text !== null) starter.push(`=== ${target.show}/${rel} ===\n${text}`);
+    if (text !== null) {
+      starter.push(`=== ${target.show}/${rel} ===\n${text}`);
+      leftover.push(`${target.show}/${rel}`);
+    }
   }
 
   const out = result(
@@ -489,8 +505,18 @@ export async function createApp({ folder, name, description, template = 'plain-h
       (needsInstall
         ? `Run this app's commands with cwd: "${target.show}" (npm run build, npm run dev).\n\n${guide}`
         : `Nothing to install and nothing to build: open ${target.show}/index.html directly, or serve the ` +
-          `folder with "python -m http.server 8000" if it fetches anything.\n\n${guide}`) +
-      (starter.length
+          `folder with "python -m http.server 8000" if it fetches anything.\n` + (mine.length ? '' : `\n${guide}`)) +
+      // With the app passed in, the starter's placeholder files printed in full
+      // read as the app having been overwritten: DeepSeek took them for that
+      // and wrote the whole app a second time. So they are only named.
+      (mine.length
+        ? '\nYour files are on disk exactly as written above; nothing overwrote them.'
+          + (starter.length
+            ? ` Starter files you did not replace were left as they were: ${leftover.join(', ')}.`
+            : '')
+          + ' Do not write the app again: to check it, read it with read_files, and to change a '
+          + 'part of it, use edit_file. Writing it out again to verify it costs minutes and checks nothing.'
+        : starter.length
         ? `\n\nThe starter's files, in full — they are below, so do not read them back:\n\n${starter.join('\n\n')}`
         : ''),
     `${copied.length} files${wrote ? ` · ${mine.length} written` : ''}` +