autopilot-ai 1.2.0 → 1.2.2

package/dist/sdk/index.d.ts

@@ -173,6 +173,9 @@ interface KimiConfig {
     compiledContext?: boolean;
     /** Number of recent user turns to retain image content; older images are dropped. */
     imageHistoryTurns?: number;
+    /** Hard safety ceiling on tool iterations per turn, across automatic
+     *  200-call counter resets. Defaults to 1000. */
+    maxTotalToolIterations?: number;
     /** Enable local structured memory (SQLite + embeddings). */
     memoryEnabled?: boolean;
     /** Path to memory database. Defaults to .kimiflare/memory.db in repo root, or ~/.local/share/kimiflare/memory.db. */

package/dist/sdk/index.js

@@ -1169,7 +1169,7 @@ var init_types = __esm({
 // src/hooks/settings.ts
 import { existsSync, readFileSync as readFileSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join17, dirname as dirname7 } from "path";
+import { join as join17, dirname as dirname8 } from "path";
 import { createHash } from "crypto";
 function globalSettingsPath() {
   const xdg = process.env.XDG_CONFIG_HOME || join17(homedir10(), ".config");
@@ -2385,7 +2385,7 @@ var RETENTION = {
   memoryMaxEntries: 1e3
 };
 async function rotateJsonl(path, maxBytes, rotations) {
-  const { rename } = await import("fs/promises");
+  const { rename: rename3 } = await import("fs/promises");
   let s;
   try {
     s = await stat(path);
@@ -2397,7 +2397,7 @@ async function rotateJsonl(path, maxBytes, rotations) {
     const src = i === 1 ? path : `${path}.${i - 1}`;
     const dst = `${path}.${i}`;
     try {
-      await rename(src, dst);
+      await rename3(src, dst);
     } catch {
     }
   }
@@ -3452,6 +3452,7 @@ function buildSystemPrompt(opts) {
 }
 
 // src/agent/loop.ts
+var MAX_LOOP_RECOVERIES = 1;
 var BudgetExhaustedError = class extends Error {
   constructor(message = "Cumulative input token budget exhausted") {
     super(message);
@@ -3459,7 +3460,7 @@ var BudgetExhaustedError = class extends Error {
   }
 };
 var AgentLoopError = class extends Error {
-  constructor(message = "Agent got stuck repeating the same tool calls") {
+  constructor(message = "Agent got stuck repeating the same tool calls and was stopped after a recovery attempt") {
     super(message);
     this.name = "AgentLoopError";
   }
@@ -3516,6 +3517,12 @@ async function runAgentTurn(opts) {
   const turnStart = performance.now();
   logger.info("turn:start", { sessionId: opts.sessionId, codeMode: opts.codeMode ?? false });
   const max = opts.maxToolIterations ?? 200;
+  const limitBehavior = opts.toolLimitBehavior ?? (opts.continueOnLimit ? "continue" : "throw");
+  const requestedCeiling = opts.maxTotalToolIterations;
+  const hardCeiling = Math.max(
+    max,
+    requestedCeiling !== void 0 && Number.isFinite(requestedCeiling) && requestedCeiling > 0 ? Math.floor(requestedCeiling) : max * 5
+  );
   const codeMode = opts.codeMode ?? false;
   const fireStopHook = async () => {
     if (opts.signal.aborted) return;
@@ -3665,8 +3672,11 @@ IMPORTANT \u2014 explore through code, not direct tools: to read files, run shel
   const WEB_FETCH_DOMAIN_THRESHOLD = 2;
   let cumulativePromptTokens = 0;
   let iter = 0;
+  let totalIter = 0;
   let budgetExhausted = false;
   let loopExhausted = false;
+  let loopRecoveries = 0;
+  let finalizeReason = null;
   let currentTasks = [];
   let mutatingToolsSinceLastTasksSet = 0;
   const MUTATING_TOOLS2 = /* @__PURE__ */ new Set(["write", "edit", "bash"]);
@@ -3684,36 +3694,43 @@ IMPORTANT \u2014 explore through code, not direct tools: to read files, run shel
         content: "You have reached the cumulative input token budget for this session. Please synthesize your findings and provide a final summary of what was accomplished."
       });
     }
-    if (loopExhausted) {
+    if (finalizeReason === null && totalIter >= hardCeiling) {
+      finalizeReason = "limit_ceiling";
       opts.messages.push({
         role: "system",
-        content: "You have repeatedly called the same tools with identical arguments and are stuck in a loop. Please synthesize what you know from the conversation history and provide a final answer."
+        content: `You have reached the hard safety ceiling of ${hardCeiling} tool iterations for this turn. Do not call any more tools. Summarize what you accomplished, what remains unfinished, and the concrete next steps needed to complete the task.`
       });
-    }
-    if (iter >= max) {
-      if (opts.callbacks.onToolLimitReached) {
-        const decision = await opts.callbacks.onToolLimitReached();
-        if (decision === "continue") {
-          opts.messages.push({
-            role: "system",
-            content: "You have reached the tool-call limit for this session. The counter has been reset so you can continue working. Please proceed with your task."
-          });
-          iter = 0;
-        } else {
-          await fireStopHook();
-          return;
-        }
-      } else if (opts.continueOnLimit) {
+      opts.callbacks.onGuardrail?.({
+        kind: "limit_ceiling",
+        message: `Tool-iteration ceiling (${hardCeiling}) reached \u2014 wrapping up the turn with a summary.`,
+        totalIterations: totalIter
+      });
+    } else if (finalizeReason === null && iter >= max) {
+      if (limitBehavior === "continue") {
         opts.messages.push({
           role: "system",
           content: "You have reached the tool-call limit for this session. The counter has been reset so you can continue working. Please proceed with your task."
         });
         iter = 0;
+        opts.callbacks.onGuardrail?.({
+          kind: "limit_reset",
+          message: `Tool-call limit (${max}) reached \u2014 counter reset automatically (${totalIter}/${hardCeiling} total).`,
+          totalIterations: totalIter
+        });
+      } else if (limitBehavior === "stop") {
+        opts.callbacks.onGuardrail?.({
+          kind: "limit_stopped",
+          message: `Tool-call limit (${max}) reached \u2014 turn stopped.`,
+          totalIterations: totalIter
+        });
+        await fireStopHook();
+        return;
       } else {
         throw new Error(`kimiflare: tool iteration limit reached (${max})`);
       }
     }
     iter++;
+    totalIter++;
     turn++;
     const previousMessages = opts.messages.slice();
     const toolCalls = [];
@@ -3852,8 +3869,21 @@ IMPORTANT \u2014 explore through code, not direct tools: to read files, run shel
         }))
       } : {}
     };
+    if (finalizeReason !== null) {
+      delete assistantMsg.tool_calls;
+      if (!assistantMsg.content) {
+        assistantMsg.content = finalizeReason === "loop" ? "Stopped: I kept repeating blocked tool calls and could not make further progress on this task." : `Stopped: reached the ${hardCeiling}-iteration safety ceiling for this turn before finishing.`;
+      }
+    }
     opts.messages.push(assistantMsg);
     opts.callbacks.onAssistantFinal?.(assistantMsg);
+    if (finalizeReason !== null) {
+      logger.info("turn:finalized", { sessionId: opts.sessionId, reason: finalizeReason, totalIter });
+      if (budgetExhausted) throw new BudgetExhaustedError();
+      await fireStopHook();
+      if (finalizeReason === "loop") throw new AgentLoopError();
+      return;
+    }
     if (toolCalls.length === 0) {
       if (opts.sessionId && lastUsage) {
         void logTurnDebug({
@@ -4485,30 +4515,30 @@ ${sandboxResult.output}` : sandboxResult.output;
       throw new BudgetExhaustedError();
     }
     if (loopExhausted) {
-      if (opts.callbacks.onLoopDetected) {
-        const decision = await opts.callbacks.onLoopDetected();
-        if (decision === "continue") {
-          opts.messages.push({
-            role: "system",
-            content: "You were stuck calling the same tools with identical arguments. The guardrail has been reset so you can continue. Try a different approach."
-          });
-          loopExhausted = false;
-          recentToolCalls.length = 0;
-          continue;
-        }
-        if (decision === "synthesize") {
-          opts.messages.push({
-            role: "system",
-            content: "You were stuck calling the same tools with identical arguments. Please synthesize and conclude your findings so far. Do not call any more tools."
-          });
-          loopExhausted = false;
-          recentToolCalls.length = 0;
-          continue;
-        }
-        await fireStopHook();
-        return;
+      loopExhausted = false;
+      recentToolCalls.length = 0;
+      if (loopRecoveries < MAX_LOOP_RECOVERIES) {
+        loopRecoveries++;
+        opts.messages.push({
+          role: "system",
+          content: "Every tool call in your last step was blocked because you kept repeating the same calls with identical arguments. Do not repeat them. Either take a genuinely different approach (different tools, arguments, or files), or, if you already have enough information, stop calling tools and give your final answer."
+        });
+        opts.callbacks.onGuardrail?.({
+          kind: "loop_recovery",
+          message: "Loop guardrail: repeated tool calls were blocked \u2014 asked the agent to change approach."
+        });
+        continue;
       }
-      throw new AgentLoopError();
+      finalizeReason = "loop";
+      opts.messages.push({
+        role: "system",
+        content: "You are still repeating blocked tool calls after being asked to change approach, so this turn is ending. Do not call any more tools. Summarize what you accomplished, what is blocking you, and what the user could do next."
+      });
+      opts.callbacks.onGuardrail?.({
+        kind: "loop_stopped",
+        message: "Loop guardrail: the agent kept repeating blocked tool calls \u2014 ending the turn with a summary."
+      });
+      continue;
     }
   }
 }
@@ -6722,6 +6752,7 @@ async function loadConfig() {
     cacheStablePrompts: persisted.cacheStablePrompts ?? cacheStablePrompts,
     compiledContext: persisted.compiledContext ?? compiledContext,
     imageHistoryTurns: imageHistoryTurns === void 0 || Number.isNaN(imageHistoryTurns) ? persisted.imageHistoryTurns : imageHistoryTurns,
+    maxTotalToolIterations: readNumberEnv("KIMIFLARE_MAX_TOTAL_TOOL_ITERATIONS") ?? persisted.maxTotalToolIterations,
     memoryEnabled: readBooleanEnv("KIMIFLARE_MEMORY_ENABLED") ?? persisted.memoryEnabled ?? false,
     memoryDbPath: process.env.KIMIFLARE_MEMORY_DB_PATH ?? persisted.memoryDbPath,
     memoryMaxAgeDays: readNumberEnv("KIMIFLARE_MEMORY_MAX_AGE_DAYS") ?? persisted.memoryMaxAgeDays,
@@ -9505,11 +9536,11 @@ async function loadSession(filePath) {
 }
 
 // src/usage-tracker.ts
-import { readFile as readFile8, writeFile as writeFile7, mkdir as mkdir6 } from "fs/promises";
+import { readFile as readFile8, rename as rename2 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { join as join15 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/pricing.ts
 var PRICE_IN_PER_M = 0.95;
@@ -9530,6 +9561,59 @@ function calculateCost(promptTokens, completionTokens, cachedTokens = 0, model)
   return { uncachedIn, cachedIn, out, total };
 }
 
+// src/util/atomic-file.ts
+import { mkdir as mkdir6, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+import { randomUUID } from "crypto";
+async function writeFileAtomic(path, data) {
+  await mkdir6(dirname6(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+  try {
+    await writeFile7(tmp, data, "utf8");
+    await rename(tmp, path);
+  } catch (err) {
+    await rm(tmp, { force: true }).catch(() => void 0);
+    throw err;
+  }
+}
+var LOCK_STALE_MS = 15e3;
+var LOCK_WAIT_MS = 5e3;
+var LOCK_RETRY_MS = 25;
+async function withFileLock(lockPath, fn) {
+  await mkdir6(dirname6(lockPath), { recursive: true });
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  let held = false;
+  while (!held) {
+    try {
+      await mkdir6(lockPath);
+      held = true;
+    } catch (err) {
+      if (err.code !== "EEXIST") break;
+      const age = await stat4(lockPath).then((s) => Date.now() - s.mtimeMs, () => 0);
+      if (age > LOCK_STALE_MS) {
+        await rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+        continue;
+      }
+      if (Date.now() > deadline) break;
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    if (held) await rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+function recoverJsonPrefix(raw) {
+  for (let i = raw.lastIndexOf("}"); i > 0; i = raw.lastIndexOf("}", i - 1)) {
+    try {
+      return JSON.parse(raw.slice(0, i + 1));
+    } catch {
+    }
+  }
+  return void 0;
+}
+
 // src/usage-tracker.ts
 var LOG_VERSION2 = 1;
 var usageEvents = new EventEmitter2();
@@ -9553,21 +9637,29 @@ function cutoffDate(daysBack) {
   return d.toISOString().slice(0, 10);
 }
 async function loadLog() {
+  let raw;
   try {
-    const raw = await readFile8(usagePath(), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version === LOG_VERSION2) return parsed;
+    raw = await readFile8(usagePath(), "utf8");
+  } catch {
+    return { version: LOG_VERSION2, days: [], sessions: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
   } catch {
+    await rename2(usagePath(), `${usagePath()}.corrupt-${Date.now()}`).catch(() => void 0);
+    parsed = recoverJsonPrefix(raw);
   }
+  if (parsed && parsed.version === LOG_VERSION2) return parsed;
   return { version: LOG_VERSION2, days: [], sessions: [] };
 }
 async function saveLog(log2) {
-  await mkdir6(usageDir(), { recursive: true });
-  await writeFile7(usagePath(), JSON.stringify(log2, null, 2), "utf8");
+  await writeFileAtomic(usagePath(), JSON.stringify(log2, null, 2));
 }
 var writeChain = Promise.resolve();
 function withLock(fn) {
-  const next = writeChain.then(fn, fn);
+  const locked = () => withFileLock(`${usagePath()}.lock`, fn);
+  const next = writeChain.then(locked, locked);
   writeChain = next.catch(() => void 0);
   return next;
 }
@@ -9597,8 +9689,7 @@ async function upsertHistoryDay(day) {
     entries.push(day);
   }
   const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await mkdir6(usageDir(), { recursive: true });
-  await writeFile7(historyPath(), lines, "utf8");
+  await writeFileAtomic(historyPath(), lines);
 }
 function getOrCreateDay(log2, date) {
   let day = log2.days.find((d) => d.date === date);
@@ -9657,7 +9748,7 @@ async function recordUsage(sessionId, usage, lookup, model) {
   );
   const estimatedCost = cost.total;
   const cachedTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
-  const turnId = randomUUID();
+  const turnId = randomUUID2();
   const generationId = lookup?.meta.generationId;
   const inlineCost = typeof usage.cost === "number" && Number.isFinite(usage.cost) ? usage.cost : void 0;
   await withLock(async () => {
@@ -9760,7 +9851,7 @@ async function reconcileTurnCost(sessionId, turnId, lookup, fetchImpl2 = fetch,
 // src/models/openrouter-catalog.ts
 import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { join as join16, dirname as dirname6 } from "path";
+import { join as join16, dirname as dirname7 } from "path";
 var CACHE_VERSION = 4;
 var DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
 function catalogCachePath() {
@@ -9826,7 +9917,7 @@ async function readCache() {
 async function writeCache(models) {
   const path = catalogCachePath();
   try {
-    await mkdir7(dirname6(path), { recursive: true });
+    await mkdir7(dirname7(path), { recursive: true });
     const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
     await writeFile8(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
@@ -10261,6 +10352,10 @@ var InternalSession = class {
       onWarning: (msg) => {
         this.emit({ type: "warning", message: msg });
       },
+      onGuardrail: (ev) => {
+        this.emit({ type: "warning", message: ev.message });
+        if (ev.kind === "limit_stopped") this.emit({ type: "status", status: "error" });
+      },
       askPermission: async (req) => {
         if (mode === "auto") return "allow";
         if (mode === "plan") {
@@ -10296,10 +10391,6 @@ var InternalSession = class {
         });
         return decision;
       },
-      onToolLimitReached: async () => {
-        this.emit({ type: "status", status: "error" });
-        return "stop";
-      },
       onKimiMdStale: () => {
         this.onKimiMdStale?.();
       }
@@ -10317,6 +10408,9 @@ var InternalSession = class {
       hooks: this.hooks,
       // M6.1: Stop fires at end-of-turn when enabled.
       maxToolIterations,
+      // SDK callers bound turns with `maxToolIterations`: stop cleanly at the
+      // limit rather than resetting (never waits on a prompt either way).
+      toolLimitBehavior: "stop",
       reasoningEffort: this.reasoningEffort,
       coauthor,
       sessionId: this.sessionId,