@rely-ai/caliber 1.40.3 → 1.41.0

package/dist/bin.js

@@ -4945,6 +4945,37 @@ var CORE_MAX_TOKENS = 16e3;
 var GENERATION_MAX_TOKENS = 64e3;
 var MODEL_MAX_OUTPUT_TOKENS = 128e3;
 var MAX_RETRIES2 = 5;
+var DEFAULT_INACTIVITY_TIMEOUT_MS = 12e4;
+var DEFAULT_TOTAL_TIMEOUT_MS = 6e5;
+function parseEnvTimeout(envVar, defaultMs, minMs = 5e3) {
+  const val = process.env[envVar];
+  if (!val) return defaultMs;
+  const parsed = parseInt(val, 10);
+  if (!Number.isFinite(parsed) || parsed < minMs) return defaultMs;
+  return parsed;
+}
+function buildDiagnostic(stopReason, raw, charsReceived) {
+  if (stopReason === "timeout_inactivity") {
+    const timeoutSec = Math.round(
+      parseEnvTimeout("CALIBER_STREAM_INACTIVITY_TIMEOUT_MS", DEFAULT_INACTIVITY_TIMEOUT_MS) / 1e3
+    );
+    if (charsReceived === 0) {
+      return `Model produced no output for ${timeoutSec}s. Check your API key and model name, or increase timeout with CALIBER_STREAM_INACTIVITY_TIMEOUT_MS.`;
+    }
+    return `Model stopped responding for ${timeoutSec}s after producing ${charsReceived} chars. The model may be stuck. Try a different model or increase timeout with CALIBER_STREAM_INACTIVITY_TIMEOUT_MS.`;
+  }
+  if (stopReason === "timeout_total") {
+    const timeoutSec = Math.round(
+      parseEnvTimeout("CALIBER_GENERATION_TIMEOUT_MS", DEFAULT_TOTAL_TIMEOUT_MS) / 1e3
+    );
+    return `Generation exceeded ${timeoutSec}s total time limit. Try a different model or increase timeout with CALIBER_GENERATION_TIMEOUT_MS.`;
+  }
+  if (!raw || raw.trim().length === 0) {
+    return "Model produced no output. Check your API key and model name.";
+  }
+  return `Model responded but output was not valid JSON. First 200 chars:
+${raw.slice(0, 200)}`;
+}
 function isTransientError2(error) {
   const msg = error.message.toLowerCase();
   return TRANSIENT_ERRORS.some((e) => msg.includes(e.toLowerCase()));
@@ -5126,18 +5157,59 @@ Generate the skill content following the instructions in the system prompt.`;
 async function streamGeneration(config) {
   const provider = getProvider();
   let attempt = 0;
+  const inactivityTimeoutMs = parseEnvTimeout(
+    "CALIBER_STREAM_INACTIVITY_TIMEOUT_MS",
+    DEFAULT_INACTIVITY_TIMEOUT_MS
+  );
+  const totalTimeoutMs = parseEnvTimeout("CALIBER_GENERATION_TIMEOUT_MS", DEFAULT_TOTAL_TIMEOUT_MS);
+  let totalTimedOut = false;
+  let totalResolve = null;
+  const totalTimer = setTimeout(() => {
+    totalTimedOut = true;
+    if (config.callbacks) config.callbacks.onError(buildDiagnostic("timeout_total", "", 0));
+    if (totalResolve) {
+      totalResolve({ setup: null, raw: "", stopReason: "timeout_total" });
+      totalResolve = null;
+    }
+  }, totalTimeoutMs);
   const attemptGeneration = async () => {
+    if (totalTimedOut) {
+      return { setup: null, raw: "", stopReason: "timeout_total" };
+    }
     attempt++;
     const maxTokensForAttempt = Math.min(
       config.baseMaxTokens + attempt * config.tokenIncrement,
       config.maxTokensCap
     );
     return new Promise((resolve3) => {
+      totalResolve = resolve3;
       let preJsonBuffer = "";
       let jsonContent = "";
       let inJson = false;
       let sentStatuses = 0;
       let stopReason = null;
+      let charsReceived = 0;
+      let settled = false;
+      let inactivityTimer = null;
+      function clearInactivityTimer() {
+        if (inactivityTimer) {
+          clearTimeout(inactivityTimer);
+          inactivityTimer = null;
+        }
+      }
+      function resetInactivityTimer() {
+        if (inactivityTimer) clearTimeout(inactivityTimer);
+        inactivityTimer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          clearInactivityTimer();
+          const raw = preJsonBuffer + jsonContent;
+          if (config.callbacks)
+            config.callbacks.onError(buildDiagnostic("timeout_inactivity", raw, charsReceived));
+          resolve3({ setup: null, raw, stopReason: "timeout_inactivity" });
+        }, inactivityTimeoutMs);
+      }
+      resetInactivityTimer();
       provider.stream(
         {
           system: config.systemPrompt,
@@ -5146,6 +5218,9 @@ async function streamGeneration(config) {
         },
         {
           onText: (text) => {
+            if (settled || totalTimedOut) return;
+            charsReceived += text.length;
+            resetInactivityTimer();
             if (!inJson) {
               preJsonBuffer += text;
               const lines = preJsonBuffer.split("\n");
@@ -5173,6 +5248,9 @@ async function streamGeneration(config) {
             }
           },
           onEnd: (meta) => {
+            clearInactivityTimer();
+            if (settled || totalTimedOut) return;
+            settled = true;
             stopReason = meta?.stopReason ?? null;
             let setup = null;
             let jsonToParse = (jsonContent || preJsonBuffer).replace(/```\s*$/g, "").trim();
@@ -5215,23 +5293,37 @@ async function streamGeneration(config) {
             }
           },
           onError: (error) => {
+            clearInactivityTimer();
+            if (settled || totalTimedOut) return;
             if (isTransientError2(error) && attempt < MAX_RETRIES2) {
+              settled = true;
               if (config.callbacks)
                 config.callbacks.onStatus("Connection interrupted, retrying...");
               setTimeout(() => attemptGeneration().then(resolve3), 2e3);
               return;
             }
+            settled = true;
             if (config.callbacks) config.callbacks.onError(error.message);
             resolve3({ setup: null, raw: error.message, stopReason: "error" });
           }
         }
       ).catch((error) => {
+        clearInactivityTimer();
+        if (settled || totalTimedOut) return;
+        settled = true;
         if (config.callbacks) config.callbacks.onError(error.message);
         resolve3({ setup: null, raw: error.message, stopReason: "error" });
       });
     });
   };
-  return attemptGeneration();
+  try {
+    const result = await attemptGeneration();
+    clearTimeout(totalTimer);
+    return totalTimedOut ? { setup: null, raw: result.raw, stopReason: "timeout_total" } : result;
+  } catch (err) {
+    clearTimeout(totalTimer);
+    throw err;
+  }
 }
 async function generateCore(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
   const userMessage = buildGeneratePrompt(
@@ -9501,6 +9593,10 @@ import fs30 from "fs";
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
   const provider = getProvider();
+  const inactivityTimeoutMs = parseEnvTimeout(
+    "CALIBER_STREAM_INACTIVITY_TIMEOUT_MS",
+    DEFAULT_INACTIVITY_TIMEOUT_MS
+  );
   const prompt = `Current setup:
 ${JSON.stringify(currentSetup, null, 2)}
 
@@ -9509,6 +9605,25 @@ User request: ${message}
 Return the complete updated AgentSetup JSON incorporating the user's changes. Respond with ONLY the JSON.`;
   return new Promise((resolve3) => {
     let buffer = "";
+    let settled = false;
+    let inactivityTimer = null;
+    function clearInactivityTimer() {
+      if (inactivityTimer) {
+        clearTimeout(inactivityTimer);
+        inactivityTimer = null;
+      }
+    }
+    function resetInactivityTimer() {
+      clearInactivityTimer();
+      inactivityTimer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const msg = buffer.length === 0 ? "Model produced no output. Try a different model." : "Model stopped responding. Try rephrasing your request or using a different model.";
+        if (callbacks) callbacks.onError(msg);
+        resolve3(null);
+      }, inactivityTimeoutMs);
+    }
+    resetInactivityTimer();
     provider.stream(
       {
         system: REFINE_SYSTEM_PROMPT,
@@ -9518,9 +9633,14 @@ Return the complete updated AgentSetup JSON incorporating the user's changes. Re
       },
       {
         onText: (text) => {
+          if (settled) return;
           buffer += text;
+          resetInactivityTimer();
         },
         onEnd: () => {
+          clearInactivityTimer();
+          if (settled) return;
+          settled = true;
           const cleaned = stripMarkdownFences(buffer);
           const jsonStart = cleaned.indexOf("{");
           const jsonToParse = jsonStart !== -1 ? cleaned.slice(jsonStart) : cleaned;
@@ -9529,16 +9649,23 @@ Return the complete updated AgentSetup JSON incorporating the user's changes. Re
             if (callbacks) callbacks.onComplete(setup);
             resolve3(setup);
           } catch {
-            if (callbacks) callbacks.onError("Failed to parse AI response. Try rephrasing your request.");
+            if (callbacks)
+              callbacks.onError("Failed to parse AI response. Try rephrasing your request.");
             resolve3(null);
           }
         },
         onError: (error) => {
+          clearInactivityTimer();
+          if (settled) return;
+          settled = true;
           if (callbacks) callbacks.onError(error.message);
           resolve3(null);
         }
       }
     ).catch((error) => {
+      clearInactivityTimer();
+      if (settled) return;
+      settled = true;
       if (callbacks) callbacks.onError(error.message);
       resolve3(null);
     });
@@ -10033,6 +10160,18 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
+    if (stopReason?.startsWith("timeout")) {
+      lines.push("", "## Troubleshooting", "");
+      lines.push("This failure was caused by a timeout. You can adjust timeouts with:");
+      lines.push("```bash");
+      lines.push("# Increase inactivity timeout (default: 120s)");
+      lines.push("export CALIBER_STREAM_INACTIVITY_TIMEOUT_MS=180000");
+      lines.push("");
+      lines.push("# Increase total generation timeout (default: 600s)");
+      lines.push("export CALIBER_GENERATION_TIMEOUT_MS=900000");
+      lines.push("```");
+      lines.push("", "If timeouts persist, try a different model.");
+    }
     fs32.mkdirSync(path26.join(process.cwd(), ".caliber"), { recursive: true });
     fs32.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
@@ -10049,7 +10188,9 @@ async function evaluateDismissals(failingChecks, fingerprint) {
     suggestion: c.suggestion
   }));
   const hasBuildFiles = fingerprint.fileTree.some(
-    (f) => /^(package\.json|Makefile|Cargo\.toml|go\.mod|pyproject\.toml|requirements\.txt|build\.gradle|pom\.xml)$/i.test(f.split("/").pop() || "")
+    (f) => /^(package\.json|Makefile|Cargo\.toml|go\.mod|pyproject\.toml|requirements\.txt|build\.gradle|pom\.xml)$/i.test(
+      f.split("/").pop() || ""
+    )
   );
   const topFiles = fingerprint.fileTree.slice(0, 30).join(", ");
   try {
@@ -10284,8 +10425,16 @@ async function initCommand(options) {
   installSessionStartHook();
   console.log(`  ${chalk14.green("\u2713")} Freshness hook \u2014 warns when configs are stale`);
   if (IS_WINDOWS5) {
-    console.log(chalk14.yellow("\n  Note: hooks use shell syntax and require Git Bash (included with Git for Windows)."));
-    console.log(chalk14.dim("  If hooks don't run, ensure Git for Windows is installed and git is using its bundled sh."));
+    console.log(
+      chalk14.yellow(
+        "\n  Note: hooks use shell syntax and require Git Bash (included with Git for Windows)."
+      )
+    );
+    console.log(
+      chalk14.dim(
+        "  If hooks don't run, ensure Git for Windows is installed and git is using its bundled sh."
+      )
+    );
   }
   const { ensureBuiltinSkills: ensureBuiltinSkills2 } = await Promise.resolve().then(() => (init_builtin_skills(), builtin_skills_exports));
   for (const agent of targetAgent) {
@@ -10584,7 +10733,8 @@ async function initCommand(options) {
       rawOutput = result.raw;
       genStopReason = result.stopReason;
       if (!generatedSetup) {
-        display.update(TASK_CONFIG, "failed", "Could not parse LLM response");
+        const diagnostic = buildDiagnostic(genStopReason, rawOutput, rawOutput?.length ?? 0);
+        display.update(TASK_CONFIG, "failed", diagnostic.split("\n")[0].slice(0, 80));
         display.update(TASK_SKILLS_GEN, "failed", "Skipped");
         return;
       }
@@ -12188,9 +12338,10 @@ async function refreshCommand(options) {
             `${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`
           )
         );
+      } finally {
+        process.chdir(originalDir);
       }
     }
-    process.chdir(originalDir);
   } catch (err) {
     if (err instanceof Error && err.message === "__exit__") throw err;
     writeRefreshError(err);
@@ -12503,6 +12654,7 @@ function trimSessionFileIfNeeded(filePath) {
     const stat = fs43.statSync(filePath);
     if (stat.size > MAX_SESSION_FILE_BYTES) {
       fs43.writeFileSync(filePath, "");
+      resetState();
       return;
     }
   } catch {
@@ -12540,6 +12692,7 @@ function readAllEvents() {
     const stat = fs43.statSync(filePath);
     if (stat.size > MAX_SESSION_FILE_BYTES) {
       fs43.writeFileSync(filePath, "");
+      resetState();
       return [];
     }
   } catch {
@@ -12568,7 +12721,10 @@ function getEventCount() {
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs43.existsSync(filePath)) fs43.unlinkSync(filePath);
+  try {
+    fs43.writeFileSync(filePath, "");
+  } catch {
+  }
 }
 function readState2() {
   const filePath = stateFilePath();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.40.3",
+  "version": "1.41.0",
   "description": "AI context infrastructure for coding agents — keeps CLAUDE.md, Cursor rules, and skills in sync as your codebase evolves",
   "type": "module",
   "bin": {