@librechat/agents 2.4.75 → 2.4.77

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

@@ -24,7 +24,12 @@ let _contentParts: t.MessageContentComplex[] = [];
 let collectedUsage: UsageMetadata[] = [];
 
 async function testStandardStreaming(): Promise<void> {
-  const { userName, location, provider, currentDate } = await getArgs();
+  const {
+    userName,
+    location,
+    provider: _provider,
+    currentDate,
+  } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   _contentParts = contentParts as t.MessageContentComplex[];
   const customHandlers = {
@@ -96,7 +101,7 @@ async function testStandardStreaming(): Promise<void> {
     },
   };
 
-  const llmConfig = getLLMConfig(provider);
+  const llmConfig = getLLMConfig(_provider);
   if (
     'configuration' in llmConfig &&
     (llmConfig as t.OpenAIClientOptions).configuration != null
@@ -112,6 +117,7 @@ async function testStandardStreaming(): Promise<void> {
       };
     }
   }
+  const provider = llmConfig.provider;
 
   if (provider === Providers.ANTHROPIC) {
     (llmConfig as t.AnthropicClientOptions).clientOptions = {
@@ -128,7 +134,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}.`,
@@ -168,7 +174,7 @@ async function testStandardStreaming(): Promise<void> {
     provider,
     inputText: userMessage,
     contentParts,
-    titleMethod: TitleMethod.STRUCTURED,
+    // titleMethod: TitleMethod.STRUCTURED,
     chainOptions: {
       callbacks: [
         {

package/src/tools/search/jina-reranker.test.ts

@@ -0,0 +1,126 @@
+import { JinaReranker } from './rerankers';
+import { createDefaultLogger } from './utils';
+
+describe('JinaReranker', () => {
+  const mockLogger = createDefaultLogger();
+  
+  describe('constructor', () => {
+    it('should use default API URL when no apiUrl is provided', () => {
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        logger: mockLogger,
+      });
+      
+      // Access private property for testing
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
+    });
+
+    it('should use custom API URL when provided', () => {
+      const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe(customUrl);
+    });
+
+    it('should use environment variable JINA_API_URL when available', () => {
+      const originalEnv = process.env.JINA_API_URL;
+      process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
+      
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        logger: mockLogger,
+      });
+      
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe('https://env-jina-endpoint.com/v1/rerank');
+      
+      // Restore original environment
+      if (originalEnv) {
+        process.env.JINA_API_URL = originalEnv;
+      } else {
+        delete process.env.JINA_API_URL;
+      }
+    });
+
+    it('should prioritize explicit apiUrl over environment variable', () => {
+      const originalEnv = process.env.JINA_API_URL;
+      process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
+      
+      const customUrl = 'https://explicit-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe(customUrl);
+      
+      // Restore original environment
+      if (originalEnv) {
+        process.env.JINA_API_URL = originalEnv;
+      } else {
+        delete process.env.JINA_API_URL;
+      }
+    });
+  });
+
+  describe('rerank method', () => {
+    it('should log the API URL being used', async () => {
+      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      
+      const logSpy = jest.spyOn(mockLogger, 'debug');
+      
+      try {
+        await reranker.rerank('test query', ['document1', 'document2'], 2);
+      } catch (error) {
+        // Expected to fail due to missing API key, but we can check the log
+      }
+      
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(`Reranking 2 chunks with Jina using API URL: ${customUrl}`)
+      );
+      
+      logSpy.mockRestore();
+    });
+  });
+});
+
+describe('createReranker', () => {
+  const { createReranker } = require('./rerankers');
+  
+  it('should create JinaReranker with jinaApiUrl when provided', () => {
+    const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
+    const reranker = createReranker({
+      rerankerType: 'jina',
+      jinaApiKey: 'test-key',
+      jinaApiUrl: customUrl,
+    });
+    
+    expect(reranker).toBeInstanceOf(JinaReranker);
+    const apiUrl = (reranker as any).apiUrl;
+    expect(apiUrl).toBe(customUrl);
+  });
+
+  it('should create JinaReranker with default URL when jinaApiUrl is not provided', () => {
+    const reranker = createReranker({
+      rerankerType: 'jina',
+      jinaApiKey: 'test-key',
+    });
+    
+    expect(reranker).toBeInstanceOf(JinaReranker);
+    const apiUrl = (reranker as any).apiUrl;
+    expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
+  });
+});

package/src/tools/search/rerankers.ts

@@ -28,15 +28,20 @@ export abstract class BaseReranker {
 }
 
 export class JinaReranker extends BaseReranker {
+  private apiUrl: string;
+
   constructor({
     apiKey = process.env.JINA_API_KEY,
+    apiUrl = process.env.JINA_API_URL || 'https://api.jina.ai/v1/rerank',
     logger,
   }: {
     apiKey?: string;
+    apiUrl?: string;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
   }
 
   async rerank(
@@ -44,7 +49,7 @@ export class JinaReranker extends BaseReranker {
     documents: string[],
     topK: number = 5
   ): Promise<t.Highlight[]> {
-    this.logger.debug(`Reranking ${documents.length} chunks with Jina`);
+    this.logger.debug(`Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`);
 
     try {
       if (this.apiKey == null || this.apiKey === '') {
@@ -61,7 +66,7 @@ export class JinaReranker extends BaseReranker {
       };
 
       const response = await axios.post<t.JinaRerankerResponse | undefined>(
-        'https://api.jina.ai/v1/rerank',
+        this.apiUrl,
         requestData,
         {
           headers: {
@@ -201,17 +206,18 @@ export class InfinityReranker extends BaseReranker {
 export const createReranker = (config: {
   rerankerType: t.RerankerType;
   jinaApiKey?: string;
+  jinaApiUrl?: string;
   cohereApiKey?: string;
   logger?: t.Logger;
 }): BaseReranker | undefined => {
-  const { rerankerType, jinaApiKey, cohereApiKey, logger } = config;
+  const { rerankerType, jinaApiKey, jinaApiUrl, cohereApiKey, logger } = config;
 
   // Create a default logger if none is provided
   const defaultLogger = logger || createDefaultLogger();
 
   switch (rerankerType.toLowerCase()) {
   case 'jina':
-    return new JinaReranker({ apiKey: jinaApiKey, logger: defaultLogger });
+    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
   case 'cohere':
     return new CohereReranker({
       apiKey: cohereApiKey,
@@ -226,7 +232,7 @@ export const createReranker = (config: {
     defaultLogger.warn(
       `Unknown reranker type: ${rerankerType}. Defaulting to InfinityReranker.`
     );
-    return new JinaReranker({ apiKey: jinaApiKey, logger: defaultLogger });
+    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
   }
 };
 

package/src/tools/search/tool.ts

@@ -349,6 +349,7 @@ export const createSearchTool = (
     firecrawlOptions,
     scraperTimeout,
     jinaApiKey,
+    jinaApiUrl,
     cohereApiKey,
     onSearchResults: _onSearchResults,
     onGetHighlights,
@@ -395,6 +396,7 @@ export const createSearchTool = (
   const selectedReranker = createReranker({
     rerankerType,
     jinaApiKey,
+    jinaApiUrl,
     cohereApiKey,
     logger,
   });

package/src/tools/search/types.ts

@@ -148,6 +148,7 @@ export interface SearchToolConfig
   logger?: Logger;
   safeSearch?: SafeSearchLevel;
   jinaApiKey?: string;
+  jinaApiUrl?: string;
   cohereApiKey?: string;
   rerankerType?: RerankerType;
   scraperTimeout?: number;