@librechat/agents 2.4.75 → 2.4.76

package/src/llm/ollama/index.ts

@@ -0,0 +1,89 @@
+import { AIMessageChunk } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ChatOllama as BaseChatOllama } from '@langchain/ollama';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type {
+  ChatResponse as OllamaChatResponse,
+  Message as OllamaMessage,
+} from 'ollama';
+import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
+import {
+  convertOllamaMessagesToLangChain,
+  convertToOllamaMessages,
+} from './utils';
+
+export class ChatOllama extends BaseChatOllama {
+  async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    if (this.checkOrPullModel) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      if (!((await this.checkModelExistsOnMachine(this.model)) as boolean)) {
+        await this.pull(this.model, {
+          logProgress: true,
+        });
+      }
+    }
+
+    const params = this.invocationParams(options);
+    // TODO: remove cast after SDK adds support for tool calls
+    const ollamaMessages = convertToOllamaMessages(messages) as OllamaMessage[];
+
+    const usageMetadata: UsageMetadata = {
+      input_tokens: 0,
+      output_tokens: 0,
+      total_tokens: 0,
+    };
+
+    const stream = await this.client.chat({
+      ...params,
+      messages: ollamaMessages,
+      stream: true,
+    });
+
+    let lastMetadata: Omit<OllamaChatResponse, 'message'> | undefined;
+
+    for await (const chunk of stream) {
+      if (options.signal?.aborted === true) {
+        this.client.abort();
+      }
+      const { message: responseMessage, ...rest } =
+        chunk as Partial<OllamaChatResponse>;
+      usageMetadata.input_tokens += rest.prompt_eval_count ?? 0;
+      usageMetadata.output_tokens += rest.eval_count ?? 0;
+      usageMetadata.total_tokens =
+        usageMetadata.input_tokens + usageMetadata.output_tokens;
+      lastMetadata = rest as Omit<OllamaChatResponse, 'message'>;
+      if (!responseMessage) {
+        continue;
+      }
+      const message = convertOllamaMessagesToLangChain(responseMessage);
+      const generationChunk = new ChatGenerationChunk({
+        text: responseMessage.content || '',
+        message,
+      });
+      yield generationChunk;
+      await runManager?.handleLLMNewToken(
+        responseMessage.content || '',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        { chunk: generationChunk }
+      );
+    }
+
+    // Yield the `response_metadata` as the final chunk.
+    yield new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: '',
+        response_metadata: lastMetadata,
+        usage_metadata: usageMetadata,
+      }),
+    });
+  }
+}

package/src/llm/ollama/utils.ts

@@ -0,0 +1,193 @@
+import {
+  AIMessage,
+  AIMessageChunk,
+  BaseMessage,
+  HumanMessage,
+  MessageContentText,
+  SystemMessage,
+  ToolMessage,
+  UsageMetadata,
+} from '@langchain/core/messages';
+import type {
+  Message as OllamaMessage,
+  ToolCall as OllamaToolCall,
+} from 'ollama';
+import { v4 as uuidv4 } from 'uuid';
+
+export function convertOllamaMessagesToLangChain(
+  messages: OllamaMessage,
+  extra?: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    responseMetadata?: Record<string, any>;
+    usageMetadata?: UsageMetadata;
+  }
+): AIMessageChunk {
+  const additional_kwargs: BaseMessage['additional_kwargs'] = {};
+  if ('thinking' in messages) {
+    additional_kwargs.reasoning_content = messages.thinking as string;
+  }
+  return new AIMessageChunk({
+    content: messages.content || '',
+    tool_call_chunks: messages.tool_calls?.map((tc) => ({
+      name: tc.function.name,
+      args: JSON.stringify(tc.function.arguments),
+      type: 'tool_call_chunk',
+      index: 0,
+      id: uuidv4(),
+    })),
+    response_metadata: extra?.responseMetadata,
+    usage_metadata: extra?.usageMetadata,
+    additional_kwargs,
+  });
+}
+
+function extractBase64FromDataUrl(dataUrl: string): string {
+  const match = dataUrl.match(/^data:.*?;base64,(.*)$/);
+  return match ? match[1] : '';
+}
+
+function convertAMessagesToOllama(messages: AIMessage): OllamaMessage[] {
+  if (typeof messages.content === 'string') {
+    return [
+      {
+        role: 'assistant',
+        content: messages.content,
+      },
+    ];
+  }
+
+  const textFields = messages.content.filter(
+    (c) => c.type === 'text' && typeof c.text === 'string'
+  );
+  const textMessages = (textFields as MessageContentText[]).map((c) => ({
+    role: 'assistant',
+    content: c.text,
+  }));
+  let toolCallMsgs: OllamaMessage | undefined;
+
+  if (
+    messages.content.find((c) => c.type === 'tool_use') &&
+    messages.tool_calls?.length
+  ) {
+    // `tool_use` content types are accepted if the message has tool calls
+    const toolCalls: OllamaToolCall[] | undefined = messages.tool_calls.map(
+      (tc) => ({
+        id: tc.id,
+        type: 'function',
+        function: {
+          name: tc.name,
+          arguments: tc.args,
+        },
+      })
+    );
+
+    if (toolCalls) {
+      toolCallMsgs = {
+        role: 'assistant',
+        tool_calls: toolCalls,
+        content: '',
+      };
+    }
+  } else if (
+    messages.content.find((c) => c.type === 'tool_use') &&
+    !messages.tool_calls?.length
+  ) {
+    throw new Error(
+      '\'tool_use\' content type is not supported without tool calls.'
+    );
+  }
+
+  return [...textMessages, ...(toolCallMsgs ? [toolCallMsgs] : [])];
+}
+
+function convertHumanGenericMessagesToOllama(
+  message: HumanMessage
+): OllamaMessage[] {
+  if (typeof message.content === 'string') {
+    return [
+      {
+        role: 'user',
+        content: message.content,
+      },
+    ];
+  }
+  return message.content.map((c) => {
+    if (c.type === 'text') {
+      return {
+        role: 'user',
+        content: c.text,
+      };
+    } else if (c.type === 'image_url') {
+      if (typeof c.image_url === 'string') {
+        return {
+          role: 'user',
+          content: '',
+          images: [extractBase64FromDataUrl(c.image_url)],
+        };
+      } else if (c.image_url.url && typeof c.image_url.url === 'string') {
+        return {
+          role: 'user',
+          content: '',
+          images: [extractBase64FromDataUrl(c.image_url.url)],
+        };
+      }
+    }
+    throw new Error(`Unsupported content type: ${c.type}`);
+  });
+}
+
+function convertSystemMessageToOllama(message: SystemMessage): OllamaMessage[] {
+  if (typeof message.content === 'string') {
+    return [
+      {
+        role: 'system',
+        content: message.content,
+      },
+    ];
+  } else if (
+    message.content.every(
+      (c) => c.type === 'text' && typeof c.text === 'string'
+    )
+  ) {
+    return (message.content as MessageContentText[]).map((c) => ({
+      role: 'system',
+      content: c.text,
+    }));
+  } else {
+    throw new Error(
+      `Unsupported content type(s): ${message.content
+        .map((c) => c.type)
+        .join(', ')}`
+    );
+  }
+}
+
+function convertToolMessageToOllama(message: ToolMessage): OllamaMessage[] {
+  if (typeof message.content !== 'string') {
+    throw new Error('Non string tool message content is not supported');
+  }
+  return [
+    {
+      role: 'tool',
+      content: message.content,
+    },
+  ];
+}
+
+export function convertToOllamaMessages(
+  messages: BaseMessage[]
+): OllamaMessage[] {
+  return messages.flatMap((msg) => {
+    if (['human', 'generic'].includes(msg._getType())) {
+      return convertHumanGenericMessagesToOllama(msg);
+    } else if (msg._getType() === 'ai') {
+      return convertAMessagesToOllama(msg);
+    } else if (msg._getType() === 'system') {
+      return convertSystemMessageToOllama(msg);
+    } else if (msg._getType() === 'tool') {
+      return convertToolMessageToOllama(msg as ToolMessage);
+    } else {
+      throw new Error(`Unsupported message type: ${msg._getType()}`);
+    }
+  });
+}

package/src/llm/openai/index.ts

@@ -342,6 +342,8 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
       );
       if ('reasoning_content' in delta) {
         chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+      } else if ('reasoning' in delta) {
+        chunk.additional_kwargs.reasoning_content = delta.reasoning;
       }
       defaultRole = delta.role ?? defaultRole;
       const newTokenIndices = {

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

@@ -648,11 +648,7 @@ export function _convertMessagesToOpenAIResponsesParams(
 }
 
 export function isReasoningModel(model?: string) {
-  return (
-    model != null &&
-    model !== '' &&
-    (/^o\d/.test(model) || /^gpt-[5-9]/.test(model))
-  );
+  return model != null && model !== '' && /\b(o\d|gpt-[5-9])\b/i.test(model);
 }
 
 function _convertOpenAIResponsesMessageToBaseMessage(

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

@@ -0,0 +1,90 @@
+import { isReasoningModel } from './index';
+
+describe('isReasoningModel', () => {
+  describe('should return true for reasoning models', () => {
+    test('basic o-series models', () => {
+      expect(isReasoningModel('o1')).toBe(true);
+      expect(isReasoningModel('o2')).toBe(true);
+      expect(isReasoningModel('o9')).toBe(true);
+      expect(isReasoningModel('o1-preview')).toBe(true);
+      expect(isReasoningModel('o1-mini')).toBe(true);
+    });
+
+    test('gpt-5+ models', () => {
+      expect(isReasoningModel('gpt-5')).toBe(true);
+      expect(isReasoningModel('gpt-6')).toBe(true);
+      expect(isReasoningModel('gpt-7')).toBe(true);
+      expect(isReasoningModel('gpt-8')).toBe(true);
+      expect(isReasoningModel('gpt-9')).toBe(true);
+    });
+
+    test('with provider prefixes', () => {
+      expect(isReasoningModel('azure/o1')).toBe(true);
+      expect(isReasoningModel('azure/gpt-5')).toBe(true);
+      expect(isReasoningModel('openai/o1')).toBe(true);
+      expect(isReasoningModel('openai/gpt-5')).toBe(true);
+    });
+
+    test('with custom prefixes', () => {
+      expect(isReasoningModel('custom-provider/o1')).toBe(true);
+      expect(isReasoningModel('my-deployment/gpt-5')).toBe(true);
+      expect(isReasoningModel('company/azure/gpt-5')).toBe(true);
+    });
+
+    test('case insensitive', () => {
+      expect(isReasoningModel('O1')).toBe(true);
+      expect(isReasoningModel('GPT-5')).toBe(true);
+      expect(isReasoningModel('gPt-6')).toBe(true);
+      expect(isReasoningModel('Azure/O1')).toBe(true);
+    });
+  });
+
+  describe('should return false for non-reasoning models', () => {
+    test('older GPT models', () => {
+      expect(isReasoningModel('gpt-3.5-turbo')).toBe(false);
+      expect(isReasoningModel('gpt-4')).toBe(false);
+      expect(isReasoningModel('gpt-4-turbo')).toBe(false);
+      expect(isReasoningModel('gpt-4o')).toBe(false);
+      expect(isReasoningModel('gpt-4o-mini')).toBe(false);
+    });
+
+    test('other model families', () => {
+      expect(isReasoningModel('claude-3')).toBe(false);
+      expect(isReasoningModel('claude-3-opus')).toBe(false);
+      expect(isReasoningModel('llama-2')).toBe(false);
+      expect(isReasoningModel('gemini-pro')).toBe(false);
+    });
+
+    test('partial matches that should not match', () => {
+      expect(isReasoningModel('proto1')).toBe(false);
+      expect(isReasoningModel('version-o1')).toBe(true);
+      expect(isReasoningModel('gpt-40')).toBe(false);
+      expect(isReasoningModel('gpt-3.5')).toBe(false);
+    });
+
+    test('empty, null, and undefined', () => {
+      expect(isReasoningModel('')).toBe(false);
+      expect(isReasoningModel()).toBe(false);
+      expect(isReasoningModel(undefined)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('with special characters', () => {
+      expect(isReasoningModel('deployment_o1_model')).toBe(false);
+      expect(isReasoningModel('gpt-5-deployment')).toBe(true);
+      expect(isReasoningModel('o1@latest')).toBe(true);
+      expect(isReasoningModel('gpt-5.0')).toBe(true);
+    });
+
+    test('word boundary behavior', () => {
+      // These should match because o1 and gpt-5 are whole words
+      expect(isReasoningModel('use-o1-model')).toBe(true);
+      expect(isReasoningModel('model-gpt-5-latest')).toBe(true);
+
+      // These should not match because o1/gpt-5 are not whole words
+      expect(isReasoningModel('proto1model')).toBe(false);
+      expect(isReasoningModel('supergpt-50')).toBe(false);
+    });
+  });
+});

package/src/llm/providers.ts

@@ -1,5 +1,4 @@
 // src/llm/providers.ts
-import { ChatOllama } from '@langchain/ollama';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 // import { ChatAnthropic } from '@langchain/anthropic';
@@ -20,6 +19,7 @@ import { CustomChatGoogleGenerativeAI } from '@/llm/google';
 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> = {

package/src/scripts/simple.ts

@@ -128,7 +128,7 @@ async function testStandardStreaming(): Promise<void> {
       type: 'standard',
       llmConfig,
       // tools: [new TavilySearchResults()],
-      reasoningKey: 'reasoning',
+      // reasoningKey: 'reasoning',
       instructions:
         'You are a friendly AI assistant. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,

package/src/utils/llmConfig.ts

@@ -56,10 +56,19 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   },
   [Providers.OLLAMA]: {
     provider: Providers.OLLAMA,
-    model: 'llama3.2',
+    model: 'gpt-oss:20b',
     streaming: true,
     streamUsage: true,
-    baseUrl: 'http://host.docker.internal:11434',
+    baseUrl: 'http://localhost:11434',
+  },
+  lmstudio: {
+    provider: Providers.OPENAI,
+    model: 'gpt-oss-120b',
+    streaming: true,
+    streamUsage: true,
+    configuration: {
+      baseURL: 'http://192.168.254.183:1233/v1',
+    },
   },
   [Providers.DEEPSEEK]: {
     provider: Providers.DEEPSEEK,