@librechat/agents 3.1.75-dev.1 → 3.1.76

package/dist/types/messages/format.d.ts

@@ -84,6 +84,9 @@ interface LangChainMessage {
  * @returns - The formatted LangChain message.
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
+interface FormatAgentMessagesOptions {
+    provider?: Providers;
+}
 /**
  * Groups content parts by agent and formats them with agent labels
  * This preprocesses multi-agent content to prevent identity confusion
@@ -107,7 +110,7 @@ export declare const labelContentByAgent: (contentParts: MessageContentComplex[]
  * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
-export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>, skills?: Map<string, string>) => {
+export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>, skills?: Map<string, string>, options?: FormatAgentMessagesOptions) => {
     messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
     indexTokenCountMap?: Record<number, number>;
     /** Cross-run summary extracted from the payload. Should be forwarded to the

package/dist/types/tools/search/tavily-scraper.d.ts

@@ -0,0 +1,19 @@
+import type * as t from './types';
+export declare class TavilyScraper implements t.BaseScraper {
+    private apiKey;
+    private apiUrl;
+    private timeout;
+    private payloadTimeout;
+    private logger;
+    private extractDepth;
+    private includeImages;
+    private includeFavicon;
+    private format;
+    constructor(config?: t.TavilyScraperConfig);
+    scrapeUrl(url: string, options?: t.TavilyScrapeOptions): Promise<[string, t.TavilyScrapeResponse]>;
+    scrapeUrls(urls: string[], options?: t.TavilyScrapeOptions): Promise<Array<[string, t.TavilyScrapeResponse]>>;
+    private extractBatch;
+    extractContent(response: t.TavilyScrapeResponse): [string, undefined | t.References];
+    extractMetadata(response: t.TavilyScrapeResponse): t.GenericScrapeMetadata;
+}
+export declare const createTavilyScraper: (config?: t.TavilyScraperConfig) => TavilyScraper;

package/dist/types/tools/search/tavily-search.d.ts

@@ -0,0 +1,4 @@
+import type * as t from './types';
+export declare const createTavilyAPI: (apiKey?: string, apiUrl?: string, options?: t.TavilySearchOptions) => {
+    getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
+};

package/dist/types/tools/search/types.d.ts

@@ -2,8 +2,8 @@ import type { Logger as WinstonLogger } from 'winston';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
-export type SearchProvider = 'serper' | 'searxng';
-export type ScraperProvider = 'firecrawl' | 'serper';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -56,11 +56,50 @@ export interface Source {
     snippet?: string;
     date?: string;
 }
+export type TavilyTimeRange = 'day' | 'week' | 'month' | 'year';
+export type TavilyTimeRangeInput = TavilyTimeRange | 'h' | 'd' | 'w' | 'm' | 'y';
+export interface TavilySearchOptions {
+    searchDepth?: 'basic' | 'advanced' | 'fast' | 'ultra-fast';
+    maxResults?: number;
+    includeImages?: boolean;
+    includeAnswer?: boolean | 'basic' | 'advanced';
+    includeRawContent?: boolean | 'markdown' | 'text';
+    includeDomains?: string[];
+    excludeDomains?: string[];
+    topic?: 'general' | 'news' | 'finance';
+    timeRange?: TavilyTimeRangeInput;
+    includeImageDescriptions?: boolean;
+    includeFavicon?: boolean;
+    chunksPerSource?: number;
+    safeSearch?: boolean;
+    timeout?: number;
+}
+export interface TavilySearchPayload {
+    query: string;
+    search_depth: NonNullable<TavilySearchOptions['searchDepth']>;
+    topic: NonNullable<TavilySearchOptions['topic']>;
+    max_results: number;
+    safe_search?: boolean;
+    time_range?: TavilyTimeRange;
+    country?: string;
+    include_images?: boolean;
+    include_answer?: NonNullable<TavilySearchOptions['includeAnswer']>;
+    include_raw_content?: NonNullable<TavilySearchOptions['includeRawContent']>;
+    include_domains?: string[];
+    exclude_domains?: string[];
+    include_image_descriptions?: boolean;
+    include_favicon?: boolean;
+    chunks_per_source?: number;
+}
 export interface SearchConfig {
     searchProvider?: SearchProvider;
     serperApiKey?: string;
     searxngInstanceUrl?: string;
     searxngApiKey?: string;
+    tavilyApiKey?: string;
+    tavilySearchUrl?: string;
+    tavilyExtractUrl?: string;
+    tavilySearchOptions?: TavilySearchOptions;
 }
 export type References = {
     links: MediaReference[];
@@ -95,6 +134,16 @@ export interface SerperScraperConfig {
     logger?: Logger;
     includeMarkdown?: boolean;
 }
+export interface TavilyScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    timeout?: number;
+    logger?: Logger;
+    extractDepth?: 'basic' | 'advanced';
+    includeImages?: boolean;
+    includeFavicon?: boolean;
+    format?: 'markdown' | 'text';
+}
 export interface ScraperContentResult {
     content: string;
 }
@@ -135,6 +184,7 @@ export interface CohereRerankerResponse {
 export type SafeSearchLevel = 0 | 1 | 2;
 export type Logger = WinstonLogger;
 export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
+    tavilyScraperOptions?: TavilyScraperConfig;
     logger?: Logger;
     safeSearch?: SafeSearchLevel;
     jinaApiKey?: string;
@@ -157,15 +207,27 @@ export type UsedReferences = {
     originalIndex: number;
     reference: MediaReference;
 }[];
+export type AnyScraperResponse = FirecrawlScrapeResponse | SerperScrapeResponse | TavilyScrapeResponse;
 /** Base Scraper Interface */
 export interface BaseScraper {
-    scrapeUrl(url: string, options?: unknown): Promise<[string, FirecrawlScrapeResponse | SerperScrapeResponse]>;
-    extractContent(response: FirecrawlScrapeResponse | SerperScrapeResponse): [string, undefined | References];
-    extractMetadata(response: FirecrawlScrapeResponse | SerperScrapeResponse): ScrapeMetadata | Record<string, string | number | boolean | null | undefined>;
+    scrapeUrl(url: string, options?: unknown): Promise<[string, AnyScraperResponse]>;
+    scrapeUrls?(urls: string[], options?: unknown): Promise<Array<[string, AnyScraperResponse]>>;
+    extractContent(response: AnyScraperResponse): [string, undefined | References];
+    extractMetadata(response: AnyScraperResponse): ScrapeMetadata | GenericScrapeMetadata;
 }
 /** Firecrawl */
 export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'version' | 'logger'>;
 export type SerperScrapeOptions = Omit<SerperScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+export type TavilyScrapeOptions = Omit<TavilyScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+export interface TavilyExtractPayload {
+    urls: string[];
+    extract_depth: NonNullable<TavilyScraperConfig['extractDepth']>;
+    include_images: boolean;
+    include_favicon?: boolean;
+    format?: NonNullable<TavilyScraperConfig['format']>;
+    timeout?: number;
+}
+export type GenericScrapeMetadata = Record<string, string | number | boolean | null | undefined>;
 export interface ScrapeMetadata {
     sourceURL?: string;
     url?: string;
@@ -241,6 +303,38 @@ export interface SerperScrapeResponse {
     };
     error?: string;
 }
+export interface TavilyScrapeResponse {
+    success: boolean;
+    data?: {
+        rawContent?: string;
+        images?: string[];
+        favicon?: string;
+    };
+    error?: string;
+}
+export interface TavilySearchResult {
+    title?: string;
+    url?: string;
+    content?: string;
+    score?: number;
+    published_date?: string;
+}
+export type TavilyImageResult = string | {
+    url?: string;
+    description?: string;
+};
+export interface TavilySearchResponse {
+    answer?: string;
+    images?: TavilyImageResult[];
+    results?: TavilySearchResult[];
+}
+export interface TavilyExtractResult {
+    url: string;
+    raw_content?: string;
+    images?: string[];
+    favicon?: string;
+    error?: string;
+}
 export interface FirecrawlScraperConfig {
     apiKey?: string;
     apiUrl?: string;

package/dist/types/tools/search/utils.d.ts

@@ -6,5 +6,5 @@ import type * as t from './types';
  */
 export declare const createDefaultLogger: () => t.Logger;
 export declare const fileExtRegex: RegExp;
-export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata, logger?: t.Logger) => string | undefined;
-export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata, logger?: t.Logger): string | undefined;
+export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata | t.GenericScrapeMetadata, logger?: t.Logger) => string | undefined;
+export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata | t.GenericScrapeMetadata, logger?: t.Logger): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.75-dev.1",
+  "version": "3.1.76",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/llm/custom-chat-models.smoke.test.ts

@@ -1,4 +1,8 @@
-import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+import {
+  AIMessage,
+  AIMessageChunk,
+  HumanMessage,
+} from '@langchain/core/messages';
 import type { OpenAIChatInput, OpenAIClient } from '@langchain/openai';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { CustomAnthropicInput } from '@/llm/anthropic';
@@ -69,6 +73,29 @@ type StreamingCompletionDelegate = {
 type StreamingCompletionBackedModel = {
   completions: StreamingCompletionDelegate;
 };
+type OpenAIStreamEvent = {
+  event: string;
+  data?: unknown;
+};
+type OpenAIStreamItem =
+  | OpenAIClient.Chat.Completions.ChatCompletionChunk
+  | OpenAIStreamEvent;
+type MockableCompletionCreate = (
+  request: unknown,
+  options?: unknown
+) => Promise<
+  AsyncIterable<OpenAIStreamItem> | OpenAIClient.Chat.Completions.ChatCompletion
+>;
+type MockableCompletionClient = {
+  chat: {
+    completions: {
+      create: MockableCompletionCreate;
+    };
+  };
+};
+type MockableCompletionDelegate = OpenAIResponsesDelegate & {
+  client?: MockableCompletionClient;
+};
 type OpenRouterReasoningStreamDelta =
   OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice.Delta & {
     reasoning_details?: Array<
@@ -93,6 +120,7 @@ type OpenRouterReasoningStreamChoice = Omit<
 > & {
   delta: OpenRouterReasoningStreamDelta;
 };
+type OpenAIStreamModel = ChatOpenAI | AzureChatOpenAI;
 
 const baseAzureFields = {
   azureOpenAIApiKey: 'test-azure-key',
@@ -109,6 +137,101 @@ const baseBedrockFields = {
   },
 };
 
+const createOpenAIStreamChunk = (
+  content: string,
+  finishReason: OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice['finish_reason'] = null
+): OpenAIClient.Chat.Completions.ChatCompletionChunk => ({
+  id: 'chatcmpl-hermes-test',
+  object: 'chat.completion.chunk',
+  created: 0,
+  model: 'hermes-agent',
+  choices: [
+    {
+      index: 0,
+      delta: { content },
+      finish_reason: finishReason,
+    },
+  ],
+});
+
+async function* createOpenAIStreamWithCustomEvents(): AsyncGenerator<OpenAIStreamItem> {
+  yield createOpenAIStreamChunk('Hello ');
+  yield {
+    event: 'hermes.tool.progress',
+    data: {
+      tool: 'execute_code',
+      toolCallId: 'call_1',
+      status: 'running',
+    },
+  };
+  yield {
+    event: 'hermes.tool.progress',
+    data: null,
+  };
+  yield {
+    event: 'message',
+    data: createOpenAIStreamChunk('world', 'stop'),
+  };
+}
+
+function mockCompletionStream(
+  model: OpenAIStreamModel
+): MockableCompletionCreate {
+  const completions = (
+    model as unknown as { completions: MockableCompletionDelegate }
+  ).completions;
+  completions._getClientOptions(undefined);
+  const client = completions.client;
+  if (client == null) {
+    throw new Error('Expected OpenAI completions client');
+  }
+
+  const createMock = jest.fn(async () =>
+    createOpenAIStreamWithCustomEvents()
+  ) as MockableCompletionCreate;
+  client.chat.completions.create = createMock;
+  return createMock;
+}
+
+function mockCompletion(
+  model: ChatOpenAI,
+  response: OpenAIClient.Chat.Completions.ChatCompletion
+): MockableCompletionCreate {
+  const completions = (
+    model as unknown as { completions: MockableCompletionDelegate }
+  ).completions;
+  completions._getClientOptions(undefined);
+  const client = completions.client;
+  if (client == null) {
+    throw new Error('Expected OpenAI completions client');
+  }
+
+  const createMock = jest.fn(async () => response) as MockableCompletionCreate;
+  client.chat.completions.create = createMock;
+  return createMock;
+}
+
+async function expectCustomSSEEventsSkipped(
+  model: OpenAIStreamModel
+): Promise<void> {
+  const createMock = mockCompletionStream(model);
+  const chunks: AIMessageChunk[] = [];
+  const stream = await model.stream([new HumanMessage('use a tool')]);
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+
+  const text = chunks
+    .map((chunk) => (typeof chunk.content === 'string' ? chunk.content : ''))
+    .join('');
+  expect(chunks).toHaveLength(2);
+  expect(text).toBe('Hello world');
+  expect(createMock).toHaveBeenCalledWith(
+    expect.objectContaining({ stream: true }),
+    expect.any(Object)
+  );
+}
+
 describe('custom chat model class smoke tests', () => {
   it('keeps the custom OpenAI client, stream delay, and reasoning precedence', () => {
     const model = new ChatOpenAI({
@@ -252,6 +375,57 @@ describe('custom chat model class smoke tests', () => {
     expect(xaiRequestOptions.baseURL).toBe('https://xai.test/v1');
   });
 
+  it('skips custom OpenAI-compatible SSE events during OpenAI streaming', async () => {
+    await expectCustomSSEEventsSkipped(
+      new ChatOpenAI({
+        model: 'hermes-agent',
+        apiKey: 'test-key',
+        streaming: true,
+      })
+    );
+  });
+
+  it('skips custom OpenAI-compatible SSE events during Azure streaming', async () => {
+    await expectCustomSSEEventsSkipped(
+      new AzureChatOpenAI({
+        ...baseAzureFields,
+      })
+    );
+  });
+
+  it('passes non-streaming OpenAI completions through unchanged', async () => {
+    const model = new ChatOpenAI({
+      model: 'hermes-agent',
+      apiKey: 'test-key',
+    });
+    const createMock = mockCompletion(model, {
+      id: 'chatcmpl-nonstream-test',
+      object: 'chat.completion',
+      created: 0,
+      model: 'hermes-agent',
+      choices: [
+        {
+          index: 0,
+          finish_reason: 'stop',
+          logprobs: null,
+          message: {
+            role: 'assistant',
+            content: 'plain response',
+            refusal: null,
+          },
+        },
+      ],
+    });
+
+    const response = await model.invoke([new HumanMessage('no stream')]);
+
+    expect(response.content).toBe('plain response');
+    expect(createMock).toHaveBeenCalledWith(
+      expect.objectContaining({ stream: false }),
+      expect.any(Object)
+    );
+  });
+
   it('keeps Moonshot reasoning content in completion requests', async () => {
     const moonshot = new ChatMoonshot({
       model: 'moonshot-v1-8k',

package/src/llm/openai/index.ts

@@ -119,6 +119,27 @@ type OpenAIClientDelegate = {
     options: OpenAICoreRequestOptions | undefined
   ): OpenAICoreRequestOptions;
 };
+type OpenAIChatCompletion = OpenAIClient.Chat.Completions.ChatCompletion;
+type OpenAIChatCompletionChunk =
+  OpenAIClient.Chat.Completions.ChatCompletionChunk;
+type OpenAIChatCompletionStreamItem =
+  | OpenAIChatCompletionChunk
+  | {
+      event: string;
+      data?: unknown;
+    };
+type OpenAIChatCompletionRequest =
+  | OpenAIClient.Chat.ChatCompletionCreateParamsStreaming
+  | OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming;
+type OpenAIChatCompletionResult =
+  | AsyncIterable<OpenAIChatCompletionChunk>
+  | OpenAIChatCompletion;
+type OpenAIChatCompletionRetry = (
+  request: OpenAIChatCompletionRequest,
+  requestOptions?: OpenAICoreRequestOptions
+) => Promise<
+  AsyncIterable<OpenAIChatCompletionStreamItem> | OpenAIChatCompletion
+>;
 
 function getExposedOpenAIClient(
   completions: OpenAIClientDelegate,
@@ -179,6 +200,67 @@ function getGatedReasoningParams(
   return getReasoningParams(baseReasoning, options);
 }
 
+function isObject(value: unknown): value is object {
+  return typeof value === 'object' && value !== null;
+}
+
+function isOpenAIChatCompletionChunk(
+  value: unknown
+): value is OpenAIChatCompletionChunk {
+  if (!isObject(value)) {
+    return false;
+  }
+
+  // Intentionally loose: downstream handlers already tolerate empty choices.
+  const { choices } = value as { choices?: unknown };
+  return Array.isArray(choices);
+}
+
+function getOpenAIChatCompletionChunk(
+  value: OpenAIChatCompletionStreamItem
+): OpenAIChatCompletionChunk | undefined {
+  if (isOpenAIChatCompletionChunk(value)) {
+    return value;
+  }
+
+  const { data } = value;
+  if (isOpenAIChatCompletionChunk(data)) {
+    return data;
+  }
+
+  return undefined;
+}
+
+async function* filterOpenAIChatCompletionStream(
+  stream: AsyncIterable<OpenAIChatCompletionStreamItem>
+): AsyncGenerator<OpenAIChatCompletionChunk> {
+  for await (const item of stream) {
+    const chunk = getOpenAIChatCompletionChunk(item);
+    if (chunk == null) {
+      continue;
+    }
+    yield chunk;
+  }
+}
+
+async function completionWithFilteredOpenAIStream(
+  request: OpenAIChatCompletionRequest,
+  requestOptions: OpenAICoreRequestOptions | undefined,
+  completionWithRetry: OpenAIChatCompletionRetry
+): Promise<OpenAIChatCompletionResult> {
+  if (request.stream !== true) {
+    return (await completionWithRetry(
+      request,
+      requestOptions
+    )) as OpenAIChatCompletion;
+  }
+
+  const stream = await completionWithRetry(request, requestOptions);
+  return filterOpenAIChatCompletionStream(
+    stream as AsyncIterable<OpenAIChatCompletionStreamItem>
+  );
+}
+
 function attachLibreChatDeltaFields(
   chunk: BaseMessageChunk,
   delta: Record<string, unknown>
@@ -406,6 +488,27 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
     return getCustomOpenAIClientOptions(this, options);
   }
 
+  async completionWithRetry(
+    request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming,
+    requestOptions?: OpenAICoreRequestOptions
+  ): Promise<AsyncIterable<OpenAIChatCompletionChunk>>;
+  async completionWithRetry(
+    request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming,
+    requestOptions?: OpenAICoreRequestOptions
+  ): Promise<OpenAIChatCompletion>;
+  async completionWithRetry(
+    request:
+      | OpenAIClient.Chat.ChatCompletionCreateParamsStreaming
+      | OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming,
+    requestOptions?: OpenAICoreRequestOptions
+  ): Promise<AsyncIterable<OpenAIChatCompletionChunk> | OpenAIChatCompletion> {
+    return completionWithFilteredOpenAIStream(
+      request,
+      requestOptions,
+      super.completionWithRetry.bind(this) as OpenAIChatCompletionRetry
+    );
+  }
+
   protected _convertCompletionsDeltaToBaseMessageChunk(
     delta: Record<string, unknown>,
     rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk,
@@ -829,6 +932,27 @@ class LibreChatAzureOpenAICompletions extends OriginalAzureChatOpenAICompletions
     }
     return requestOptions;
   }
+
+  async completionWithRetry(
+    request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming,
+    requestOptions?: OpenAICoreRequestOptions
+  ): Promise<AsyncIterable<OpenAIChatCompletionChunk>>;
+  async completionWithRetry(
+    request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming,
+    requestOptions?: OpenAICoreRequestOptions
+  ): Promise<OpenAIChatCompletion>;
+  async completionWithRetry(
+    request:
+      | OpenAIClient.Chat.ChatCompletionCreateParamsStreaming
+      | OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming,
+    requestOptions?: OpenAICoreRequestOptions
+  ): Promise<AsyncIterable<OpenAIChatCompletionChunk> | OpenAIChatCompletion> {
+    return completionWithFilteredOpenAIStream(
+      request,
+      requestOptions,
+      super.completionWithRetry.bind(this) as OpenAIChatCompletionRetry
+    );
+  }
 }
 
 class LibreChatAzureOpenAIResponses extends OriginalAzureChatOpenAIResponses {

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

@@ -303,6 +303,7 @@ export function _convertMessagesToOpenAIParams(
   model?: string,
   options?: ConvertMessagesOptions
 ): OpenAICompletionParam[] {
+  let hasReasoningToolCallContext = false;
   // TODO: Function messages do not support array content, fix cast
   return messages.flatMap((message) => {
     let role = messageToOpenAIRole(message);
@@ -333,6 +334,8 @@ export function _convertMessagesToOpenAIParams(
       role,
       content,
     };
+    let messageHasToolCalls = false;
+    let messageIsToolResult = false;
     if (message.name != null) {
       completionParam.name = message.name;
     }
@@ -341,17 +344,11 @@ export function _convertMessagesToOpenAIParams(
       completionParam.content = '';
     }
     if (isAIMessage(message) && !!message.tool_calls?.length) {
+      messageHasToolCalls = true;
       completionParam.tool_calls = message.tool_calls.map(
         convertLangChainToolCallToOpenAI
       );
       completionParam.content = hasAnthropicThinkingBlock ? content : '';
-      if (
-        options?.includeReasoningContent === true &&
-        message.additional_kwargs.reasoning_content != null
-      ) {
-        completionParam.reasoning_content =
-          message.additional_kwargs.reasoning_content;
-      }
       if (
         options?.includeReasoningDetails === true &&
         message.additional_kwargs.reasoning_details != null
@@ -399,14 +396,10 @@ export function _convertMessagesToOpenAIParams(
       }
     } else {
       if (message.additional_kwargs.tool_calls != null) {
+        messageHasToolCalls =
+          !Array.isArray(message.additional_kwargs.tool_calls) ||
+          message.additional_kwargs.tool_calls.length > 0;
         completionParam.tool_calls = message.additional_kwargs.tool_calls;
-        if (
-          options?.includeReasoningContent === true &&
-          message.additional_kwargs.reasoning_content != null
-        ) {
-          completionParam.reasoning_content =
-            message.additional_kwargs.reasoning_content;
-        }
         if (
           options?.includeReasoningDetails === true &&
           message.additional_kwargs.reasoning_details != null
@@ -454,10 +447,26 @@ export function _convertMessagesToOpenAIParams(
         }
       }
       if ((message as ToolMessage).tool_call_id != null) {
+        messageIsToolResult = true;
         completionParam.tool_call_id = (message as ToolMessage).tool_call_id;
       }
     }
 
+    if (
+      options?.includeReasoningContent === true &&
+      isAIMessage(message) &&
+      (hasReasoningToolCallContext || messageHasToolCalls) &&
+      typeof message.additional_kwargs.reasoning_content === 'string' &&
+      message.additional_kwargs.reasoning_content !== ''
+    ) {
+      completionParam.reasoning_content =
+        message.additional_kwargs.reasoning_content;
+    }
+
+    if (messageHasToolCalls || messageIsToolResult) {
+      hasReasoningToolCallContext = true;
+    }
+
     if (
       message.additional_kwargs.audio &&
       typeof message.additional_kwargs.audio === 'object' &&