opencode-immune 1.0.53 → 1.0.55

package/dist/plugin.js

@@ -11,9 +11,17 @@ import { execFile } from "child_process";
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.53";
+const PLUGIN_VERSION = "1.0.55";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
 const PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
+function getServerAuthHeaders() {
+    const password = process.env.OPENCODE_SERVER_PASSWORD;
+    if (!password)
+        return undefined;
+    return {
+        Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`,
+    };
+}
 /**
  * Read plugin version from package.json at runtime.
  * Falls back to PLUGIN_VERSION constant if read fails.
@@ -80,6 +88,7 @@ function createState(input) {
         client: createOpencodeClientV2({
             baseUrl: input.serverUrl.toString(),
             directory: input.directory,
+            headers: getServerAuthHeaders(),
         }),
         recoveryContext: null,
         managedUltraworkSessions: new Map(),
@@ -126,12 +135,17 @@ const RETRY_PROMPT_DELIVERY_ATTEMPTS = 3;
 const CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1000;
 const RATE_LIMIT_FALLBACK_MODEL = {
     providerID: "codexsale",
-    modelID: "gpt-5.5",
+    modelID: "gpt-5.4-mini",
 };
 const CHILD_SESSION_FALLBACK_MODEL = {
-    providerID: "codexsale",
-    modelID: "gpt-5.5",
+    providerID: "claudehub",
+    modelID: "claude-opus-4-7",
 };
+const FALLBACK_MODEL_CANDIDATES = [
+    CHILD_SESSION_FALLBACK_MODEL,
+    RATE_LIMIT_FALLBACK_MODEL,
+    { providerID: "codexsale", modelID: "gpt-5.5" },
+];
 function isManagedUltraworkSession(state, sessionID) {
     return !!sessionID && state.managedUltraworkSessions.has(sessionID);
 }
@@ -308,6 +322,7 @@ async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now
         rootSessionID: existing?.rootSessionID ?? sessionID,
         createdAt: existing?.createdAt ?? timestamp,
         updatedAt: timestamp,
+        currentModel: existing?.currentModel,
         fallbackModel: existing?.fallbackModel,
     };
     if (existing &&
@@ -335,6 +350,7 @@ async function addManagedChildSession(state, sessionID, parentSessionID, timesta
         rootSessionID: parent.rootSessionID,
         createdAt: existing?.createdAt ?? timestamp,
         updatedAt: timestamp,
+        currentModel: existing?.currentModel ?? parent.currentModel,
         fallbackModel: existing?.fallbackModel ?? parent.fallbackModel,
     });
 }
@@ -387,6 +403,60 @@ function markUltraworkSessionActive(state, sessionID) {
     });
     return true;
 }
+function getModelProviderID(model) {
+    return model?.providerID || model?.modelID.split("/")[0];
+}
+function isSameModel(a, b) {
+    if (!a || !b)
+        return false;
+    return a.providerID === b.providerID && a.modelID === b.modelID;
+}
+function selectFallbackModel(currentModel) {
+    const currentProviderID = getModelProviderID(currentModel);
+    const otherProviderModel = FALLBACK_MODEL_CANDIDATES.find((candidate) => !isSameModel(candidate, currentModel) &&
+        getModelProviderID(candidate) !== currentProviderID);
+    if (otherProviderModel)
+        return otherProviderModel;
+    return (FALLBACK_MODEL_CANDIDATES.find((candidate) => !isSameModel(candidate, currentModel)) ?? RATE_LIMIT_FALLBACK_MODEL);
+}
+function getFailedModelFromError(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const maybeError = error;
+    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`;
+    const providerModelMatch = message.match(/\b([a-z0-9_-]+)\/([a-z0-9._-]+)\b/i);
+    if (providerModelMatch?.[1] && providerModelMatch[2]) {
+        return {
+            providerID: providerModelMatch[1].toLowerCase(),
+            modelID: providerModelMatch[2].toLowerCase(),
+        };
+    }
+    const unsupportedModelMatch = message.match(/["']([^"']+)["']\s+model\s+is\s+not\s+supported/i);
+    if (unsupportedModelMatch?.[1] && /\bcodex\b/i.test(message)) {
+        return {
+            providerID: "codexsale",
+            modelID: unsupportedModelMatch[1].toLowerCase(),
+        };
+    }
+    return undefined;
+}
+async function updateManagedSessionModel(state, sessionID, model) {
+    const existing = state.managedUltraworkSessions.get(sessionID);
+    if (!existing || isSameModel(existing.currentModel, model))
+        return;
+    state.managedUltraworkSessions.set(sessionID, {
+        ...existing,
+        currentModel: model,
+        updatedAt: Date.now(),
+    });
+}
+function getSessionFallbackModel(state, sessionID, preferredModel) {
+    const currentModel = state.managedUltraworkSessions.get(sessionID)?.currentModel;
+    if (preferredModel && !isSameModel(preferredModel, currentModel)) {
+        return preferredModel;
+    }
+    return selectFallbackModel(currentModel);
+}
 function isRetryableApiError(error) {
     if (!error || typeof error !== "object")
         return false;
@@ -422,6 +492,7 @@ function isRetryableApiError(error) {
     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") ||
@@ -476,6 +547,7 @@ function isModelAccessError(error) {
     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") ||
@@ -525,12 +597,13 @@ function getRetryableErrorType(error) {
     return "retryable provider error";
 }
 function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
+    const fallbackModel = selectFallbackModel(getFailedModelFromError(error) ?? managedSession.currentModel);
     const request = {
         childSessionID,
         rootSessionID: managedSession.rootSessionID,
         agent: managedSession.agent || "unknown",
         errorType: getRetryableErrorType(error),
-        fallbackModel: CHILD_SESSION_FALLBACK_MODEL,
+        fallbackModel,
         createdAt: Date.now(),
     };
     state.childFallbackRequests.set(managedSession.rootSessionID, request);
@@ -556,10 +629,11 @@ function scheduleProviderRetryWatchdog(state, sessionID, model) {
             return;
         if (state.sessionRetryTimers.has(sessionID))
             return;
-        await setSessionFallbackModel(state, sessionID, model);
+        const fallbackModel = getSessionFallbackModel(state, sessionID, model);
+        await setSessionFallbackModel(state, sessionID, fallbackModel);
         await writeDiagnosticLog(state, "provider-retry-watchdog:fired", {
             sessionID,
-            fallbackModel: model,
+            fallbackModel,
         });
         scheduleManagedSessionRetry(state, sessionID, {
             delayMs: 1_000,
@@ -1255,7 +1329,7 @@ function createSystemTransform(state) {
                     `- Agent: ${childFallbackRequest.agent}\n` +
                     `- Error type: ${childFallbackRequest.errorType}\n` +
                     `- Required fallback model: ${childFallbackRequest.fallbackModel.providerID}/${childFallbackRequest.fallbackModel.modelID}\n` +
-                    `Router action: retry the SAME agent/slot once using the fallback model if available; if it still fails or cannot be retried, record DECLINE/failed-provider-retry for that slot before continuing. ` +
+                    `Router action: retry the SAME agent/slot once using the required fallback model from a different provider; never reuse the failed model for this retry. If it still fails or cannot be retried, record DECLINE/failed-provider-retry for that slot before continuing. ` +
                     `Never resume the failed child session directly; create a router-owned replacement attempt instead.`);
             }
         }
@@ -1429,7 +1503,7 @@ function createFallbackModels(state) {
             const wasAlreadyManaged = isManagedUltraworkSession(state, input.sessionID);
             await addManagedUltraworkSession(state, input.sessionID);
             await writeUltraworkMarker(state);
-            scheduleProviderRetryWatchdog(state, input.sessionID, RATE_LIMIT_FALLBACK_MODEL);
+            scheduleProviderRetryWatchdog(state, input.sessionID);
             // First contact with 0-ultrawork after plugin restart:
             // if marker is active and tasks.md has incomplete work, send AUTO-RESUME prompt.
             if (!wasAlreadyManaged && !state.autoResumeAttempted) {
@@ -1463,11 +1537,17 @@ function createFallbackModels(state) {
         // Subagent calls from 0-ultrawork (1-van, 7-backlog, etc.) use the same session.
         // Log model and agent for observability
         const modelId = input.model && "id" in input.model
-            ? input.model.id
+            ? input.model.id ?? "unknown"
             : "unknown";
         const providerId = input.provider?.info && "id" in input.provider.info
-            ? input.provider.info.id
+            ? input.provider.info.id ?? "unknown"
             : "unknown";
+        if (input.sessionID && modelId !== "unknown" && providerId !== "unknown") {
+            await updateManagedSessionModel(state, input.sessionID, {
+                providerID: providerId,
+                modelID: modelId,
+            });
+        }
         pluginLog.info(`[opencode-immune] Model Observer: agent="${input.agent}", ` +
             `model="${modelId}", provider="${providerId}"`);
     };
@@ -1555,11 +1635,12 @@ function createEventHandler(state) {
                     state.sessionErrorRetryCount.set(sessionID, count);
                     return;
                 }
-                else if (isRoot && (isRateLimitApiError(error) || isCertificateApiError(error))) {
-                    await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
-                    const errorType = isCertificateApiError(error) ? "certificate error" : "rate limit";
+                else if (isRoot && (isModelAccessError(error) || isRateLimitApiError(error) || isCertificateApiError(error))) {
+                    const selectedFallbackModel = selectFallbackModel(getFailedModelFromError(error) ?? managedSession.currentModel);
+                    await setSessionFallbackModel(state, sessionID, selectedFallbackModel);
+                    const errorType = getRetryableErrorType(error);
                     pluginLog.info(`[opencode-immune] ${errorType} detected for root session ${sessionID}. ` +
-                        `Retry will use fallback model ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
+                        `Retry will use fallback model ${selectedFallbackModel.providerID}/${selectedFallbackModel.modelID}.`);
                 }
                 const scheduled = scheduleManagedSessionRetry(state, sessionID, {
                     delayMs: delay,
@@ -1737,7 +1818,7 @@ function createTextCompleteHandler(state) {
         // Some provider/SDK failures render as a retry banner instead of a
         // session.error event, leaving the UI waiting for long internal backoff.
         if (isProviderRetryBanner(text) && isManagedRootUltraworkSession(state, sessionID)) {
-            const fallbackModel = RATE_LIMIT_FALLBACK_MODEL;
+            const fallbackModel = getSessionFallbackModel(state, sessionID);
             await setSessionFallbackModel(state, sessionID, fallbackModel);
             scheduleManagedSessionRetry(state, sessionID, {
                 delayMs: 1_000,
@@ -1848,9 +1929,10 @@ function createMultiCycleHandler(state) {
         if (sessionID &&
             RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
             if (managedSession && !managedSession.fallbackModel) {
-                await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
+                const fallbackModel = getSessionFallbackModel(state, sessionID);
+                await setSessionFallbackModel(state, sessionID, fallbackModel);
                 pluginLog.info(`[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. ` +
-                    `Fallback model pinned to ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
+                    `Fallback model pinned to ${fallbackModel.providerID}/${fallbackModel.modelID}.`);
             }
             if (managedSession) {
                 scheduleManagedSessionRetry(state, sessionID, {

package/package.json

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