opencode-immune 1.0.54 → 1.0.56

package/dist/plugin.js

@@ -11,7 +11,7 @@ import { execFile } from "child_process";
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.54";
+const PLUGIN_VERSION = "1.0.56";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
 const PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -96,6 +96,8 @@ function createState(input) {
         providerRetryWatchdogs: new Map(),
         childFallbackRequests: new Map(),
         sessionErrorRetryCount: new Map(),
+        fallbackAgentByAgent: new Map(),
+        baseAgentByFallbackAgent: new Map(),
         ultraworkMarkerPath: join(input.directory, ".opencode", "state", "ultrawork-active.json"),
         diagnosticsLogPath: join(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
         lastEditAttempt: null,
@@ -135,12 +137,18 @@ 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" },
+];
+const FALLBACK_AGENT_SUFFIX = "-provider-fallback";
 function isManagedUltraworkSession(state, sessionID) {
     return !!sessionID && state.managedUltraworkSessions.has(sessionID);
 }
@@ -315,8 +323,10 @@ async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now
         kind: existing?.kind ?? "root",
         agent: ULTRAWORK_AGENT,
         rootSessionID: existing?.rootSessionID ?? sessionID,
+        parentSessionID: existing?.parentSessionID,
         createdAt: existing?.createdAt ?? timestamp,
         updatedAt: timestamp,
+        currentModel: existing?.currentModel,
         fallbackModel: existing?.fallbackModel,
     };
     if (existing &&
@@ -342,8 +352,10 @@ async function addManagedChildSession(state, sessionID, parentSessionID, timesta
         kind: "child",
         agent: existing?.agent ?? "unknown",
         rootSessionID: parent.rootSessionID,
+        parentSessionID,
         createdAt: existing?.createdAt ?? timestamp,
         updatedAt: timestamp,
+        currentModel: existing?.currentModel ?? parent.currentModel,
         fallbackModel: existing?.fallbackModel ?? parent.fallbackModel,
     });
 }
@@ -396,6 +408,66 @@ 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 getFallbackAgentForAgent(state, agent) {
+    return state.fallbackAgentByAgent.get(agent) ?? agent;
+}
+function getRouterSessionIDForChild(record) {
+    return record.parentSessionID ?? record.rootSessionID;
+}
 function isRetryableApiError(error) {
     if (!error || typeof error !== "object")
         return false;
@@ -431,6 +503,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") ||
@@ -485,6 +558,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") ||
@@ -534,22 +608,26 @@ function getRetryableErrorType(error) {
     return "retryable provider error";
 }
 function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
+    const fallbackModel = selectFallbackModel(getFailedModelFromError(error) ?? managedSession.currentModel);
+    const routerSessionID = getRouterSessionIDForChild(managedSession);
     const request = {
         childSessionID,
         rootSessionID: managedSession.rootSessionID,
+        routerSessionID,
         agent: managedSession.agent || "unknown",
+        fallbackAgent: getFallbackAgentForAgent(state, managedSession.agent || "unknown"),
         errorType: getRetryableErrorType(error),
-        fallbackModel: CHILD_SESSION_FALLBACK_MODEL,
+        fallbackModel,
         createdAt: Date.now(),
     };
-    state.childFallbackRequests.set(managedSession.rootSessionID, request);
+    state.childFallbackRequests.set(routerSessionID, request);
 }
-function getChildFallbackRequest(state, rootSessionID, now = Date.now()) {
-    const request = state.childFallbackRequests.get(rootSessionID);
+function getChildFallbackRequest(state, sessionID, now = Date.now()) {
+    const request = state.childFallbackRequests.get(sessionID);
     if (!request)
         return undefined;
     if (now - request.createdAt > CHILD_FALLBACK_REQUEST_TTL_MS) {
-        state.childFallbackRequests.delete(rootSessionID);
+        state.childFallbackRequests.delete(sessionID);
         return undefined;
     }
     return request;
@@ -565,10 +643,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,
@@ -766,6 +845,129 @@ function compositeChatMessage(handlers) {
         }
     };
 }
+function isRecord(value) {
+    return !!value && typeof value === "object";
+}
+function getTaskAgentFromArgs(args) {
+    if (!isRecord(args))
+        return undefined;
+    const subagentType = args.subagent_type;
+    if (typeof subagentType === "string")
+        return subagentType;
+    const agent = args.agent;
+    if (typeof agent === "string")
+        return agent;
+    return undefined;
+}
+function setTaskAgentInArgs(args, agent) {
+    if (!isRecord(args))
+        return;
+    if ("subagent_type" in args) {
+        args.subagent_type = agent;
+        return;
+    }
+    if ("agent" in args) {
+        args.agent = agent;
+        return;
+    }
+    args.subagent_type = agent;
+}
+function createProviderFallbackToolBefore(state) {
+    return async (input, output) => {
+        if (input.tool !== "task" && input.tool !== "Task")
+            return;
+        const request = getChildFallbackRequest(state, input.sessionID);
+        if (!request)
+            return;
+        const requestedAgent = getTaskAgentFromArgs(output.args);
+        if (!requestedAgent || requestedAgent !== request.agent)
+            return;
+        if (request.fallbackAgent === request.agent)
+            return;
+        setTaskAgentInArgs(output.args, request.fallbackAgent);
+        state.childFallbackRequests.delete(input.sessionID);
+        await writeDiagnosticLog(state, "provider-fallback-task:rewrite", {
+            sessionID: input.sessionID,
+            childSessionID: request.childSessionID,
+            callID: input.callID,
+            fromAgent: request.agent,
+            toAgent: request.fallbackAgent,
+            fallbackModel: request.fallbackModel,
+        });
+        writePluginLog(state, "warn", `[opencode-immune] Rewrote provider retry Task agent ${request.agent} -> ${request.fallbackAgent} for session ${input.sessionID}.`);
+    };
+}
+function modelRefToString(model) {
+    return `${model.providerID}/${model.modelID}`;
+}
+function parseModelRef(model) {
+    if (!model)
+        return undefined;
+    const [providerID, ...modelParts] = model.split("/");
+    const modelID = modelParts.join("/");
+    if (!providerID || !modelID)
+        return undefined;
+    return { providerID, modelID };
+}
+function canCreateFallbackForAgent(agentID, agentConfig) {
+    if (agentID.endsWith(FALLBACK_AGENT_SUFFIX))
+        return false;
+    if (!isRecord(agentConfig))
+        return false;
+    return typeof agentConfig.model === "string";
+}
+function globPatternMatchesAgent(pattern, agentID) {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`^${escaped.replace(/\\\*/g, ".*")}$`);
+    return regex.test(agentID);
+}
+function allowFallbackAgentInTaskPermissions(config, baseAgentID, fallbackAgentID) {
+    if (!config.agent)
+        return;
+    for (const agentConfig of Object.values(config.agent)) {
+        if (!isRecord(agentConfig))
+            continue;
+        const permission = agentConfig.permission;
+        if (!isRecord(permission))
+            continue;
+        const taskPermission = permission.task;
+        if (!isRecord(taskPermission))
+            continue;
+        const hasExplicitAllow = taskPermission[baseAgentID] === "allow";
+        const hasGlobAllow = Object.entries(taskPermission).some(([pattern, action]) => action === "allow" &&
+            pattern.includes("*") &&
+            globPatternMatchesAgent(pattern, baseAgentID));
+        if (hasExplicitAllow || hasGlobAllow) {
+            taskPermission[fallbackAgentID] = "allow";
+        }
+    }
+}
+function createConfigHandler(state) {
+    return async (config) => {
+        if (!config.agent)
+            return;
+        for (const [agentID, agentConfig] of Object.entries(config.agent)) {
+            if (!canCreateFallbackForAgent(agentID, agentConfig))
+                continue;
+            const baseModel = parseModelRef(agentConfig.model);
+            const fallbackModel = selectFallbackModel(baseModel);
+            if (!baseModel || isSameModel(baseModel, fallbackModel))
+                continue;
+            const fallbackAgentID = `${agentID}${FALLBACK_AGENT_SUFFIX}`;
+            if (config.agent[fallbackAgentID])
+                continue;
+            config.agent[fallbackAgentID] = {
+                ...agentConfig,
+                hidden: true,
+                model: modelRefToString(fallbackModel),
+                description: `${String(agentConfig.description ?? agentID)} (provider fallback)`,
+            };
+            state.fallbackAgentByAgent.set(agentID, fallbackAgentID);
+            state.baseAgentByFallbackAgent.set(fallbackAgentID, agentID);
+            allowFallbackAgentInTaskPermissions(config, agentID, fallbackAgentID);
+        }
+    };
+}
 // ═══════════════════════════════════════════════════════════════════════════════
 // UTILITY: TASKS.MD PARSER
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1262,9 +1464,10 @@ function createSystemTransform(state) {
                     `Do not advance to the next sequential pipeline slot until this failed slot is explicitly resolved.\n` +
                     `- Failed child session: ${childFallbackRequest.childSessionID}\n` +
                     `- Agent: ${childFallbackRequest.agent}\n` +
+                    `- Runtime fallback agent: ${childFallbackRequest.fallbackAgent}\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 pipeline slot once by creating a NEW Task call to the same original agent. Do not resume the failed task_id. The plugin will rewrite that one Task call to the runtime fallback agent above so the model actually changes. If it still fails, record DECLINE/failed-provider-retry for that slot before continuing. ` +
                     `Never resume the failed child session directly; create a router-owned replacement attempt instead.`);
             }
         }
@@ -1438,7 +1641,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) {
@@ -1472,11 +1675,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}"`);
     };
@@ -1564,11 +1773,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,
@@ -1746,7 +1956,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,
@@ -1857,9 +2067,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, {
@@ -1984,9 +2195,11 @@ async function server(input) {
         createMultiCycleHandler(state),
     ];
     return {
+        config: withErrorBoundary(state, "config", createConfigHandler(state)),
         event: withErrorBoundary(state, "event", createEventHandler(state)),
         "chat.message": withErrorBoundary(state, "chat.message", compositeChatMessage(chatMessageHandlers)),
         "chat.params": withErrorBoundary(state, "chat.params", createFallbackModels(state)),
+        "tool.execute.before": withErrorBoundary(state, "tool.execute.before", createProviderFallbackToolBefore(state)),
         "tool.execute.after": withErrorBoundary(state, "tool.execute.after", compositeToolAfter(toolAfterHandlers)),
         "experimental.chat.system.transform": withErrorBoundary(state, "experimental.chat.system.transform", createSystemTransform(state)),
         "experimental.session.compacting": withErrorBoundary(state, "experimental.session.compacting", createCompactionHandler(state)),

package/package.json

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