indusagi 0.12.33 → 0.13.0

package/dist/ai.js

@@ -13199,24 +13199,58 @@ function normalizeProviderError(error) {
   }
   return new SimpleOptionsProviderError("Unknown provider error", "unknown", error);
 }
+function abortReason(signal) {
+  const reason = signal.reason;
+  if (reason instanceof SimpleOptionsProviderError) return reason;
+  if (reason instanceof Error) return new SimpleOptionsProviderError(reason.message, "unknown", reason);
+  return new SimpleOptionsProviderError("Request was aborted", "unknown", reason);
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortReason(signal));
+      return;
+    }
+    let onAbort;
+    const timer = setTimeout(() => {
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        reject(abortReason(signal));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
 async function executeWithRetry(operation, policy) {
   let attempt = 0;
   let lastError;
   while (attempt < policy.maxAttempts) {
+    if (policy.signal?.aborted) {
+      throw abortReason(policy.signal);
+    }
     attempt++;
     try {
       return await operation();
     } catch (error) {
       lastError = error;
       const normalized = normalizeProviderError(error);
+      if (policy.signal?.aborted) {
+        throw normalized;
+      }
       const defaultRetryable = normalized.code === "rate_limit" || normalized.code === "timeout" || normalized.code === "network";
       const retryable = policy.shouldRetry ? policy.shouldRetry(error, attempt) : defaultRetryable;
       if (!retryable || attempt >= policy.maxAttempts) {
         throw normalized;
       }
       const maxDelay = policy.maxDelayMs ?? Number.MAX_SAFE_INTEGER;
-      const backoff = Math.min(policy.baseDelayMs * 2 ** (attempt - 1), maxDelay);
-      await new Promise((resolve) => setTimeout(resolve, backoff));
+      const retryAfterMs = policy.getRetryAfterMs?.(error) ?? null;
+      const backoff = retryAfterMs != null ? Math.min(retryAfterMs, maxDelay) : Math.min(policy.baseDelayMs * 2 ** (attempt - 1), maxDelay);
+      await abortableSleep(backoff, policy.signal);
     }
   }
   throw normalizeProviderError(lastError);
@@ -13692,6 +13726,30 @@ var AnthropicEventReducer = class {
     calculateCost(this.model, this.output.usage);
   }
 };
+function parseAnthropicRetryAfterMs(error) {
+  if (error instanceof Anthropic.APIError) {
+    const header = error.headers?.get?.("retry-after");
+    const seconds = header ? parseInt(header, 10) : Number.NaN;
+    if (!Number.isNaN(seconds) && seconds >= 0) return seconds * 1e3;
+  }
+  return null;
+}
+function shouldRetryAnthropic(error, _attempt) {
+  if (error instanceof Anthropic.APIError) {
+    const status = error.status;
+    if (status === 408 || status === 409 || status === 429 || status === 529) return true;
+    if (typeof status === "number" && status >= 500) return true;
+    if (typeof status === "number" && status >= 400 && status < 500) return false;
+    const body = `${error.message} ${JSON.stringify(error.error ?? "")}`.toLowerCase();
+    if (body.includes('"type":"overloaded_error"') || body.includes("overloaded")) return true;
+    return false;
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("timeout") || msg.includes("timed out") || msg.includes("network") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("overloaded");
+  }
+  return false;
+}
 var streamAnthropic = (model, context, options) => {
   const stream2 = new AssistantMessageEventStream();
   const output = createAssistantMessageOutput(model);
@@ -13719,8 +13777,16 @@ var streamAnthropic = (model, context, options) => {
           });
         },
         {
-          maxAttempts: options?.signal ? 1 : 3,
-          baseDelayMs: 250
+          // Transient retries are NO LONGER gated on signal presence:
+          // the live path always carries a signal, so the old ternary
+          // collapsed to a single attempt = zero retries on 429/529/5xx.
+          // Abort still short-circuits immediately (see executeWithRetry).
+          maxAttempts: 3,
+          baseDelayMs: 500,
+          maxDelayMs: 32e3,
+          signal: options?.signal,
+          shouldRetry: shouldRetryAnthropic,
+          getRetryAfterMs: parseAnthropicRetryAfterMs
         }
       );
       if (options?.signal?.aborted) {
@@ -19700,6 +19766,7 @@ export {
   normalizeToolCallId,
   normalizeToolName,
   openaiCodexOAuthProvider,
+  parseAnthropicRetryAfterMs,
   parseStreamingJson,
   parseStreamingJsonWithDiagnostics,
   processResponsesStream,
@@ -19719,6 +19786,7 @@ export {
   retainThoughtSignature,
   rotateEnvApiKey,
   sanitizeContentString,
+  shouldRetryAnthropic,
   stream,
   streamAnthropic,
   streamAzureOpenAIResponses,

package/dist/capabilities.js

@@ -1,4 +1,5 @@
 // src/capabilities/kernel/spec.ts
+var READ_STATE_HANDLE_KEY = "readState";
 function coerceInput(raw) {
   if (typeof raw === "string") {
     const trimmed = raw.trim();
@@ -452,7 +453,7 @@ var standardBudget = {
 [${omitted} bytes elided to stay within the output ceiling]
 `
 };
-function makeNodeContext(cwd, signal, budget) {
+function makeNodeContext(cwd, signal, budget, framework) {
   if (typeof cwd !== "string" || cwd.length === 0) {
     throw new Error("makeNodeContext requires a non-empty working directory.");
   }
@@ -461,10 +462,60 @@ function makeNodeContext(cwd, signal, budget) {
     fs: nodeFs,
     shell: nodeShell,
     signal: signal ?? neverAborts(),
-    budget: budget ?? standardBudget
+    budget: budget ?? standardBudget,
+    ...framework ? { framework } : {}
   };
 }
 
+// src/capabilities/files/read-state-gate.ts
+var READ_BEFORE_EDIT_MESSAGE = "File has not been read yet. Read it first before writing to it.";
+var MODIFIED_SINCE_READ_MESSAGE = "File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.";
+function getReadStateHandle(ctx) {
+  const bag = ctx.framework;
+  if (!bag || typeof bag !== "object") return void 0;
+  const candidate = bag[READ_STATE_HANDLE_KEY];
+  if (!candidate || typeof candidate !== "object") return void 0;
+  const handle = candidate;
+  if (typeof handle.get !== "function" || typeof handle.set !== "function" || typeof handle.has !== "function") {
+    return void 0;
+  }
+  return handle;
+}
+async function recordReadState(ctx, absPath, handle) {
+  if (!handle) return;
+  try {
+    const info = await ctx.fs.stat(absPath);
+    const record = {
+      mtimeMs: Math.floor(info.modifiedMs),
+      size: info.size,
+      readAt: Date.now()
+    };
+    handle.set(absPath, record);
+  } catch {
+  }
+}
+async function enforceReadGate(ctx, absPath, handle) {
+  if (!handle) return { ok: true };
+  if (!handle.has(absPath)) {
+    return { ok: false, message: READ_BEFORE_EDIT_MESSAGE };
+  }
+  const recorded = handle.get(absPath);
+  if (!recorded) {
+    return { ok: false, message: READ_BEFORE_EDIT_MESSAGE };
+  }
+  let info;
+  try {
+    info = await ctx.fs.stat(absPath);
+  } catch {
+    return { ok: true };
+  }
+  const currentMtime = Math.floor(info.modifiedMs);
+  if (currentMtime > recorded.mtimeMs || info.size !== recorded.size) {
+    return { ok: false, message: MODIFIED_SINCE_READ_MESSAGE };
+  }
+  return { ok: true };
+}
+
 // src/capabilities/files/read.ts
 var GUTTER_WIDTH = 6;
 var DESCRIPTION = [
@@ -567,6 +618,7 @@ var readTool = defineTool({
       const detail = err instanceof Error ? err.message : String(err);
       return failure(`Could not read ${path}: ${detail}`);
     }
+    await recordReadState(ctx, path, getReadStateHandle(ctx));
     const allLines = toLines(text);
     const totalLines = allLines.length;
     if (totalLines === 0) {
@@ -674,11 +726,19 @@ var writeTool = defineTool({
   async run(input, ctx) {
     const path = readPath(input?.path);
     const content = readContent(input?.content);
+    const handle = getReadStateHandle(ctx);
+    if (handle && await ctx.fs.exists(path)) {
+      const gate = await enforceReadGate(ctx, path, handle);
+      if (!gate.ok) {
+        return asText(gate.message, true);
+      }
+    }
     const folder = parentDir(path);
     if (folder.length > 0) {
       await ctx.fs.mkdir(folder, { recursive: true });
     }
     await ctx.fs.writeFile(path, content, "utf8");
+    await recordReadState(ctx, path, handle);
     const bytes = Buffer.byteLength(content, "utf8");
     const unit = bytes === 1 ? "byte" : "bytes";
     return asText(`Saved ${bytes} ${unit} to ${path}.`);
@@ -968,6 +1028,11 @@ async function runEdit(input, ctx) {
   if (!info.isFile) {
     return failure2(`${path} is not a regular file, so it cannot be edited.`);
   }
+  const handle = getReadStateHandle(ctx);
+  const gate = await enforceReadGate(ctx, path, handle);
+  if (!gate.ok) {
+    return failure2(gate.message);
+  }
   const before = await ctx.fs.readFile(path, "utf8");
   const literalHits = countLiteral(before, oldText);
   if (literalHits > 0) {
@@ -981,6 +1046,7 @@ async function runEdit(input, ctx) {
       return failure2(`The replacement left ${path} unchanged.`);
     }
     await ctx.fs.writeFile(path, after2, "utf8");
+    await recordReadState(ctx, path, handle);
     return success(path, before, after2, replaceAll ? literalHits : 1);
   }
   const spans = findFuzzySpans(before, oldText);
@@ -1004,6 +1070,7 @@ async function runEdit(input, ctx) {
     return failure2(`The fuzzy replacement left ${path} unchanged.`);
   }
   await ctx.fs.writeFile(path, after, "utf8");
+  await recordReadState(ctx, path, handle);
   return success(path, before, after, targets.length);
 }
 var editTool = defineTool({