@librechat/agents 3.0.33 → 3.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.0.33",
+  "version": "3.0.35",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -51,7 +51,7 @@
     "caching": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/caching.ts --name 'Jo' --location 'New York, NY'",
     "thinking": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/thinking.ts --name 'Jo' --location 'New York, NY'",
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
-    "tool": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
+    "tool": "node --trace-warnings -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'openrouter' --name 'Jo' --location 'New York, NY'",
     "search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/search.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
     "ant_web_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search.ts --name 'Jo' --location 'New York, NY'",
     "ant_web_search_edge_case": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search_edge_case.ts --name 'Jo' --location 'New York, NY'",
@@ -106,7 +106,6 @@
     "@langchain/google-vertexai": "^0.2.18",
     "@langchain/langgraph": "^0.4.9",
     "@langchain/mistralai": "^0.2.1",
-    "@langchain/ollama": "^0.2.3",
     "@langchain/openai": "0.5.18",
     "@langchain/textsplitters": "^0.1.0",
     "@langchain/xai": "^0.0.3",

package/src/common/enum.ts

@@ -77,7 +77,6 @@ export enum Providers {
   ANTHROPIC = 'anthropic',
   MISTRALAI = 'mistralai',
   MISTRAL = 'mistral',
-  OLLAMA = 'ollama',
   GOOGLE = 'google',
   AZURE = 'azureOpenAI',
   DEEPSEEK = 'deepseek',

package/src/llm/openai/index.ts

@@ -643,6 +643,132 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
     } as OpenAICoreRequestOptions;
     return requestOptions;
   }
+
+  async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped: OpenAICompletionParam[] =
+      _convertMessagesToOpenAIParams(messages, this.model, {
+        includeReasoningContent: true,
+      });
+
+    const params = {
+      ...this.invocationParams(options, {
+        streaming: true,
+      }),
+      messages: messagesMapped,
+      stream: true as const,
+    };
+    let defaultRole: OpenAIRoleEnum | undefined;
+
+    const streamIterable = await this.completionWithRetry(params, options);
+    let usage: OpenAIClient.Completions.CompletionUsage | undefined;
+    for await (const data of streamIterable) {
+      const choice = data.choices[0] as
+        | Partial<OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice>
+        | undefined;
+      if (data.usage) {
+        usage = data.usage;
+      }
+      if (!choice) {
+        continue;
+      }
+
+      const { delta } = choice;
+      if (!delta) {
+        continue;
+      }
+      const chunk = this._convertOpenAIDeltaToBaseMessageChunk(
+        delta,
+        data,
+        defaultRole
+      );
+      if ('reasoning_content' in delta) {
+        chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+      }
+      defaultRole = delta.role ?? defaultRole;
+      const newTokenIndices = {
+        prompt: (options as OpenAIChatCallOptions).promptIndex ?? 0,
+        completion: choice.index ?? 0,
+      };
+      if (typeof chunk.content !== 'string') {
+        // eslint-disable-next-line no-console
+        console.log(
+          '[WARNING]: Received non-string content from OpenAI. This is currently not supported.'
+        );
+        continue;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const generationInfo: Record<string, any> = { ...newTokenIndices };
+      if (choice.finish_reason != null) {
+        generationInfo.finish_reason = choice.finish_reason;
+        generationInfo.system_fingerprint = data.system_fingerprint;
+        generationInfo.model_name = data.model;
+        generationInfo.service_tier = data.service_tier;
+      }
+      if (this.logprobs == true) {
+        generationInfo.logprobs = choice.logprobs;
+      }
+      const generationChunk = new ChatGenerationChunk({
+        message: chunk,
+        text: chunk.content,
+        generationInfo,
+      });
+      yield generationChunk;
+      await runManager?.handleLLMNewToken(
+        generationChunk.text || '',
+        newTokenIndices,
+        undefined,
+        undefined,
+        undefined,
+        { chunk: generationChunk }
+      );
+    }
+    if (usage) {
+      const inputTokenDetails = {
+        ...(usage.prompt_tokens_details?.audio_tokens != null && {
+          audio: usage.prompt_tokens_details.audio_tokens,
+        }),
+        ...(usage.prompt_tokens_details?.cached_tokens != null && {
+          cache_read: usage.prompt_tokens_details.cached_tokens,
+        }),
+      };
+      const outputTokenDetails = {
+        ...(usage.completion_tokens_details?.audio_tokens != null && {
+          audio: usage.completion_tokens_details.audio_tokens,
+        }),
+        ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+          reasoning: usage.completion_tokens_details.reasoning_tokens,
+        }),
+      };
+      const generationChunk = new ChatGenerationChunk({
+        message: new AIMessageChunk({
+          content: '',
+          response_metadata: {
+            usage: { ...usage },
+          },
+          usage_metadata: {
+            input_tokens: usage.prompt_tokens,
+            output_tokens: usage.completion_tokens,
+            total_tokens: usage.total_tokens,
+            ...(Object.keys(inputTokenDetails).length > 0 && {
+              input_token_details: inputTokenDetails,
+            }),
+            ...(Object.keys(outputTokenDetails).length > 0 && {
+              output_token_details: outputTokenDetails,
+            }),
+          },
+        }),
+        text: '',
+      });
+      yield generationChunk;
+    }
+    if (options.signal?.aborted === true) {
+      throw new Error('AbortError');
+    }
+  }
 }
 
 /** xAI-specific usage metadata type */

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

@@ -286,10 +286,21 @@ const completionsApiContentBlockConverter: StandardContentBlockConverter<{
   },
 };
 
+/** Options for converting messages to OpenAI params */
+export interface ConvertMessagesOptions {
+  /** Include reasoning_content field for DeepSeek thinking mode with tool calls */
+  includeReasoningContent?: boolean;
+  /** Include reasoning_details field for OpenRouter/Gemini thinking mode with tool calls */
+  includeReasoningDetails?: boolean;
+  /** Convert reasoning_details to content blocks for Claude (requires content array format) */
+  convertReasoningDetailsToContent?: boolean;
+}
+
 // Used in LangSmith, export is important here
 export function _convertMessagesToOpenAIParams(
   messages: BaseMessage[],
-  model?: string
+  model?: string,
+  options?: ConvertMessagesOptions
 ): OpenAICompletionParam[] {
   // TODO: Function messages do not support array content, fix cast
   return messages.flatMap((message) => {
@@ -333,9 +344,113 @@ export function _convertMessagesToOpenAIParams(
         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
+      ) {
+        // For Claude via OpenRouter, convert reasoning_details to content blocks
+        const isClaudeModel =
+          model?.includes('claude') === true ||
+          model?.includes('anthropic') === true;
+        if (
+          options.convertReasoningDetailsToContent === true &&
+          isClaudeModel
+        ) {
+          const reasoningDetails = message.additional_kwargs
+            .reasoning_details as Record<string, unknown>[];
+          const contentBlocks = [];
+
+          // Add thinking blocks from reasoning_details
+          for (const detail of reasoningDetails) {
+            if (detail.type === 'reasoning.text' && detail.text != null) {
+              contentBlocks.push({
+                type: 'thinking',
+                thinking: detail.text,
+              });
+            } else if (
+              detail.type === 'reasoning.encrypted' &&
+              detail.data != null
+            ) {
+              contentBlocks.push({
+                type: 'redacted_thinking',
+                data: detail.data,
+                id: detail.id,
+              });
+            }
+          }
+
+          // Set content to array with thinking blocks
+          if (contentBlocks.length > 0) {
+            completionParam.content = contentBlocks;
+          }
+        } else {
+          // For non-Claude models, pass as separate field
+          completionParam.reasoning_details =
+            message.additional_kwargs.reasoning_details;
+        }
+      }
     } else {
       if (message.additional_kwargs.tool_calls != null) {
         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
+        ) {
+          // For Claude via OpenRouter, convert reasoning_details to content blocks
+          const isClaudeModel =
+            model?.includes('claude') === true ||
+            model?.includes('anthropic') === true;
+          if (
+            options.convertReasoningDetailsToContent === true &&
+            isClaudeModel
+          ) {
+            const reasoningDetails = message.additional_kwargs
+              .reasoning_details as Record<string, unknown>[];
+            const contentBlocks = [];
+
+            // Add thinking blocks from reasoning_details
+            for (const detail of reasoningDetails) {
+              if (detail.type === 'reasoning.text' && detail.text != null) {
+                contentBlocks.push({
+                  type: 'thinking',
+                  thinking: detail.text,
+                });
+              } else if (
+                detail.type === 'reasoning.encrypted' &&
+                detail.data != null
+              ) {
+                contentBlocks.push({
+                  type: 'redacted_thinking',
+                  data: detail.data,
+                  id: detail.id,
+                });
+              }
+            }
+
+            // Set content to array with thinking blocks
+            if (contentBlocks.length > 0) {
+              completionParam.content = contentBlocks;
+            }
+          } else {
+            // For non-Claude models, pass as separate field
+            completionParam.reasoning_details =
+              message.additional_kwargs.reasoning_details;
+          }
+        }
       }
       if ((message as ToolMessage).tool_call_id != null) {
         completionParam.tool_call_id = (message as ToolMessage).tool_call_id;

package/src/llm/openrouter/index.ts

@@ -1,4 +1,7 @@
 import { ChatOpenAI } from '@/llm/openai';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { AIMessageChunk as AIMessageChunkClass } from '@langchain/core/messages';
 import type {
   FunctionMessageChunk,
   SystemMessageChunk,
@@ -6,12 +9,25 @@ import type {
   ToolMessageChunk,
   ChatMessageChunk,
   AIMessageChunk,
+  BaseMessage,
 } from '@langchain/core/messages';
 import type {
   ChatOpenAICallOptions,
   OpenAIChatInput,
   OpenAIClient,
 } from '@langchain/openai';
+import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
+
+type OpenAICompletionParam =
+  OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
+
+type OpenAIRoleEnum =
+  | 'system'
+  | 'developer'
+  | 'assistant'
+  | 'user'
+  | 'function'
+  | 'tool';
 
 export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
   include_reasoning?: boolean;
@@ -54,7 +70,212 @@ export class ChatOpenRouter extends ChatOpenAI {
       rawResponse,
       defaultRole
     );
-    messageChunk.additional_kwargs.reasoning = delta.reasoning;
+    if (delta.reasoning != null) {
+      messageChunk.additional_kwargs.reasoning = delta.reasoning;
+    }
+    if (delta.reasoning_details != null) {
+      messageChunk.additional_kwargs.reasoning_details =
+        delta.reasoning_details;
+    }
     return messageChunk;
   }
+
+  async *_streamResponseChunks2(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped: OpenAICompletionParam[] =
+      _convertMessagesToOpenAIParams(messages, this.model, {
+        includeReasoningDetails: true,
+        convertReasoningDetailsToContent: true,
+      });
+
+    const params = {
+      ...this.invocationParams(options, {
+        streaming: true,
+      }),
+      messages: messagesMapped,
+      stream: true as const,
+    };
+    let defaultRole: OpenAIRoleEnum | undefined;
+
+    const streamIterable = await this.completionWithRetry(params, options);
+    let usage: OpenAIClient.Completions.CompletionUsage | undefined;
+
+    // Store reasoning_details keyed by unique identifier to prevent incorrect merging
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reasoningTextByIndex: Map<number, Record<string, any>> = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reasoningEncryptedById: Map<string, Record<string, any>> = new Map();
+
+    for await (const data of streamIterable) {
+      const choice = data.choices[0] as
+        | Partial<OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice>
+        | undefined;
+      if (data.usage) {
+        usage = data.usage;
+      }
+      if (!choice) {
+        continue;
+      }
+
+      const { delta } = choice;
+      if (!delta) {
+        continue;
+      }
+
+      // Accumulate reasoning_details from each delta
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const deltaAny = delta as Record<string, any>;
+      if (
+        deltaAny.reasoning_details != null &&
+        Array.isArray(deltaAny.reasoning_details)
+      ) {
+        for (const detail of deltaAny.reasoning_details) {
+          // For encrypted reasoning (thought signatures), store by ID - MUST be separate
+          if (detail.type === 'reasoning.encrypted' && detail.id) {
+            reasoningEncryptedById.set(detail.id, {
+              type: detail.type,
+              id: detail.id,
+              data: detail.data,
+              format: detail.format,
+              index: detail.index,
+            });
+          } else if (detail.type === 'reasoning.text') {
+            // For text reasoning, accumulate text by index
+            const idx = detail.index ?? 0;
+            const existing = reasoningTextByIndex.get(idx);
+            if (existing) {
+              // Only append text, keep other fields from first entry
+              existing.text = (existing.text || '') + (detail.text || '');
+            } else {
+              reasoningTextByIndex.set(idx, {
+                type: detail.type,
+                text: detail.text || '',
+                format: detail.format,
+                index: idx,
+              });
+            }
+          }
+        }
+      }
+
+      const chunk = this._convertOpenAIDeltaToBaseMessageChunk(
+        delta,
+        data,
+        defaultRole
+      );
+
+      // IMPORTANT: Only set reasoning_details on the FINAL chunk to prevent
+      // LangChain's chunk concatenation from corrupting the array
+      // Check if this is the final chunk (has finish_reason)
+      if (choice.finish_reason != null) {
+        // Build properly structured reasoning_details array
+        // Text entries first (but we only need the encrypted ones for thought signatures)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const finalReasoningDetails: Record<string, any>[] = [
+          ...reasoningTextByIndex.values(),
+          ...reasoningEncryptedById.values(),
+        ];
+
+        if (finalReasoningDetails.length > 0) {
+          chunk.additional_kwargs.reasoning_details = finalReasoningDetails;
+        }
+      } else {
+        // Clear reasoning_details from intermediate chunks to prevent concatenation issues
+        delete chunk.additional_kwargs.reasoning_details;
+      }
+
+      defaultRole = delta.role ?? defaultRole;
+      const newTokenIndices = {
+        prompt: options.promptIndex ?? 0,
+        completion: choice.index ?? 0,
+      };
+      if (typeof chunk.content !== 'string') {
+        // eslint-disable-next-line no-console
+        console.log(
+          '[WARNING]: Received non-string content from OpenAI. This is currently not supported.'
+        );
+        continue;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const generationInfo: Record<string, any> = { ...newTokenIndices };
+      if (choice.finish_reason != null) {
+        generationInfo.finish_reason = choice.finish_reason;
+        generationInfo.system_fingerprint = data.system_fingerprint;
+        generationInfo.model_name = data.model;
+        generationInfo.service_tier = data.service_tier;
+      }
+      if (this.logprobs == true) {
+        generationInfo.logprobs = choice.logprobs;
+      }
+      const generationChunk = new ChatGenerationChunk({
+        message: chunk,
+        text: chunk.content,
+        generationInfo,
+      });
+      yield generationChunk;
+      if (this._lc_stream_delay != null) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, this._lc_stream_delay)
+        );
+      }
+      await runManager?.handleLLMNewToken(
+        generationChunk.text || '',
+        newTokenIndices,
+        undefined,
+        undefined,
+        undefined,
+        { chunk: generationChunk }
+      );
+    }
+    if (usage) {
+      const inputTokenDetails = {
+        ...(usage.prompt_tokens_details?.audio_tokens != null && {
+          audio: usage.prompt_tokens_details.audio_tokens,
+        }),
+        ...(usage.prompt_tokens_details?.cached_tokens != null && {
+          cache_read: usage.prompt_tokens_details.cached_tokens,
+        }),
+      };
+      const outputTokenDetails = {
+        ...(usage.completion_tokens_details?.audio_tokens != null && {
+          audio: usage.completion_tokens_details.audio_tokens,
+        }),
+        ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+          reasoning: usage.completion_tokens_details.reasoning_tokens,
+        }),
+      };
+      const generationChunk = new ChatGenerationChunk({
+        message: new AIMessageChunkClass({
+          content: '',
+          response_metadata: {
+            usage: { ...usage },
+          },
+          usage_metadata: {
+            input_tokens: usage.prompt_tokens,
+            output_tokens: usage.completion_tokens,
+            total_tokens: usage.total_tokens,
+            ...(Object.keys(inputTokenDetails).length > 0 && {
+              input_token_details: inputTokenDetails,
+            }),
+            ...(Object.keys(outputTokenDetails).length > 0 && {
+              output_token_details: outputTokenDetails,
+            }),
+          },
+        }),
+        text: '',
+      });
+      yield generationChunk;
+      if (this._lc_stream_delay != null) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, this._lc_stream_delay)
+        );
+      }
+    }
+    if (options.signal?.aborted === true) {
+      throw new Error('AbortError');
+    }
+  }
 }

package/src/llm/providers.ts

@@ -16,13 +16,11 @@ import { CustomChatBedrockConverse } from '@/llm/bedrock';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
-import { ChatOllama } from '@/llm/ollama';
 import { Providers } from '@/common';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.XAI]: ChatXAI,
   [Providers.OPENAI]: ChatOpenAI,
-  [Providers.OLLAMA]: ChatOllama,
   [Providers.AZURE]: AzureChatOpenAI,
   [Providers.VERTEXAI]: ChatVertexAI,
   [Providers.DEEPSEEK]: ChatDeepSeek,
@@ -38,7 +36,6 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
 export const manualToolStreamProviders = new Set<Providers | string>([
   Providers.ANTHROPIC,
   Providers.BEDROCK,
-  Providers.OLLAMA,
 ]);
 
 export const getChatModelClass = <P extends Providers>(

package/src/stream.ts

@@ -107,6 +107,25 @@ export function getChunkContent({
         | undefined
     )?.summary?.[0]?.text;
   }
+  if (
+    provider === Providers.OPENROUTER &&
+    chunk?.additional_kwargs?.reasoning_details != null &&
+    Array.isArray(chunk.additional_kwargs.reasoning_details)
+  ) {
+    // Extract text from reasoning_details array (for Gemini, DeepSeek, etc.)
+    const textEntries = chunk.additional_kwargs.reasoning_details
+      .filter(
+        (detail) =>
+          detail.type === 'reasoning.text' &&
+          detail.text != null &&
+          detail.text !== ''
+      )
+      .map((detail) => detail.text)
+      .join('');
+    if (textEntries) {
+      return textEntries;
+    }
+  }
   return (
     ((chunk?.additional_kwargs?.[reasoningKey] as string | undefined) ?? '') ||
     chunk?.content
@@ -355,6 +374,13 @@ hasToolCallChunks: ${hasToolCallChunks}
       reasoning_content.summary[0].text
     ) {
       reasoning_content = 'valid';
+    } else if (
+      agentContext.provider === Providers.OPENROUTER &&
+      chunk.additional_kwargs?.reasoning_details != null &&
+      Array.isArray(chunk.additional_kwargs.reasoning_details) &&
+      chunk.additional_kwargs.reasoning_details.length > 0
+    ) {
+      reasoning_content = 'valid';
     }
     if (
       reasoning_content != null &&

package/src/types/llm.ts

@@ -1,5 +1,4 @@
 // src/types/llm.ts
-import { ChatOllama } from '@langchain/ollama';
 import { ChatMistralAI } from '@langchain/mistralai';
 import type {
   BindToolsInput,
@@ -22,7 +21,6 @@ import type { RequestOptions } from '@google/generative-ai';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
-import type { ChatOllamaInput } from '@langchain/ollama';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
 import {
@@ -57,7 +55,6 @@ export type AnthropicReasoning = {
   thinkingBudget?: number;
 };
 export type OpenAIClientOptions = ChatOpenAIFields;
-export type OllamaClientOptions = ChatOllamaInput;
 export type AnthropicClientOptions = AnthropicInput;
 export type MistralAIClientOptions = ChatMistralAIInput;
 export type VertexAIClientOptions = ChatVertexAIInput & {
@@ -80,7 +77,6 @@ export type XAIClientOptions = ChatXAIInput;
 export type ClientOptions =
   | OpenAIClientOptions
   | AzureClientOptions
-  | OllamaClientOptions
   | AnthropicClientOptions
   | MistralAIClientOptions
   | VertexAIClientOptions
@@ -103,7 +99,6 @@ export type LLMConfig = SharedLLMConfig &
 export type ProviderOptionsMap = {
   [Providers.AZURE]: AzureClientOptions;
   [Providers.OPENAI]: OpenAIClientOptions;
-  [Providers.OLLAMA]: OllamaClientOptions;
   [Providers.GOOGLE]: GoogleClientOptions;
   [Providers.VERTEXAI]: VertexAIClientOptions;
   [Providers.DEEPSEEK]: DeepSeekClientOptions;
@@ -118,7 +113,6 @@ export type ProviderOptionsMap = {
 export type ChatModelMap = {
   [Providers.XAI]: ChatXAI;
   [Providers.OPENAI]: ChatOpenAI;
-  [Providers.OLLAMA]: ChatOllama;
   [Providers.AZURE]: AzureChatOpenAI;
   [Providers.DEEPSEEK]: ChatDeepSeek;
   [Providers.VERTEXAI]: ChatVertexAI;

package/src/utils/llm.ts

@@ -12,7 +12,6 @@ export function isOpenAILike(provider?: string | Providers): boolean {
       Providers.OPENROUTER,
       Providers.XAI,
       Providers.DEEPSEEK,
-      Providers.OLLAMA,
     ] as string[]
   ).includes(provider);
 }