@librechat/agents 2.0.5 → 2.1.1

package/dist/types/types/stream.d.ts

@@ -2,6 +2,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;
 export type MetadataAggregatorResult = {
@@ -206,3 +207,14 @@ export type SplitStreamHandlers = Partial<{
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "2.0.5",
+  "version": "2.1.1",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -45,9 +45,9 @@
     "code_exec": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec.ts --provider 'google' --name 'Jo' --location 'New York, NY'",
     "image": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/image.ts --provider 'vertexai' --name 'Jo' --location 'New York, NY'",
     "code_exec_simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec_simple.ts --provider 'vertexai' --name 'Jo' --location 'New York, NY'",
-    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'vertexai' --name 'Jo' --location 'New York, NY'",
+    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'deepseek' --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-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
+    "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'alibaba' --name 'Jo' --location 'New York, NY'",
     "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "start:cli2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli2.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "script2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/proto/example_test.ts",
@@ -74,6 +74,7 @@
     "@langchain/aws": "^0.1.3",
     "@langchain/community": "^0.3.27",
     "@langchain/core": "^0.3.37",
+    "@langchain/deepseek": "^0.0.1",
     "@langchain/google-genai": "^0.1.7",
     "@langchain/google-vertexai": "^0.1.8",
     "@langchain/langgraph": "^0.2.41",
@@ -84,7 +85,8 @@
     "@smithy/protocol-http": "^3.0.6",
     "@smithy/signature-v4": "^2.0.10",
     "@smithy/util-utf8": "^2.0.0",
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.4.7",
+    "https-proxy-agent": "^7.0.6",
     "nanoid": "^3.3.7"
   },
   "resolutions": {
@@ -103,38 +105,25 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^11.1.6",
+    "@rollup/plugin-typescript": "^12.1.2",
     "@swc/core": "^1.6.13",
-    "@types/babel__generator": "^7.6.8",
-    "@types/babel__template": "^7.4.4",
-    "@types/istanbul-lib-report": "^3.0.3",
     "@types/jest": "^29.5.14",
     "@types/node": "^20.14.11",
-    "@types/rollup": "^0.54.0",
     "@types/yargs-parser": "^21.0.3",
-    "@typescript-eslint/eslint-plugin": "^7.16.1",
-    "@typescript-eslint/parser": "^7.16.1",
-    "better-sqlite3": "^9.6.0",
-    "concurrently": "^8.2.2",
-    "cross-env": "^7.0.3",
-    "eslint": "^8.57.0",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.1",
-    "husky": "^9.0.11",
-    "javascript-obfuscator": "^4.1.1",
+    "@typescript-eslint/eslint-plugin": "^8.24.0",
+    "@typescript-eslint/parser": "^8.24.0",
+    "eslint": "^9.20.1",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-import": "^2.31.0",
+    "husky": "^9.1.7",
     "jest": "^29.7.0",
     "lint-staged": "^15.2.7",
-    "nodemon": "^3.1.4",
-    "prettier": "^3.3.2",
-    "rimraf": "^6.0.0",
-    "rollup": "^4.18.1",
+    "prettier": "^3.5.1",
+    "rollup": "^4.34.6",
     "rollup-plugin-cleandir": "^2.0.0",
-    "rollup-plugin-cleaner": "^1.0.0",
     "rollup-plugin-obfuscator": "^1.1.0",
-    "rollup-plugin-visualizer": "^5.12.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "ts-node-dev": "^2.0.0",
     "tsc-alias": "^1.8.10",
     "tsconfig-paths": "^4.2.0",
     "tslib": "^2.6.3",

package/src/common/enum.ts

@@ -78,6 +78,7 @@ export enum Providers {
   OLLAMA = 'ollama',
   GOOGLE = 'google',
   AZURE = 'azureOpenAI',
+  DEEPSEEK = 'deepseek',
 }
 
 export enum GraphNodeKeys {

package/src/events.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-console */
 // src/events.ts
+import type { UsageMetadata, BaseMessageFields } from '@langchain/core/messages';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
 import { handleToolCalls } from '@/stream';
@@ -18,6 +19,14 @@ export class HandlerRegistry {
 }
 
 export class ModelEndHandler implements t.EventHandler {
+  collectedUsage?: UsageMetadata[];
+  constructor(collectedUsage?: UsageMetadata[]) {
+    if (collectedUsage && !Array.isArray(collectedUsage)) {
+      throw new Error('collectedUsage must be an array');
+    }
+    this.collectedUsage = collectedUsage;
+  }
+
   handle(event: string, data: t.ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
@@ -25,6 +34,9 @@ export class ModelEndHandler implements t.EventHandler {
     }
 
     const usage = data?.output?.usage_metadata;
+    if (usage != null && this.collectedUsage != null) {
+      this.collectedUsage.push(usage);
+    }
 
     console.log(`====== ${event.toUpperCase()} ======`);
     console.dir({
@@ -117,7 +129,7 @@ export class LLMStreamHandler implements t.EventHandler {
   }
 }
 
-export const createMetadataAggregator = (_collected?: Record<string, unknown>[]): t.MetadataAggregatorResult => {
+export const createMetadataAggregator = (_collected?: Record<string, NonNullable<BaseMessageFields['response_metadata']>>[]): t.MetadataAggregatorResult => {
   const collected = _collected || [];
 
   const handleLLMEnd: t.HandleLLMEnd = (output) => {

package/src/graphs/Graph.ts

@@ -10,7 +10,7 @@ import { dispatchCustomEvent } from '@langchain/core/callbacks/dispatch';
 import { AIMessageChunk, ToolMessage, SystemMessage } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
-import { Providers, GraphEvents, GraphNodeKeys, StepTypes, Callback } from '@/common';
+import { Providers, GraphEvents, GraphNodeKeys, StepTypes, Callback, ContentTypes } from '@/common';
 import { getChatModelClass, manualToolStreamProviders } from '@/llm/providers';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import {
@@ -20,6 +20,7 @@ import {
   formatAnthropicArtifactContent,
 } from '@/messages';
 import { resetIfNotEmpty, isOpenAILike, isGoogleLike, joinKeys, sleep } from '@/utils';
+import { createFakeStreamingLLM } from '@/llm/fake';
 import { HandlerRegistry } from '@/events';
 
 const { AGENT, TOOLS } = GraphNodeKeys;
@@ -56,10 +57,15 @@ export abstract class Graph<
   abstract dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): string;
   abstract dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void;
   abstract dispatchMessageDelta(id: string, delta: t.MessageDelta): void;
+  abstract dispatchReasoningDelta(stepId: string, delta: t.ReasoningDelta): void;
   abstract handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>): void;
 
   abstract createCallModel(): (state: T, config?: RunnableConfig) => Promise<Partial<T>>;
   abstract createWorkflow(): t.CompiledWorkflow<T>;
+  lastToken?: string;
+  tokenTypeSwitch?: 'reasoning' | 'content';
+  reasoningKey: 'reasoning_content' | 'reasoning' = 'reasoning_content';
+  currentTokenType: ContentTypes.TEXT | ContentTypes.THINK = ContentTypes.TEXT;
   messageStepHasToolCalls: Map<string, boolean> = new Map();
   messageIdsByStepKey: Map<string, string> = new Map();
   prelimMessageIdsByStepKey: Map<string, string> = new Map();
@@ -96,37 +102,30 @@ export class StandardGraph extends Graph<
   constructor({
     runId,
     tools,
+    signal,
     toolMap,
     provider,
-    clientOptions,
-    instructions,
-    signal,
-    additional_instructions = '',
     streamBuffer,
+    instructions,
+    reasoningKey,
+    clientOptions,
     toolEnd = false,
-  } : {
-    runId?: string;
-    signal?: AbortSignal;
-    provider: Providers;
-    tools?: t.GenericTool[];
-    toolMap?: t.ToolMap;
-    clientOptions: Record<string, unknown>;
-    instructions?: string;
-    additional_instructions?: string;
-    streamBuffer?: number;
-    toolEnd?: boolean;
-  }) {
+    additional_instructions = '',
+  } : t.StandardGraphInput) {
     super();
     this.runId = runId;
     this.tools = tools;
+    this.signal = signal;
+    this.toolEnd = toolEnd;
     this.toolMap = toolMap;
     this.provider = provider;
-    this.signal = signal;
-    this.clientOptions = clientOptions;
     this.streamBuffer = streamBuffer;
+    this.clientOptions = clientOptions;
     this.graphState = this.createGraphState();
     this.boundModel = this.initializeModel();
-    this.toolEnd = toolEnd;
+    if (reasoningKey) {
+      this.reasoningKey = reasoningKey;
+    }
 
     let finalInstructions = instructions ?? '';
     if (additional_instructions) {
@@ -152,6 +151,10 @@ export class StandardGraph extends Graph<
     this.messageIdsByStepKey = resetIfNotEmpty(this.messageIdsByStepKey, new Map());
     this.messageStepHasToolCalls = resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
     this.prelimMessageIdsByStepKey = resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
+    this.reasoningKey = resetIfNotEmpty(this.reasoningKey, 'reasoning_content');
+    this.currentTokenType = resetIfNotEmpty(this.currentTokenType, ContentTypes.TEXT);
+    this.lastToken = resetIfNotEmpty(this.lastToken, undefined);
+    this.tokenTypeSwitch = resetIfNotEmpty(this.tokenTypeSwitch, undefined);
   }
 
   /* Run Step Processing */
@@ -208,13 +211,18 @@ export class StandardGraph extends Graph<
   getKeyList(metadata: Record<string, unknown> | undefined): (string | number | undefined)[] {
     if (!metadata) return [];
 
-    return [
+    const keyList = [
       metadata.run_id as string,
       metadata.thread_id as string,
       metadata.langgraph_node as string,
       metadata.langgraph_step as number,
       metadata.checkpoint_ns as string,
     ];
+    if (this.currentTokenType === ContentTypes.THINK) {
+      keyList.push('reasoning');
+    }
+
+    return keyList;
   }
 
   checkKeyList(keyList: (string | number | undefined)[]): boolean {
@@ -288,6 +296,9 @@ export class StandardGraph extends Graph<
 
     return (model as t.ModelWithTools).bindTools(this.tools);
   }
+  overrideTestModel(responses: string[], sleep?: number): void {
+    this.boundModel = createFakeStreamingLLM(responses, sleep);
+  }
 
   getNewModel({
     clientOptions = {},
@@ -512,4 +523,15 @@ export class StandardGraph extends Graph<
     };
     dispatchCustomEvent(GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
   }
+
+  dispatchReasoningDelta = (stepId: string, delta: t.ReasoningDelta): void => {
+    if (!this.config) {
+      throw new Error('No config provided');
+    }
+    const reasoningDelta: t.ReasoningDeltaEvent = {
+      id: stepId,
+      delta,
+    };
+    dispatchCustomEvent(GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+  };
 }

package/src/llm/fake.ts

@@ -0,0 +1,83 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { FakeListChatModel } from '@langchain/core/utils/testing';
+
+type SplitStrategy = {
+  type: 'regex' | 'fixed';
+  value: RegExp | number;
+};
+
+export class FakeChatModel extends FakeListChatModel {
+  private splitStrategy: SplitStrategy;
+
+  constructor({
+    responses,
+    sleep,
+    emitCustomEvent,
+    splitStrategy = { type: 'regex', value: /(?<=\s+)|(?=\s+)/ }
+  }: {
+    responses: string[];
+    sleep?: number;
+    emitCustomEvent?: boolean;
+    splitStrategy?: SplitStrategy;
+  }) {
+    super({ responses, sleep, emitCustomEvent });
+    this.splitStrategy = splitStrategy;
+  }
+
+  private splitText(text: string): string[] {
+    if (this.splitStrategy.type === 'regex') {
+      return text.split(this.splitStrategy.value as RegExp);
+    } else {
+      const chunkSize = this.splitStrategy.value as number;
+      const chunks: string[] = [];
+      for (let i = 0; i < text.length; i += chunkSize) {
+        chunks.push(text.slice(i, i + chunkSize));
+      }
+      return chunks;
+    }
+  }
+
+  async *_streamResponseChunks(
+    _messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const response = this._currentResponse();
+    this._incrementResponse();
+
+    if (this.emitCustomEvent) {
+      await runManager?.handleCustomEvent('some_test_event', {
+        someval: true,
+      });
+    }
+
+    const chunks = this.splitText(response);
+
+    for await (const chunk of chunks) {
+      await this._sleepIfRequested();
+
+      if (options.thrownErrorString != null && options.thrownErrorString) {
+        throw new Error(options.thrownErrorString);
+      }
+
+      const responseChunk = this._createResponseChunk(chunk);
+      yield responseChunk;
+      void runManager?.handleLLMNewToken(chunk);
+    }
+  }
+}
+
+export function createFakeStreamingLLM(
+  responses: string[],
+  sleep?: number,
+  splitStrategy?: SplitStrategy
+): FakeChatModel {
+  return new FakeChatModel({
+    sleep,
+    responses,
+    emitCustomEvent: true,
+    splitStrategy,
+  });
+}

package/src/llm/providers.ts

@@ -1,25 +1,27 @@
 // src/llm/providers.ts
 import { ChatOllama } from '@langchain/ollama';
+import { ChatDeepSeek } from '@langchain/deepseek';
+import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 // import { ChatAnthropic } from '@langchain/anthropic';
-import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatVertexAI } from '@langchain/google-vertexai';
 import { ChatOpenAI, AzureChatOpenAI } from '@langchain/openai';
 import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
-import { Providers } from '@/common';
 import { CustomAnthropic } from '@/llm/anthropic/llm';
+import { Providers } from '@/common';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.OPENAI]: ChatOpenAI,
-  [Providers.AZURE]: AzureChatOpenAI,
   [Providers.OLLAMA]: ChatOllama,
+  [Providers.AZURE]: AzureChatOpenAI,
   [Providers.VERTEXAI]: ChatVertexAI,
-  [Providers.BEDROCK_LEGACY]: BedrockChat,
+  [Providers.DEEPSEEK]: ChatDeepSeek,
   [Providers.MISTRALAI]: ChatMistralAI,
-  [Providers.BEDROCK]: ChatBedrockConverse,
   [Providers.ANTHROPIC]: CustomAnthropic,
+  [Providers.BEDROCK_LEGACY]: BedrockChat,
+  [Providers.BEDROCK]: ChatBedrockConverse,
   // [Providers.ANTHROPIC]: ChatAnthropic,
   [Providers.GOOGLE]: ChatGoogleGenerativeAI,
 };

package/src/run.ts

@@ -56,19 +56,15 @@ export class Run<T extends t.BaseGraphState> {
   }
 
   private createStandardGraph(config: t.StandardGraphConfig): t.CompiledWorkflow<t.IState, Partial<t.IState>, string> {
-    const { llmConfig, instructions, additional_instructions, signal, streamBuffer, toolEnd, tools = [] } = config;
+    const { llmConfig, tools = [], ...graphInput } = config;
     const { provider, ...clientOptions } = llmConfig;
 
     const standardGraph = new StandardGraph({
-      runId: this.id,
       tools,
       provider,
-      signal,
-      instructions,
       clientOptions,
-      additional_instructions,
-      streamBuffer,
-      toolEnd,
+      ...graphInput,
+      runId: this.id,
     });
     this.Graph = standardGraph;
     return standardGraph.createWorkflow();

package/src/scripts/simple.ts

@@ -12,10 +12,12 @@ import { GraphEvents } from '@/common';
 import { Run } from '@/run';
 
 const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
 
 async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
   const customHandlers = {
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
@@ -48,6 +50,13 @@ async function testStandardStreaming(): Promise<void> {
         aggregateContent({ event, data: data as t.MessageDeltaEvent });
       }
     },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_REASONING_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      }
+    },
     [GraphEvents.TOOL_START]: {
       handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
         console.log('====== TOOL_START ======');
@@ -63,7 +72,7 @@ async function testStandardStreaming(): Promise<void> {
     graphConfig: {
       type: 'standard',
       llmConfig,
-      tools: [new TavilySearchResults()],
+      // tools: [new TavilySearchResults()],
       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}.`,
     },
@@ -81,7 +90,7 @@ async function testStandardStreaming(): Promise<void> {
 
   console.log('Test 1: Simple message test');
 
-  const userMessage = `hi tell me a long story`;
+  const userMessage = `hi`;
 
   conversationHistory.push(new HumanMessage(userMessage));
 
@@ -97,23 +106,26 @@ async function testStandardStreaming(): Promise<void> {
   // console.dir(finalContentParts, { depth: null });
   console.log('\n\n====================\n\n');
   console.dir(contentParts, { depth: null });
-  const { handleLLMEnd, collected } = createMetadataAggregator();
-  const titleResult = await run.generateTitle({
-    inputText: userMessage,
-    contentParts,
-    chainOptions: {
-      callbacks: [{
-        handleLLMEnd,
-      }],
-    },
-  });
-  console.log('Generated Title:', titleResult);
-  console.log('Collected metadata:', collected);
+  // const { handleLLMEnd, collected } = createMetadataAggregator();
+  // const titleResult = await run.generateTitle({
+  //   inputText: userMessage,
+  //   contentParts,
+  //   chainOptions: {
+  //     callbacks: [{
+  //       handleLLMEnd,
+  //     }],
+  //   },
+  // });
+  // console.log('Generated Title:', titleResult);
+  // console.log('Collected metadata:', collected);
 }
 
 process.on('unhandledRejection', (reason, promise) => {
   console.error('Unhandled Rejection at:', promise, 'reason:', reason);
   console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
   process.exit(1);
 });
 
@@ -125,5 +137,7 @@ testStandardStreaming().catch((err) => {
   console.error(err);
   console.log('Conversation history:');
   console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
   process.exit(1);
 });