opencode-immune 1.0.55 → 1.0.56

package/dist/plugin.js

@@ -11,7 +11,7 @@ import { execFile } from "child_process";
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.55";
+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,
@@ -146,6 +148,7 @@ const FALLBACK_MODEL_CANDIDATES = [
     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);
 }
@@ -320,6 +323,7 @@ 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,
@@ -348,6 +352,7 @@ 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,
@@ -457,6 +462,12 @@ function getSessionFallbackModel(state, sessionID, 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;
@@ -598,22 +609,25 @@ function getRetryableErrorType(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,
         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;
@@ -831,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
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1327,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 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. ` +
+                    `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.`);
             }
         }
@@ -2057,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.55",
+  "version": "1.0.56",
   "type": "module",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {