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

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

@@ -10,12 +10,12 @@ import {
 } from "./roy-agent-core-p8rf4z89.js";
 import {
   SessionMessageConverter
-} from "./roy-agent-core-x1d6edkh.js";
+} from "./roy-agent-core-rfhxj8v2.js";
 import {
   parseToolArgsStrict,
   safeParseToolArgs,
   withTimeout
-} from "./roy-agent-core-9qgrc9dy.js";
+} from "./roy-agent-core-03k5drfp.js";
 import {
   getCurrentBgTaskId
 } from "./roy-agent-core-c1v263jn.js";
@@ -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
       };

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

@@ -1,6 +1,6 @@
 import {
   builtInHandlers
-} from "./roy-agent-core-nmn853z0.js";
+} from "./roy-agent-core-t6nx0rsz.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-7hh0brvs.js";

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

@@ -1113,7 +1113,7 @@ class BackgroundTaskManager {
     return null;
   }
   async createTask(options) {
-    const { parentSessionId, description, prompt, subagentType, timeout, similarTaskIds, existingSubSessionId, triggerEventId } = options;
+    const { parentSessionId, description, prompt, subagentType, timeout, similarTaskIds, existingSubSessionId, triggerEventId, model, fallbackModel } = options;
     const taskIdGen = `process_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
     const sessionComponent = this.getSessionComponent();
     if (!sessionComponent) {
@@ -1211,6 +1211,8 @@ class BackgroundTaskManager {
       abortController,
       similarTaskIds,
       triggerEventId,
+      model,
+      fallbackModel,
       replyChannel: replyChannelSnapshot
     };
     this.tasks.set(taskIdGen, task);
@@ -1622,13 +1624,19 @@ ${reuseSection.markdown}`;
       if (signal) {
         signal.addEventListener("abort", onAbort);
       }
-      const invokeHandleQuery = () => this.env.handle_query?.(delegateQuery, {
-        sessionId,
-        deniedTools: deniedTools.length > 0 ? deniedTools : undefined,
-        agentType: subagentType,
-        abort: signal,
-        runId: capturedRunId
-      });
+      const invokeHandleQuery = () => {
+        const inheritedModel = task?.model;
+        const inheritedFallbackModel = task?.fallbackModel;
+        return this.env.handle_query?.(delegateQuery, {
+          sessionId,
+          deniedTools: deniedTools.length > 0 ? deniedTools : undefined,
+          agentType: subagentType,
+          abort: signal,
+          runId: capturedRunId,
+          ...inheritedModel ? { model: inheritedModel } : {},
+          ...inheritedFallbackModel ? { fallbackModel: inheritedFallbackModel } : {}
+        });
+      };
       const wrappedPromise = processRegistry ? runWithProcessRegistryAsync(processRegistry, () => runWithBgTaskIdAsync(bgTaskId, () => invokeHandleQuery())) : runWithBgTaskIdAsync(bgTaskId, () => invokeHandleQuery());
       wrappedPromise?.then((result) => {
         if (settled)
@@ -2004,7 +2012,7 @@ No need to poll — just wait for the notification and use \`task_get\` with the
       };
       await globalHookManager.execute(TaskHookPoints.DELEGATE_BEFORE, delegateCtx, { sessionId: parentSessionId });
       promptWithTaskInfo = delegateCtx.prompt;
-      return await handleBackgroundTask(backgroundTaskManager, parentSessionId, description, promptWithTaskInfo, delegateCtx.subagentType, delegateCtx.timeout, similar_task_ids, params.sub_session_id, resolvedTriggerEventId);
+      return await handleBackgroundTask(backgroundTaskManager, parentSessionId, description, promptWithTaskInfo, delegateCtx.subagentType, delegateCtx.timeout, similar_task_ids, params.sub_session_id, resolvedTriggerEventId, ctx.model, ctx.fallbackModel);
     }
   };
   tool.execute = wrapFunction(tool.execute, "delegate.execute", {
@@ -2048,7 +2056,7 @@ function _captureReplyChannelSnapshot() {
   };
 }
 var captureReplyChannelSnapshot = wrapFunction(_captureReplyChannelSnapshot, "delegate.captureReplyChannel", { recordParams: false, recordResult: true, recordError: true });
-async function handleBackgroundTask(backgroundTaskManager, parentSessionId, description, prompt, subagentType, timeout, similarTaskIds, existingSubSessionId, triggerEventId) {
+async function handleBackgroundTask(backgroundTaskManager, parentSessionId, description, prompt, subagentType, timeout, similarTaskIds, existingSubSessionId, triggerEventId, model, fallbackModel) {
   const startTime = Date.now();
   try {
     let actualSubagentType = subagentType;
@@ -2074,7 +2082,9 @@ async function handleBackgroundTask(backgroundTaskManager, parentSessionId, desc
       similarTaskIds,
       originalWorkflowName,
       existingSubSessionId,
-      triggerEventId
+      triggerEventId,
+      model,
+      fallbackModel
     });
     const output = [
       `✅ Background task accepted`,

package/dist/shared/@ai-setting/roy-agent-core-ntn32q7j.js

@@ -0,0 +1,72 @@
+// src/env/llm/redact.ts
+function redactSecrets(text, knownSecrets = []) {
+  let out = text;
+  for (const secret of knownSecrets) {
+    if (secret && secret.length >= 8) {
+      out = out.split(secret).join("<redacted>");
+    }
+  }
+  out = out.replace(/\boc_sk_[A-Za-z0-9_-]{8,}\b/g, "<redacted>");
+  out = out.replace(/\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}\b/g, "<redacted>");
+  out = out.replace(/\bBearer\s+[A-Za-z0-9._\-+/=]{12,}\b/g, "<redacted>");
+  return out;
+}
+var CREDENTIAL_BEARING_KEYS = new Set([
+  "url",
+  "requestBodyValues",
+  "requestBody",
+  "responseBody",
+  "responseHeaders",
+  "headers"
+]);
+function redactDeep(value, knownSecrets, depth = 0) {
+  if (depth > 4)
+    return value;
+  if (typeof value === "string")
+    return redactSecrets(value, knownSecrets);
+  if (Array.isArray(value))
+    return value.map((v) => redactDeep(v, knownSecrets, depth + 1));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redactDeep(v, knownSecrets, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+function redactErrorForTransport(error, knownSecrets = [], depth = 0) {
+  if (depth > 6)
+    return;
+  if (!error || typeof error !== "object") {
+    return typeof error === "string" ? redactSecrets(error, knownSecrets) : error;
+  }
+  const src = error;
+  const out = {};
+  for (const key of Object.getOwnPropertyNames(src)) {
+    const desc = Object.getOwnPropertyDescriptor(src, key);
+    if (!desc || !("value" in desc))
+      continue;
+    const value = src[key];
+    if (typeof value === "string") {
+      out[key] = redactSecrets(value, knownSecrets);
+    } else if (key === "cause" || key === "lastError") {
+      out[key] = redactErrorForTransport(value, knownSecrets, depth + 1);
+    } else if (key === "errors" && Array.isArray(value)) {
+      out[key] = value.map((inner) => redactErrorForTransport(inner, knownSecrets, depth + 1));
+    } else if (CREDENTIAL_BEARING_KEYS.has(key)) {
+      out[key] = redactDeep(value, knownSecrets);
+    } else {
+      out[key] = value;
+    }
+  }
+  for (const key of ["name", "message", "stack"]) {
+    const value = src[key];
+    if (typeof value === "string" && !(key in out)) {
+      out[key] = redactSecrets(value, knownSecrets);
+    }
+  }
+  return out;
+}
+
+export { redactSecrets, redactErrorForTransport };

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

@@ -1,6 +1,6 @@
 import {
   safeParseToolArgs
-} from "./roy-agent-core-9qgrc9dy.js";
+} from "./roy-agent-core-03k5drfp.js";
 
 // src/env/session/session-message-converter.ts
 import { randomUUID } from "crypto";

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

@@ -3,7 +3,7 @@ import {
 } from "./roy-agent-core-bxkjk7zx.js";
 import {
   notifyReactFailure
-} from "./roy-agent-core-9nvyffxg.js";
+} from "./roy-agent-core-va4m04e8.js";
 import {
   cliCommandHandler
 } from "./roy-agent-core-p37kh0kt.js";