@librechat/agents 3.8.0 → 3.8.2

package/src/messages/toolResultTypes.ts

@@ -1,4 +1,11 @@
 import { isProxy } from 'node:util/types';
+import type {
+  BaseMessage,
+  ChatMessage,
+  ToolMessage,
+} from '@langchain/core/messages';
+import type { ProviderName } from '@/types/llm';
+import { getProviderFamily } from '@/llm/providers';
 
 export type ProviderToolCallKind =
   | 'tool'
@@ -26,7 +33,7 @@ export interface ProviderToolResultPartDescriptor {
 
 export interface ProviderToolCallIndexEntry {
   readonly descriptor: ProviderToolCallPartDescriptor;
-  secondarySourceType?: string;
+  secondarySourceTypes?: Set<string>;
 }
 
 export type ProviderToolCallIndex = Map<
@@ -323,10 +330,7 @@ function isCacheControl(value: unknown): boolean {
   }
   const ttl = readDataProperty(record, 'ttl');
   return (
-    !ttl.found ||
-    ttl.value === null ||
-    ttl.value === '5m' ||
-    ttl.value === '1h'
+    !ttl.found || ttl.value === null || ttl.value === '5m' || ttl.value === '1h'
   );
 }
 
@@ -359,9 +363,7 @@ function hasValidCallerProperty(record: Record<string, unknown>): boolean {
   return !property.found || isServerToolCaller(property.value);
 }
 
-function hasValidProviderMetadata(
-  record: Record<string, unknown>
-): boolean {
+function hasValidProviderMetadata(record: Record<string, unknown>): boolean {
   const id = readDataProperty(record, 'id');
   if (id.found && !isBoundedProviderPairingString(id.value)) {
     return false;
@@ -393,8 +395,7 @@ function hasValidProviderMetadata(
   }
   const signature = readDataProperty(record, 'thoughtSignature');
   return (
-    !signature.found ||
-    isBoundedProviderPairingString(signature.value, true)
+    !signature.found || isBoundedProviderPairingString(signature.value, true)
   );
 }
 
@@ -486,9 +487,7 @@ export function hasStructurallyValidAnthropicWebSearchResultContent(
   );
 }
 
-function isGoogleCodeExecutionResult(
-  record: Record<string, unknown>
-): boolean {
+function isGoogleCodeExecutionResult(record: Record<string, unknown>): boolean {
   const nested = readDataProperty(record, 'codeExecutionResult');
   const result = nested.found ? getRecord(nested.value) : undefined;
   const outcome = result == null ? undefined : readString(result, 'outcome');
@@ -602,48 +601,42 @@ const LOCAL_RESULT_METADATA_FIELDS = [
   'agentId',
   'groupId',
 ] as const;
-const TOOL_RESULT_ENVELOPE_FIELDS: Readonly<
-  Record<string, readonly string[]>
-> = {
-  advisor_tool_result: ANTHROPIC_RESULT_FIELDS,
-  bash_code_execution_tool_result: ANTHROPIC_RESULT_FIELDS,
-  code_execution_tool_result: ANTHROPIC_RESULT_FIELDS,
-  mcp_tool_result: ANTHROPIC_GENERIC_RESULT_FIELDS,
-  text_editor_code_execution_tool_result: ANTHROPIC_RESULT_FIELDS,
-  tool_search_tool_result: ANTHROPIC_RESULT_FIELDS,
-  tool_result: ANTHROPIC_GENERIC_RESULT_FIELDS,
-  web_fetch_tool_result: ANTHROPIC_SERVER_RESULT_FIELDS,
-  web_search_tool_result: ANTHROPIC_SERVER_RESULT_FIELDS,
-  server_tool_call_result: [
-    'type',
-    'toolCallId',
-    'status',
-    'output',
-    ...LOCAL_RESULT_METADATA_FIELDS,
-  ],
-  server_tool_result: [
-    'type',
-    'tool_call_id',
-    'status',
-    'output',
-    ...LOCAL_RESULT_METADATA_FIELDS,
-  ],
-  codeExecutionResult: [
-    'type',
-    'codeExecutionResult',
-    'agentId',
-    'groupId',
-  ],
-  toolResponse: [
-    'type',
-    'toolResponse',
-    'thought',
-    'thoughtSignature',
-    'agentId',
-    'groupId',
-  ],
-  toolResult: ['type', 'toolResult', 'agentId', 'groupId'],
-};
+const TOOL_RESULT_ENVELOPE_FIELDS: Readonly<Record<string, readonly string[]>> =
+  {
+    advisor_tool_result: ANTHROPIC_RESULT_FIELDS,
+    bash_code_execution_tool_result: ANTHROPIC_RESULT_FIELDS,
+    code_execution_tool_result: ANTHROPIC_RESULT_FIELDS,
+    mcp_tool_result: ANTHROPIC_GENERIC_RESULT_FIELDS,
+    text_editor_code_execution_tool_result: ANTHROPIC_RESULT_FIELDS,
+    tool_search_tool_result: ANTHROPIC_RESULT_FIELDS,
+    tool_result: ANTHROPIC_GENERIC_RESULT_FIELDS,
+    web_fetch_tool_result: ANTHROPIC_SERVER_RESULT_FIELDS,
+    web_search_tool_result: ANTHROPIC_SERVER_RESULT_FIELDS,
+    server_tool_call_result: [
+      'type',
+      'toolCallId',
+      'status',
+      'output',
+      ...LOCAL_RESULT_METADATA_FIELDS,
+    ],
+    server_tool_result: [
+      'type',
+      'tool_call_id',
+      'status',
+      'output',
+      ...LOCAL_RESULT_METADATA_FIELDS,
+    ],
+    codeExecutionResult: ['type', 'codeExecutionResult', 'agentId', 'groupId'],
+    toolResponse: [
+      'type',
+      'toolResponse',
+      'thought',
+      'thoughtSignature',
+      'agentId',
+      'groupId',
+    ],
+    toolResult: ['type', 'toolResult', 'agentId', 'groupId'],
+  };
 
 function anthropicDescriptor(
   record: Record<string, unknown>,
@@ -652,9 +645,7 @@ function anthropicDescriptor(
 ): ProviderToolResultPartDescriptor | undefined {
   const toolCallId = readPairingString(record, 'tool_use_id');
   const content = readDataProperty(record, 'content');
-  return toolCallId != null &&
-    content.found &&
-    getRecord(content.value) != null
+  return toolCallId != null && content.found && getRecord(content.value) != null
     ? {
       type,
       toolCallId,
@@ -672,7 +663,8 @@ export function getProviderToolResultPartDescriptor(
     return undefined;
   }
   const type = readString(record, 'type');
-  const allowedFields = type == null ? undefined : TOOL_RESULT_ENVELOPE_FIELDS[type];
+  const allowedFields =
+    type == null ? undefined : TOOL_RESULT_ENVELOPE_FIELDS[type];
   if (
     type == null ||
     allowedFields == null ||
@@ -685,19 +677,14 @@ export function getProviderToolResultPartDescriptor(
   }
   const structuredToolNames = ANTHROPIC_STRUCTURED_RESULT_TOOL_NAMES[type];
   if (structuredToolNames != null) {
-    return anthropicDescriptor(
-      record,
-      type,
-      structuredToolNames
-    );
+    return anthropicDescriptor(record, type, structuredToolNames);
   }
   if (type === 'web_search_tool_result') {
     const toolCallId = readPairingString(record, 'tool_use_id');
     const content = readDataProperty(record, 'content');
     return toolCallId != null &&
       content.found &&
-      (getRecord(content.value) != null ||
-        isOpaqueBoundedArray(content.value))
+      (getRecord(content.value) != null || isOpaqueBoundedArray(content.value))
       ? {
         type,
         toolCallId,
@@ -766,6 +753,33 @@ export function getProviderToolResultPartDescriptor(
   return undefined;
 }
 
+const PROVIDER_TOOL_CALL_CONTENT_TYPES: ReadonlySet<string> = new Set([
+  'tool_call',
+  'tool_use',
+  'server_tool_use',
+  'mcp_tool_use',
+  'server_tool_call',
+  'toolCall',
+  'toolUse',
+  'executableCode',
+]);
+
+export function isProviderToolCallContentPart(part: unknown): boolean {
+  const record = getRecord(part);
+  const type = record == null ? undefined : readString(record, 'type');
+  return type != null && PROVIDER_TOOL_CALL_CONTENT_TYPES.has(type);
+}
+
+export function isProviderToolContentPart(part: unknown): boolean {
+  const record = getRecord(part);
+  const type = record == null ? undefined : readString(record, 'type');
+  return (
+    type != null &&
+    (PROVIDER_TOOL_CALL_CONTENT_TYPES.has(type) ||
+      Object.prototype.hasOwnProperty.call(TOOL_RESULT_ENVELOPE_FIELDS, type))
+  );
+}
+
 function optionalName(
   record: Record<string, unknown>
 ): { readonly name?: string } | undefined {
@@ -817,10 +831,7 @@ function getAnthropicCallKind(
   if (type === 'mcp_tool_use') {
     return 'mcp';
   }
-  if (
-    type === 'server_tool_use' ||
-    isAnthropicServerToolCall(callId, name)
-  ) {
+  if (type === 'server_tool_use' || isAnthropicServerToolCall(callId, name)) {
     return 'anthropic-server';
   }
   return 'tool';
@@ -880,11 +891,7 @@ export function getProviderAIMessageToolCallDescriptor(
   const record = getRecord(toolCall);
   if (
     record == null ||
-    !hasExactCallShape(
-      record,
-      AI_TOOL_CALL_FIELDS,
-      ['id', 'name', 'args']
-    ) ||
+    !hasExactCallShape(record, AI_TOOL_CALL_FIELDS, ['id', 'name', 'args']) ||
     !hasOptionalCallType(record, 'tool_call')
   ) {
     return undefined;
@@ -920,18 +927,14 @@ export function getProviderToolCallPartDescriptor(
         ['type', 'tool_call', 'agentId', 'groupId'],
         ['tool_call']
       )
-      : hasExactCallShape(
-        record,
-        STANDARD_CALL_FIELDS,
-        ['id', 'name', 'args']
-      );
+      : hasExactCallShape(record, STANDARD_CALL_FIELDS, ['id', 'name', 'args']);
     const callIsValid = nested.found
       ? call != null &&
-        hasExactCallShape(
-          call,
-          LIBRECHAT_CALL_FIELDS,
-          ['id', 'name', 'args']
-        ) &&
+        hasExactCallShape(call, LIBRECHAT_CALL_FIELDS, [
+          'id',
+          'name',
+          'args',
+        ]) &&
         hasOptionalCallType(call, 'tool_call')
       : call != null;
     if (!outerIsValid || !callIsValid) {
@@ -991,11 +994,7 @@ export function getProviderToolCallPartDescriptor(
   }
   if (type === 'server_tool_call') {
     if (
-      !hasExactCallShape(
-        record,
-        STANDARD_CALL_FIELDS,
-        ['id', 'name', 'args']
-      )
+      !hasExactCallShape(record, STANDARD_CALL_FIELDS, ['id', 'name', 'args'])
     ) {
       return undefined;
     }
@@ -1099,23 +1098,24 @@ export function appendProviderToolCallDescriptor(
   if (existing === null) {
     return;
   }
-  const isDualRepresentation =
-    existing.secondarySourceType == null &&
-    existing.descriptor.sourceType !== descriptor.sourceType &&
-    (existing.descriptor.sourceType === 'ai_tool_calls' ||
-      descriptor.sourceType === 'ai_tool_calls');
-  if (
+  const sourceTypes =
+    existing.secondarySourceTypes ??
+    new Set<string>([existing.descriptor.sourceType]);
+  const isEquivalentRepresentation =
     existing.descriptor.kind === descriptor.kind &&
     existing.descriptor.name === descriptor.name &&
-    isDualRepresentation
-  ) {
-    existing.secondarySourceType = descriptor.sourceType;
+    !sourceTypes.has(descriptor.sourceType);
+  if (isEquivalentRepresentation) {
+    sourceTypes.add(descriptor.sourceType);
+    existing.secondarySourceTypes = sourceTypes;
     return;
   }
   index.set(descriptor.callId, null);
 }
 
-function isExecutableCodePart(part: unknown): boolean {
+/** Google's built-in code execution emits an `executableCode` part with no call
+ *  id; its `codeExecutionResult` pairs by adjacency instead. */
+export function isExecutableCodePart(part: unknown): boolean {
   const record = getRecord(part);
   if (
     record == null ||
@@ -1172,3 +1172,234 @@ export function consumeProviderToolResultPair(
   calls.delete(descriptor.toolCallId);
   return true;
 }
+
+function readOwnString(value: unknown, key: string): string | undefined {
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor != null &&
+      'value' in descriptor &&
+      typeof descriptor.value === 'string' &&
+      descriptor.value !== '' &&
+      descriptor.value.length <= PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS
+      ? descriptor.value
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function readOwnValue(value: unknown, key: string): unknown {
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor != null && 'value' in descriptor
+      ? descriptor.value
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+const LEGACY_FUNCTION_CALL_PREFIX = 'legacy_function:';
+
+export function getLegacyFunctionCallId(name: string): string | undefined {
+  const callId = `${LEGACY_FUNCTION_CALL_PREFIX}${name}`;
+  return callId.length <= PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS
+    ? callId
+    : undefined;
+}
+
+export type ProviderMessageRole =
+  | 'assistant'
+  | 'user'
+  | 'system'
+  | 'tool'
+  | 'function';
+
+/** The OpenAI converter forwards `assistant` / `user` / `system` / `developer`
+ *  / `tool` / `function`; the Google converter additionally reads `ai`,
+ *  `model` and `supervisor` as the model turn and `human` as the user. */
+const GENERIC_MESSAGE_ROLES: Readonly<Record<string, ProviderMessageRole>> = {
+  assistant: 'assistant',
+  ai: 'assistant',
+  model: 'assistant',
+  supervisor: 'assistant',
+  user: 'user',
+  human: 'user',
+  system: 'system',
+  developer: 'system',
+  tool: 'tool',
+  function: 'function',
+};
+
+/**
+ * Normalizes a message to the role a provider converter would send it as. A
+ * `ChatMessage` reports its type as `generic` and carries the wire role on
+ * `role`, so every classifier that keys on `getType()` alone silently skips
+ * generic assistant, tool and function messages the converters accept.
+ */
+export function getProviderMessageRole(
+  message: BaseMessage,
+  provider?: ProviderName
+): ProviderMessageRole | undefined {
+  const type = message.getType();
+  switch (type) {
+  case 'ai':
+    return 'assistant';
+  case 'human':
+    return 'user';
+  case 'system':
+    return 'system';
+  case 'tool':
+    return 'tool';
+  case 'function':
+    return 'function';
+  case 'generic': {
+    if (provider != null && getProviderFamily(provider) === 'bedrock') {
+      return 'user';
+    }
+    const role = (message as Partial<ChatMessage>).role;
+    return typeof role === 'string' ? GENERIC_MESSAGE_ROLES[role] : undefined;
+  }
+  default:
+    return undefined;
+  }
+}
+
+export function getRawToolCallDescriptor(
+  toolCall: unknown
+): ProviderToolCallPartDescriptor | undefined {
+  const callId = readOwnString(toolCall, 'id');
+  if (callId == null) {
+    return undefined;
+  }
+  let name: string | undefined;
+  if (toolCall != null && typeof toolCall === 'object') {
+    try {
+      const property = Object.getOwnPropertyDescriptor(toolCall, 'function');
+      name =
+        property != null && 'value' in property
+          ? readOwnString(property.value, 'name')
+          : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  return {
+    callId,
+    kind: 'tool',
+    sourceType: 'raw_tool_calls',
+    ...(name == null ? {} : { name }),
+  };
+}
+
+/**
+ * Appends every tool call an assistant message carries: parsed
+ * `AIMessage.tool_calls`, raw `additional_kwargs.tool_calls` (where OpenAI
+ * keeps calls when the parsed array is empty) and a legacy
+ * `additional_kwargs.function_call`. Content-block calls are the caller's to
+ * append, since only the caller knows whether the block is being replayed.
+ * Returns how many descriptors were recognized, so a caller can tell an
+ * invocation from a plain assistant turn without re-deriving the shapes.
+ */
+export function appendProviderMessageToolCalls(
+  message: BaseMessage,
+  calls: ProviderToolCallIndex,
+  provider?: ProviderName
+): number {
+  if (getProviderMessageRole(message, provider) !== 'assistant') {
+    return 0;
+  }
+  let recognized = 0;
+  const toolCalls = getBoundedProviderPairingArrayProperty(
+    message,
+    'tool_calls'
+  );
+  if (toolCalls != null) {
+    for (let index = 0; index < toolCalls.length; index++) {
+      const descriptor = getProviderAIMessageToolCallDescriptor(
+        toolCalls[index]
+      );
+      if (descriptor != null) {
+        appendProviderToolCallDescriptor(calls, descriptor);
+        recognized += 1;
+      }
+    }
+  }
+
+  const rawToolCalls = getBoundedProviderPairingArrayProperty(
+    message.additional_kwargs,
+    'tool_calls'
+  );
+  if (rawToolCalls != null) {
+    for (let index = 0; index < rawToolCalls.length; index++) {
+      const descriptor = getRawToolCallDescriptor(rawToolCalls[index]);
+      if (descriptor != null) {
+        appendProviderToolCallDescriptor(calls, descriptor);
+        recognized += 1;
+      }
+    }
+  }
+
+  const legacyFunctionCall = readOwnValue(
+    message.additional_kwargs,
+    'function_call'
+  );
+  const legacyFunctionName = readOwnString(legacyFunctionCall, 'name');
+  const legacyFunctionCallId =
+    legacyFunctionName == null
+      ? undefined
+      : getLegacyFunctionCallId(legacyFunctionName);
+  if (legacyFunctionCallId != null) {
+    appendProviderToolCallDescriptor(calls, {
+      callId: legacyFunctionCallId,
+      kind: 'tool',
+      name: legacyFunctionName,
+      sourceType: 'legacy_function_call',
+    });
+    recognized += 1;
+  }
+  return recognized;
+}
+
+/** Describes a whole-message tool result: a `ToolMessage`, a `FunctionMessage`,
+ *  or a generic message carrying the equivalent wire role. */
+export function getProviderToolMessageResultDescriptor(
+  message: BaseMessage,
+  provider?: ProviderName
+): ProviderToolResultPartDescriptor | undefined {
+  const role = getProviderMessageRole(message, provider);
+  if (role === 'function' && message.name != null) {
+    const toolCallId = getLegacyFunctionCallId(message.name);
+    return toolCallId == null
+      ? undefined
+      : {
+        type: 'function_message',
+        toolCallId,
+        compatibleCallKinds: ['tool'],
+        expectedToolNames: [message.name],
+      };
+  }
+  if (role !== 'tool') {
+    return undefined;
+  }
+  const toolMessage = message as ToolMessage & { toolCallId?: unknown };
+  const toolCallId =
+    typeof toolMessage.tool_call_id === 'string'
+      ? toolMessage.tool_call_id
+      : toolMessage.toolCallId;
+  return typeof toolCallId === 'string' &&
+    toolCallId !== '' &&
+    toolCallId.length <= PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS
+    ? {
+      type: 'tool_message',
+      toolCallId,
+      compatibleCallKinds: ['tool'],
+    }
+    : undefined;
+}