ucode-agent 1.60.0 → 1.60.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.60.0",
+  "version": "1.60.2",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on Google Gemini models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/provider.js

@@ -118,6 +118,18 @@ const RATE_LIMIT_BACKOFF = [5, 10, 20];
  */
 export const stallLimit = () => Number(process.env.UCODE_STALL_MS) || 60_000;
 
+/**
+ * How long to wait for the first piece of a reply.
+ *
+ * Gemini sends a tool call whole, at the end, not piece by piece. A whole app
+ * in one create_app is 50-70 silent seconds before anything arrives, and the
+ * one-minute watchdog was cancelling those replies as frozen and starting them
+ * again — "provider stalled" on requests that were working fine. Silence before
+ * the reply starts gets this long; once it is arriving, stallLimit applies.
+ */
+export const firstReplyLimit = () =>
+  Number(process.env.UCODE_FIRST_REPLY_MS) || Number(process.env.UCODE_STALL_MS) || 180_000;
+
 /** Freezes in a row before ucode stops asking and says to switch models. */
 export const MAX_STALLS = 3;
 let stalls = 0;
@@ -755,17 +767,21 @@ async function streamed(request, opts, id) {
   opts.signal?.addEventListener('abort', stop, { once: true });
   let stalled = false;
   let timer;
+  // Nothing of the reply itself yet: text, reasoning or a tool call. Chunks
+  // that carry none of those (a role, usage) do not count as it having started.
+  let started = false;
+  const limit = () => (started ? stallLimit() : firstReplyLimit());
   const frozen = (cause) => 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.`,
+    failed: `${modelName(id)} went silent for ${Math.round(limit() / 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,
   });
   const alive = () => {
     clearTimeout(timer);
-    timer = setTimeout(() => { stalled = true; quiet.abort(); }, stallLimit());
+    timer = setTimeout(() => { stalled = true; quiet.abort(); }, limit());
   };
 
   let text = '';
@@ -788,14 +804,15 @@ async function streamed(request, opts, id) {
     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];
+      const delta = choice?.delta ?? {};
+      if (delta.content || delta.reasoning || delta.reasoning_content || delta.tool_calls?.length) started = true;
+      alive();
       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.

package/src/tools/files.js

@@ -228,6 +228,27 @@ export function assetImport(abs, text) {
     'instead — <link rel="stylesheet" href="…"> for a stylesheet, an <img> or a plain URL for an image.';
 }
 
+/**
+ * A page styled with Tailwind classes that never loads Tailwind.
+ *
+ * A live build wrote a 27 KB page of "flex px-4 bg-[var(--bg)]" and a
+ * stylesheet of colour tokens only: every class was ignored and the app came
+ * out as bare browser defaults, with nothing failing to tell anyone. When a
+ * page leans on those classes and has no Tailwind of its own, the browser
+ * build is added to its head, so the page looks the way it was written.
+ */
+const TAILWIND_CLASS = /^(?:-?(?:m|p)[trblxy]?-\S+|flex|grid|hidden|block|inline-flex|items-\S+|justify-\S+|gap-\S+|space-[xy]-\S+|(?:min-|max-)?[wh]-\S+|text-\S+|bg-\S+|rounded(?:-\S+)?|border(?:-\S+)?|shadow(?:-\S+)?|font-\S+|leading-\S+|tracking-\S+|(?:sm|md|lg|xl|hover|focus|dark):\S+)$/;
+export function withTailwind(html) {
+  if (/tailwindcss|cdn\.tailwind/i.test(html) || !/<\/head>/i.test(html)) return html;
+  let count = 0;
+  for (const [, list] of html.matchAll(/class="([^"]*)"/g)) {
+    for (const token of list.split(/\s+/)) if (TAILWIND_CLASS.test(token)) count++;
+    if (count >= 12) break;
+  }
+  if (count < 12) return html;
+  return html.replace(/<\/head>/i, '  <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>\n</head>');
+}
+
 /** The note for that, appended to a write's result like a parse problem is. */
 const pageNote = (target, text) => {
   const problem = assetImport(target.abs, text);
@@ -355,6 +376,7 @@ export async function readFiles({ paths, limit = READ_LINES }) {
 /** Write one file, returning the rows that show what changed. */
 async function put(target, content, { diffMax = 16 } = {}) {
   const attempted = `writing ${target.show}`;
+  if (/\.html?$/i.test(target.abs)) content = withTailwind(content);
 
   // Read what is there before clobbering it, so an overwrite can be shown as
   // an actual diff rather than as a claim that something changed.