@librechat/agents 3.9.8 → 4.0.1

package/src/llm/bedrock/utils/message_inputs.ts

@@ -29,8 +29,8 @@ import type {
   MessageContentReasoningBlock,
 } from '../types';
 import { serializeStructuredValueBounded } from '@/utils/toolContent';
-import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 import { isReasoningContentBlock } from '@/messages/reasoningTypes';
+import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 
 /**
  * Reasoning blocks from other providers, relative to Bedrock. Bedrock's native
@@ -714,13 +714,16 @@ function coerceBedrockToolUseInput(input: unknown): Record<string, unknown> {
     : {};
 }
 
-function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
+function convertAIMessageToConverseMessage(
+  msg: BaseMessage,
+  replayReasoning = true
+): BedrockMessage {
   // Check for v1 format from other providers (PR #9766 fix)
   const responseMetadata = msg.response_metadata as
     | { output_version?: string }
     | undefined;
   if (responseMetadata?.output_version === 'v1') {
-    return convertFromV1ToChatBedrockConverseMessage(msg);
+    return convertFromV1ToChatBedrockConverseMessage(msg, replayReasoning);
   }
 
   const assistantMsg: BedrockMessage = {
@@ -733,9 +736,7 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
   } else if (Array.isArray(msg.content)) {
     const parsedToolCallIds = new Set(
       isAIMessage(msg)
-        ? (msg.tool_calls ?? []).flatMap((toolCall) =>
-          toolCall.id != null ? [toolCall.id] : []
-        )
+        ? (msg.tool_calls ?? []).flatMap(({ id }) => id ?? [])
         : []
     );
     const concatenatedBlocks = concatenateLangchainReasoningBlocks(
@@ -775,10 +776,14 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
       } else if (block.type === 'reasoning_content') {
         const reasoningBlock = block as MessageContentReasoningBlock;
         // Bedrock Converse rejects reasoningContent whose reasoningText.text is
-        // null/empty (a signature-only block that never merged with its text).
-        // Drop it rather than emit an invalid request; the empty-turn
-        // placeholder below covers a turn left with no content.
-        if (!isSerializableBedrockReasoningBlock(reasoningBlock)) {
+        // null/empty (a signature-only block that never merged with its text),
+        // and OpenAI models reject reasoningContent outright. Drop
+        // it rather than emit an invalid request; the empty-turn placeholder
+        // below covers a turn left with no content.
+        if (
+          !replayReasoning ||
+          !isSerializableBedrockReasoningBlock(reasoningBlock)
+        ) {
           return;
         }
         contentBlocks.push({
@@ -856,7 +861,8 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
  * (Implements PR #9766 fix for output_version v1 detection)
  */
 function convertFromV1ToChatBedrockConverseMessage(
-  msg: BaseMessage
+  msg: BaseMessage,
+  replayReasoning = true
 ): BedrockMessage {
   const contentBlocks: BedrockContentBlock[] = [];
   const assistantMsg: BedrockMessage = {
@@ -898,7 +904,11 @@ function convertFromV1ToChatBedrockConverseMessage(
         /** Bedrock Converse rejects `reasoningText` with a null/empty `text`
          * (`Member must not be null`), e.g. when the producing model omitted
          * reasoning text (`thinking.display: "omitted"`) — drop rather than send. */
-        if (reasoning.reasoning == null || reasoning.reasoning === '') {
+        if (
+          !replayReasoning ||
+          reasoning.reasoning == null ||
+          reasoning.reasoning === ''
+        ) {
           droppedUnserializableContent = true;
           continue;
         }
@@ -909,7 +919,10 @@ function convertFromV1ToChatBedrockConverseMessage(
         } as BedrockContentBlock);
       } else if (block.type === 'reasoning_content') {
         const reasoningBlock = block as MessageContentReasoningBlock;
-        if (!isSerializableBedrockReasoningBlock(reasoningBlock)) {
+        if (
+          !replayReasoning ||
+          !isSerializableBedrockReasoningBlock(reasoningBlock)
+        ) {
           droppedUnserializableContent = true;
           continue;
         }
@@ -1118,13 +1131,47 @@ function convertToolMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
   };
 }
 
+/** Options for {@link convertToConverseMessages}. */
+export interface ConvertToConverseMessagesOptions {
+  /** The model the request is for, which decides whether prior reasoning is replayed. */
+  model?: string;
+}
+
+/**
+ * OpenAI Bedrock models reject prior `reasoningContent`, including on Claude-to-GPT handoffs.
+ * Only suppress replay for identified OpenAI targets; other model families retain the existing
+ * behavior because their Bedrock reasoning-replay requirements have not been verified here.
+ * Missing model IDs and opaque resource ARNs also retain the existing behavior.
+ */
+export function replaysBedrockReasoning(model?: string): boolean {
+  if (model == null || model === '') {
+    return true;
+  }
+  let id = model.toLowerCase();
+  if (id.startsWith('arn:')) {
+    const modelId =
+      /^arn:[^:]+:bedrock:[^:]*:[^:]*:(?:foundation-model|inference-profile)\/(.+)$/.exec(
+        id
+      )?.[1];
+    if (modelId == null) {
+      return true;
+    }
+    id = modelId;
+  }
+  return !/(?:^|\.)openai\./.test(id);
+}
+
 /**
  * Convert LangChain messages to Bedrock Converse messages.
  */
-export function convertToConverseMessages(messages: BaseMessage[]): {
+export function convertToConverseMessages(
+  messages: BaseMessage[],
+  options: ConvertToConverseMessagesOptions = {}
+): {
   converseMessages: BedrockMessage[];
   converseSystem: BedrockSystemContentBlock[];
 } {
+  const replayReasoning = replaysBedrockReasoning(options.model);
   const converseSystem = messages
     .filter((msg) => msg._getType() === 'system')
     .flatMap((msg) => convertSystemMessageToConverseMessage(msg));
@@ -1133,7 +1180,7 @@ export function convertToConverseMessages(messages: BaseMessage[]): {
     .filter((msg) => msg._getType() !== 'system')
     .map((msg) => {
       if (msg._getType() === 'ai') {
-        return convertAIMessageToConverseMessage(msg);
+        return convertAIMessageToConverseMessage(msg, replayReasoning);
       } else if (msg._getType() === 'human' || msg._getType() === 'generic') {
         return convertHumanMessageToConverseMessage(msg);
       } else if (msg._getType() === 'tool') {

package/src/tools/subagent/SubagentExecutor.ts

@@ -141,6 +141,7 @@ import { stripRunStepResumeState } from '@/tools/runStepResume';
 import { seedAgentInitialSessions } from '@/utils/toolSessions';
 import { stableStringify } from '@/tools/eagerEventExecution';
 import { convertInjectedMessages } from '@/messages/injected';
+import { logSubagentResolutionFailure } from './diagnostics';
 import { resolveClientOptionsModel } from '@/llm/request';
 import { isBackgroundDenyMode } from '@/types/hitl';
 import { composeAbortSignals } from '@/utils/misc';
@@ -1358,10 +1359,7 @@ export class SubagentExecutor {
       };
       let deliveryAttempts = 1;
       let result = await executeAttempt();
-      while (
-        result.retryableDelivery === true &&
-        deliveryAttempts < 3
-      ) {
+      while (result.retryableDelivery === true && deliveryAttempts < 3) {
         if (deliveryAttempts > 1) {
           await sleep(
             Math.min(100 * 2 ** Math.min(deliveryAttempts - 2, 6), 5_000)
@@ -2245,7 +2243,10 @@ export class SubagentExecutor {
       parentToolCallId,
       parentConfigurable,
     });
-    if (execution.completedResult != null && settled.output.status === 'error') {
+    if (
+      execution.completedResult != null &&
+      settled.output.status === 'error'
+    ) {
       return;
     }
     const { resumeExecution } = execution;
@@ -2492,6 +2493,12 @@ export class SubagentExecutor {
       if (error instanceof StreamLimitExceededError) {
         throw error;
       }
+      logSubagentResolutionFailure(
+        'identity',
+        executableConfig.type,
+        childSignal,
+        error
+      );
       return createSubagentFailure(SUBAGENT_RESOLUTION_ERROR_MESSAGE);
     }
     const { childRunId, childThreadId, approvalExecutionScope } = identity;
@@ -2522,6 +2529,12 @@ export class SubagentExecutor {
       if (error instanceof StreamLimitExceededError) {
         throw error;
       }
+      logSubagentResolutionFailure(
+        'config',
+        executableConfig.type,
+        childSignal,
+        error
+      );
       return createSubagentFailure(SUBAGENT_RESOLUTION_ERROR_MESSAGE);
     }
 
@@ -2609,9 +2622,7 @@ export class SubagentExecutor {
       }
     } catch (error) {
       if (childSignal.aborted) {
-        throw childSignal.reason instanceof Error
-          ? childSignal.reason
-          : error;
+        throw childSignal.reason instanceof Error ? childSignal.reason : error;
       }
       if (execution.completedResult != null) {
         return {
@@ -2958,10 +2969,11 @@ export class SubagentExecutor {
             },
             sessionId: currentHookSessionId,
             matchQuery: subagentType,
-          }).catch((): AggregatedHookResult =>
-            isBackgroundDenyMode(this.humanInTheLoop)
-              ? { ...HOOK_FALLBACK, hasHookFailures: true }
-              : HOOK_FALLBACK
+          }).catch(
+            (): AggregatedHookResult =>
+              isBackgroundDenyMode(this.humanInTheLoop)
+                ? { ...HOOK_FALLBACK, hasHookFailures: true }
+                : HOOK_FALLBACK
           );
 
           const policyFailed =
@@ -3823,7 +3835,10 @@ export function sanitizeForwardedSubagentUpdateData(
   if (eventName === GraphEvents.ON_TOOL_CALLS_DISPATCHED) {
     if (!isObjectLike(data)) return undefined;
     const event = data as { dispatched_at?: number; toolCalls?: unknown };
-    if (!Array.isArray(event.toolCalls) || typeof event.dispatched_at !== 'number') {
+    if (
+      !Array.isArray(event.toolCalls) ||
+      typeof event.dispatched_at !== 'number'
+    ) {
       return undefined;
     }
     return {
@@ -3831,12 +3846,17 @@ export function sanitizeForwardedSubagentUpdateData(
       toolCalls: (event.toolCalls as unknown[]).flatMap((call) => {
         if (!isObjectLike(call)) return [];
         const entry = call as Record<string, unknown>;
-        if (typeof entry.id !== 'string' || typeof entry.name !== 'string') return [];
-        return [{
-          id: entry.id,
-          name: entry.name,
-          ...(typeof entry.stepId === 'string' ? { stepId: entry.stepId } : {}),
-        }];
+        if (typeof entry.id !== 'string' || typeof entry.name !== 'string')
+          return [];
+        return [
+          {
+            id: entry.id,
+            name: entry.name,
+            ...(typeof entry.stepId === 'string'
+              ? { stepId: entry.stepId }
+              : {}),
+          },
+        ];
       }),
     };
   }

package/src/tools/subagent/diagnostics.ts

@@ -0,0 +1,63 @@
+import {
+  SubagentSettlementBindingError,
+  SubagentDefinitionBindingError,
+  SubagentInvocationBindingError,
+  SubagentExecutionInvalidatedError,
+} from './SubagentExecutionRegistry';
+import { describeCodeApiError } from '@/tools/diagnostics';
+
+/** Which step of child start-up failed: execution identity, then host config resolution. */
+export type SubagentResolutionPhase = 'identity' | 'config';
+
+const SUBAGENT_ERROR_TYPES = [
+  ['SubagentExecutionInvalidatedError', SubagentExecutionInvalidatedError],
+  ['SubagentDefinitionBindingError', SubagentDefinitionBindingError],
+  ['SubagentInvocationBindingError', SubagentInvocationBindingError],
+  ['SubagentSettlementBindingError', SubagentSettlementBindingError],
+] as const;
+
+type SubagentErrorLabel =
+  | (typeof SUBAGENT_ERROR_TYPES)[number][0]
+  | ReturnType<typeof describeCodeApiError>['type'];
+
+/**
+ * Follows the rule in `@/tools/diagnostics`: every field is a value this
+ * module owns or a host-registered subagent type, never text from the error.
+ * The failure the model sees is a fixed sentence, so this line is the only
+ * operator account of it; the host logs its own error text where it throws.
+ */
+export type SubagentResolutionDiagnostic = {
+  phase: SubagentResolutionPhase;
+  subagentType: string;
+  aborted: boolean;
+  type: SubagentErrorLabel;
+};
+
+function describeSubagentError(error: unknown): SubagentErrorLabel {
+  try {
+    for (const [label, constructor] of SUBAGENT_ERROR_TYPES) {
+      if (error instanceof constructor) {
+        return label;
+      }
+    }
+  } catch {
+    return 'UndescribableError';
+  }
+  return describeCodeApiError(error).type;
+}
+
+export function logSubagentResolutionFailure(
+  phase: SubagentResolutionPhase,
+  subagentType: string,
+  signal: AbortSignal,
+  error: unknown
+): void {
+  const detail: SubagentResolutionDiagnostic = {
+    phase,
+    subagentType,
+    aborted: signal.aborted,
+    type: describeSubagentError(error),
+  };
+  // eslint-disable-next-line no-console
+  console.warn('[SubagentExecutor] Subagent resolution failed', detail);
+}