@librechat/agents 3.0.32 → 3.0.34

package/dist/types/llm/ollama/index.d.ts

@@ -1,8 +0,0 @@
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { ChatOllama as BaseChatOllama } from '@langchain/ollama';
-import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { BaseMessage } from '@langchain/core/messages';
-export declare class ChatOllama extends BaseChatOllama {
-    static lc_name(): 'LibreChatOllama';
-    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-}

package/dist/types/llm/ollama/utils.d.ts

@@ -1,7 +0,0 @@
-import { AIMessageChunk, BaseMessage, UsageMetadata } from '@langchain/core/messages';
-import type { Message as OllamaMessage } from 'ollama';
-export declare function convertOllamaMessagesToLangChain(messages: OllamaMessage, extra?: {
-    responseMetadata?: Record<string, any>;
-    usageMetadata?: UsageMetadata;
-}): AIMessageChunk;
-export declare function convertToOllamaMessages(messages: BaseMessage[]): OllamaMessage[];

package/src/llm/ollama/index.ts

@@ -1,92 +0,0 @@
-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 {
-  static lc_name(): 'LibreChatOllama' {
-    return 'LibreChatOllama';
-  }
-  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

@@ -1,193 +0,0 @@
-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()}`);
-    }
-  });
-}