@librechat/agents 3.3.3 → 3.3.5

package/src/llm/openai/index.ts

@@ -29,16 +29,28 @@ import type {
   BaseMessageChunk,
   UsageMetadata,
 } from '@langchain/core/messages';
+import type { ChatModelStreamEvent } from '@langchain/core/language_models/event';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { ChatGeneration, ChatResult } from '@langchain/core/outputs';
 import type { ChatXAIInput } from '@langchain/xai';
 import type * as t from '@langchain/openai';
 import type { SeenScalarMetadata } from './streamMetadata';
 import type { HeaderValue, HeadersLike } from './types';
+import type { PromptCacheTtl } from '@/messages/cache';
+import {
+  buildAnthropicCacheControl,
+  resolvePromptCacheTtl,
+  stripAnthropicCacheControl,
+  stripBedrockCacheControl,
+} from '@/messages/cache';
 import {
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
   OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,
 } from '@/tools/streamedToolCallSeals';
+import {
+  projectOpenAIResponsesToolMessageContent,
+  projectToolStreamContentForProvider,
+} from '@/messages/core';
 import { isReasoningModel, _convertMessagesToOpenAIParams } from './utils';
 import { dropRepeatedScalarMetadata } from './streamMetadata';
 
@@ -102,6 +114,9 @@ type LibreChatOpenAIFields = t.ChatOpenAIFields & {
   includeReasoningContent?: boolean;
   includeReasoningDetails?: boolean;
   convertReasoningDetailsToContent?: boolean;
+  preserveToolCacheControl?: boolean;
+  responsesPromptCache?: boolean;
+  responsesPromptCacheTtl?: PromptCacheTtl;
   promptCacheExplicit?: boolean;
   safety_identifier?: string;
 };
@@ -168,6 +183,40 @@ type OpenAIManagedRequestParams = {
   };
   safety_identifier?: string;
 };
+
+function stripResponsesToolCacheControl<T>(tools: T): T {
+  if (!Array.isArray(tools)) {
+    return tools;
+  }
+
+  return tools.map((tool) => {
+    if (tool == null || typeof tool !== 'object') {
+      return tool;
+    }
+    const clone = { ...(tool as Record<string, unknown>) };
+    delete clone.cache_control;
+    if (
+      clone.extras != null &&
+      typeof clone.extras === 'object' &&
+      !Array.isArray(clone.extras)
+    ) {
+      clone.extras = { ...(clone.extras as Record<string, unknown>) };
+      delete (clone.extras as Record<string, unknown>).cache_control;
+    }
+    return clone;
+  }) as T;
+}
+
+function projectOpenAIResponsesProviderMessages(
+  messages: BaseMessage[]
+): BaseMessage[] {
+  return projectOpenAIResponsesToolMessageContent(
+    stripAnthropicCacheControl(
+      stripBedrockCacheControl(projectToolStreamContentForProvider(messages))
+    )
+  );
+}
+
 type ResponsesRequest =
   | OpenAIClient.Responses.ResponseCreateParamsStreaming
   | OpenAIClient.Responses.ResponseCreateParamsNonStreaming;
@@ -1116,6 +1165,7 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
   private includeReasoningContent?: boolean;
   private includeReasoningDetails?: boolean;
   private convertReasoningDetailsToContent?: boolean;
+  private preserveToolCacheControl?: boolean;
   private promptCacheExplicit?: boolean;
   private safetyIdentifier?: string;
 
@@ -1125,6 +1175,7 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
     this.includeReasoningDetails = fields?.includeReasoningDetails;
     this.convertReasoningDetailsToContent =
       fields?.convertReasoningDetailsToContent;
+    this.preserveToolCacheControl = fields?.preserveToolCacheControl;
     this.promptCacheExplicit = fields?.promptCacheExplicit;
     this.safetyIdentifier = fields?.safety_identifier;
   }
@@ -1225,6 +1276,7 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
         includeReasoningContent: this.includeReasoningContent,
         includeReasoningDetails: this.includeReasoningDetails,
         convertReasoningDetailsToContent: this.convertReasoningDetailsToContent,
+        preserveToolCacheControl: this.preserveToolCacheControl,
       }
     );
 
@@ -1393,6 +1445,7 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
         includeReasoningContent: this.includeReasoningContent,
         includeReasoningDetails: this.includeReasoningDetails,
         convertReasoningDetailsToContent: this.convertReasoningDetailsToContent,
+        preserveToolCacheControl: this.preserveToolCacheControl,
       });
 
     const params = {
@@ -1533,21 +1586,52 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
 
 class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
   private promptCacheExplicit?: boolean;
+  private responsesPromptCache?: boolean;
+  private responsesPromptCacheTtl?: PromptCacheTtl;
   private safetyIdentifier?: string;
 
   constructor(fields?: LibreChatOpenAIFields) {
     super(fields);
     this.promptCacheExplicit = fields?.promptCacheExplicit;
+    this.responsesPromptCache = fields?.responsesPromptCache;
+    this.responsesPromptCacheTtl = fields?.responsesPromptCacheTtl;
     this.safetyIdentifier = fields?.safety_identifier;
   }
 
   invocationParams(
     options?: this['ParsedCallOptions']
   ): ReturnType<OriginalChatOpenAIResponses['invocationParams']> {
-    const params = applyManagedRequestParams(super.invocationParams(options), {
-      promptCacheExplicit: this.promptCacheExplicit,
-      safetyIdentifier: this.safetyIdentifier,
-    });
+    const cacheOptions = options as
+      | {
+          promptCache?: boolean;
+          promptCacheTtl?: PromptCacheTtl;
+        }
+      | undefined;
+    const promptCache = cacheOptions?.promptCache ?? this.responsesPromptCache;
+    const cacheControl =
+      promptCache === true
+        ? buildAnthropicCacheControl(
+          resolvePromptCacheTtl(
+            cacheOptions?.promptCacheTtl ?? this.responsesPromptCacheTtl
+          )
+        )
+        : undefined;
+    const baseParams = applyManagedRequestParams(
+      super.invocationParams(options),
+      {
+        promptCacheExplicit: this.promptCacheExplicit,
+        safetyIdentifier: this.safetyIdentifier,
+      }
+    );
+    const params = {
+      ...baseParams,
+      ...(baseParams.tools != null && {
+        tools: stripResponsesToolCacheControl(baseParams.tools),
+      }),
+      ...(cacheControl != null && {
+        cache_control: cacheControl,
+      }),
+    };
     if (shouldIncludeEncryptedReasoning(this.model, params)) {
       params.include = [
         ...new Set([
@@ -1592,7 +1676,11 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
     options: this['ParsedCallOptions'],
     runManager?: CallbackManagerForLLMRun
   ): Promise<ChatResult> {
-    const result = await super._generate(messages, options, runManager);
+    const result = await super._generate(
+      projectOpenAIResponsesProviderMessages(messages),
+      options,
+      runManager
+    );
     for (const generation of result.generations) {
       attachCacheWriteUsage(generation.message);
     }
@@ -1605,7 +1693,7 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
     runManager?: CallbackManagerForLLMRun
   ): AsyncGenerator<ChatGenerationChunk> {
     for await (const chunk of super._streamResponseChunks(
-      messages,
+      projectOpenAIResponsesProviderMessages(messages),
       options,
       runManager
     )) {
@@ -1614,6 +1702,18 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
     }
   }
 
+  async *_streamChatModelEvents(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatModelStreamEvent> {
+    yield* super._streamChatModelEvents(
+      projectOpenAIResponsesProviderMessages(messages),
+      options,
+      runManager
+    );
+  }
+
   protected _getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {

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!] } : {}),
               })