opencode-immune 1.0.71 → 1.0.74

package/dist/plugin/server.js

@@ -3777,7 +3777,7 @@ import { fileURLToPath } from "url";
 import { createHash } from "crypto";
 import { tmpdir } from "os";
 import { execFile } from "child_process";
-var PLUGIN_VERSION = "1.0.71";
+var PLUGIN_VERSION = "1.0.74";
 var PLUGIN_PACKAGE_NAME = "opencode-immune";
 var PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -3855,6 +3855,7 @@ function createState(input) {
     ultraworkPermissionSessions: /* @__PURE__ */ new Set(),
     fallbackAgentByAgent: /* @__PURE__ */ new Map(),
     baseAgentByFallbackAgent: /* @__PURE__ */ new Map(),
+    fallbackModelCandidates: [],
     ultraworkMarkerPath: join(
       input.directory,
       ".opencode",
@@ -3911,20 +3912,15 @@ var MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var PROVIDER_RETRY_WATCHDOG_MS = 3e4;
 var RETRY_PROMPT_DELIVERY_ATTEMPTS = 3;
 var CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1e3;
-var RATE_LIMIT_FALLBACK_MODEL = {
-  providerID: "codexsale",
-  modelID: "gpt-5.4-mini"
-};
-var CHILD_SESSION_FALLBACK_MODEL = {
-  providerID: "claudehub",
-  modelID: "claude-opus-4-7"
-};
 var AUTO_CYCLE_LOCK_TTL_MS = 30 * 60 * 1e3;
-var FALLBACK_MODEL_CANDIDATES = [
-  CHILD_SESSION_FALLBACK_MODEL,
-  RATE_LIMIT_FALLBACK_MODEL,
-  { providerID: "codexsale", modelID: "gpt-5.5" }
-];
+var MODEL_NAME_CAPABILITY_SCORE = {
+  "claude-opus-4-7": 100,
+  "gpt-5.5": 100,
+  "gpt-5.4": 90,
+  "claude-sonnet-4-6": 90,
+  "gpt-5.4-mini": 50,
+  "claude-haiku-4-5": 50
+};
 var FALLBACK_AGENT_SUFFIX = "-provider-fallback";
 function isManagedUltraworkSession(state, sessionID) {
   return !!sessionID && state.managedUltraworkSessions.has(sessionID);
@@ -4208,15 +4204,57 @@ function isSameModel(a, b) {
   if (!a || !b) return false;
   return a.providerID === b.providerID && a.modelID === b.modelID;
 }
-function selectFallbackModel(currentModel) {
+function getModelCapabilityScore(model) {
+  if (!model) return 90;
+  const modelID = model.modelID.toLowerCase();
+  const explicitScore = MODEL_NAME_CAPABILITY_SCORE[modelID];
+  if (explicitScore !== void 0) return explicitScore;
+  if (/\b(mini|nano|small|lite|haiku|flash)\b/i.test(modelID)) return 50;
+  if (/\b(opus|gpt-5\.5|gpt-5\.4|o3|o4|gpt-4\.1|gpt-4o)\b/i.test(modelID)) return 90;
+  return 70;
+}
+function getMinimumFallbackCapabilityScore(currentModel) {
+  const currentScore = getModelCapabilityScore(currentModel);
+  if (currentScore >= 90) return 90;
+  if (currentScore >= 70) return 70;
+  return 0;
+}
+function sortFallbackModelsByCapability(candidates, currentModel) {
+  const currentScore = getModelCapabilityScore(currentModel);
+  const minimumScore = getMinimumFallbackCapabilityScore(currentModel);
+  return [...candidates].sort((a, b) => {
+    const aScore = getModelCapabilityScore(a);
+    const bScore = getModelCapabilityScore(b);
+    const aAllowed = aScore >= minimumScore ? 0 : 1;
+    const bAllowed = bScore >= minimumScore ? 0 : 1;
+    if (aAllowed !== bAllowed) return aAllowed - bAllowed;
+    const aDirectionPenalty = aScore >= currentScore ? 0 : 1;
+    const bDirectionPenalty = bScore >= currentScore ? 0 : 1;
+    if (aDirectionPenalty !== bDirectionPenalty) {
+      return aDirectionPenalty - bDirectionPenalty;
+    }
+    const aSameModelName = currentModel && a.modelID === currentModel.modelID ? 0 : 1;
+    const bSameModelName = currentModel && b.modelID === currentModel.modelID ? 0 : 1;
+    if (aSameModelName !== bSameModelName) return aSameModelName - bSameModelName;
+    const aDistance = Math.abs(aScore - currentScore);
+    const bDistance = Math.abs(bScore - currentScore);
+    if (aDistance !== bDistance) return aDistance - bDistance;
+    return bScore - aScore;
+  });
+}
+function selectFallbackModel(state, currentModel) {
   const currentProviderID = getModelProviderID(currentModel);
-  const otherProviderModel = FALLBACK_MODEL_CANDIDATES.find(
-    (candidate) => !isSameModel(candidate, currentModel) && getModelProviderID(candidate) !== currentProviderID
+  const fallbackCandidates = state.fallbackModelCandidates.filter(
+    (candidate) => !isSameModel(candidate, currentModel)
   );
+  const otherProviderModel = sortFallbackModelsByCapability(
+    fallbackCandidates.filter(
+      (candidate) => getModelProviderID(candidate) !== currentProviderID
+    ),
+    currentModel
+  )[0];
   if (otherProviderModel) return otherProviderModel;
-  return FALLBACK_MODEL_CANDIDATES.find(
-    (candidate) => !isSameModel(candidate, currentModel)
-  ) ?? RATE_LIMIT_FALLBACK_MODEL;
+  return sortFallbackModelsByCapability(fallbackCandidates, currentModel)[0];
 }
 function getFailedModelFromError(error) {
   if (!error || typeof error !== "object") return void 0;
@@ -4229,13 +4267,6 @@ function getFailedModelFromError(error) {
       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 void 0;
 }
 async function updateManagedSessionModel(state, sessionID, model) {
@@ -4252,7 +4283,7 @@ function getSessionFallbackModel(state, sessionID, preferredModel) {
   if (preferredModel && !isSameModel(preferredModel, currentModel)) {
     return preferredModel;
   }
-  return selectFallbackModel(currentModel);
+  return selectFallbackModel(state, currentModel);
 }
 function getFallbackAgentForAgent(state, agent) {
   return state.fallbackAgentByAgent.get(agent) ?? agent;
@@ -4389,8 +4420,10 @@ async function recoverUntrackedRootSessionForActiveTask(state, sessionID, reason
 }
 function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
   const fallbackModel = selectFallbackModel(
+    state,
     getFailedModelFromError(error) ?? managedSession.currentModel
   );
+  if (!fallbackModel) return;
   const routerSessionID = getRouterSessionIDForChild(managedSession);
   const request = {
     childSessionID,
@@ -4421,6 +4454,7 @@ function scheduleProviderRetryWatchdog(state, sessionID, model) {
     if (!isManagedRootUltraworkSession(state, sessionID)) return;
     if (state.sessionRetryTimers.has(sessionID)) return;
     const fallbackModel = getSessionFallbackModel(state, sessionID, model);
+    if (!fallbackModel) return;
     await setSessionFallbackModel(state, sessionID, fallbackModel);
     await writeDiagnosticLog(state, "provider-retry-watchdog:fired", {
       sessionID,
@@ -4652,6 +4686,36 @@ function parseModelRef(model) {
   if (!providerID || !modelID) return void 0;
   return { providerID, modelID };
 }
+function addFallbackModelCandidate(candidates, model) {
+  const parsed = parseModelRef(model);
+  if (!parsed) return;
+  candidates.set(modelRefToString(parsed).toLowerCase(), parsed);
+}
+function collectFallbackModelCandidates(config) {
+  const candidates = /* @__PURE__ */ new Map();
+  addFallbackModelCandidate(candidates, config.model);
+  addFallbackModelCandidate(candidates, config.small_model);
+  for (const agentConfig of Object.values(config.agent ?? {})) {
+    if (!isRecord(agentConfig)) continue;
+    const model = agentConfig.model;
+    if (typeof model === "string") addFallbackModelCandidate(candidates, model);
+  }
+  const enabledProviders = new Set(config.enabled_providers ?? []);
+  const disabledProviders = new Set(config.disabled_providers ?? []);
+  const isProviderEnabled = (providerID) => {
+    if (enabledProviders.size > 0 && !enabledProviders.has(providerID)) return false;
+    return !disabledProviders.has(providerID);
+  };
+  for (const [providerID, providerConfig] of Object.entries(config.provider ?? {})) {
+    if (!isProviderEnabled(providerID) || !isRecord(providerConfig)) continue;
+    const models = providerConfig.models;
+    if (!isRecord(models)) continue;
+    for (const modelID of Object.keys(models)) {
+      addFallbackModelCandidate(candidates, `${providerID}/${modelID}`);
+    }
+  }
+  return sortFallbackModelsByCapability([...candidates.values()]);
+}
 function canCreateFallbackForAgent(agentID, agentConfig) {
   if (agentID.endsWith(FALLBACK_AGENT_SUFFIX)) return false;
   if (!isRecord(agentConfig)) return false;
@@ -4682,11 +4746,12 @@ function allowFallbackAgentInTaskPermissions(config, baseAgentID, fallbackAgentI
 function createConfigHandler(state) {
   return async (config) => {
     if (!config.agent) return;
+    state.fallbackModelCandidates = collectFallbackModelCandidates(config);
     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 fallbackModel = selectFallbackModel(state, baseModel);
+      if (!baseModel || !fallbackModel || isSameModel(baseModel, fallbackModel)) continue;
       const fallbackAgentID = `${agentID}${FALLBACK_AGENT_SUFFIX}`;
       if (config.agent[fallbackAgentID]) continue;
       config.agent[fallbackAgentID] = {
@@ -5499,9 +5564,12 @@ function createEventHandler(state) {
           state.sessionErrorRetryCount.set(fallbackSessionID, count + 1);
           if (shouldUseFallbackForManagedError(error, managedSession, count)) {
             const fallbackModel = selectFallbackModel(
+              state,
               getFailedModelFromError(error) ?? managedSession.currentModel
             );
-            await setSessionFallbackModel(state, fallbackSessionID, fallbackModel);
+            if (fallbackModel) {
+              await setSessionFallbackModel(state, fallbackSessionID, fallbackModel);
+            }
           }
           pluginLog.warn(
             `[opencode-immune] session.error without sessionID matched retryable error. Retrying sole managed root session ${fallbackSessionID}.`
@@ -5557,8 +5625,10 @@ function createEventHandler(state) {
           return;
         } else if (isRoot && shouldUseFallbackForManagedError(error, managedSession, count)) {
           const selectedFallbackModel = selectFallbackModel(
+            state,
             getFailedModelFromError(error) ?? managedSession.currentModel
           );
+          if (!selectedFallbackModel) return;
           await setSessionFallbackModel(state, sessionID, selectedFallbackModel);
           const errorType = getRetryableErrorType(error);
           pluginLog.info(
@@ -5705,6 +5775,7 @@ function createTextCompleteHandler(state) {
     cancelProviderRetryWatchdog(state, sessionID, "assistant text completed");
     if (isProviderRetryBanner(text) && isManagedRootSession) {
       const fallbackModel = getSessionFallbackModel(state, sessionID);
+      if (!fallbackModel) return;
       await setSessionFallbackModel(state, sessionID, fallbackModel);
       scheduleManagedSessionRetry(state, sessionID, {
         delayMs: 1e3,
@@ -5831,6 +5902,7 @@ function createMultiCycleHandler(state) {
     if (sessionID && RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
       if (managedSession && !managedSession.fallbackModel) {
         const fallbackModel = getSessionFallbackModel(state, sessionID);
+        if (!fallbackModel) return;
         await setSessionFallbackModel(state, sessionID, fallbackModel);
         pluginLog.info(
           `[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. Fallback model pinned to ${fallbackModel.providerID}/${fallbackModel.modelID}.`

package/package.json

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