@librechat/agents 2.0.5 → 2.1.1

package/src/stream.ts

@@ -1,7 +1,7 @@
 // src/stream.ts
 import { nanoid } from 'nanoid';
 import type { AIMessageChunk } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
 import { StepTypes, ContentTypes, GraphEvents, ToolCallTypes } from '@/common';
@@ -107,27 +107,25 @@ export class ChatModelStreamHandler implements t.EventHandler {
     if (!graph) {
       throw new Error('Graph not found');
     }
-
-    const chunk = data.chunk as AIMessageChunk | undefined;
-    const content = chunk?.content;
-
     if (!graph.config) {
       throw new Error('Config not found in graph');
     }
-
-    if (!chunk) {
+    if (!data.chunk) {
       console.warn(`No chunk found in ${event} event`);
       return;
     }
 
-    let hasToolCalls = false;
-    const hasToolCallChunks = (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) ?? false;
+    const chunk = data.chunk as Partial<AIMessageChunk>;
+    const content = (chunk.additional_kwargs?.[graph.reasoningKey] as string | undefined) ?? chunk.content;
+    this.handleReasoning(chunk, graph);
 
+    let hasToolCalls = false;
     if (chunk.tool_calls && chunk.tool_calls.length > 0 && chunk.tool_calls.every((tc) => tc.id)) {
       hasToolCalls = true;
       handleToolCalls(chunk.tool_calls, metadata, graph);
     }
 
+    const hasToolCallChunks = (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) ?? false;
     const isEmptyContent = typeof content === 'undefined' || !content.length || typeof content === 'string' && !content;
     const isEmptyChunk = isEmptyContent && !hasToolCallChunks;
     const chunkId = chunk.id ?? '';
@@ -151,51 +149,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       && chunk.tool_call_chunks
       && chunk.tool_call_chunks.length
       && typeof chunk.tool_call_chunks[0]?.index === 'number') {
-      const prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-      const prevRunStep = graph.getRunStep(prevStepId);
-      const _stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
-      /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
-      const tool_calls: ToolCall[] | undefined =
-      prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
-        ? []
-        : undefined;
-      /** Edge Case: `id` and `name` fields cannot be empty strings */
-      for (const toolCallChunk of chunk.tool_call_chunks) {
-        if (toolCallChunk.name === '') {
-          toolCallChunk.name = undefined;
-        }
-        if (toolCallChunk.id === '') {
-          toolCallChunk.id = undefined;
-        } else if (tool_calls != null && toolCallChunk.id != null && toolCallChunk.name != null) {
-          tool_calls.push({
-            args: {},
-            id: toolCallChunk.id,
-            name: toolCallChunk.name,
-            type: ToolCallTypes.TOOL_CALL,
-          });
-        }
-      }
-
-      let stepId: string = _stepId;
-      const alreadyDispatched = prevRunStep?.type === StepTypes.MESSAGE_CREATION && graph.messageStepHasToolCalls.has(prevStepId);
-      if (!alreadyDispatched && tool_calls?.length === chunk.tool_call_chunks.length) {
-        graph.dispatchMessageDelta(prevStepId, {
-          content: [{
-            type: 'text',
-            text: '',
-            tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
-          }],
-        });
-        graph.messageStepHasToolCalls.set(prevStepId, true);
-        stepId = graph.dispatchRunStep(stepKey, {
-          type: StepTypes.TOOL_CALLS,
-          tool_calls,
-        });
-      }
-      graph.dispatchRunStepDelta(stepId, {
-        type: StepTypes.TOOL_CALLS,
-        tool_calls: chunk.tool_call_chunks,
-      });
+      this.handleToolCallChunks({ graph, stepKey, toolCallChunks: chunk.tool_call_chunks });
     }
 
     if (isEmptyContent) {
@@ -240,32 +194,106 @@ hasToolCallChunks: ${hasToolCallChunks}
     } else if (hasToolCallChunks && (chunk.tool_call_chunks?.some((tc) => tc.args === content) ?? false)) {
       return;
     } else if (typeof content === 'string') {
+      if (graph.currentTokenType === ContentTypes.TEXT) {
+        graph.dispatchMessageDelta(stepId, {
+          content: [{
+            type: ContentTypes.TEXT,
+            text: content,
+          }],
+        });
+      } else {
+        graph.dispatchReasoningDelta(stepId, {
+          content: [{
+            type: ContentTypes.THINK,
+            think: content,
+          }],
+        });
+      }
+    } else if (content.every((c) => c.type?.startsWith(ContentTypes.TEXT))) {
       graph.dispatchMessageDelta(stepId, {
+        content,
+      });
+    }
+  }
+  handleToolCallChunks = ({
+    graph,
+    stepKey,
+    toolCallChunks,
+  }: {
+    graph: Graph;
+    stepKey: string;
+    toolCallChunks: ToolCallChunk[],
+  }): void => {
+    const prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+    const prevRunStep = graph.getRunStep(prevStepId);
+    const _stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
+    /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
+    const tool_calls: ToolCall[] | undefined =
+    prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
+      ? []
+      : undefined;
+    /** Edge Case: `id` and `name` fields cannot be empty strings */
+    for (const toolCallChunk of toolCallChunks) {
+      if (toolCallChunk.name === '') {
+        toolCallChunk.name = undefined;
+      }
+      if (toolCallChunk.id === '') {
+        toolCallChunk.id = undefined;
+      } else if (tool_calls != null && toolCallChunk.id != null && toolCallChunk.name != null) {
+        tool_calls.push({
+          args: {},
+          id: toolCallChunk.id,
+          name: toolCallChunk.name,
+          type: ToolCallTypes.TOOL_CALL,
+        });
+      }
+    }
+
+    let stepId: string = _stepId;
+    const alreadyDispatched = prevRunStep?.type === StepTypes.MESSAGE_CREATION && graph.messageStepHasToolCalls.has(prevStepId);
+    if (!alreadyDispatched && tool_calls?.length === toolCallChunks.length) {
+      graph.dispatchMessageDelta(prevStepId, {
         content: [{
-          type: 'text',
-          text: content,
+          type: ContentTypes.TEXT,
+          text: '',
+          tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
         }],
       });
-    } else if (content.every((c) => c.type?.startsWith('text'))) {
-      graph.dispatchMessageDelta(stepId, {
-        content,
+      graph.messageStepHasToolCalls.set(prevStepId, true);
+      stepId = graph.dispatchRunStep(stepKey, {
+        type: StepTypes.TOOL_CALLS,
+        tool_calls,
       });
     }
+    graph.dispatchRunStepDelta(stepId, {
+      type: StepTypes.TOOL_CALLS,
+      tool_calls: toolCallChunks,
+    });
+  };
+  handleReasoning(chunk: Partial<AIMessageChunk>, graph: Graph): void {
+    const reasoning_content = chunk.additional_kwargs?.[graph.reasoningKey] as string | undefined;
+    if (reasoning_content != null && reasoning_content && (chunk.content == null || chunk.content === '')) {
+      graph.currentTokenType = ContentTypes.THINK;
+      graph.tokenTypeSwitch = 'reasoning';
+      return;
+    } else if (graph.tokenTypeSwitch === 'reasoning' && graph.currentTokenType !== ContentTypes.TEXT && chunk.content != null && chunk.content !== '') {
+      graph.currentTokenType = ContentTypes.TEXT;
+      graph.tokenTypeSwitch = 'content';
+    } else if (chunk.content != null && typeof chunk.content === 'string' && chunk.content.includes('<think>')) {
+      graph.currentTokenType = ContentTypes.THINK;
+      graph.tokenTypeSwitch = 'content';
+    } else if (graph.lastToken != null && graph.lastToken.includes('</think>')) {
+      graph.currentTokenType = ContentTypes.TEXT;
+      graph.tokenTypeSwitch = 'content';
+    }
+    if (typeof chunk.content !== 'string') {
+      return;
+    }
+    graph.lastToken = chunk.content;
   }
 }
 
-export type ContentAggregatorResult = {
-  stepMap: Map<string, t.RunStep | undefined>;
-  contentParts: Array<t.MessageContentComplex | undefined>;
-  aggregateContent: ({ event, data }: {
-    event: GraphEvents;
-    data: t.RunStep | t.MessageDeltaEvent | t.RunStepDeltaEvent | {
-        result: t.ToolEndEvent;
-    };
-}) => void
-};
-
-export function createContentAggregator(): ContentAggregatorResult {
+export function createContentAggregator(): t.ContentAggregatorResult {
   const contentParts: Array<t.MessageContentComplex | undefined> = [];
   const stepMap = new Map<string, t.RunStep>();
   const toolCallIdMap = new Map<string, string>();
@@ -389,7 +417,7 @@ export function createContentAggregator(): ContentAggregatorResult {
       const reasoningDelta = data as t.ReasoningDeltaEvent;
       const runStep = stepMap.get(reasoningDelta.id);
       if (!runStep) {
-        console.warn('No run step or runId found for message delta event');
+        console.warn('No run step or runId found for reasoning delta event');
         return;
       }
 

package/src/tools/CodeExecutor.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { config } from 'dotenv';
+import fetch, { RequestInit } from 'node-fetch';
+import { HttpsProxyAgent } from 'https-proxy-agent';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import { getEnvironmentVariable } from '@langchain/core/utils/env';
 import type * as t from '@/types';
@@ -71,7 +73,7 @@ Usage:
       };
 
       try {
-        const response = await fetch(EXEC_ENDPOINT, {
+        const fetchOptions: RequestInit = {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
@@ -79,8 +81,12 @@ Usage:
             'X-API-Key': apiKey,
           },
           body: JSON.stringify(postData),
-        });
+        };
 
+        if (process.env.PROXY != null && process.env.PROXY !== '') {
+          fetchOptions.agent = new HttpsProxyAgent(process.env.PROXY);
+        }
+        const response = await fetch(EXEC_ENDPOINT, fetchOptions);
         if (!response.ok) {
           throw new Error(`HTTP error! status: ${response.status}`);
         }

package/src/types/graph.ts

@@ -3,6 +3,9 @@ import type { StateGraphArgs, StateGraph, CompiledStateGraph } from '@langchain/
 import type { BaseMessage, AIMessageChunk } from '@langchain/core/messages';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolMap, GenericTool } from '@/types/tools';
+import type { ClientOptions } from '@/types/llm';
+import type { Providers } from '@/common';
 import type { Graph } from '@/graphs';
 // import type { RunnableConfig } from '@langchain/core/runnables';
 
@@ -135,4 +138,18 @@ export type PartMetadata = {
   output?: string;
 };
 
-export type ModelEndData = StreamEventData & { output: AIMessageChunk | undefined } | undefined;
+export type ModelEndData = StreamEventData & { output: AIMessageChunk | undefined } | undefined;
+
+export type StandardGraphInput = {
+  runId?: string;
+  toolEnd?: boolean;
+  toolMap?: ToolMap;
+  provider: Providers;
+  signal?: AbortSignal;
+  instructions?: string;
+  streamBuffer?: number;
+  tools?: GenericTool[];
+  clientOptions: ClientOptions;
+  additional_instructions?: string;
+  reasoningKey?: 'reasoning_content' | 'reasoning';
+};

package/src/types/llm.ts

@@ -1,5 +1,6 @@
 // src/types/llm.ts
 import { ChatOllama } from '@langchain/ollama';
+import { ChatDeepSeek } from '@langchain/deepseek';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
@@ -12,6 +13,7 @@ import type { ChatOpenAIFields, OpenAIChatInput, AzureOpenAIInput } from '@langc
 import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
 import type { StructuredTool } from '@langchain/core/tools';
@@ -41,32 +43,35 @@ export type VertexAIClientOptions = ChatVertexAIInput;
 export type BedrockClientOptions = BedrockChatFields;
 export type BedrockConverseClientOptions = ChatBedrockConverseInput;
 export type GoogleClientOptions = GoogleGenerativeAIChatInput;
+export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
 
-export type ClientOptions = OpenAIClientOptions | AzureClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions;
+export type ClientOptions = OpenAIClientOptions | AzureClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions;
 
 export type LLMConfig = {
   provider: Providers;
 } & ClientOptions;
 
 export type ProviderOptionsMap = {
-  [Providers.OPENAI]: OpenAIClientOptions;
   [Providers.AZURE]: AzureClientOptions;
+  [Providers.OPENAI]: OpenAIClientOptions;
   [Providers.OLLAMA]: OllamaClientOptions;
+  [Providers.GOOGLE]: GoogleClientOptions;
+  [Providers.VERTEXAI]: VertexAIClientOptions;
+  [Providers.DEEPSEEK]: DeepSeekClientOptions;
   [Providers.ANTHROPIC]: AnthropicClientOptions;
   [Providers.MISTRALAI]: MistralAIClientOptions;
-  [Providers.VERTEXAI]: VertexAIClientOptions;
   [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
   [Providers.BEDROCK]: BedrockConverseClientOptions;
-  [Providers.GOOGLE]: GoogleClientOptions;
 };
 
 export type ChatModelMap = {
   [Providers.OPENAI]: ChatOpenAI;
   [Providers.OLLAMA]: ChatOllama;
   [Providers.AZURE]: AzureChatOpenAI;
+  [Providers.DEEPSEEK]: ChatDeepSeek;
+  [Providers.VERTEXAI]: ChatVertexAI;
   [Providers.ANTHROPIC]: ChatAnthropic;
   [Providers.MISTRALAI]: ChatMistralAI;
-  [Providers.VERTEXAI]: ChatVertexAI;
   [Providers.BEDROCK_LEGACY]: BedrockChat;
   [Providers.BEDROCK]: ChatBedrockConverse;
   [Providers.GOOGLE]: ChatGoogleGenerativeAI;

package/src/types/run.ts

@@ -6,26 +6,18 @@ import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/cor
 import type * as graph from '@/graphs/Graph';
 import type * as e from '@/common/enum';
 import type * as g from '@/types/graph';
-import type * as t from '@/types/tools';
 import type * as l from '@/types/llm';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
-
-export type StandardGraphConfig = {
-  runId?: string;
+export type BaseGraphConfig = {
   type?: 'standard';
-  provider?: e.Providers;
-  instructions?: string;
   llmConfig: l.LLMConfig;
-  tools?: t.GenericTool[];
-  toolMap?: t.ToolMap;
-  additional_instructions?: string;
-  streamBuffer?: number;
-  signal?: AbortSignal;
-  clientOptions?: Record<string, unknown>;
-  toolEnd?: boolean;
+  provider?: e.Providers;
+  clientOptions?: l.ClientOptions;
 };
+export type StandardGraphConfig = BaseGraphConfig &
+  Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
 
 export interface AgentStateChannels {
   messages: BaseMessage[];

package/src/types/stream.ts

@@ -3,6 +3,7 @@ import type OpenAITypes from 'openai';
 import type { MessageContentImageUrl, MessageContentText, ToolMessage, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
+import type { ToolEndEvent } from '@/types/tools';
 import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
 
 export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
@@ -239,4 +240,16 @@ export type SplitStreamHandlers = Partial<{
   [GraphEvents.ON_RUN_STEP]: ({ event, data}: { event: GraphEvents, data: RunStep }) => void;
   [GraphEvents.ON_MESSAGE_DELTA]: ({ event, data}: { event: GraphEvents, data: MessageDeltaEvent }) => void;
   [GraphEvents.ON_REASONING_DELTA]: ({ event, data}: { event: GraphEvents, data: ReasoningDeltaEvent }) => void;
-}>
+}>
+
+export type ContentAggregator = ({ event, data }: {
+  event: GraphEvents;
+  data: RunStep | MessageDeltaEvent | RunStepDeltaEvent | {
+      result: ToolEndEvent;
+  };
+}) => void;
+export type ContentAggregatorResult = {
+  stepMap: Map<string, RunStep | undefined>;
+  contentParts: Array<MessageContentComplex | undefined>;
+  aggregateContent: ContentAggregator;
+};

package/src/utils/llmConfig.ts

@@ -5,7 +5,7 @@ import type * as t from '@/types';
 export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   [Providers.OPENAI]: {
     provider: Providers.OPENAI,
-    model: 'gpt-4o',
+    model: 'gpt-4o-mini',
     temperature: 0.7,
     streaming: true,
     streamUsage: true,
@@ -39,6 +39,12 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     streamUsage: true,
     baseUrl: 'http://host.docker.internal:11434'
   },
+  [Providers.DEEPSEEK]: {
+    provider: Providers.DEEPSEEK,
+    model: 'deepseek-reasoner',
+    streaming: true,
+    streamUsage: true,
+  },
   [Providers.ANTHROPIC]: {
     provider: Providers.ANTHROPIC,
     model: 'claude-3-5-sonnet-20240620',