@librechat/agents 3.3.3 → 3.3.4

package/src/llm/openai/utils/index.ts

@@ -3,7 +3,6 @@
 import { type OpenAI as OpenAIClient } from 'openai';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
 import {
-  convertLangChainToolCallToOpenAI,
   makeInvalidToolCall,
   parseToolCall,
 } from '@langchain/core/output_parsers/openai_tools';
@@ -37,11 +36,23 @@ import type {
   ChatOpenAIReasoningSummary,
 } from '@langchain/openai';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import {
+  getBoundedCacheControlledTextToolContent,
+  getComputerCallOutputScreenshot,
+  isComputerCallOutputMessage,
+  serializeStructuredValueBounded,
+} from '@/utils/toolContent';
 import {
   STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
   OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
 } from '@/tools/streamedToolCallSeals';
+import {
+  calculateMaxToolCallInputChars,
+  projectToolCallInputs,
+  serializeToolCallInput,
+} from '@/messages/prune';
+import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 import { toLangChainContent } from '@/messages/langchain';
 
 export type { OpenAICallOptions, OpenAIChatInput };
@@ -83,6 +94,32 @@ type OpenAIRoleEnum =
 type OpenAICompletionParam =
   OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
 
+const MAX_PROVIDER_TOOL_CALL_INPUT_CHARS = calculateMaxToolCallInputChars();
+
+function convertLangChainToolCallToBoundedOpenAI(toolCall: ToolCall): {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+} {
+  if (toolCall.id == null) {
+    throw new Error('All OpenAI tool calls must have an "id" field.');
+  }
+  return {
+    id: toolCall.id,
+    type: 'function',
+    function: {
+      name: toolCall.name,
+      arguments: serializeToolCallInput(
+        toolCall.args,
+        MAX_PROVIDER_TOOL_CALL_INPUT_CHARS
+      ),
+    },
+  };
+}
+
 function extractGenericMessageCustomRole(message: ChatMessage) {
   if (
     message.role !== 'system' &&
@@ -300,6 +337,8 @@ export interface ConvertMessagesOptions {
   includeReasoningDetails?: boolean;
   /** Convert reasoning_details to content blocks for Claude (requires content array format) */
   convertReasoningDetailsToContent?: boolean;
+  /** Preserve OpenRouter's canonical cache-decorated tool text block. */
+  preserveToolCacheControl?: boolean;
 }
 
 // Used in LangSmith, export is important here
@@ -308,9 +347,13 @@ export function _convertMessagesToOpenAIParams(
   model?: string,
   options?: ConvertMessagesOptions
 ): OpenAICompletionParam[] {
+  const projectedMessages = projectToolCallInputs(
+    messages,
+    MAX_PROVIDER_TOOL_CALL_INPUT_CHARS
+  );
   let hasReasoningToolCallContext = false;
   // TODO: Function messages do not support array content, fix cast
-  return messages.flatMap((message) => {
+  return projectedMessages.flatMap((message) => {
     let role = messageToOpenAIRole(message);
     if (role === 'system' && isReasoningModel(model)) {
       role = 'developer';
@@ -318,22 +361,40 @@ export function _convertMessagesToOpenAIParams(
 
     let hasAnthropicThinkingBlock: boolean = false;
 
-    const content =
-      typeof message.content === 'string'
-        ? message.content
-        : message.content.map((m) => {
-          if ('type' in m && m.type === 'thinking') {
-            hasAnthropicThinkingBlock = true;
-            return m;
-          }
-          if (isDataContentBlock(m)) {
-            return convertToProviderContentBlock(
-              m,
-              completionsApiContentBlockConverter
-            );
-          }
+    let content: unknown;
+    if (
+      role === 'tool' &&
+      typeof message.content !== 'string' &&
+      !isComputerCallOutputMessage(message)
+    ) {
+      content =
+        options?.preserveToolCacheControl === true
+          ? getBoundedCacheControlledTextToolContent(
+            message.content,
+            HARD_MAX_TOOL_RESULT_CHARS
+          )
+          : undefined;
+      content ??= serializeStructuredValueBounded(
+        message.content,
+        HARD_MAX_TOOL_RESULT_CHARS
+      ).content;
+    } else if (typeof message.content === 'string') {
+      content = message.content;
+    } else {
+      content = message.content.map((m) => {
+        if ('type' in m && m.type === 'thinking') {
+          hasAnthropicThinkingBlock = true;
           return m;
-        });
+        }
+        if (isDataContentBlock(m)) {
+          return convertToProviderContentBlock(
+            m,
+            completionsApiContentBlockConverter
+          );
+        }
+        return m;
+      });
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const completionParam: Record<string, any> = {
       role,
@@ -351,7 +412,7 @@ export function _convertMessagesToOpenAIParams(
     if (isAIMessage(message) && !!message.tool_calls?.length) {
       messageHasToolCalls = true;
       completionParam.tool_calls = message.tool_calls.map(
-        convertLangChainToolCallToOpenAI
+        convertLangChainToolCallToBoundedOpenAI
       );
       completionParam.content = hasAnthropicThinkingBlock ? content : '';
       if (
@@ -527,7 +588,11 @@ export function _convertMessagesToOpenAIResponsesParams(
   model?: string,
   zdrEnabled?: boolean
 ): ResponsesInputItem[] {
-  return messages.flatMap(
+  const projectedMessages = projectToolCallInputs(
+    messages,
+    MAX_PROVIDER_TOOL_CALL_INPUT_CHARS
+  );
+  return projectedMessages.flatMap(
     (lcMsg): ResponsesInputItem | ResponsesInputItem[] => {
       const additional_kwargs =
         lcMsg.additional_kwargs as BaseMessageFields['additional_kwargs'] & {
@@ -552,44 +617,29 @@ export function _convertMessagesToOpenAIResponsesParams(
 
         // Handle computer call output
         if (additional_kwargs.type === 'computer_call_output') {
-          const output = (() => {
-            if (typeof toolMessage.content === 'string') {
-              return {
-                type: 'computer_screenshot' as const,
-                image_url: toolMessage.content,
-              };
-            }
-
-            if (Array.isArray(toolMessage.content)) {
-              const oaiScreenshot = toolMessage.content.find(
-                (i) => i.type === 'computer_screenshot'
-              ) as { type: 'computer_screenshot'; image_url: string };
-
-              if (oaiScreenshot) return oaiScreenshot;
-
-              const lcImage = toolMessage.content.find(
-                (i) => i.type === 'image_url'
-              ) as MessageContentImageUrl;
-
-              if (lcImage) {
-                return {
-                  type: 'computer_screenshot' as const,
-                  image_url:
-                    typeof lcImage.image_url === 'string'
-                      ? lcImage.image_url
-                      : lcImage.image_url.url,
-                };
-              }
-            }
-
+          const screenshot = getComputerCallOutputScreenshot(
+            toolMessage.content
+          );
+          if (screenshot == null) {
             throw new Error('Invalid computer call output');
-          })();
+          }
 
-          return {
+          const output: OpenAIClient.Responses.ResponseComputerToolCallOutputScreenshot =
+            'image_url' in screenshot
+              ? {
+                type: 'computer_screenshot',
+                image_url: screenshot.image_url,
+              }
+              : {
+                type: 'computer_screenshot',
+                file_id: screenshot.file_id,
+              };
+          const computerCallOutput: ResponsesInputItem = {
             type: 'computer_call_output',
             output,
             call_id: toolMessage.tool_call_id,
           };
+          return computerCallOutput;
         }
 
         return {
@@ -598,7 +648,10 @@ export function _convertMessagesToOpenAIResponsesParams(
           id: toolMessage.id?.startsWith('fc_') ? toolMessage.id : undefined,
           output:
             typeof toolMessage.content !== 'string'
-              ? JSON.stringify(toolMessage.content)
+              ? serializeStructuredValueBounded(
+                toolMessage.content,
+                HARD_MAX_TOOL_RESULT_CHARS
+              ).content
               : toolMessage.content,
         };
       }
@@ -682,7 +735,10 @@ export function _convertMessagesToOpenAIResponsesParams(
               (toolCall): ResponsesInputItem => ({
                 type: 'function_call',
                 name: toolCall.name,
-                arguments: JSON.stringify(toolCall.args),
+                arguments: serializeToolCallInput(
+                  toolCall.args,
+                  MAX_PROVIDER_TOOL_CALL_INPUT_CHARS
+                ),
                 call_id: toolCall.id!,
                 ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id!] } : {}),
               })

package/src/llm/openai/utils/messages.test.ts

@@ -1,5 +1,10 @@
 import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
-import { _convertMessagesToOpenAIParams } from './index';
+import {
+  _convertMessagesToOpenAIParams,
+  _convertMessagesToOpenAIResponsesParams,
+} from './index';
+import { calculateMaxToolCallInputChars } from '@/messages/prune';
+import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 
 describe('_convertMessagesToOpenAIParams', () => {
   it('includes reasoning_content for assistant messages in tool-call context when requested', () => {
@@ -156,4 +161,328 @@ describe('_convertMessagesToOpenAIParams', () => {
       })
     );
   });
+
+  it('bounds structured function-tool output for Chat and Responses adapters', () => {
+    let toJSONCalls = 0;
+    const toolMessage = new ToolMessage({
+      content: [
+        { type: 'text', text: 'rendered chart' },
+        {
+          type: 'image_url',
+          image_url: {
+            url: `data:image/png;base64,${'A'.repeat(
+              HARD_MAX_TOOL_RESULT_CHARS + 1_000
+            )}`,
+          },
+          toJSON() {
+            toJSONCalls++;
+            return { expanded: 'B'.repeat(HARD_MAX_TOOL_RESULT_CHARS * 2) };
+          },
+        },
+      ],
+      tool_call_id: 'call_structured',
+    });
+
+    const chat = _convertMessagesToOpenAIParams([toolMessage]);
+    const responses = _convertMessagesToOpenAIResponsesParams([toolMessage]);
+    const chatContent = chat[0].content;
+
+    expect(typeof chatContent).toBe('string');
+    expect((chatContent as string).length).toBeLessThanOrEqual(
+      HARD_MAX_TOOL_RESULT_CHARS
+    );
+    expect(responses[0]).toMatchObject({
+      type: 'function_call_output',
+      call_id: 'call_structured',
+      output: chatContent,
+    });
+    expect(toJSONCalls).toBe(0);
+    expect(Array.isArray(toolMessage.content)).toBe(true);
+  });
+
+  it('preserves canonical OpenRouter cache blocks only when requested', () => {
+    const toolMessage = new ToolMessage({
+      content: [
+        {
+          type: 'text',
+          text: 'result body',
+          cache_control: { type: 'ephemeral', ttl: '1h' },
+        },
+      ],
+      tool_call_id: 'call_cached',
+    });
+
+    const defaultContent = _convertMessagesToOpenAIParams([toolMessage])[0]
+      .content;
+    const openRouterContent = _convertMessagesToOpenAIParams(
+      [toolMessage],
+      'anthropic/claude-sonnet-4',
+      { preserveToolCacheControl: true }
+    )[0].content;
+
+    expect(typeof defaultContent).toBe('string');
+    expect(openRouterContent).toEqual(toolMessage.content);
+  });
+
+  it('bounds direct structured tool-call args without invoking accessors or toJSON', () => {
+    const maxInputChars = calculateMaxToolCallInputChars();
+    let getterCalls = 0;
+    let toJSONCalls = 0;
+    const args: Record<string, unknown> = {
+      query: 'safe',
+      payload: 'x'.repeat(maxInputChars + 1_000),
+    };
+    Object.defineProperty(args, 'expanded', {
+      enumerable: true,
+      get() {
+        getterCalls++;
+        return 'y'.repeat(maxInputChars * 2);
+      },
+    });
+    args.self = args;
+    args.toJSON = (): Record<string, string> => {
+      toJSONCalls++;
+      return { payload: 'z'.repeat(maxInputChars * 2) };
+    };
+    const message = new AIMessage({
+      content: '',
+      tool_calls: [
+        {
+          id: 'call_adversarial',
+          name: 'lookup',
+          args,
+        },
+      ],
+    });
+
+    const chat = _convertMessagesToOpenAIParams([message]);
+    const responses = _convertMessagesToOpenAIResponsesParams([message]);
+    const chatArguments = (
+      chat[0] as {
+        tool_calls: Array<{ function: { arguments: string } }>;
+      }
+    ).tool_calls[0].function.arguments;
+    const responseArguments = (
+      responses.find((item) => item.type === 'function_call') as {
+        arguments: string;
+      }
+    ).arguments;
+
+    expect(chatArguments).toBe(responseArguments);
+    expect(chatArguments.length).toBeLessThanOrEqual(maxInputChars);
+    expect(() => JSON.parse(chatArguments)).not.toThrow();
+    expect(getterCalls).toBe(0);
+    expect(toJSONCalls).toBe(0);
+    expect(args.self).toBe(args);
+  });
+
+  it('bounds and synchronizes raw Chat and Responses function-call arguments', () => {
+    const maxInputChars = calculateMaxToolCallInputChars();
+    const rawArguments = `{"payload":"${'x'.repeat(maxInputChars + 1_000)}"}`;
+    const rawOnlyMessage = new AIMessage({
+      content: '',
+      additional_kwargs: {
+        tool_calls: [
+          {
+            id: 'call_raw',
+            type: 'function',
+            function: { name: 'lookup', arguments: rawArguments },
+          },
+        ],
+      },
+      response_metadata: {
+        output: [
+          {
+            type: 'function_call',
+            id: 'fc_raw',
+            call_id: 'call_raw',
+            name: 'lookup',
+            arguments: rawArguments,
+          },
+        ],
+      },
+    });
+
+    const chat = _convertMessagesToOpenAIParams([rawOnlyMessage]);
+    const responses = _convertMessagesToOpenAIResponsesParams([rawOnlyMessage]);
+    const chatArguments = (
+      chat[0] as {
+        tool_calls: Array<{ function: { arguments: string } }>;
+      }
+    ).tool_calls[0].function.arguments;
+    const responseArguments = (
+      responses.find((item) => item.type === 'function_call') as {
+        arguments: string;
+      }
+    ).arguments;
+
+    expect(chatArguments.length).toBeLessThanOrEqual(maxInputChars);
+    expect(responseArguments.length).toBeLessThanOrEqual(maxInputChars);
+    expect(() => JSON.parse(chatArguments)).not.toThrow();
+    expect(() => JSON.parse(responseArguments)).not.toThrow();
+    expect(
+      (
+        rawOnlyMessage.additional_kwargs.tool_calls as Array<{
+          function: { arguments: string };
+        }>
+      )[0].function.arguments
+    ).toBe(rawArguments);
+    expect(
+      (
+        rawOnlyMessage.response_metadata.output as Array<{
+          arguments: string;
+        }>
+      )[0].arguments
+    ).toBe(rawArguments);
+  });
+
+  it('normalizes legacy function calls before wire serialization', () => {
+    let toJSONCalls = 0;
+    const functionCall = {
+      name: 'legacy_lookup',
+      arguments: '{}',
+    };
+    const message = new AIMessage({
+      content: '',
+      additional_kwargs: {
+        function_call: functionCall,
+      },
+    });
+    Object.defineProperty(functionCall, 'toJSON', {
+      enumerable: true,
+      value: () => {
+        toJSONCalls++;
+        return {
+          name: 'legacy_lookup',
+          arguments: 'x'.repeat(500_000),
+        };
+      },
+    });
+
+    const [chat] = _convertMessagesToOpenAIParams([message]);
+    const serialized = JSON.stringify(chat);
+
+    expect(chat).toMatchObject({
+      role: 'assistant',
+      function_call: {
+        name: 'legacy_lookup',
+        arguments: '{}',
+      },
+    });
+    expect(serialized.length).toBeLessThanOrEqual(300);
+    expect(toJSONCalls).toBe(0);
+  });
+
+  it('makes Responses raw reuse match the projected LangChain tool-call args', () => {
+    const message = new AIMessage({
+      content: '',
+      tool_calls: [
+        {
+          id: 'call_synced',
+          name: 'lookup',
+          args: { query: 'canonical', payload: 'x'.repeat(500_000) },
+        },
+      ],
+      response_metadata: {
+        output: [
+          {
+            type: 'function_call',
+            id: 'fc_synced',
+            call_id: 'call_synced',
+            name: 'lookup',
+            arguments: '{"query":"stale"}',
+          },
+        ],
+      },
+    });
+
+    const chat = _convertMessagesToOpenAIParams([message]);
+    const responses = _convertMessagesToOpenAIResponsesParams([message]);
+    const chatArguments = (
+      chat[0] as {
+        tool_calls: Array<{ function: { arguments: string } }>;
+      }
+    ).tool_calls[0].function.arguments;
+    const responseArguments = (
+      responses.find((item) => item.type === 'function_call') as {
+        arguments: string;
+      }
+    ).arguments;
+
+    expect(responseArguments).toBe(chatArguments);
+    expect(() => JSON.parse(responseArguments)).not.toThrow();
+    expect(
+      (
+        message.response_metadata.output as Array<{
+          arguments: string;
+        }>
+      )[0].arguments
+    ).toBe('{"query":"stale"}');
+  });
+
+  it('normalizes native Responses computer-call output screenshots', () => {
+    const screenshot = `data:image/png;base64,${'A'.repeat(2_000)}`;
+    const messages = [
+      new ToolMessage({
+        content: screenshot,
+        tool_call_id: 'call_computer_string',
+        additional_kwargs: { type: 'computer_call_output' },
+      }),
+      new ToolMessage({
+        content: [{ type: 'computer_screenshot', image_url: screenshot }],
+        tool_call_id: 'call_computer_structured',
+        additional_kwargs: { type: 'computer_call_output' },
+      }),
+      new ToolMessage({
+        content: [{ type: 'input_image', file_id: 'file_screenshot123' }],
+        tool_call_id: 'call_computer_file',
+        additional_kwargs: { type: 'computer_call_output' },
+      }),
+    ];
+
+    expect(_convertMessagesToOpenAIResponsesParams(messages)).toEqual([
+      {
+        type: 'computer_call_output',
+        call_id: 'call_computer_string',
+        output: { type: 'computer_screenshot', image_url: screenshot },
+      },
+      {
+        type: 'computer_call_output',
+        call_id: 'call_computer_structured',
+        output: { type: 'computer_screenshot', image_url: screenshot },
+      },
+      {
+        type: 'computer_call_output',
+        call_id: 'call_computer_file',
+        output: {
+          type: 'computer_screenshot',
+          file_id: 'file_screenshot123',
+        },
+      },
+    ]);
+  });
+
+  it('rejects malformed native Responses computer-call output', () => {
+    const message = new ToolMessage({
+      content: 'not a screenshot URL',
+      tool_call_id: 'call_computer_invalid',
+      additional_kwargs: { type: 'computer_call_output' },
+    });
+
+    expect(() => _convertMessagesToOpenAIResponsesParams([message])).toThrow(
+      'Invalid computer call output'
+    );
+  });
+
+  it('rejects a truncated data URI marked as a computer screenshot', () => {
+    const message = new ToolMessage({
+      content: 'data:image/png;base64,AAAA\n\n… [truncated: 1000 chars] …',
+      tool_call_id: 'call_computer_truncated',
+      additional_kwargs: { type: 'computer_call_output' },
+    });
+
+    expect(() => _convertMessagesToOpenAIResponsesParams([message])).toThrow(
+      'Invalid computer call output'
+    );
+  });
 });

package/src/llm/openrouter/index.ts

@@ -32,6 +32,7 @@ export interface ChatOpenRouterCallOptions
   include_reasoning?: boolean;
   reasoning?: OpenRouterReasoning;
   modelKwargs?: OpenAIChatInput['modelKwargs'];
+  useResponsesApi?: boolean;
   promptCache?: boolean;
   /**
    * Prompt-cache breakpoint TTL. Defaults to `'1h'` (extended cache) when
@@ -52,6 +53,7 @@ export type OpenRouterInvocationParams = Omit<
   'messages'
 > & {
   reasoning?: OpenRouterReasoning;
+  cache_control?: { type: 'ephemeral'; ttl?: '1h' };
 };
 
 type InvocationParamsExtra = {
@@ -150,6 +152,9 @@ export class ChatOpenRouter extends ChatOpenAI {
       modelKwargs: parentModelKwargs,
       includeReasoningDetails: true,
       convertReasoningDetailsToContent: true,
+      preserveToolCacheControl: true,
+      responsesPromptCache: _fields.promptCache,
+      responsesPromptCacheTtl: _fields.promptCacheTtl,
     });
 
     // Merge reasoning config: modelKwargs.reasoning < constructor reasoning
@@ -171,11 +176,16 @@ export class ChatOpenRouter extends ChatOpenAI {
     type MutableParams = Omit<
       OpenAIClient.Chat.ChatCompletionCreateParams,
       'messages'
-    > & { reasoning_effort?: string; reasoning?: OpenRouterReasoning };
+    > & {
+      reasoning_effort?: string;
+      reasoning?: OpenRouterReasoning;
+      cache_control?: { type: 'ephemeral'; ttl?: '1h' };
+    };
 
     const optionsWithDefaults = this._combineCallOptions(options);
+    const useResponsesApi = this._useResponsesApi(options);
     const params = (
-      this._useResponsesApi(options)
+      useResponsesApi
         ? this.responses.invocationParams(optionsWithDefaults)
         : this.completions.invocationParams(optionsWithDefaults, extra)
     ) as MutableParams;