@tea-agent/loop-agent 0.25.3 → 0.25.5

package/dist/commands/client-recovery.js

@@ -1,7 +1,12 @@
-import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, rm, writeFile, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-export const CLIENT_RECOVERY_MODES = ["auto", "project", "user", "off"];
+export const CLIENT_RECOVERY_MODES = [
+    "auto",
+    "project",
+    "user",
+    "off",
+];
 export const OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH = ".opencode/plugins/loop-agent-transient-retry.js";
 export const PERMANENT_ERROR_INTERACTION = "plugin-ignore-permanent-error";
 export const BACKOFF_MS = [2000, 4000, 8000, 16000, 30000];
@@ -16,14 +21,26 @@ export const PI_RECOMMENDED_RETRY = {
     },
 };
 const PERMANENT_MESSAGE_PATTERNS = [
-    { reason: "auth", pattern: /\b(401|unauthorized|invalid api key|authentication)\b/i },
-    { reason: "permission", pattern: /\b(403|forbidden|permission denied|not allowed)\b/i },
-    { reason: "quota", pattern: /\b(quota|rate.?limit|billing|insufficient.?credit)\b/i },
+    {
+        reason: "auth",
+        pattern: /\b(401|unauthorized|invalid api key|authentication)\b/i,
+    },
+    {
+        reason: "permission",
+        pattern: /\b(403|forbidden|permission denied|not allowed)\b/i,
+    },
+    {
+        reason: "quota",
+        pattern: /\b(quota|rate.?limit|billing|insufficient.?credit)\b/i,
+    },
     {
         reason: "context-overflow",
         pattern: /\b(context (length )?overflow|too many tokens|maximum context|context window)\b/i,
     },
-    { reason: "cancelled", pattern: /\b(cancelled|canceled|aborted by user|user cancel)\b/i },
+    {
+        reason: "cancelled",
+        pattern: /\b(cancelled|canceled|aborted by user|user cancel)\b/i,
+    },
     {
         reason: "business-validation",
         pattern: /\b(business validation|invalid task|schema validation)\b/i,
@@ -33,7 +50,6 @@ const TRANSIENT_MESSAGE_PATTERNS = [
     /\bcode[:\s]*502\b/i,
     /\b502\b/,
     /\bLLMRequestError\b/i,
-    /\bTypeValidationError\b/i,
     /\bnetwork fluctuation\b/i,
     /\btimeout\b/i,
     /\btransient provider failure\b/i,
@@ -90,13 +106,34 @@ function hasUnknownErrorShape(error) {
     }
     return false;
 }
+/**
+ * TypeValidation bypass shape: bare TypeValidationError (zod invalid_union
+ * surfaced directly by the provider/SDK instead of wrapped as UnknownError).
+ * Bypass only fires when combined with a transient signal (see classifyTransientUnknownError).
+ */
+function hasTypeValidationShape(error) {
+    const text = collectErrorText(error);
+    if (/\bTypeValidationError\b/i.test(text))
+        return true;
+    if (/Type validation failed/i.test(text))
+        return true;
+    if (error && typeof error === "object") {
+        const record = error;
+        if (typeof record.name === "string" &&
+            /TypeValidationError/i.test(record.name)) {
+            return true;
+        }
+    }
+    return false;
+}
 function isStandardApiError(error) {
     if (!error || typeof error !== "object")
         return false;
     const record = error;
     if (typeof record.name === "string" && /^APIError$/i.test(record.name))
         return true;
-    if (typeof record.name === "string" && /^(AuthError|PermissionError)$/i.test(record.name)) {
+    if (typeof record.name === "string" &&
+        /^(AuthError|PermissionError)$/i.test(record.name)) {
         return true;
     }
     return false;
@@ -106,7 +143,8 @@ function permanentReason(error) {
         const record = error;
         if (typeof record.name === "string" && /AuthError/i.test(record.name))
             return "auth";
-        if (typeof record.name === "string" && /PermissionError/i.test(record.name)) {
+        if (typeof record.name === "string" &&
+            /PermissionError/i.test(record.name)) {
             return "permission";
         }
         return "api-error";
@@ -137,6 +175,12 @@ function looksTransient(error) {
 /**
  * Decide whether an OpenCode error should be resumed by the project plugin.
  * Only compensates transient UnknownError paths that built-in APIError retry misses.
+ *
+ * TypeValidation bypass: a bare TypeValidationError (provider/SDK surfaces
+ * zod invalid_union directly, without the UnknownError wrapper) is treated as
+ * a retryable transient-unknown-error ONLY when it also carries a transient
+ * signal (502 / LLMRequestError / timeout / etc.). A pure schema mismatch
+ * without a transient signal is still rejected (resumable: false).
  */
 export function classifyTransientUnknownError(error) {
     const permanent = permanentReason(error);
@@ -147,7 +191,9 @@ export function classifyTransientUnknownError(error) {
             interaction: PERMANENT_ERROR_INTERACTION,
         };
     }
-    if (!hasUnknownErrorShape(error)) {
+    const isUnknownShape = hasUnknownErrorShape(error);
+    const isTypeValidationShape = hasTypeValidationShape(error);
+    if (!isUnknownShape && !isTypeValidationShape) {
         return {
             resumable: false,
             reason: "not-unknown-error",
@@ -164,7 +210,9 @@ export function classifyTransientUnknownError(error) {
     return { resumable: true, reason: "transient-unknown-error" };
 }
 export function nextBackoffMs(attempt) {
-    if (!Number.isInteger(attempt) || attempt < 0 || attempt >= BACKOFF_MS.length) {
+    if (!Number.isInteger(attempt) ||
+        attempt < 0 ||
+        attempt >= BACKOFF_MS.length) {
         return undefined;
     }
     return BACKOFF_MS[attempt];
@@ -173,10 +221,15 @@ export function canResumeSession(input) {
     if (input.sessionStatus === "retry") {
         return { allowed: false, reason: "builtin-retry-active" };
     }
+    if (!input.sessionStatus) {
+        return { allowed: false, reason: "session-status-unknown" };
+    }
     if (input.locked) {
         return { allowed: false, reason: "session-locked" };
     }
-    if (!input.idle || input.sessionStatus === "busy" || input.sessionStatus === "running") {
+    if (!input.idle ||
+        input.sessionStatus === "busy" ||
+        input.sessionStatus === "running") {
         return { allowed: false, reason: "session-busy" };
     }
     if (input.attempt >= MAX_SESSION_RETRIES) {
@@ -253,7 +306,12 @@ export function planPiRetryMerge(existing) {
             action: "write",
             reason: "missing-file",
             path: settingsPath,
-            next: { retry: { ...PI_RECOMMENDED_RETRY, provider: { ...PI_RECOMMENDED_RETRY.provider } } },
+            next: {
+                retry: {
+                    ...PI_RECOMMENDED_RETRY,
+                    provider: { ...PI_RECOMMENDED_RETRY.provider },
+                },
+            },
         };
     }
     if (!isRecord(existing)) {
@@ -276,7 +334,8 @@ export function planPiRetryMerge(existing) {
     }
     const retry = isRecord(existing.retry) ? { ...existing.retry } : {};
     const provider = isRecord(retry.provider) ? { ...retry.provider } : {};
-    let changed = !isRecord(existing.retry) || !isRecord(existing.retry.provider);
+    let changed = !isRecord(existing.retry) ||
+        !isRecord(existing.retry.provider);
     if (retry.enabled === undefined) {
         retry.enabled = PI_RECOMMENDED_RETRY.enabled;
         changed = true;
@@ -383,7 +442,8 @@ export async function applyPiRetryMerge(input) {
             const dir = path.dirname(settingsPath);
             const entries = await readdir(dir);
             await Promise.all(entries
-                .filter((name) => name.startsWith(`.${path.basename(settingsPath)}.`) && name.endsWith(".tmp"))
+                .filter((name) => name.startsWith(`.${path.basename(settingsPath)}.`) &&
+                name.endsWith(".tmp"))
                 .map((name) => rm(path.join(dir, name), { force: true })));
         }
         catch {
@@ -414,11 +474,13 @@ const MAX_RETRIES = ${MAX_SESSION_RETRIES};
 
 const sessionState = new Map();
 const sessionStatus = new Map();
+const pendingErrors = new Map();
+const recoveryWorkers = new Map();
 
 function getState(sessionId) {
   let state = sessionState.get(sessionId);
   if (!state) {
-    state = { attempt: 0, locked: false };
+    state = { attempt: 0, locked: false, rerunRequested: false };
     sessionState.set(sessionId, state);
   }
   return state;
@@ -449,9 +511,13 @@ function isTransientUnknown(error) {
   if (isPermanent(error)) return false;
   const text = textOf(error);
   const hasUnknown = /UnknownError/i.test(text) || (error && /UnknownError/i.test(String(error.name || "")));
-  if (!hasUnknown) return false;
+  const hasTypeValidation =
+    /\\bTypeValidationError\\b/i.test(text) ||
+    /Type validation failed/i.test(text) ||
+    (error && /TypeValidationError/i.test(String(error.name || "")));
+  if (!hasUnknown && !hasTypeValidation) return false;
   return (
-    /\\b(code[:\\s]*502|502|LLMRequestError|TypeValidationError|Type validation failed|network fluctuation|timeout|transient provider failure|non-standard)\\b/i.test(
+    /\\b(code[:\\s]*502|502|LLMRequestError|network fluctuation|timeout|transient provider failure|non-standard)\\b/i.test(
       text,
     ) ||
     (error && (error.code === 502 || error.status === 502))
@@ -474,68 +540,121 @@ async function wait(ms) {
 }
 
 function statusType(status) {
-  return status && typeof status.type === "string" ? status.type : undefined;
+  const type = status && typeof status.type === "string" ? status.type : undefined;
+  return type === "idle" || type === "retry" || type === "busy" ? type : undefined;
 }
 
 async function readSessionStatus(client, sessionId) {
   const cached = sessionStatus.get(sessionId);
-  if (cached === "retry") return cached;
+  if (cached === "retry" || cached === "busy") {
+    return { ok: true, type: cached };
+  }
   try {
-    const response = await client.session.status();
+    const response = await client.session.status({ throwOnError: true });
+    if (!response || typeof response !== "object" || response.error != null) {
+      return { ok: false };
+    }
     const current = statusType(response?.data?.[sessionId]);
-    if (current) sessionStatus.set(sessionId, current);
-    return current || cached || "idle";
+    if (!current) return { ok: false };
+    sessionStatus.set(sessionId, current);
+    return { ok: true, type: current };
   } catch {
-    return cached || "idle";
+    return { ok: false };
   }
 }
 
+function promptWasAccepted(response) {
+  return Boolean(
+    response &&
+      typeof response === "object" &&
+      response.error == null &&
+      Object.prototype.hasOwnProperty.call(response, "data") &&
+      response.data !== null &&
+      typeof response.data === "object",
+  );
+}
+
 export default async function loopAgentTransientRetryPlugin({ client, $ }) {
   void $;
   void PLUGIN_PATH;
 
-  async function maybeResume(sessionId, error) {
-    if (!sessionId) return { interaction: PERMANENT_INTERACTION, reason: "missing-session" };
-    if (!isTransientUnknown(error)) {
-      return { interaction: PERMANENT_INTERACTION, reason: "plugin-ignore-permanent-error" };
-    }
-
+  async function drainPendingRecovery(sessionId) {
     const state = getState(sessionId);
-    if (state.locked) {
-      return { interaction: PERMANENT_INTERACTION, reason: "session-locked" };
-    }
+    const pending = pendingErrors.get(sessionId);
+    if (!pending) return;
     if (state.attempt >= MAX_RETRIES) {
-      return { interaction: PERMANENT_INTERACTION, reason: "max-retries" };
+      pendingErrors.delete(sessionId);
+      return;
     }
 
-    state.locked = true;
-    try {
-      let status = await readSessionStatus(client, sessionId);
-      // Never race OpenCode built-in retry.
-      if (status === "retry") {
-        return { interaction: PERMANENT_INTERACTION, reason: "builtin-retry-active" };
-      }
-      if (status === "busy" || status === "running") {
-        return { interaction: PERMANENT_INTERACTION, reason: "session-busy" };
-      }
+    // A status event may be stale by the time this worker runs. Confirm idle via
+    // the SDK before and after backoff; every other outcome keeps the error pending.
+    const beforeDelay = await readSessionStatus(client, sessionId);
+    if (pendingErrors.get(sessionId) !== pending) return;
+    if (!beforeDelay.ok || beforeDelay.type !== "idle") return;
 
-      const delay = BACKOFF_MS[state.attempt];
-      const nextAttempt = state.attempt + 1;
-      if (typeof delay === "number") await wait(delay);
-      // Re-check idle after backoff.
-      status = await readSessionStatus(client, sessionId);
-      if (status === "retry" || status === "busy" || status === "running") {
-        return { interaction: PERMANENT_INTERACTION, reason: "session-not-idle" };
-      }
-      const prompt = buildResumePrompt(sessionId, error, nextAttempt);
-      state.attempt = nextAttempt;
-      await client.session.promptAsync({
+    const delay = BACKOFF_MS[state.attempt];
+    if (typeof delay !== "number") {
+      pendingErrors.delete(sessionId);
+      return;
+    }
+    await wait(delay);
+    if (pendingErrors.get(sessionId) !== pending) return;
+
+    const beforePrompt = await readSessionStatus(client, sessionId);
+    if (pendingErrors.get(sessionId) !== pending) return;
+    if (!beforePrompt.ok || beforePrompt.type !== "idle") return;
+
+    const nextAttempt = state.attempt + 1;
+    const prompt = buildResumePrompt(sessionId, pending.error, nextAttempt);
+    let response;
+    try {
+      response = await client.session.promptAsync({
         path: { id: sessionId },
         body: { parts: [{ type: "text", text: prompt }] },
+        throwOnError: true,
       });
-      return { resumed: true, attempt: state.attempt };
-    } finally {
-      state.locked = false;
+    } catch {
+      return;
+    }
+    if (!promptWasAccepted(response)) return;
+
+    state.attempt = nextAttempt;
+    if (pendingErrors.get(sessionId) === pending) {
+      pendingErrors.delete(sessionId);
+    }
+  }
+
+  function startRecoveryWorker(sessionId) {
+    const state = getState(sessionId);
+    if (recoveryWorkers.has(sessionId)) {
+      state.rerunRequested = true;
+      return;
+    }
+    state.locked = true;
+    state.rerunRequested = false;
+    const worker = drainPendingRecovery(sessionId)
+      .catch(() => {})
+      .finally(() => {
+        recoveryWorkers.delete(sessionId);
+        const rerun = state.rerunRequested;
+        state.rerunRequested = false;
+        state.locked = false;
+        if (rerun && pendingErrors.has(sessionId)) {
+          startRecoveryWorker(sessionId);
+        }
+      });
+    recoveryWorkers.set(sessionId, worker);
+  }
+
+  function clearSession(sessionId) {
+    pendingErrors.delete(sessionId);
+    sessionStatus.delete(sessionId);
+    const state = sessionState.get(sessionId);
+    if (state) {
+      state.attempt = 0;
+      state.rerunRequested = false;
+      if (!recoveryWorkers.has(sessionId)) state.locked = false;
     }
   }
 
@@ -544,11 +663,27 @@ export default async function loopAgentTransientRetryPlugin({ client, $ }) {
       if (!event || typeof event !== "object") return;
       const properties = event.properties || {};
       const sessionId =
-        properties.sessionID || properties.sessionId || properties.id;
+        properties.sessionID || properties.sessionId || properties.id || properties.info?.id;
 
       if (event.type === "session.status") {
         const current = statusType(properties.status);
         if (sessionId && current) sessionStatus.set(sessionId, current);
+        if (sessionId && current === "idle" && pendingErrors.has(sessionId)) {
+          startRecoveryWorker(sessionId);
+        }
+        return;
+      }
+
+      if (event.type === "session.idle") {
+        if (sessionId) {
+          sessionStatus.set(sessionId, "idle");
+          if (pendingErrors.has(sessionId)) startRecoveryWorker(sessionId);
+        }
+        return;
+      }
+
+      if (event.type === "session.deleted") {
+        if (sessionId) clearSession(sessionId);
         return;
       }
 
@@ -557,16 +692,26 @@ export default async function loopAgentTransientRetryPlugin({ client, $ }) {
         if (
           info?.role === "assistant" &&
           info.sessionID &&
+          (info.status === undefined || info.status === "completed") &&
           info.time?.completed != null &&
           info.error == null
         ) {
-          getState(info.sessionID).attempt = 0;
+          clearSession(info.sessionID);
         }
         return;
       }
 
       if (event.type === "session.error") {
-        return maybeResume(sessionId, properties.error || properties);
+        if (!sessionId) return;
+        const error = properties.error || properties;
+        if (!isTransientUnknown(error)) {
+          pendingErrors.delete(sessionId);
+          getState(sessionId).rerunRequested = false;
+          return { interaction: PERMANENT_INTERACTION, reason: "plugin-ignore-permanent-error" };
+        }
+        pendingErrors.set(sessionId, { error });
+        startRecoveryWorker(sessionId);
+        return { pending: true };
       }
     },
   };
@@ -647,7 +792,9 @@ export async function runClientRecovery(input) {
             },
         };
     }
-    const plugin = await installProjectOpenCodePlugin({ repoRoot: input.repoRoot });
+    const plugin = await installProjectOpenCodePlugin({
+        repoRoot: input.repoRoot,
+    });
     if (mode !== "user") {
         return { mode, plugin };
     }