codeply-cli 0.5.5 → 0.6.0

package/lib/ai.js

@@ -45,10 +45,13 @@ const RETRY_BACKOFF_MS = [1500, 4000, 9000];
 const RETRY_AFTER_CAP_MS = 30000;
 
 // Stop must not wait out a backoff: the sleep ends the moment the signal fires.
+// The abort listener is removed when the sleep ends normally, so a long run
+// of retries does not pile listeners onto the run's one signal.
 const sleep = (ms, signal) => new Promise((r) => {
   if (signal?.aborted) return r();
-  const t = setTimeout(r, ms);
-  signal?.addEventListener('abort', () => { clearTimeout(t); r(); }, { once: true });
+  const onAbort = () => { clearTimeout(t); r(); };
+  const t = setTimeout(() => { signal?.removeEventListener('abort', onAbort); r(); }, ms);
+  signal?.addEventListener('abort', onAbort, { once: true });
 });
 
 /**
@@ -234,13 +237,18 @@ function isAbortError(e) {
 // This gives every attempt a hard ceiling so a stalled request surfaces as a
 // real, retryable error instead of an indefinite silent wait.
 const REQUEST_TIMEOUT_MS = 120_000;
+const ANTHROPIC_TIMEOUT_MS = 300_000;
 
 /** Combines the caller's own abort signal (Stop button) with a hard timeout into one signal to hand fetch(). */
 function withTimeout(signal, ms = REQUEST_TIMEOUT_MS) {
   const controller = new AbortController();
+  // One listener per request on the run's long-lived signal; cleanup() takes
+  // it off again, or a run with many model calls trips Node's
+  // MaxListenersExceededWarning (11 abort listeners) and leaks them.
+  const onAbort = () => controller.abort();
   if (signal) {
     if (signal.aborted) controller.abort();
-    else signal.addEventListener('abort', () => controller.abort(), { once: true });
+    else signal.addEventListener('abort', onAbort, { once: true });
   }
   const timer = setTimeout(() => controller.abort(new Error('timeout')), ms);
   return {
@@ -249,7 +257,7 @@ function withTimeout(signal, ms = REQUEST_TIMEOUT_MS) {
     // user's own Stop - callers use this to report "the request stalled"
     // instead of silently treating a stall as if the user had cancelled it.
     isTimeout: () => controller.signal.reason instanceof Error && controller.signal.reason.message === 'timeout',
-    cleanup: () => clearTimeout(timer),
+    cleanup: () => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); },
   };
 }
 
@@ -262,22 +270,25 @@ function withTimeout(signal, ms = REQUEST_TIMEOUT_MS) {
  */
 function withIdleTimeout(signal, ms = REQUEST_TIMEOUT_MS) {
   const controller = new AbortController();
+  const onAbort = () => controller.abort();
   if (signal) {
     if (signal.aborted) controller.abort();
-    else signal.addEventListener('abort', () => controller.abort(), { once: true });
+    else signal.addEventListener('abort', onAbort, { once: true });
   }
+  let done = false;
   let timer = setTimeout(() => controller.abort(new Error('timeout')), ms);
   return {
     signal: controller.signal,
-    poke: () => { clearTimeout(timer); timer = setTimeout(() => controller.abort(new Error('timeout')), ms); },
+    // A no-op once cleaned up, so a late chunk cannot restart a timer nobody clears.
+    poke: () => { if (done) return; clearTimeout(timer); timer = setTimeout(() => controller.abort(new Error('timeout')), ms); },
     isTimeout: () => controller.signal.reason instanceof Error && controller.signal.reason.message === 'timeout',
-    cleanup: () => clearTimeout(timer),
+    cleanup: () => { done = true; clearTimeout(timer); signal?.removeEventListener('abort', onAbort); },
   };
 }
 
 async function chatViaProxy(messages, opts) {
   const token = await getAccessToken();
-  if (!token) return { success: false, error: 'Not signed in. Sign in to use Auto, or pick one of your own models.' };
+  if (!token) return { success: false, error: 'Not signed in. Sign in to use Haze 2, or pick one of your own models.' };
 
   return withRetries(async () => {
     let res, body;
@@ -299,6 +310,7 @@ async function chatViaProxy(messages, opts) {
         signal,
       });
       body = await res.json().catch(() => ({}));
+      if (isTimeout()) return { retryable: true, error: 'The AI proxy stopped sending its answer partway - retrying.' };
     } catch (e) {
       if (isTimeout()) return { retryable: true, error: 'The request timed out with no response from the AI proxy - retrying.' };
       if (isAbortError(e)) return { aborted: true };
@@ -478,8 +490,11 @@ async function streamingChatRequest({ url, label, model, apiKey, isLocal, messag
     const isStream = (res.headers.get('content-type') || '').includes('text/event-stream');
 
     if (!isStream) {
-      cleanup(); // no more bytes expected - the idle clock has nothing left to guard
+      // The clock keeps guarding the body read: clearing it before res.json()
+      // left a server that sent headers and then went quiet hanging forever.
       const body = await res.json().catch(() => ({}));
+      cleanup();
+      if (isTimeout()) return { retryable: true, error: `${label} stopped sending data mid-response - retrying.` };
       if (res.ok && body.choices?.[0]) {
         return { done: true, value: { success: true, data: body, modelUsed: body.model || model } };
       }
@@ -516,7 +531,6 @@ async function streamingChatRequest({ url, label, model, apiKey, isLocal, messag
     const toolCalls = [];
     try {
       for await (const chunk of res.body) {
-        poke(); // a real chunk arrived - the stream is alive, push the stall clock back out
         buffer += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : Buffer.from(chunk).toString('utf8');
         let nlIndex;
         while ((nlIndex = buffer.indexOf('\n')) !== -1) {
@@ -524,7 +538,12 @@ async function streamingChatRequest({ url, label, model, apiKey, isLocal, messag
           buffer = buffer.slice(nlIndex + 1);
           if (!line.startsWith('data:')) continue;
           const payload = line.slice(5).trim();
-          if (!payload || payload === '[DONE]') continue;
+          if (!payload) continue;
+          // Only real data pushes the stall clock back out. Keep-alive comments
+          // (": OPENROUTER PROCESSING") used to count, so an upstream that
+          // never answered but kept pinging held the run open forever.
+          poke();
+          if (payload === '[DONE]') continue;
           let evt;
           try { evt = JSON.parse(payload); } catch { continue; }
           modelUsed = evt.model || modelUsed;
@@ -663,6 +682,7 @@ async function chatViaOpenAICompatible(messages, opts, providerName, cfg) {
         signal,
       });
       body = await res.json().catch(() => ({}));
+      if (isTimeout()) return { retryable: true, error: `${label} stopped sending its answer partway - retrying.` };
     } catch (e) {
       if (isTimeout()) return { retryable: true, error: `${label} timed out with no response - retrying.` };
       if (isAbortError(e)) return { aborted: true };
@@ -793,7 +813,11 @@ async function chatViaAnthropic(messages, opts, cfg) {
   }
 
   return withRetries(async () => {
-    let res;
+    let res, body;
+    // This call is not streamed, so nothing arrives until the whole answer is
+    // ready: a longer ceiling than the others, but a ceiling. Without one a
+    // stalled connection here waited forever with no events at all.
+    const { signal, isTimeout, cleanup } = withTimeout(opts.signal, ANTHROPIC_TIMEOUT_MS);
     try {
       res = await fetch('https://api.anthropic.com/v1/messages', {
         method: 'POST',
@@ -810,15 +834,18 @@ async function chatViaAnthropic(messages, opts, cfg) {
           ...temperatureParam(model, opts),
           ...(opts.tools ? { tools: toAnthropicTools(opts.tools) } : {}),
         }),
-        signal: opts.signal,
+        signal,
       });
+      body = await res.json().catch(() => ({}));
+      if (isTimeout()) return { retryable: true, error: 'Anthropic stopped sending its answer partway - retrying.' };
     } catch (e) {
+      if (isTimeout()) return { retryable: true, error: 'Anthropic timed out with no response - retrying.' };
       if (isAbortError(e)) return { aborted: true };
       return { retryable: true, error: e.message };
+    } finally {
+      cleanup();
     }
 
-    const body = await res.json().catch(() => ({}));
-
     if (res.ok && Array.isArray(body.content)) {
       const text = body.content.filter((b) => b.type === 'text').map((b) => b.text).join('');
       const message = { role: 'assistant', content: text };
@@ -960,9 +987,10 @@ async function chatViaOllamaNative(messages, opts, m) {
     }
 
     if (!res.ok) {
-      cleanup();
-      if (m.research === 'cloud' && (res.status === 401 || res.status === 403)) return { done: true, value: { success: false, error: researchMode().ERR_CLOUD_KEY } };
+      if (m.research === 'cloud' && (res.status === 401 || res.status === 403)) { cleanup(); return { done: true, value: { success: false, error: researchMode().ERR_CLOUD_KEY } }; }
       const body = await res.json().catch(() => ({}));
+      cleanup();
+      if (isTimeout()) return { retryable: true, error: 'Ollama stopped sending data mid-response - retrying.' };
       const msg = body.error || describeStatus(res.status);
       const fatal = res.status === 404 || /not found|pull/i.test(String(msg));
       if (fatal) return { done: true, value: { success: false, error: `Ollama: ${msg}${/not found/i.test(String(msg)) ? ` - run \`ollama pull ${m.model}\` first.` : ''}` } };
@@ -1223,12 +1251,11 @@ async function testModel(m) {
   return { ok: true, ms: Date.now() - started, reply: (r.data.choices?.[0]?.message?.content || '').trim().slice(0, 80) };
 }
 
-// ─── Auto ───────────────────────────────────────────────────────────────────
-// "Auto" is Codeply's router (Codeply-App/supabase/functions/auto): Claude
-// Sonnet 5.5 for coding and hard work, Claude Haiku 5.5 for chat, images and
-// background jobs, gpt-oss-120b and Gemma 4 when a daily allowance is used up.
-// It decides per turn on the server, where the Claude key and the budgets
-// live. If the router can't be reached at all, Auto falls back to Gemma 4 31B
+// ─── Haze 2 (route.auto) ──────────────────────────────────────────────
+// Haze 2 is Codeply's hosted model: a router that picks the model for each
+// turn on the server, where the keys and the budgets live. The front door is
+// the Supabase function Codeply-App/supabase/functions/auto. If the router
+// can't be reached at all, the client falls back to Gemma 4 31B
 // on Ollama Cloud directly (two account keys: a release build bakes
 // OLLAMA_API_KEY / OLLAMA_API_KEY_FALLBACK in via scripts/embed-secrets.js;
 // from source they come from ~/.codeply/config.json), then the hosted proxy.
@@ -1269,6 +1296,62 @@ function deviceId() {
   return deviceIdCache;
 }
 
+// Haze 2 routes once per user turn. Every agent step says which turn it
+// belongs to (opts.haze, from agent.mjs); the router decides on the first step
+// and keeps the same model, effort and cache for the rest of the turn. The
+// router's state comes back with each answer and goes out again with the next
+// turn of the same chat. Memory only: a restart just starts a fresh state.
+const hazeStates = new Map(); // chatId -> state
+function hazeField(h) {
+  if (!h) return {};
+  return {
+    haze: {
+      product: h.product || 'craft',
+      surface: h.surface || 'agent', // 'voice': Haze's fast path for live voice (Haiku, no thinking)
+      turnId: h.turnId,
+      continuation: (h.step || 0) > 0,
+      historyCount: h.historyCount || 0,
+      ...(h.screen ? { screen: true } : {}), // this turn carries the user's screen
+      state: hazeStates.get(h.chatId) || undefined,
+    },
+  };
+}
+function keepHazeState(h, route) {
+  if (!h || !route || !route.haze || !route.haze.state) return;
+  hazeStates.delete(h.chatId);
+  hazeStates.set(h.chatId, route.haze.state);
+  if (hazeStates.size > 300) hazeStates.delete(hazeStates.keys().next().value);
+}
+
+const localClock = (iso) => { try { return new Date(iso).toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' }); } catch { return ''; } };
+
+// What Haze 2 says about its own limits, once per chat each: answers moved to
+// lighter models (the day's Claude allowance is used up, or Claude is down),
+// and a heads-up when the lighter models' 5-hour amount is nearly used.
+const hazeNoticed = new Map(); // chatId|what -> when it was said
+function hazeNotice(route, chatId = '') {
+  if (!route) return [];
+  const once = (key, text) => {
+    const k = `${chatId}|${key}`;
+    if (hazeNoticed.has(k)) return '';
+    hazeNoticed.set(k, Date.now());
+    if (hazeNoticed.size > 500) hazeNoticed.delete(hazeNoticed.keys().next().value);
+    return text;
+  };
+  const out = [];
+  const l = route.lighter;
+  if (l && (l.why === 'allowance' || l.why === 'pool')) {
+    out.push(once(`lighter|${l.resetsAt}`, `Using lighter models now: ${l.why === 'pool' ? 'Haze 2 is busy today' : 'today\'s Claude allowance is used up'}. Claude is back at ${localClock(l.resetsAt)}.`));
+  } else if (l && l.why === 'claude-down') {
+    out.push(once(`down|${new Date().toISOString().slice(0, 13)}`, 'Claude isn\'t answering right now, so Haze 2 used lighter models.'));
+  }
+  const f = route.free;
+  if (f && f.limit && f.used >= f.limit * 0.8 && f.resetsAt) {
+    out.push(once(`free80|${f.resetsAt}`, `You've used most of Haze 2's lighter models for now. They reset at ${localClock(f.resetsAt)}.`));
+  }
+  return out.filter(Boolean);
+}
+
 async function chatViaRouter(messages, opts) {
   const token = await getAccessToken();
   // A cloud run has no sign-in: its usage key (CODEPLY_TRACK_KEY) stands in for the person
@@ -1286,17 +1369,27 @@ async function chatViaRouter(messages, opts) {
           messages: wireMessages(messages),
           ...(opts.tools ? { tools: opts.tools } : {}),
           opts: { json: !!opts.json, maxTokens: opts.maxTokens, temperature: opts.temperature },
+          ...hazeField(opts.haze),
         }),
         signal,
       });
       body = JSON.parse((await res.text()).trim() || '{}');
     } catch (e) {
       if (isAbortError(e) && !isTimeout()) return { aborted: true };
-      return { retryable: true, error: isTimeout() ? 'Auto took too long to answer.' : e.message };
+      return { retryable: true, error: isTimeout() ? 'Haze 2 took too long to answer.' : e.message };
     } finally {
       cleanup();
     }
-    if (body.success) return { done: true, value: { success: true, data: body.data, modelUsed: body.modelUsed, route: body.route } };
+    if (body.success) {
+      keepHazeState(opts.haze, body.route);
+      return { done: true, value: { success: true, data: body.data, modelUsed: body.modelUsed, route: body.route } };
+    }
+    // Past the lighter models' 5-hour amount: say when it comes back, in the person's own time.
+    if (body.limited) {
+      const at = body.resetsAt ? localClock(body.resetsAt) : '';
+      const error = at ? String(body.error || '').replace(/It resets in [^,.]+/, `It resets at ${at}`) : body.error;
+      return { done: true, value: { success: false, limited: true, resetsAt: body.resetsAt || null, error: error || 'You\'ve reached Haze 2\'s limit for now.' } };
+    }
     if (body.error) return { done: true, value: { success: false, error: body.error } };
     return { retryable: isTransientStatus(res.status), retryAfterMs: retryAfterMs(res), error: describeStatus(res.status) };
   }, opts.signal);
@@ -1304,7 +1397,8 @@ async function chatViaRouter(messages, opts) {
 
 async function chatViaAuto(messages, opts) {
   const routed = await chatViaRouter(messages, opts);
-  if (routed.success || routed.aborted) return routed;
+  // A limit is an answer, not an outage: no going around it on the direct route.
+  if (routed.success || routed.aborted || routed.limited) return routed;
   // The router itself is unreachable or broken: the old direct route still works.
   const cfg = getConfig();
   const keys = { apiKey: cfg.ollama.apiKey, apiKeyFallback: cfg.ollama.apiKeyFallback };
@@ -1444,4 +1538,18 @@ async function chatJson(messages, opts = {}) {
   return { success: true, json: parsed, usage: r.data.usage || {}, modelUsed: r.modelUsed };
 }
 
-module.exports = { chatResearch, chat, chatJson, isRateLimitError, listOllamaModels, testModel, chatCompletionsUrl };
+/**
+ * Gemma 4 31B on Ollama Cloud, which can see images: what voice mode uses when
+ * Haze 2 is on its free tier (the day's Claude allowance is used up), since
+ * Haze's free model and the hosted proxy are text only.
+ */
+async function chatVision(messages, opts = {}) {
+  const cfg = getConfig();
+  const keys = { apiKey: cfg.ollama.apiKey, apiKeyFallback: cfg.ollama.apiKeyFallback };
+  if (!keys.apiKey && !keys.apiKeyFallback) return { success: false, error: 'This build has no Gemma key for screenshots.' };
+  const r = await chatViaOllama(messages, opts, { ollama: { ...AUTO_MODEL, ...keys, numCtx: null } });
+  if (r && r.success && !r.modelUsed) r.modelUsed = AUTO_MODEL.model;
+  return r;
+}
+
+module.exports = { chatResearch, chat, chatJson, chatVision, isRateLimitError, listOllamaModels, testModel, chatCompletionsUrl, hazeNotice };

package/lib/ai.mjs

@@ -1,6 +1,6 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-
-const ai = require('../lib/ai.js');
-export default ai;
-export const { chat, chatJson, isRateLimitError } = ai;
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const ai = require('../lib/ai.js');
+export default ai;
+export const { chat, chatJson, isRateLimitError } = ai;