@skj1724/oh-my-opencode 3.19.6 → 3.19.8

package/dist/index.js

@@ -4859,7 +4859,7 @@ var init_agent_tool_restrictions = __esm(() => {
 });
 
 // src/shared/model-requirements.ts
-var AGENT_MODEL_REQUIREMENTS;
+var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
 var init_model_requirements = __esm(() => {
   AGENT_MODEL_REQUIREMENTS = {
     sisyphus: {
@@ -4928,6 +4928,58 @@ var init_model_requirements = __esm(() => {
       ]
     }
   };
+  CATEGORY_MODEL_REQUIREMENTS = {
+    "visual-engineering": {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" }
+      ]
+    },
+    ultrabrain: {
+      fallbackChain: [
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "xhigh" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    artistry: {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
+      ]
+    },
+    quick: {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+        { providers: ["opencode"], model: "gpt-5-nano" }
+      ]
+    },
+    "unspecified-low": {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "medium" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }
+      ]
+    },
+    "unspecified-high": {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    writing: {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
+        { providers: ["zai-coding-plan"], model: "glm-4.7" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
+      ]
+    }
+  };
 });
 
 // src/shared/model-availability.ts
@@ -5064,6 +5116,99 @@ var init_model_resolver = __esm(() => {
   init_model_availability();
 });
 
+// src/shared/runtime-fallback.ts
+function expandChain(chain) {
+  const candidates = [];
+  for (const entry of chain) {
+    for (const provider of entry.providers) {
+      candidates.push({
+        providerID: provider,
+        modelID: entry.model,
+        variant: entry.variant
+      });
+    }
+  }
+  return candidates;
+}
+function modelKey(m) {
+  return `${m.providerID}/${m.modelID}`;
+}
+function getChain(agent, category) {
+  if (agent && AGENT_MODEL_REQUIREMENTS[agent]) {
+    return AGENT_MODEL_REQUIREMENTS[agent].fallbackChain;
+  }
+  if (category && CATEGORY_MODEL_REQUIREMENTS[category]) {
+    return CATEGORY_MODEL_REQUIREMENTS[category].fallbackChain;
+  }
+  return;
+}
+function resolveNextFallbackModel(input) {
+  const {
+    agent,
+    category,
+    currentModel,
+    attempts,
+    availableModels,
+    lastErrorClassification,
+    configuredFallbackModels,
+    maxAttempts
+  } = input;
+  if (maxAttempts !== undefined && attempts.length >= maxAttempts) {
+    return {
+      kind: "exhausted",
+      attempts,
+      reason: "max fallback attempts reached",
+      lastErrorClassification
+    };
+  }
+  const chain = getChain(agent, category);
+  const candidates = configuredFallbackModels && configuredFallbackModels.length > 0 ? configuredFallbackModels : chain ? expandChain(chain) : undefined;
+  if (!candidates) {
+    return {
+      kind: "unconfigured",
+      reason: `No fallback chain found for agent="${agent ?? ""}" category="${category ?? ""}"`
+    };
+  }
+  const skipKeys = new Set;
+  skipKeys.add(modelKey(currentModel));
+  for (const a of attempts) {
+    skipKeys.add(modelKey(a.model));
+  }
+  const skipped = [];
+  const hasAvailabilityFilter = availableModels != null && availableModels.size > 0;
+  for (const candidate of candidates) {
+    const key = modelKey(candidate);
+    if (skipKeys.has(key)) {
+      skipped.push({ model: candidate, reason: "already attempted or current model" });
+      continue;
+    }
+    if (hasAvailabilityFilter) {
+      const match = fuzzyMatchModel(key, availableModels, [candidate.providerID]);
+      if (!match) {
+        skipped.push({ model: candidate, reason: "model unavailable" });
+        continue;
+      }
+    }
+    return {
+      kind: "next",
+      model: candidate,
+      attempts,
+      skipped
+    };
+  }
+  return {
+    kind: "exhausted",
+    attempts,
+    reason: "No fallback candidates available",
+    skipped,
+    lastErrorClassification
+  };
+}
+var init_runtime_fallback = __esm(() => {
+  init_model_availability();
+  init_model_requirements();
+});
+
 // src/shared/perf-timer.ts
 class PerfTimer {
   marks = new Map;
@@ -5348,6 +5493,7 @@ var init_shared = __esm(() => {
   init_model_requirements();
   init_model_resolver();
   init_model_availability();
+  init_runtime_fallback();
   init_perf_tracer();
   init_fileio_monitor();
   init_windows_reserved_names();
@@ -24501,6 +24647,450 @@ function createPerfProfilerHook(options) {
     "chat.message": async () => {}
   };
 }
+// src/shared/provider-error-classifier.ts
+function extractErrorInfo(error) {
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (error instanceof Error) {
+    const anyErr = error;
+    return {
+      statusCode: anyErr.status ?? anyErr.statusCode ?? anyErr.httpStatus,
+      code: anyErr.code ?? anyErr.error?.code,
+      type: anyErr.type ?? anyErr.error?.type,
+      message: error.message,
+      status: anyErr.status ?? anyErr.error?.status,
+      headers: anyErr.headers
+    };
+  }
+  if (typeof error === "object" && error !== null) {
+    const obj = error;
+    const inner = obj.error ?? {};
+    return {
+      statusCode: obj.status ?? obj.statusCode ?? inner.status,
+      code: inner.code ?? obj.code,
+      type: inner.type ?? obj.type,
+      message: inner.message ?? obj.message ?? String(error),
+      status: inner.status ?? obj.status,
+      headers: obj.headers
+    };
+  }
+  return { message: String(error) };
+}
+function parseRetryAfterMs(headers) {
+  if (!headers)
+    return;
+  const retryAfter = headers["retry-after"] ?? headers["Retry-After"];
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (!isNaN(seconds) && seconds > 0) {
+      return seconds * 1000;
+    }
+  }
+  const reset = headers["x-ratelimit-reset"] ?? headers["X-Ratelimit-Reset"];
+  if (reset) {
+    const resetTimestamp = Number(reset);
+    if (!isNaN(resetTimestamp)) {
+      const resetMs = resetTimestamp > 1000000000000 ? resetTimestamp : resetTimestamp * 1000;
+      const delayMs = resetMs - Date.now();
+      return delayMs > 0 ? delayMs : 0;
+    }
+  }
+  return;
+}
+function isContextOverflow(message, code) {
+  const lowerMessage = message.toLowerCase();
+  return lowerMessage.includes("context_length_exceeded") || lowerMessage.includes("prompt is too long") || lowerMessage.includes("maximum context length") || code === "context_length_exceeded";
+}
+function isZhipuQuotaCode(code) {
+  if (typeof code !== "number")
+    return false;
+  return [1113, 1304, 1308, 1309].includes(code);
+}
+function isZhipuRateLimitCode(code) {
+  if (typeof code !== "number")
+    return false;
+  return [1302, 1303].includes(code);
+}
+function isZhipuOverloadedCode(code) {
+  if (typeof code !== "number")
+    return false;
+  return code === 1312;
+}
+function isGeminiQuotaDetails(details) {
+  if (!Array.isArray(details))
+    return false;
+  return details.some((d) => d?.["@type"]?.includes("QuotaFailure") || d?.["@type"]?.includes("google.rpc.QuotaFailure"));
+}
+function isGeminiPerMinuteLimit(message, details) {
+  const lowerMessage = message.toLowerCase();
+  if (lowerMessage.includes("per_minute") || lowerMessage.includes("per minute")) {
+    return true;
+  }
+  if (Array.isArray(details)) {
+    return details.some((d) => d?.["@type"]?.includes("RetryInfo"));
+  }
+  return false;
+}
+function classifyProviderError(error) {
+  const info = extractErrorInfo(error);
+  const { statusCode, code, type: type2, message, status, headers } = info;
+  if (isContextOverflow(message, code)) {
+    return {
+      category: "context_overflow",
+      retryable: false,
+      shouldFallback: false,
+      statusCode,
+      reason: "Context length exceeded, prompt too long for model"
+    };
+  }
+  if (statusCode === 401 || statusCode === 403) {
+    return {
+      category: "auth",
+      retryable: false,
+      shouldFallback: false,
+      statusCode,
+      reason: statusCode === 401 ? "Invalid API key or authentication" : "Permission denied"
+    };
+  }
+  const lowerMessage = message.toLowerCase();
+  const isModelUnavailableMessage = lowerMessage.includes("model not found") || lowerMessage.includes("model unavailable") || lowerMessage.includes("unsupported model") || lowerMessage.includes("invalid model") || lowerMessage.includes("unknown model");
+  const isProviderUnavailableMessage = lowerMessage.includes("provider not found") || lowerMessage.includes("unknown provider") || lowerMessage.includes("invalid provider");
+  if (isProviderUnavailableMessage && (statusCode === 400 || statusCode === 404 || statusCode === 422)) {
+    return {
+      category: "provider_unavailable",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      reason: `Provider unavailable: ${message.substring(0, 100)}`
+    };
+  }
+  if (isModelUnavailableMessage && (statusCode === 400 || statusCode === 404 || statusCode === 422)) {
+    return {
+      category: "model_unavailable",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      reason: `Model unavailable: ${message.substring(0, 100)}`
+    };
+  }
+  if (statusCode === 404) {
+    return {
+      category: "model_unavailable",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      reason: `Model not found (404): ${message.substring(0, 100)}`
+    };
+  }
+  if (statusCode === 400) {
+    return {
+      category: "bad_request",
+      retryable: false,
+      shouldFallback: false,
+      statusCode,
+      reason: "Invalid request parameters"
+    };
+  }
+  if (statusCode === 429 && (code === "insufficient_quota" || type2 === "insufficient_quota")) {
+    return {
+      category: "quota",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      providerGuess: "openai",
+      reason: "OpenAI quota exceeded, billing issue"
+    };
+  }
+  if (statusCode === 402 && type2 === "billing_error") {
+    return {
+      category: "quota",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      providerGuess: "anthropic",
+      reason: "Anthropic billing error, payment required"
+    };
+  }
+  if (statusCode === 429 && status === "RESOURCE_EXHAUSTED" && isGeminiQuotaDetails(info.headers ? undefined : error?.error?.details)) {
+    return {
+      category: "quota",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      providerGuess: "gemini",
+      reason: "Gemini daily quota exceeded"
+    };
+  }
+  if (statusCode === 429 && isZhipuQuotaCode(code)) {
+    const quotaReasons = {
+      1113: "\u8D26\u6237\u6B20\u8D39",
+      1304: "\u8C03\u7528\u6B21\u6570\u8D85\u8FC7\u9650\u989D",
+      1308: "\u4F7F\u7528\u91CF\u8D85\u8FC7\u4E0A\u9650",
+      1309: "\u5957\u9910\u5DF2\u5230\u671F"
+    };
+    return {
+      category: "quota",
+      retryable: false,
+      shouldFallback: true,
+      statusCode,
+      providerGuess: "zhipu",
+      reason: `Zhipu/GLM: ${quotaReasons[code] ?? "quota exceeded"}`
+    };
+  }
+  if (statusCode === 529 && type2 === "overloaded_error") {
+    return {
+      category: "overloaded",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      providerGuess: "anthropic",
+      reason: "Anthropic API overloaded"
+    };
+  }
+  if (statusCode === 429 && isZhipuOverloadedCode(code)) {
+    return {
+      category: "overloaded",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      providerGuess: "zhipu",
+      reason: "Zhipu/GLM: \u5F53\u524D\u8D1F\u8F7D\u8FC7\u9AD8"
+    };
+  }
+  if (statusCode === 429 && type2 === "rate_limit_error") {
+    return {
+      category: "rate_limit",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      providerGuess: "anthropic",
+      retryAfterMs: parseRetryAfterMs(headers),
+      reason: "Anthropic rate limit exceeded"
+    };
+  }
+  if (statusCode === 429 && code === "rate_limit_exceeded") {
+    return {
+      category: "rate_limit",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      providerGuess: "openai",
+      retryAfterMs: parseRetryAfterMs(headers),
+      reason: "OpenAI rate limit exceeded"
+    };
+  }
+  if (statusCode === 429 && status === "RESOURCE_EXHAUSTED" && isGeminiPerMinuteLimit(message, error?.error?.details)) {
+    return {
+      category: "rate_limit",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      providerGuess: "gemini",
+      retryAfterMs: parseRetryAfterMs(headers),
+      reason: "Gemini per-minute rate limit exceeded"
+    };
+  }
+  if (statusCode === 429 && isZhipuRateLimitCode(code)) {
+    const rateLimitReasons = {
+      1302: "\u5E76\u53D1\u8BF7\u6C42\u8D85\u8FC7\u9650\u5236",
+      1303: "\u8BF7\u6C42\u9891\u7387\u8D85\u8FC7\u9650\u5236"
+    };
+    return {
+      category: "rate_limit",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      providerGuess: "zhipu",
+      retryAfterMs: parseRetryAfterMs(headers),
+      reason: `Zhipu/GLM: ${rateLimitReasons[code] ?? "rate limit exceeded"}`
+    };
+  }
+  if (statusCode === 429) {
+    return {
+      category: "rate_limit",
+      retryable: true,
+      shouldFallback: false,
+      statusCode,
+      retryAfterMs: parseRetryAfterMs(headers),
+      reason: "Rate limit exceeded (generic 429)"
+    };
+  }
+  return {
+    category: "unknown",
+    retryable: false,
+    shouldFallback: false,
+    statusCode,
+    reason: `Unknown error: ${message.substring(0, 100)}`
+  };
+}
+
+// src/shared/retry-strategy.ts
+var DEFAULT_RETRY_CONFIG = {
+  max_attempts: 3,
+  initial_delay_ms: 1000,
+  backoff_factor: 2,
+  max_delay_ms: 30000,
+  jitter: true,
+  respect_retry_after: true
+};
+function calculateRetryDelay(attempt, config, retryAfterMs) {
+  if (attempt >= config.max_attempts) {
+    return {
+      retryable: false,
+      delay_ms: 0,
+      attempt,
+      reason: `max attempts (${config.max_attempts}) reached`
+    };
+  }
+  const exponentialDelay = config.initial_delay_ms * Math.pow(config.backoff_factor, attempt);
+  let baseDelay;
+  let reason;
+  if (config.respect_retry_after && retryAfterMs !== undefined && retryAfterMs > 0) {
+    baseDelay = retryAfterMs;
+    reason = "Retry-After";
+  } else {
+    baseDelay = exponentialDelay;
+    reason = "exponential backoff";
+  }
+  baseDelay = Math.min(baseDelay, config.max_delay_ms);
+  let finalDelay;
+  if (config.jitter) {
+    const jitterRange = baseDelay * 0.5;
+    finalDelay = baseDelay + (Math.random() * 2 - 1) * jitterRange;
+    finalDelay = Math.max(0, finalDelay);
+  } else {
+    finalDelay = baseDelay;
+  }
+  return {
+    retryable: true,
+    delay_ms: Math.round(finalDelay),
+    attempt,
+    reason
+  };
+}
+
+// src/hooks/runtime-fallback/index.ts
+init_logger();
+init_runtime_fallback();
+function createRuntimeFallbackHook(ctx, options) {
+  const retryStates = new Map;
+  const fallbackAttempts = new Map;
+  const config = options?.config ?? {
+    enabled: true,
+    max_attempts: 3,
+    initial_delay_ms: DEFAULT_RETRY_CONFIG.initial_delay_ms,
+    backoff_factor: DEFAULT_RETRY_CONFIG.backoff_factor,
+    max_delay_ms: DEFAULT_RETRY_CONFIG.max_delay_ms,
+    respect_retry_after: DEFAULT_RETRY_CONFIG.respect_retry_after,
+    jitter: DEFAULT_RETRY_CONFIG.jitter
+  };
+  const handler = async ({
+    event
+  }) => {
+    if (!config.enabled)
+      return false;
+    if (event.type === "session.deleted") {
+      const props2 = event.properties;
+      const info = props2?.info;
+      const sessionID2 = info?.id ?? props2?.sessionID;
+      if (sessionID2) {
+        retryStates.delete(sessionID2);
+        fallbackAttempts.delete(sessionID2);
+      }
+      return false;
+    }
+    if (event.type !== "session.error")
+      return false;
+    const props = event.properties;
+    const sessionID = props?.sessionID;
+    const error = props?.error;
+    if (!sessionID || error === undefined || error === null)
+      return false;
+    if (options?.sessionRecovery?.isRecoverableError(error)) {
+      return false;
+    }
+    const classification = classifyProviderError(error);
+    if (classification.category === "context_overflow") {
+      return false;
+    }
+    if (classification.category === "auth" || classification.category === "bad_request") {
+      return false;
+    }
+    if (classification.category === "rate_limit") {
+      const state2 = retryStates.get(sessionID) ?? { attempt: 0, lastAttemptTime: Date.now() };
+      const decision = calculateRetryDelay(state2.attempt, config, classification.retryAfterMs);
+      if (decision.retryable) {
+        retryStates.set(sessionID, {
+          attempt: state2.attempt + 1,
+          lastAttemptTime: Date.now()
+        });
+        await new Promise((resolve8) => setTimeout(resolve8, decision.delay_ms));
+        return false;
+      }
+      retryStates.delete(sessionID);
+    }
+    if (classification.category !== "quota" && classification.category !== "rate_limit") {
+      return false;
+    }
+    let currentModel = { providerID: "", modelID: "" };
+    let agent = props?.agent;
+    const category = props?.category;
+    try {
+      const messagesResp = await ctx.client.session.messages?.({ path: { id: sessionID } });
+      const messages = messagesResp?.data ?? [];
+      for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+        const info = messages[i2].info;
+        if (!agent && info?.agent)
+          agent = info.agent;
+        const msgModel = info?.model;
+        if (msgModel?.providerID && msgModel?.modelID) {
+          currentModel = { providerID: msgModel.providerID, modelID: msgModel.modelID };
+          break;
+        }
+        if (info?.providerID && info?.modelID) {
+          currentModel = { providerID: info.providerID, modelID: info.modelID };
+          break;
+        }
+      }
+    } catch (messageReadError) {
+      log("[runtime-fallback] failed to read session messages", { sessionID, error: String(messageReadError) });
+    }
+    agent ??= "sisyphus";
+    const attempts = fallbackAttempts.get(sessionID) ?? [];
+    const fallbackResult = resolveNextFallbackModel({
+      agent,
+      category,
+      currentModel,
+      attempts,
+      configuredFallbackModels: options?.getConfiguredFallbackModels?.(agent, category),
+      maxAttempts: config.max_attempts,
+      lastErrorClassification: classification
+    });
+    if (fallbackResult.kind !== "next") {
+      return false;
+    }
+    try {
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          model: fallbackResult.model,
+          parts: [{ type: "text", text: "continue" }]
+        },
+        query: { directory: ctx.directory }
+      });
+      fallbackAttempts.delete(sessionID);
+      return true;
+    } catch (fallbackError) {
+      fallbackAttempts.set(sessionID, [
+        ...attempts,
+        { model: fallbackResult.model, error: classifyProviderError(fallbackError) }
+      ]);
+      return false;
+    }
+  };
+  return { handler };
+}
 // src/features/context-injector/collector.ts
 var PRIORITY_ORDER = {
   critical: 0,
@@ -43257,6 +43847,7 @@ function initTaskToastManager(client2, concurrencyManager) {
 }
 // src/tools/delegate-task/tools.ts
 init_shared();
+init_runtime_fallback();
 var SISYPHUS_JUNIOR_AGENT = "sisyphus-junior";
 function parseModelString(model) {
   const parts = model.split("/");
@@ -43265,6 +43856,19 @@ function parseModelString(model) {
   }
   return;
 }
+function parseFallbackModelEntries(entries) {
+  return entries?.map((entry) => {
+    if ("model" in entry) {
+      const parsed = parseModelString(entry.model);
+      return {
+        providerID: parsed?.providerID ?? "",
+        modelID: parsed?.modelID ?? entry.model,
+        variant: entry.variant
+      };
+    }
+    return entry;
+  });
+}
 function getMessageDir9(sessionID) {
   if (!existsSync48(MESSAGE_STORAGE))
     return null;
@@ -43354,8 +43958,15 @@ ${categoryPromptAppend}`;
   return skillContent || categoryPromptAppend;
 }
 function createDelegateTask(options) {
-  const { manager, client: client2, directory, userCategories, gitMasterConfig, sisyphusJuniorModel } = options;
+  const { manager, client: client2, directory, userCategories, gitMasterConfig, sisyphusJuniorModel, runtimeFallbackConfig, agentFallbackModels } = options;
   const allCategories = { ...DEFAULT_CATEGORIES, ...userCategories };
+  const getConfiguredFallbackModels = (agent, category) => {
+    const agentModels = agent ? agentFallbackModels?.[agent] : undefined;
+    if (agentModels)
+      return parseFallbackModelEntries(agentModels);
+    const categoryModels = category ? userCategories?.[category]?.fallback_models : undefined;
+    return parseFallbackModelEntries(categoryModels);
+  };
   const categoryNames = Object.keys(allCategories);
   const categoryExamples = categoryNames.map((k) => `'${k}'`).join(", ");
   const categoryList = categoryNames.map((name) => {
@@ -43684,6 +44295,7 @@ ${textContent || "(\u65E0\u6587\u672C\u8F93\u51FA)"}
             parentMessageID: ctx.messageID,
             parentModel,
             parentAgent,
+            category: args.category,
             model: categoryModel,
             skills: args.load_skills.length > 0 ? args.load_skills : undefined,
             skillContent: systemContent
@@ -43784,26 +44396,85 @@ Status: ${task.status}
             }
           });
         } catch (promptError) {
-          if (toastManager && taskId !== undefined) {
-            toastManager.removeTask(taskId);
-          }
-          const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
-          if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-            return formatDetailedError(new Error(`Agent "${agentToUse}" \u672A\u627E\u5230\u3002\u8BF7\u786E\u8BA4\u8BE5 agent \u5DF2\u5728 opencode.json \u4E2D\u6CE8\u518C\u6216\u7531\u63D2\u4EF6\u63D0\u4F9B\u3002`), {
-              operation: "\u53D1\u9001 prompt \u7ED9 agent",
+          const classification = classifyProviderError(promptError);
+          const canFallback = runtimeFallbackConfig?.enabled !== false && (classification.retryable || classification.shouldFallback);
+          if (canFallback) {
+            const attempts = [];
+            let fallbackSucceeded = false;
+            let currentModel = categoryModel ?? { providerID: "", modelID: "" };
+            let currentClassification = classification;
+            while (true) {
+              const fallbackResult = resolveNextFallbackModel({
+                agent: agentToUse,
+                category: args.category,
+                currentModel,
+                attempts,
+                configuredFallbackModels: getConfiguredFallbackModels(agentToUse, args.category),
+                maxAttempts: runtimeFallbackConfig?.max_attempts,
+                lastErrorClassification: currentClassification
+              });
+              if (fallbackResult.kind !== "next")
+                break;
+              try {
+                await client2.session.prompt({
+                  path: { id: sessionID },
+                  body: {
+                    agent: agentToUse,
+                    system: systemContent,
+                    tools: {
+                      task: false,
+                      delegate_task: false,
+                      call_omo_agent: true
+                    },
+                    parts: [{ type: "text", text: args.prompt }],
+                    model: fallbackResult.model
+                  }
+                });
+                fallbackSucceeded = true;
+                break;
+              } catch (fallbackError) {
+                currentClassification = classifyProviderError(fallbackError);
+                attempts.push({ model: fallbackResult.model, error: currentClassification });
+                currentModel = fallbackResult.model;
+                if (!currentClassification.retryable && !currentClassification.shouldFallback) {
+                  throw fallbackError;
+                }
+              }
+            }
+            if (!fallbackSucceeded) {
+              if (toastManager && taskId !== undefined) {
+                toastManager.removeTask(taskId);
+              }
+              return formatDetailedError(promptError, {
+                operation: "\u53D1\u9001 prompt",
+                args,
+                sessionID,
+                agent: agentToUse,
+                category: args.category
+              });
+            }
+          } else {
+            if (toastManager && taskId !== undefined) {
+              toastManager.removeTask(taskId);
+            }
+            const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
+            if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
+              return formatDetailedError(new Error(`Agent "${agentToUse}" \u672A\u627E\u5230\u3002\u8BF7\u786E\u8BA4\u8BE5 agent \u5DF2\u5728 opencode.json \u4E2D\u6CE8\u518C\u6216\u7531\u63D2\u4EF6\u63D0\u4F9B\u3002`), {
+                operation: "\u53D1\u9001 prompt \u7ED9 agent",
+                args,
+                sessionID,
+                agent: agentToUse,
+                category: args.category
+              });
+            }
+            return formatDetailedError(promptError, {
+              operation: "\u53D1\u9001 prompt",
               args,
               sessionID,
               agent: agentToUse,
               category: args.category
             });
           }
-          return formatDetailedError(promptError, {
-            operation: "\u53D1\u9001 prompt",
-            args,
-            sessionID,
-            agent: agentToUse,
-            category: args.category
-          });
         }
         const POLL_INTERVAL_MS = 500;
         const MAX_POLL_TIME_MS = 10 * 60 * 1000;
@@ -43868,7 +44539,12 @@ Session ID: ${sessionID}`;
           path: { id: sessionID }
         });
         if (messagesResult.error) {
-          return `Error fetching result: ${messagesResult.error}
+          const classification = classifyProviderError(messagesResult.error);
+          const diagnosis = classification.category !== "unknown" ? `
+
+\uD83D\uDD0D **\u9519\u8BEF\u5206\u7C7B**: ${classification.reason}
+${classification.shouldFallback ? "\uD83D\uDCA1 \u6B64\u9519\u8BEF\u7B26\u5408 runtime fallback \u6761\u4EF6\u3002" : classification.retryable ? "\u23F3 \u6B64\u9519\u8BEF\u53EF\u91CD\u8BD5\u3002" : ""}` : "";
+          return `Error fetching result: ${messagesResult.error}${diagnosis}
 
 Session ID: ${sessionID}`;
         }
@@ -43906,13 +44582,14 @@ ${textContent || "(\u65E0\u6587\u672C\u8F93\u51FA)"}
         if (syncSessionID) {
           subagentSessions.delete(syncSessionID);
         }
-        return formatDetailedError(error45, {
-          operation: "\u6267\u884C\u4EFB\u52A1",
-          args,
-          sessionID: syncSessionID,
-          agent: agentToUse,
-          category: args.category
-        });
+        const classification = classifyProviderError(error45);
+        const diagnosis = classification.category !== "unknown" ? `
+
+\uD83D\uDD0D **\u9519\u8BEF\u5206\u7C7B**: ${classification.reason}
+${classification.shouldFallback ? "\uD83D\uDCA1 \u6B64\u9519\u8BEF\u7B26\u5408 runtime fallback \u6761\u4EF6\u3002" : classification.retryable ? "\u23F3 \u6B64\u9519\u8BEF\u53EF\u91CD\u8BD5\u3002" : ""}` : "";
+        return `\u4EFB\u52A1\u6267\u884C\u5931\u8D25: ${error45 instanceof Error ? error45.message : String(error45)}${diagnosis}
+
+Session ID: ${syncSessionID ?? "unknown"}`;
       }
     }
   });
@@ -44041,6 +44718,9 @@ class ConcurrencyManager {
   }
 }
 
+// src/features/background-agent/manager.ts
+init_runtime_fallback();
+
 // src/features/background-agent/perf-aggregator.ts
 function percentile(sorted, p) {
   if (sorted.length === 0)
@@ -44161,6 +44841,7 @@ class BackgroundManager {
       parentMessageID: input.parentMessageID,
       parentModel: input.parentModel,
       parentAgent: input.parentAgent,
+      category: input.category,
       model: input.model,
       maxSteps: this.config?.maxSteps,
       maxRuntimeMs: this.config?.maxRuntimeMs,
@@ -44289,27 +44970,79 @@ class BackgroundManager {
         },
         parts: [{ type: "text", text: input.prompt }]
       }
-    }).catch((error45) => {
-      log("[background-agent] promptAsync error:", error45);
-      const existingTask = this.findBySession(sessionID);
-      if (existingTask) {
-        existingTask.status = "error";
-        const errorMessage = error45 instanceof Error ? error45.message : String(error45);
-        if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-          existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`;
-        } else {
-          existingTask.error = errorMessage;
+    }).catch(async (error45) => {
+      await this.handlePromptFailure(sessionID, input, error45);
+    });
+  }
+  async handlePromptFailure(sessionID, input, error45) {
+    log("[background-agent] promptAsync error:", error45);
+    const existingTask = this.findBySession(sessionID);
+    if (!existingTask)
+      return;
+    const runtimeFallback = this.config?.runtimeFallback;
+    const classification = classifyProviderError(error45);
+    const canFallback = runtimeFallback?.enabled !== false && (classification.retryable || classification.shouldFallback);
+    if (canFallback) {
+      let currentError = error45;
+      let currentClassification = classification;
+      let currentModel = input.model ?? { providerID: "", modelID: "" };
+      while (true) {
+        const attempts = existingTask.attempts ?? [];
+        const fallbackResult = resolveNextFallbackModel({
+          agent: input.agent,
+          category: input.category,
+          currentModel,
+          attempts,
+          maxAttempts: runtimeFallback?.max_attempts,
+          lastErrorClassification: currentClassification
+        });
+        if (fallbackResult.kind !== "next") {
+          existingTask.error = fallbackResult.kind === "exhausted" ? `All fallback models exhausted. Last error: ${currentClassification.reason}` : fallbackResult.reason;
+          break;
         }
-        existingTask.completedAt = new Date;
-        if (existingTask.concurrencyKey) {
-          this.concurrencyManager.release(existingTask.concurrencyKey);
-          existingTask.concurrencyKey = undefined;
+        log("[background-agent] Fallback to model:", fallbackResult.model);
+        try {
+          await this.client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              agent: input.agent,
+              model: fallbackResult.model,
+              parts: [{ type: "text", text: input.prompt }]
+            }
+          });
+          existingTask.attempts = attempts;
+          return;
+        } catch (retryError) {
+          currentError = retryError;
+          currentClassification = classifyProviderError(currentError);
+          existingTask.attempts = [...attempts, {
+            model: fallbackResult.model,
+            error: currentClassification
+          }];
+          currentModel = fallbackResult.model;
+          if (!currentClassification.retryable && !currentClassification.shouldFallback) {
+            existingTask.error = `Fallback failed: ${retryError instanceof Error ? retryError.message : String(retryError)}`;
+            break;
+          }
         }
-        this.markForNotification(existingTask);
-        this.notifyParentSession(existingTask).catch((err) => {
-          log("[background-agent] Failed to notify on error:", err);
-        });
       }
+    } else {
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
+        existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`;
+      } else {
+        existingTask.error = errorMessage;
+      }
+    }
+    existingTask.status = "error";
+    existingTask.completedAt = new Date;
+    if (existingTask.concurrencyKey) {
+      this.concurrencyManager.release(existingTask.concurrencyKey);
+      existingTask.concurrencyKey = undefined;
+    }
+    this.markForNotification(existingTask);
+    this.notifyParentSession(existingTask).catch((err) => {
+      log("[background-agent] Failed to notify on error:", err);
     });
   }
   getTask(id) {
@@ -63126,6 +63859,7 @@ var HookNameSchema = exports_external2.enum([
   "auto-slash-command",
   "edit-error-recovery",
   "delegate-task-retry",
+  "runtime-fallback",
   "prometheus-md-only",
   "perf-profiler",
   "start-work",
@@ -63135,6 +63869,23 @@ var BuiltinCommandNameSchema = exports_external2.enum([
   "init-deep",
   "start-work"
 ]);
+var ProviderModelStringSchema = exports_external2.string().refine((value) => {
+  const separatorIndex = value.indexOf("/");
+  return separatorIndex > 0 && separatorIndex < value.length - 1;
+}, "Expected provider/model format");
+var NonEmptyStringSchema = exports_external2.string().min(1);
+var FallbackModelEntrySchema = exports_external2.union([
+  exports_external2.object({
+    model: ProviderModelStringSchema,
+    variant: exports_external2.string().optional()
+  }).strict(),
+  exports_external2.object({
+    providerID: NonEmptyStringSchema,
+    modelID: NonEmptyStringSchema,
+    variant: exports_external2.string().optional()
+  }).strict()
+]);
+var FallbackModelsSchema = exports_external2.array(FallbackModelEntrySchema);
 var AgentOverrideConfigSchema = exports_external2.object({
   model: exports_external2.string().optional(),
   variant: exports_external2.string().optional(),
@@ -63149,7 +63900,8 @@ var AgentOverrideConfigSchema = exports_external2.object({
   description: exports_external2.string().optional(),
   mode: exports_external2.enum(["subagent", "primary", "all"]).optional(),
   color: exports_external2.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
-  permission: AgentPermissionSchema.optional()
+  permission: AgentPermissionSchema.optional(),
+  fallback_models: FallbackModelsSchema.optional()
 });
 var AgentOverridesSchema = exports_external2.object({
   build: AgentOverrideConfigSchema.optional(),
@@ -63185,6 +63937,7 @@ var CategoryConfigSchema = exports_external2.object({
   description: exports_external2.string().optional(),
   model: exports_external2.string().optional(),
   variant: exports_external2.string().optional(),
+  fallback_models: FallbackModelsSchema.optional(),
   temperature: exports_external2.number().min(0).max(2).optional(),
   top_p: exports_external2.number().min(0).max(1).optional(),
   maxTokens: exports_external2.number().optional(),
@@ -63312,6 +64065,15 @@ var GitMasterConfigSchema = exports_external2.object({
   commit_footer: exports_external2.boolean().default(true),
   include_co_authored_by: exports_external2.boolean().default(true)
 });
+var RuntimeFallbackConfigSchema = exports_external2.object({
+  enabled: exports_external2.boolean().default(true),
+  max_attempts: exports_external2.number().min(0).default(3),
+  initial_delay_ms: exports_external2.number().min(0).default(2000),
+  backoff_factor: exports_external2.number().min(1).default(2),
+  max_delay_ms: exports_external2.number().min(0).default(30000),
+  respect_retry_after: exports_external2.boolean().default(true),
+  jitter: exports_external2.boolean().default(true)
+});
 var OhMyOpenCodeConfigSchema = exports_external2.object({
   $schema: exports_external2.string().optional(),
   disabled_mcps: exports_external2.array(AnyMcpNameSchema).optional(),
@@ -63330,7 +64092,8 @@ var OhMyOpenCodeConfigSchema = exports_external2.object({
   ralph_loop: RalphLoopConfigSchema.optional(),
   background_task: BackgroundTaskConfigSchema.optional(),
   notification: NotificationConfigSchema.optional(),
-  git_master: GitMasterConfigSchema.optional()
+  git_master: GitMasterConfigSchema.optional(),
+  runtime_fallback: RuntimeFallbackConfigSchema.optional()
 });
 // src/plugin-config.ts
 init_shared();
@@ -68386,9 +69149,31 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const firstMessageVariantGate = createFirstMessageVariantGate();
   const isHookEnabled = (hookName) => !disabledHooks.has(hookName);
+  const parseConfiguredFallbackModels = (entries) => entries?.map((entry) => {
+    if ("model" in entry) {
+      const separatorIndex = entry.model.indexOf("/");
+      return {
+        providerID: entry.model.slice(0, separatorIndex),
+        modelID: entry.model.slice(separatorIndex + 1),
+        variant: entry.variant
+      };
+    }
+    return entry;
+  });
   const modelCacheState = createModelCacheState();
   const contextWindowMonitor = isHookEnabled("context-window-monitor") ? createContextWindowMonitorHook(ctx) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental }) : null;
+  const runtimeFallback = isHookEnabled("runtime-fallback") && pluginConfig.runtime_fallback?.enabled !== false ? createRuntimeFallbackHook(ctx, {
+    config: pluginConfig.runtime_fallback,
+    sessionRecovery: sessionRecovery ?? undefined,
+    getConfiguredFallbackModels: (agent, category) => {
+      const agentModels = agent && pluginConfig.agents?.[agent]?.fallback_models;
+      if (agentModels)
+        return parseConfiguredFallbackModels(agentModels);
+      const categoryModels = category ? pluginConfig.categories?.[category]?.fallback_models : undefined;
+      return parseConfiguredFallbackModels(categoryModels);
+    }
+  }) : null;
   let sessionNotification = null;
   if (isHookEnabled("session-notification")) {
     const forceEnable = pluginConfig.notification?.force_enable ?? false;
@@ -68441,7 +69226,10 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const prometheusMdOnly = isHookEnabled("prometheus-md-only") ? createPrometheusMdOnlyHook(ctx) : null;
   const questionLabelTruncator = createQuestionLabelTruncatorHook();
   const taskResumeInfo = createTaskResumeInfoHook();
-  const backgroundManager = new BackgroundManager(ctx, pluginConfig.background_task);
+  const backgroundManager = new BackgroundManager(ctx, {
+    ...pluginConfig.background_task,
+    runtimeFallback: pluginConfig.runtime_fallback
+  });
   const atlasHook = isHookEnabled("atlas") ? createAtlasHook(ctx, { directory: ctx.directory, backgroundManager }) : null;
   const perfTracer = pluginConfig.experimental?.profiling?.enabled ? new PerfTracer({
     enabled: true,
@@ -68488,7 +69276,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
     directory: ctx.directory,
     userCategories: pluginConfig.categories,
     gitMasterConfig: pluginConfig.git_master,
-    sisyphusJuniorModel: pluginConfig.agents?.["sisyphus-junior"]?.model
+    sisyphusJuniorModel: pluginConfig.agents?.["sisyphus-junior"]?.model,
+    runtimeFallbackConfig: pluginConfig.runtime_fallback,
+    agentFallbackModels: Object.fromEntries(Object.entries(pluginConfig.agents ?? {}).map(([agent, config4]) => [agent, config4?.fallback_models]))
   });
   const disabledSkills = new Set(pluginConfig.disabled_skills ?? []);
   const systemMcpNames = getSystemMcpServerNames();
@@ -68657,6 +69447,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
       hookCount++;
       await wrapWithTiming(perfTracer, "event", "anthropicContextWindowLimitRecovery", () => anthropicContextWindowLimitRecovery?.event(input), evtSessionID);
       hookCount++;
+      await wrapWithTiming(perfTracer, "event", "runtimeFallback", () => runtimeFallback?.handler(input), evtSessionID);
+      hookCount++;
       await wrapWithTiming(perfTracer, "event", "agentUsageReminder", () => agentUsageReminder?.event(input), evtSessionID);
       hookCount++;
       await wrapWithTiming(perfTracer, "event", "interactiveBashSession", () => interactiveBashSession?.event(input), evtSessionID);