@librechat/agents 2.3.92 → 2.3.94

package/src/run.ts

@@ -3,7 +3,10 @@ import { zodToJsonSchema } from 'zod-to-json-schema';
 import { PromptTemplate } from '@langchain/core/prompts';
 import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
 import { SystemMessage } from '@langchain/core/messages';
-import type { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
+import type {
+  BaseMessage,
+  MessageContentComplex,
+} from '@langchain/core/messages';
 import type { ClientCallbacks, SystemCallbacks } from '@/graphs/Graph';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
@@ -37,7 +40,9 @@ export class Run<T extends t.BaseGraphState> {
     const handlerRegistry = new HandlerRegistry();
 
     if (config.customHandlers) {
-      for (const [eventType, handler] of Object.entries(config.customHandlers)) {
+      for (const [eventType, handler] of Object.entries(
+        config.customHandlers
+      )) {
         handlerRegistry.register(eventType, handler);
       }
     }
@@ -50,7 +55,9 @@ export class Run<T extends t.BaseGraphState> {
 
     if (config.graphConfig.type === 'standard' || !config.graphConfig.type) {
       this.provider = config.graphConfig.llmConfig.provider;
-      this.graphRunnable = this.createStandardGraph(config.graphConfig) as unknown as t.CompiledWorkflow<T, Partial<T>, string>;
+      this.graphRunnable = this.createStandardGraph(
+        config.graphConfig
+      ) as unknown as t.CompiledWorkflow<T, Partial<T>, string>;
       if (this.Graph) {
         this.Graph.handlerRegistry = handlerRegistry;
       }
@@ -59,7 +66,9 @@ export class Run<T extends t.BaseGraphState> {
     this.returnContent = config.returnContent ?? false;
   }
 
-  private createStandardGraph(config: t.StandardGraphConfig): t.CompiledWorkflow<t.IState, Partial<t.IState>, string> {
+  private createStandardGraph(
+    config: t.StandardGraphConfig
+  ): t.CompiledWorkflow<t.IState, Partial<t.IState>, string> {
     const { llmConfig, tools = [], ...graphInput } = config;
     const { provider, ...clientOptions } = llmConfig;
 
@@ -74,13 +83,17 @@ export class Run<T extends t.BaseGraphState> {
     return standardGraph.createWorkflow();
   }
 
-  static async create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>> {
+  static async create<T extends t.BaseGraphState>(
+    config: t.RunConfig
+  ): Promise<Run<T>> {
     return new Run<T>(config);
   }
 
   getRunMessages(): BaseMessage[] | undefined {
     if (!this.Graph) {
-      throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
+      throw new Error(
+        'Graph not initialized. Make sure to use Run.create() to instantiate the Run.'
+      );
     }
     return this.Graph.getRunMessages();
   }
@@ -88,13 +101,17 @@ export class Run<T extends t.BaseGraphState> {
   async processStream(
     inputs: t.IState,
     config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string },
-    streamOptions?: t.EventStreamOptions,
+    streamOptions?: t.EventStreamOptions
   ): Promise<MessageContentComplex[] | undefined> {
     if (!this.graphRunnable) {
-      throw new Error('Run not initialized. Make sure to use Run.create() to instantiate the Run.');
+      throw new Error(
+        'Run not initialized. Make sure to use Run.create() to instantiate the Run.'
+      );
     }
     if (!this.Graph) {
-      throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
+      throw new Error(
+        'Graph not initialized. Make sure to use Run.create() to instantiate the Run.'
+      );
     }
 
     this.Graph.resetValues(streamOptions?.keepContent);
@@ -102,30 +119,46 @@ export class Run<T extends t.BaseGraphState> {
     const hasTools = this.Graph.tools ? this.Graph.tools.length > 0 : false;
     if (streamOptions?.callbacks) {
       /* TODO: conflicts with callback manager */
-      const callbacks = config.callbacks as t.ProvidedCallbacks ?? [];
-      config.callbacks = callbacks.concat(this.getCallbacks(streamOptions.callbacks));
+      const callbacks = (config.callbacks as t.ProvidedCallbacks) ?? [];
+      config.callbacks = callbacks.concat(
+        this.getCallbacks(streamOptions.callbacks)
+      );
     }
 
     if (!this.id) {
       throw new Error('Run ID not provided');
     }
 
-    const tokenCounter = streamOptions?.tokenCounter ?? (streamOptions?.indexTokenCountMap ? await createTokenCounter() : undefined);
-    const toolTokens = tokenCounter ? (this.Graph.tools?.reduce((acc, tool) => {
-      if (!tool.schema) {
-        return acc;
-      }
+    const tokenCounter =
+      streamOptions?.tokenCounter ??
+      (streamOptions?.indexTokenCountMap
+        ? await createTokenCounter()
+        : undefined);
+    const toolTokens = tokenCounter
+      ? (this.Graph.tools?.reduce((acc, tool) => {
+        if (!(tool as Partial<t.GenericTool>).schema) {
+          return acc;
+        }
 
-      const jsonSchema = zodToJsonSchema(tool.schema.describe(tool.description ?? ''), tool.name);
-      return acc + tokenCounter(new SystemMessage(JSON.stringify(jsonSchema)));
-    }, 0) ?? 0) : 0;
+        const jsonSchema = zodToJsonSchema(
+          tool.schema.describe(tool.description ?? ''),
+          tool.name
+        );
+        return (
+          acc + tokenCounter(new SystemMessage(JSON.stringify(jsonSchema)))
+        );
+      }, 0) ?? 0)
+      : 0;
     let instructionTokens = toolTokens;
     if (this.Graph.systemMessage && tokenCounter) {
       instructionTokens += tokenCounter(this.Graph.systemMessage);
     }
     const tokenMap = streamOptions?.indexTokenCountMap ?? {};
-    if (this.Graph.systemMessage  && instructionTokens > 0) {
-      this.Graph.indexTokenCountMap = shiftIndexTokenCountMap(tokenMap, instructionTokens);
+    if (this.Graph.systemMessage && instructionTokens > 0) {
+      this.Graph.indexTokenCountMap = shiftIndexTokenCountMap(
+        tokenMap,
+        instructionTokens
+      );
     } else if (instructionTokens > 0) {
       tokenMap[0] = tokenMap[0] + instructionTokens;
       this.Graph.indexTokenCountMap = tokenMap;
@@ -137,7 +170,10 @@ export class Run<T extends t.BaseGraphState> {
     this.Graph.tokenCounter = tokenCounter;
 
     config.run_id = this.id;
-    config.configurable = Object.assign(config.configurable ?? {}, { run_id: this.id, provider: this.provider });
+    config.configurable = Object.assign(config.configurable ?? {}, {
+      run_id: this.id,
+      provider: this.provider,
+    });
 
     const stream = this.graphRunnable.streamEvents(inputs, config);
 
@@ -145,7 +181,11 @@ export class Run<T extends t.BaseGraphState> {
       const { data, name, metadata, ...info } = event;
 
       let eventName: t.EventName = info.event;
-      if (hasTools && manualToolStreamProviders.has(provider) && eventName === GraphEvents.CHAT_MODEL_STREAM) {
+      if (
+        hasTools &&
+        manualToolStreamProviders.has(provider) &&
+        eventName === GraphEvents.CHAT_MODEL_STREAM
+      ) {
         /* Skipping CHAT_MODEL_STREAM event due to double-call edge case */
         continue;
       }
@@ -179,9 +219,18 @@ export class Run<T extends t.BaseGraphState> {
 
   getCallbacks(clientCallbacks: ClientCallbacks): SystemCallbacks {
     return {
-      [Callback.TOOL_ERROR]: this.createSystemCallback(clientCallbacks, Callback.TOOL_ERROR),
-      [Callback.TOOL_START]: this.createSystemCallback(clientCallbacks, Callback.TOOL_START),
-      [Callback.TOOL_END]: this.createSystemCallback(clientCallbacks, Callback.TOOL_END),
+      [Callback.TOOL_ERROR]: this.createSystemCallback(
+        clientCallbacks,
+        Callback.TOOL_ERROR
+      ),
+      [Callback.TOOL_START]: this.createSystemCallback(
+        clientCallbacks,
+        Callback.TOOL_START
+      ),
+      [Callback.TOOL_END]: this.createSystemCallback(
+        clientCallbacks,
+        Callback.TOOL_END
+      ),
     };
   }
 
@@ -192,35 +241,55 @@ export class Run<T extends t.BaseGraphState> {
     clientOptions,
     chainOptions,
     skipLanguage,
-  } : {
-    inputText: string;
-    contentParts: (t.MessageContentComplex | undefined)[];
-    titlePrompt?: string;
-    skipLanguage?: boolean;
-    clientOptions?: t.ClientOptions;
-    chainOptions?: Partial<RunnableConfig> | undefined;
-  }): Promise<{ language: string; title: string }> {
-    const convoTemplate = PromptTemplate.fromTemplate('User: {input}\nAI: {output}');
-    const response = contentParts.map((part) => {
-      if (part?.type === 'text') return part.text;
-      return '';
-    }).join('\n');
-    const convo = (await convoTemplate.invoke({ input: inputText, output: response })).value;
+  }: t.RunTitleOptions): Promise<{ language: string; title: string }> {
+    const convoTemplate = PromptTemplate.fromTemplate(
+      'User: {input}\nAI: {output}'
+    );
+    const response = contentParts
+      .map((part) => {
+        if (part?.type === 'text') return part.text;
+        return '';
+      })
+      .join('\n');
+    const convo = (
+      await convoTemplate.invoke({ input: inputText, output: response })
+    ).value;
     const model = this.Graph?.getNewModel({
       clientOptions,
-      omitOriginalOptions: ['streaming', 'stream', 'thinking', 'maxTokens', 'maxOutputTokens', 'additionalModelRequestFields'],
+      omitOriginalOptions: new Set([
+        'clientOptions',
+        'streaming',
+        'stream',
+        'thinking',
+        'maxTokens',
+        'maxOutputTokens',
+        'additionalModelRequestFields',
+      ]),
     });
     if (!model) {
       return { language: '', title: '' };
     }
-    if (isOpenAILike(this.provider) && (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)) {
-      model.temperature = (clientOptions as t.OpenAIClientOptions | undefined)?.temperature as number;
-      model.topP = (clientOptions as t.OpenAIClientOptions | undefined)?.topP as number;
-      model.frequencyPenalty = (clientOptions as t.OpenAIClientOptions | undefined)?.frequencyPenalty as number;
-      model.presencePenalty = (clientOptions as t.OpenAIClientOptions | undefined)?.presencePenalty as number;
-      model.n = (clientOptions as t.OpenAIClientOptions | undefined)?.n as number;
+    if (
+      isOpenAILike(this.provider) &&
+      (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)
+    ) {
+      model.temperature = (clientOptions as t.OpenAIClientOptions | undefined)
+        ?.temperature as number;
+      model.topP = (clientOptions as t.OpenAIClientOptions | undefined)
+        ?.topP as number;
+      model.frequencyPenalty = (
+        clientOptions as t.OpenAIClientOptions | undefined
+      )?.frequencyPenalty as number;
+      model.presencePenalty = (
+        clientOptions as t.OpenAIClientOptions | undefined
+      )?.presencePenalty as number;
+      model.n = (clientOptions as t.OpenAIClientOptions | undefined)
+        ?.n as number;
     }
     const chain = await createTitleRunnable(model, titlePrompt);
-    return await chain.invoke({ convo, inputText, skipLanguage }, chainOptions) as { language: string; title: string };
+    return (await chain.invoke(
+      { convo, inputText, skipLanguage },
+      chainOptions
+    )) as { language: string; title: string };
   }
 }

package/src/scripts/simple.ts

@@ -5,10 +5,14 @@ import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
 import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler, createMetadataAggregator } from '@/events';
+import {
+  ToolEndHandler,
+  ModelEndHandler,
+  createMetadataAggregator,
+} from '@/events';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
-import { GraphEvents } from '@/common';
+import { GraphEvents, Providers } from '@/common';
 import { Run } from '@/run';
 
 const conversationHistory: BaseMessage[] = [];
@@ -23,49 +27,79 @@ async function testStandardStreaming(): Promise<void> {
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
         console.log('====== ON_RUN_STEP_COMPLETED ======');
         // console.dir(data, { depth: null });
-        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
-      }
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
     },
     [GraphEvents.ON_RUN_STEP]: {
-      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData): void => {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
         console.log('====== ON_RUN_STEP ======');
         console.dir(data, { depth: null });
         aggregateContent({ event, data: data as t.RunStep });
-      }
+      },
     },
     [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
         console.log('====== ON_RUN_STEP_DELTA ======');
         console.dir(data, { depth: null });
         aggregateContent({ event, data: data as t.RunStepDeltaEvent });
-      }
+      },
     },
     [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData): void => {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
         console.log('====== ON_MESSAGE_DELTA ======');
         console.dir(data, { depth: null });
         aggregateContent({ event, data: data as t.MessageDeltaEvent });
-      }
+      },
     },
     [GraphEvents.ON_REASONING_DELTA]: {
-      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.StreamEventData): void => {
+      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 => {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
         console.log('====== TOOL_START ======');
         // console.dir(data, { depth: null });
-      }
+      },
     },
   };
 
   const llmConfig = getLLMConfig(provider);
+  if (provider === Providers.ANTHROPIC) {
+    (llmConfig as t.AnthropicClientOptions).clientOptions = {
+      defaultHeaders: {
+        'anthropic-beta':
+          'token-efficient-tools-2025-02-19,output-128k-2025-02-19,prompt-caching-2024-07-31',
+      },
+    };
+  }
 
   const run = await Run.create<t.IState>({
     runId: 'test-run-id',
@@ -74,7 +108,8 @@ async function testStandardStreaming(): Promise<void> {
       llmConfig,
       // tools: [new TavilySearchResults()],
       reasoningKey: 'reasoning',
-      instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+      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}.`,
     },
     returnContent: true,
@@ -107,18 +142,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 titleOptions: t.RunTitleOptions = {
+    inputText: userMessage,
+    contentParts,
+    chainOptions: {
+      callbacks: [
+        {
+          handleLLMEnd,
+        },
+      ],
+    },
+  };
+  if (provider === Providers.ANTHROPIC) {
+    titleOptions.clientOptions = {
+      model: 'claude-3-5-haiku-latest',
+    };
+  }
+  const titleResult = await run.generateTitle(titleOptions);
+  console.log('Generated Title:', titleResult);
+  console.log('Collected metadata:', collected);
 }
 
 process.on('unhandledRejection', (reason, promise) => {

package/src/specs/token-distribution-edge-case.test.ts

@@ -243,9 +243,9 @@ describe('Token Distribution Edge Case Tests', () => {
 
     // Second usage metadata update
     const secondUsageMetadata: Partial<UsageMetadata> = {
-      input_tokens: 40,
-      output_tokens: 30,
-      total_tokens: 70
+      input_tokens: 30,
+      output_tokens: 20,
+      total_tokens: 50
     };
 
     // Apply second usage metadata with extended messages

package/src/types/run.ts

@@ -2,8 +2,13 @@
 import type * as z from 'zod';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredTool } from '@langchain/core/tools';
-import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/core/callbacks/base';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type {
+  BaseCallbackHandler,
+  CallbackHandlerMethods,
+} from '@langchain/core/callbacks/base';
 import type * as graph from '@/graphs/Graph';
+import type * as s from '@/types/stream';
 import type * as e from '@/common/enum';
 import type * as g from '@/types/graph';
 import type * as l from '@/types/llm';
@@ -19,6 +24,15 @@ export type BaseGraphConfig = {
 export type StandardGraphConfig = BaseGraphConfig &
   Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
 
+export type RunTitleOptions = {
+  inputText: string;
+  contentParts: (s.MessageContentComplex | undefined)[];
+  titlePrompt?: string;
+  skipLanguage?: boolean;
+  clientOptions?: l.ClientOptions;
+  chainOptions?: Partial<RunnableConfig> | undefined;
+};
+
 export interface AgentStateChannels {
   messages: BaseMessage[];
   next: string;
@@ -48,12 +62,17 @@ export type TaskManagerGraphConfig = {
 
 export type RunConfig = {
   runId: string;
-  graphConfig: StandardGraphConfig | CollaborativeGraphConfig | TaskManagerGraphConfig;
+  graphConfig:
+    | StandardGraphConfig
+    | CollaborativeGraphConfig
+    | TaskManagerGraphConfig;
   customHandlers?: Record<string, g.EventHandler>;
   returnContent?: boolean;
 };
 
-export type ProvidedCallbacks = (BaseCallbackHandler | CallbackHandlerMethods)[] | undefined;
+export type ProvidedCallbacks =
+  | (BaseCallbackHandler | CallbackHandlerMethods)[]
+  | undefined;
 
 export type TokenCounter = (message: BaseMessage) => number;
 export type EventStreamOptions = {
@@ -63,4 +82,4 @@ export type EventStreamOptions = {
   maxContextTokens?: number;
   tokenCounter?: TokenCounter;
   indexTokenCountMap?: Record<string, number>;
-}
+};