opencode-immune 1.0.56 → 1.0.58

package/dist/plugin.js

@@ -11,7 +11,7 @@ import { execFile } from "child_process";
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.56";
+const PLUGIN_VERSION = "1.0.58";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
 const PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -468,144 +468,114 @@ function getFallbackAgentForAgent(state, agent) {
 function getRouterSessionIDForChild(record) {
     return record.parentSessionID ?? record.rootSessionID;
 }
-function isRetryableApiError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const maybeError = error;
-    // Structured retryable flag
-    if (maybeError.name === "APIError" &&
-        maybeError.data?.isRetryable === true) {
-        return true;
-    }
-    // HTTP status code based detection (retryable server/gateway errors + rate limits)
-    const status = maybeError.status ?? maybeError.statusCode ?? maybeError.data?.status ?? maybeError.error?.status;
-    if (status && (status === 404 || // transient endpoint not found (API gateway issues)
-        status === 429 || // rate limit
-        status === 500 || // internal server error
-        status === 502 || // bad gateway
-        status === 503 || // service unavailable
-        status === 504 // gateway timeout
-    )) {
-        return true;
+function stringifyErrorField(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return undefined;
+}
+function numberFromErrorField(value) {
+    if (typeof value === "number")
+        return value;
+    if (typeof value !== "string")
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function firstDefinedNumber(...values) {
+    for (const value of values) {
+        const parsed = numberFromErrorField(value);
+        if (parsed !== undefined)
+            return parsed;
     }
-    // Text-based detection for model access errors (not marked as retryable
-    // by the API but retryable with a fallback model)
+    return undefined;
+}
+function extractManagedErrorDetails(error) {
+    if (!isRecord(error))
+        return undefined;
+    const data = isRecord(error.data) ? error.data : undefined;
+    const nestedError = isRecord(error.error) ? error.error : undefined;
+    const name = stringifyErrorField(error.name) ?? "";
+    const status = firstDefinedNumber(error.status, error.statusCode, data?.status, nestedError?.status);
+    const code = [error.code, data?.code, nestedError?.code]
+        .map(stringifyErrorField)
+        .find(Boolean);
+    const type = [error.type, data?.type, nestedError?.type]
+        .map(stringifyErrorField)
+        .find(Boolean);
+    const isRetryable = error.isRetryable === true || data?.isRetryable === true || nestedError?.isRetryable === true
+        ? true
+        : undefined;
     const message = [
-        maybeError.message,
-        maybeError.code,
-        maybeError.data?.message,
-        maybeError.data?.type,
-        maybeError.data?.code,
-        maybeError.error?.message,
-        maybeError.error?.type,
-        maybeError.error?.code,
-    ].filter((value) => value !== undefined && value !== null).join(" ").toLowerCase();
-    if (message.includes("api_error") ||
-        message.includes("не разрешен") ||
-        message.includes("not allowed") ||
-        message.includes("not supported") ||
-        message.includes("internal error") ||
-        message.includes("internal server error") ||
-        message.includes("expected") ||
-        message.includes("to be a string") ||
-        message.includes("invalid_type") ||
-        message.includes("validation") ||
-        message.includes("schema") ||
-        message.includes("zod") ||
-        message.includes("parse error") ||
-        message.includes("invalid id") ||
-        message.includes("expected id") ||
-        message.includes("model not available") ||
-        message.includes("model_not_found") ||
-        message.includes("access denied") ||
-        message.includes("404") ||
-        message.includes("not found") ||
-        message.includes("page not found") ||
-        message.includes("502") ||
-        message.includes("bad gateway") ||
-        message.includes("503") ||
-        message.includes("service unavailable") ||
-        message.includes("504") ||
-        message.includes("gateway timeout") ||
-        message.includes("econnrefused") ||
-        message.includes("econnreset") ||
-        message.includes("etimedout") ||
-        message.includes("fetch failed") ||
-        message.includes("timed out") ||
-        message.includes("timeout") ||
-        message.includes("sse read") ||
-        message.includes("stream error") ||
-        // Certificate/TLS provider failures must pass this primary retry gate
-        // before the managed-session fallback model branch can run.
-        message.includes("unknown certificate verification error") ||
-        message.includes("unknown_certificate_verification_error") ||
-        message.includes("certificate has expired") ||
-        message.includes("certificate verification") ||
-        message.includes("tls") ||
-        message.includes("ssl") ||
-        message.includes("connection reset") ||
-        message.includes("socket hang up") ||
-        message.includes("aborted")) {
-        return true;
-    }
-    return false;
+        error.message,
+        data?.message,
+        nestedError?.message,
+        code,
+        type,
+    ].map(stringifyErrorField).filter(Boolean).join(" ").toLowerCase();
+    return {
+        name,
+        message,
+        status,
+        code,
+        type,
+        isRetryable,
+        hasApiShape: name === "APIError" ||
+            status !== undefined ||
+            isRetryable !== undefined ||
+            data !== undefined ||
+            nestedError !== undefined,
+    };
 }
-function isModelAccessError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const maybeError = error;
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
-    const type = `${maybeError.data?.type ?? ""}`.toLowerCase();
-    return (message.includes("не разрешен") ||
-        message.includes("not allowed") ||
-        message.includes("not supported") ||
-        message.includes("model not available") ||
-        message.includes("model_not_found") ||
-        message.includes("access denied") ||
-        type.includes("model_not_found") ||
-        type.includes("invalid_model"));
-}
-function isRateLimitApiError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const maybeError = error;
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`.toLowerCase();
-    const type = `${maybeError.data?.type ?? ""} ${maybeError.error?.type ?? ""}`.toLowerCase();
-    return ((type.includes("rate_limit") || message.includes("too many requests") || message.includes("rate limit")));
+function getManagedSessionErrorAction(error) {
+    const details = extractManagedErrorDetails(error);
+    if (!details)
+        return "none";
+    if (details.name === "AbortError" || details.code === "ABORT_ERR") {
+        return "none";
+    }
+    if (details.status !== undefined) {
+        if (details.status === 408 || details.status === 409 || details.status === 425 || details.status >= 500) {
+            return "retry";
+        }
+        if (details.status >= 400 && details.status < 500) {
+            return "fallback";
+        }
+    }
+    if (details.isRetryable === true)
+        return "retry";
+    if (details.code && /^E[A-Z0-9_]+$/.test(details.code))
+        return "retry";
+    // Managed session errors originate from the active model/provider request.
+    // If the server emitted an API-shaped error but did not expose a stable status
+    // or retryability flag, prefer one fallback-model attempt over hard-stopping.
+    if (details.hasApiShape || details.message)
+        return "fallback";
+    return "none";
+}
+function shouldUseFallbackForManagedError(error, managedSession, retryCount) {
+    if (managedSession.kind === "child")
+        return true;
+    return getManagedSessionErrorAction(error) === "fallback" || retryCount > 0;
 }
-function isCertificateApiError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const maybeError = error;
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`.toLowerCase();
-    const code = `${maybeError.code ?? ""} ${maybeError.data?.code ?? ""} ${maybeError.error?.code ?? ""}`.toLowerCase();
-    const type = `${maybeError.data?.type ?? ""} ${maybeError.error?.type ?? ""}`.toLowerCase();
-    return (message.includes("unknown certificate verification error") ||
-        message.includes("unknown_certificate_verification_error") ||
-        message.includes("certificate has expired") ||
-        message.includes("certificate verification") ||
-        message.includes("tls") ||
-        message.includes("ssl") ||
-        code.includes("cert_has_expired") ||
-        code.includes("unknown_certificate_verification_error") ||
-        code.includes("unable_to_verify_leaf_signature") ||
-        code.includes("self_signed_cert") ||
-        code.includes("tls") ||
-        type.includes("certificate") ||
-        type.includes("tls") ||
-        type.includes("ssl"));
+function isRetryableApiError(error) {
+    return getManagedSessionErrorAction(error) !== "none";
 }
 function isProviderRetryBanner(text) {
     return /(?:<none>\s*)?retrying in \d+s\s*-\s*attempt #\d+/i.test(text);
 }
 function getRetryableErrorType(error) {
-    if (isModelAccessError(error))
-        return "model access error";
-    if (isRateLimitApiError(error))
-        return "rate limit";
-    if (isCertificateApiError(error))
-        return "certificate error";
-    return "retryable provider error";
+    const action = getManagedSessionErrorAction(error);
+    const status = extractManagedErrorDetails(error)?.status;
+    const statusSuffix = status !== undefined ? ` (${status})` : "";
+    if (action === "fallback")
+        return `provider fallback error${statusSuffix}`;
+    if (action === "retry")
+        return `transient provider error${statusSuffix}`;
+    return "non-retryable provider error";
 }
 function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
     const fallbackModel = selectFallbackModel(getFailedModelFromError(error) ?? managedSession.currentModel);
@@ -1716,14 +1686,17 @@ function createEventHandler(state) {
         // active managed root session, retry it as a best-effort recovery path.
         if (eventType === "session.error" && !sessionID && isRetryableApiError(error)) {
             const rootCandidates = Array.from(state.managedUltraworkSessions.entries())
-                .filter(([, record]) => record.kind === "root")
-                .map(([id]) => id);
+                .filter(([, record]) => record.kind === "root");
             if (rootCandidates.length === 1) {
-                const fallbackSessionID = rootCandidates[0];
+                const [fallbackSessionID, managedSession] = rootCandidates[0];
                 const count = state.sessionErrorRetryCount.get(fallbackSessionID) ?? 0;
                 if (count < MAX_RETRIES && !state.sessionRetryTimers.has(fallbackSessionID)) {
                     const delay = Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS);
                     state.sessionErrorRetryCount.set(fallbackSessionID, count + 1);
+                    if (shouldUseFallbackForManagedError(error, managedSession, count)) {
+                        const fallbackModel = selectFallbackModel(getFailedModelFromError(error) ?? managedSession.currentModel);
+                        await setSessionFallbackModel(state, fallbackSessionID, fallbackModel);
+                    }
                     pluginLog.warn(`[opencode-immune] session.error without sessionID matched retryable error. ` +
                         `Retrying sole managed root session ${fallbackSessionID}.`);
                     scheduleManagedSessionRetry(state, fallbackSessionID, {
@@ -1773,7 +1746,7 @@ function createEventHandler(state) {
                     state.sessionErrorRetryCount.set(sessionID, count);
                     return;
                 }
-                else if (isRoot && (isModelAccessError(error) || isRateLimitApiError(error) || isCertificateApiError(error))) {
+                else if (isRoot && shouldUseFallbackForManagedError(error, managedSession, count)) {
                     const selectedFallbackModel = selectFallbackModel(getFailedModelFromError(error) ?? managedSession.currentModel);
                     await setSessionFallbackModel(state, sessionID, selectedFallbackModel);
                     const errorType = getRetryableErrorType(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.56",
+  "version": "1.0.58",
   "type": "module",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {