@ai-setting/roy-agent-core 1.7.61 → 1.7.63

package/dist/shared/@ai-setting/{roy-agent-core-yr5eqyhz.js → roy-agent-core-g23yp3t1.js}

@@ -1,21 +1,21 @@
 import {
   isToolUnavailableError,
   truncateOutputInline
-} from "./roy-agent-core-pj5tfmn5.js";
+} from "./roy-agent-core-w2ev3z5q.js";
 import {
   AgentRegistry
-} from "./roy-agent-core-dythsgkn.js";
+} from "./roy-agent-core-06jakebr.js";
 import {
   enqueueToAddFakeUserMessage
-} from "./roy-agent-core-hf0t8agb.js";
+} from "./roy-agent-core-p8rf4z89.js";
 import {
   SessionMessageConverter
-} from "./roy-agent-core-jsdqzfbj.js";
+} from "./roy-agent-core-rfhxj8v2.js";
 import {
   parseToolArgsStrict,
   safeParseToolArgs,
   withTimeout
-} from "./roy-agent-core-m2tv4pj0.js";
+} from "./roy-agent-core-03k5drfp.js";
 import {
   getCurrentBgTaskId
 } from "./roy-agent-core-c1v263jn.js";
@@ -31,20 +31,20 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-9s3payp1.js";
+} from "./roy-agent-core-gtdtzbs7.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-ajmgyawx.js";
+} from "./roy-agent-core-v7mwj8eq.js";
 import {
   init_context
-} from "./roy-agent-core-bdzdw1g3.js";
+} from "./roy-agent-core-33hn1beg.js";
 import {
   getCurrentTaskId,
   getEnvContext,
   resolveEnvParentTaskId,
   runWithEnvContextAsync
-} from "./roy-agent-core-qrjs2500.js";
+} from "./roy-agent-core-hfyxv2kx.js";
 import {
   TracedAs,
   agentRunParamFilter,
@@ -56,11 +56,11 @@ import {
   recordSessionMessagesParamFilter,
   toolExecParamFilter,
   toolExecResultFilter
-} from "./roy-agent-core-2qkrpc7m.js";
+} from "./roy-agent-core-386wa4wy.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-y0k9kaxz.js";
+} from "./roy-agent-core-6awgfh3x.js";
 import {
   __legacyDecorateClassTS,
   __require
@@ -197,6 +197,184 @@ var AGENT_CONFIG_REGISTRATION = {
 // src/env/agent/agent-component.ts
 init_decorator();
 init_trace_filters();
+
+// src/env/llm/model-fallback.ts
+var NON_FALLBACKABLE_STATUS = new Set([400, 401, 403]);
+var MODEL_UNAVAILABLE_PATTERNS = [
+  /model(?:\s+id|\s+name)?\s+(?:is\s+)?(?:unavailable|not\s+available)/i,
+  /model(?:\s+id|\s+name)?\s+(?:is\s+)?(?:not\s+found|does\s+not\s+exist|not\s+supported|deprecated|disabled|invalid|unknown)/i,
+  /\b(?:unknown|unsupported|nonexistent)\s+model\b/i,
+  /model[_\s-]?not[_\s-]?found/i,
+  /no\s+such\s+model/i,
+  /模型(?:不存在|不可用|未找到|不支持|已下线)/
+];
+var CREDIT_PATTERNS = [
+  /credit balance/i,
+  /balance (?:is )?too? ?low/i,
+  /insufficient (?:balance|credits?|funds?)/i,
+  /payment required/i,
+  /\b402\b/,
+  /充值|欠费/
+];
+var INTRINSIC_BLOCKERS = [
+  /abort(?:ed|error)?/i,
+  /operation was (?:aborted|cancelled)/i,
+  /context threshold exceeded/i,
+  /context window (?:exceeded|overflow)/i
+];
+var QUOTA_PATTERNS = [
+  /insufficient[_ ]quota/i,
+  /exceeded your current quota/i,
+  /quota (?:exceeded|exhausted)/i,
+  /rate[ _-]?limit/i,
+  /\b429\b/,
+  /too many requests/i,
+  /billing/i,
+  /insufficient balance/i,
+  /余额不足/i,
+  /额度(?:不足|耗尽|用尽|超限)/,
+  /配额(?:不足|耗尽|用尽)/
+];
+var SERVER_ERROR_PATTERNS = [
+  /(?:http|status|code|error)\D{0,12}5\d{2}\b/i,
+  /\b5\d{2}\s+(?:internal|bad\s+gateway|service\s+unavailable|gateway\s+timeout|server\s+error)/i,
+  /internal server error/i,
+  /bad gateway/i,
+  /service unavailable/i,
+  /gateway timeout/i,
+  /overloaded/i
+];
+var TIMEOUT_PATTERNS = [
+  /timed?[\s_-]?out/i,
+  /timeout/i,
+  /etimedout/i,
+  /econnreset/i,
+  /econnrefused/i,
+  /socket hang up/i,
+  /network (?:error|failure)/i,
+  /fetch failed/i
+];
+var RETRY_EXHAUSTED_PATTERNS = [
+  /retry(?:ing)? (?:failed|exhausted)/i,
+  /retries exhausted/i,
+  /max(?:imum)? ?retries/i,
+  /too many retries/i,
+  /\bretryerror\b/i,
+  /all retries? failed/i
+];
+var HARD_BLOCKERS = [
+  /\b401\b/,
+  /unauthorized/i,
+  /\b403\b/,
+  /forbidden/i,
+  /invalid[ _-]?api[ _-]?key/i,
+  /authentication (?:failed|error)/i,
+  /\b400\b/,
+  /bad request/i,
+  /abort(?:ed|error)?/i,
+  /operation was (?:aborted|cancelled)/i,
+  /context threshold exceeded/i,
+  /context window (?:exceeded|overflow)/i
+];
+function extractStatusCode(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const candidate = error;
+  const cause = candidate.cause ?? undefined;
+  const raw = candidate.statusCode ?? candidate.status ?? candidate.response?.status ?? cause?.statusCode ?? cause?.status;
+  const num = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(num) && num > 0 ? num : undefined;
+}
+var TEXT_KEYS = [
+  "message",
+  "errorMessage",
+  "reason",
+  "detail",
+  "body",
+  "responseBody",
+  "error",
+  "data",
+  "lastError"
+];
+function collectErrorText(error) {
+  const parts = [];
+  const pushFromObject = (obj) => {
+    for (const key of TEXT_KEYS) {
+      const value = obj[key];
+      if (typeof value === "string")
+        parts.push(value);
+    }
+  };
+  if (typeof error === "string") {
+    parts.push(error);
+  } else if (error instanceof Error) {
+    parts.push(error.message);
+    parts.push(error.name);
+    const cause = error.cause;
+    if (cause instanceof Error) {
+      parts.push(cause.message);
+      parts.push(cause.name);
+    } else if (typeof cause === "string") {
+      parts.push(cause);
+    } else if (cause && typeof cause === "object") {
+      pushFromObject(cause);
+    }
+  } else if (error && typeof error === "object") {
+    pushFromObject(error);
+  }
+  return parts.filter(Boolean).join(" | ");
+}
+function isFallbackEligibleError(error, hasFallback = true) {
+  if (!hasFallback)
+    return false;
+  if (error === undefined || error === null)
+    return false;
+  const text = collectErrorText(error);
+  const status = extractStatusCode(error);
+  const timedOut = TIMEOUT_PATTERNS.some((re) => re.test(text));
+  if (timedOut)
+    return true;
+  if (INTRINSIC_BLOCKERS.some((re) => re.test(text)))
+    return false;
+  if (MODEL_UNAVAILABLE_PATTERNS.some((re) => re.test(text)))
+    return true;
+  if (CREDIT_PATTERNS.some((re) => re.test(text)))
+    return true;
+  if (HARD_BLOCKERS.some((re) => re.test(text)))
+    return false;
+  if (status !== undefined && NON_FALLBACKABLE_STATUS.has(status))
+    return false;
+  if (status !== undefined) {
+    if (status === 404 || status === 408 || status === 429 || status >= 500)
+      return true;
+  }
+  if (/(?:^|[^/\w])404(?!\d)/.test(text))
+    return true;
+  if (QUOTA_PATTERNS.some((re) => re.test(text)))
+    return true;
+  if (SERVER_ERROR_PATTERNS.some((re) => re.test(text)))
+    return true;
+  if (RETRY_EXHAUSTED_PATTERNS.some((re) => re.test(text)))
+    return true;
+  return false;
+}
+function parseFallbackModel(fallbackModel) {
+  if (!fallbackModel)
+    return;
+  const trimmed = fallbackModel.trim();
+  if (!trimmed)
+    return;
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex > 0) {
+    return {
+      providerId: trimmed.slice(0, slashIndex),
+      modelId: trimmed.slice(slashIndex + 1)
+    };
+  }
+  return { modelId: trimmed };
+}
+
+// src/env/agent/agent-component.ts
 init_global_hook_manager();
 init_context();
 init_workflow_hil();
@@ -403,6 +581,7 @@ class AgentComponent extends BaseComponent {
   abortControllers = new Map;
   defaultTools = [];
   doomLoopCaches = new Map;
+  fallbackState = new Map;
   configComponent;
   configWatcher;
   messageConverter = new SessionMessageConverter;
@@ -882,6 +1061,7 @@ class AgentComponent extends BaseComponent {
       tools: this.getAvailableTools(agent, effectiveContext),
       systemPrompt: resolvedSystemPrompt ?? agent.config.systemPrompt ?? "You are a helpful assistant.",
       context: effectiveContext,
+      _runId: runId,
       ...cacheSnapshot ? { _cacheSnapshot: cacheSnapshot } : {}
     };
     let historyMessageCount = 0;
@@ -1295,6 +1475,7 @@ class AgentComponent extends BaseComponent {
       this.aborted.delete(runId);
       this.abortControllers.delete(runId);
       this.doomLoopCaches.delete(runId);
+      this.fallbackState.delete(runId);
       if (result.error) {
         this.pushEnvEvent({
           type: "agent.error",
@@ -1484,45 +1665,78 @@ class AgentComponent extends BaseComponent {
   async invokeLLM(ctx) {
     logger2.debug("[invokeLLM] Starting LLM invocation");
     if (this.llmComponent?.invoke) {
+      const llm = this.llmComponent;
       const messages = await this.buildMessages(ctx);
       const convertedMessages = messages.map(toLLMMessage);
       logger2.debug(`[invokeLLM] Calling LLMComponent.invoke with ${convertedMessages.length} messages`);
-      try {
-        const llmPromise = this.llmComponent.invoke({
-          messages: convertedMessages,
-          tools: ctx.tools.map((t) => ({
-            name: t.name,
-            description: t.description || "",
-            parameters: t.parameters ?? {}
-          })),
-          model: ctx.context.model,
-          context: {
-            sessionId: ctx.context.sessionId,
-            messageId: ctx.context.messageId
-          },
-          abortSignal: ctx.context.abort,
-          skipThresholdCheck: ctx.context.agentType === "sub",
-          ...ctx.context.toolChoice ? { toolChoice: ctx.context.toolChoice } : {}
-        });
-        const result = await withTimeout(llmPromise, 300000, "LLM invocation timeout after 300s");
-        logger2.debug("[invokeLLM] LLMComponent.invoke returned successfully");
+      const runKey = ctx._runId ?? ctx.context.sessionId ?? "default-run";
+      const sticky = this.fallbackState.get(runKey);
+      const configuredFallback = this.resolveFallbackModel(ctx.context.fallbackModel);
+      const activeModel = sticky?.activeModel ?? ctx.context.model;
+      const invokeWithModel = (model, signal) => llm.invoke({
+        messages: convertedMessages,
+        tools: ctx.tools.map((t) => ({
+          name: t.name,
+          description: t.description || "",
+          parameters: t.parameters ?? {}
+        })),
+        model,
+        context: {
+          sessionId: ctx.context.sessionId,
+          messageId: ctx.context.messageId
+        },
+        abortSignal: signal,
+        skipThresholdCheck: ctx.context.agentType === "sub",
+        ...ctx.context.toolChoice ? { toolChoice: ctx.context.toolChoice } : {}
+      });
+      const startAttempt = (model, label) => {
+        const attemptController = new AbortController;
+        const signal = ctx.context.abort ? AbortSignal.any([ctx.context.abort, attemptController.signal]) : attemptController.signal;
         return {
-          content: result.output?.content || "",
-          reasoning: result.output?.reasoning,
-          toolCalls: result.output?.toolCalls?.map((tc) => ({
-            id: tc.id,
-            function: tc.function ? {
-              name: tc.function.name,
-              arguments: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
-            } : undefined,
-            name: tc.name,
-            arguments: tc.arguments
-          })),
-          finishReason: result.output?.finishReason
+          promise: withTimeout(invokeWithModel(model, signal), 300000, label),
+          cancel: () => {
+            try {
+              attemptController.abort();
+            } catch {}
+          }
         };
+      };
+      let primaryAttempt;
+      try {
+        primaryAttempt = startAttempt(activeModel, "LLM invocation timeout after 300s");
+        const result = await primaryAttempt.promise;
+        logger2.debug("[invokeLLM] LLMComponent.invoke returned successfully");
+        return this.normalizeLLMOutput(result);
       } catch (error) {
         logger2.error("[invokeLLM] LLMComponent.invoke threw an error:", error);
-        throw error;
+        primaryAttempt?.cancel();
+        if (ctx.context.abort?.aborted) {
+          throw error;
+        }
+        const alreadyDowngraded = sticky?.fallbackModel !== undefined;
+        const canFallback = !alreadyDowngraded && !!configuredFallback && !AgentComponent.sameModel(configuredFallback, activeModel) && isFallbackEligibleError(error, true);
+        if (!canFallback) {
+          throw error;
+        }
+        logger2.warn(`[invokeLLM] primary model "${activeModel ?? "(default)"}" failed with a fallback-eligible error; downgrading to fallback model "${configuredFallback}" for run ${runKey}`);
+        this.fallbackState.set(runKey, {
+          activeModel: configuredFallback,
+          fallbackModel: configuredFallback
+        });
+        const fallbackAttempt = startAttempt(configuredFallback, "LLM invocation timeout after 300s (fallback)");
+        try {
+          const result = await fallbackAttempt.promise;
+          logger2.info(`[invokeLLM] fallback model "${configuredFallback}" succeeded for run ${runKey}`);
+          return this.normalizeLLMOutput(result);
+        } catch (fallbackError) {
+          fallbackAttempt.cancel();
+          if (fallbackError instanceof ContextError) {
+            logger2.warn(`[invokeLLM] fallback model "${configuredFallback}" hit a context limit; re-throwing ContextError so the compaction pipeline can handle it`);
+            throw fallbackError;
+          }
+          logger2.error(`[invokeLLM] fallback model "${configuredFallback}" also failed; re-throwing the ORIGINAL primary error`, fallbackError);
+          throw error;
+        }
       }
     }
     logger2.warn("[invokeLLM] No LLMComponent available, using mock");
@@ -1531,6 +1745,53 @@ class AgentComponent extends BaseComponent {
       finishReason: "stop"
     };
   }
+  resolveFallbackModel(explicit) {
+    const readConfig = (key) => {
+      const raw2 = this.configComponent?.get?.(key);
+      if (typeof raw2 !== "string")
+        return;
+      const trimmed = raw2.trim();
+      return trimmed ? trimmed : undefined;
+    };
+    const raw = explicit?.trim() || readConfig("llm.fallbackModel");
+    if (!raw)
+      return;
+    const parsed = parseFallbackModel(raw);
+    if (!parsed?.modelId)
+      return;
+    if (parsed.providerId)
+      return `${parsed.providerId}/${parsed.modelId}`;
+    const provider = readConfig("llm.fallbackProvider");
+    return provider ? `${provider}/${parsed.modelId}` : parsed.modelId;
+  }
+  static sameModel(a, b) {
+    const norm = (value) => {
+      if (!value)
+        return "";
+      const trimmed = value.trim();
+      const slash = trimmed.indexOf("/");
+      return slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
+    };
+    const left = norm(a);
+    const right = norm(b);
+    return !!left && left === right;
+  }
+  normalizeLLMOutput(result) {
+    return {
+      content: result.output?.content || "",
+      reasoning: result.output?.reasoning,
+      toolCalls: result.output?.toolCalls?.map((tc) => ({
+        id: tc.id,
+        function: tc.function ? {
+          name: tc.function.name,
+          arguments: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+        } : undefined,
+        name: tc.name,
+        arguments: tc.arguments
+      })),
+      finishReason: result.output?.finishReason
+    };
+  }
   parseToolCallArguments(toolCall) {
     const rawArgs = toolCall.function?.arguments ?? toolCall.arguments;
     return safeParseToolArgs(rawArgs);
@@ -1579,10 +1840,13 @@ class AgentComponent extends BaseComponent {
         },
         sessionId: toolEventSessionId
       });
+      const effectiveRunModel = this.fallbackState.get(ctx._runId ?? ctx.context.sessionId ?? "default-run")?.activeModel ?? ctx.context.model;
       const toolContext = {
         session_id: ctx.context.sessionId,
         message_id: ctx.context.messageId,
         abort: ctx.context.abort,
+        model: effectiveRunModel,
+        fallbackModel: ctx.context.fallbackModel,
         workdir: ctx.context.metadata?.workdir,
         metadata: ctx.context.metadata
       };
@@ -1949,19 +2213,5 @@ function buildMultiBlockSystem(ctx) {
   }
   return messages;
 }
-// src/env/agent/summary-agent.ts
-class SummaryAgent {
-  llmComponent;
-  config;
-  constructor(_promptComponent, llmComponent, config) {
-    this.llmComponent = llmComponent;
-    this.config = {
-      type: "summary",
-      promptName: "session/compact",
-      maxIterations: 1,
-      model: undefined,
-      ...config
-    };
-  }
-}
-export { AgentComponentConfigSchema, AgentComponent, SummaryAgent };
+
+export { parseToolList, composeToolOutputForLLM, toLLMMessage, AgentComponentConfigSchema, filterToolsByAgent, buildRunEnvContext, AgentComponent, buildMultiBlockSystem };