@librechat/agents 3.1.57 → 3.1.61

package/src/messages/reducer.ts

@@ -1,5 +1,6 @@
 import {
   BaseMessage,
+  RemoveMessage,
   BaseMessageLike,
   coerceMessageLikeToMessage,
 } from '@langchain/core/messages';
@@ -7,6 +8,27 @@ import { v4 } from 'uuid';
 
 export const REMOVE_ALL_MESSAGES = '__remove_all__';
 
+/**
+ * Creates a message that instructs messagesStateReducer to remove ALL
+ * existing messages from state.  Messages appearing after this one in
+ * the array become the new state.
+ *
+ * Usage (in a node return value):
+ * ```ts
+ * return { messages: [createRemoveAllMessage(), ...survivingMessages] };
+ * ```
+ *
+ * This works because the reducer checks for `getType() === 'remove'`
+ * with `id === REMOVE_ALL_MESSAGES` and discards everything before it.
+ *
+ * NOTE: Uses RemoveMessage from @langchain/core with a sentinel id so
+ * the reducer can distinguish a "remove-all" marker from a single-message
+ * removal.
+ */
+export function createRemoveAllMessage(): BaseMessage {
+  return new RemoveMessage({ id: REMOVE_ALL_MESSAGES });
+}
+
 export type Messages =
   | Array<BaseMessage | BaseMessageLike>
   | BaseMessage

package/src/run.ts

@@ -20,6 +20,7 @@ import { createTokenCounter, encodingForModel } from '@/utils/tokens';
 import { GraphEvents, Callback, TitleMethod } from '@/common';
 import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
 import { StandardGraph } from '@/graphs/Graph';
+import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
 import { isOpenAILike } from '@/utils/llm';
 import { isPresent } from '@/utils/misc';
@@ -42,10 +43,12 @@ export class Run<_T extends t.BaseGraphState> {
   private tokenCounter?: t.TokenCounter;
   private handlerRegistry?: HandlerRegistry;
   private indexTokenCountMap?: Record<string, number>;
+  calibrationRatio: number = 1;
   graphRunnable?: t.CompiledStateWorkflow;
   Graph: StandardGraph | MultiAgentGraph | undefined;
   returnContent: boolean = false;
   private skipCleanup: boolean = false;
+  private _streamResult: t.MessageContentComplex[] | undefined;
 
   private constructor(config: Partial<t.RunConfig>) {
     const runId = config.runId ?? '';
@@ -56,6 +59,9 @@ export class Run<_T extends t.BaseGraphState> {
     this.id = runId;
     this.tokenCounter = config.tokenCounter;
     this.indexTokenCountMap = config.indexTokenCountMap;
+    if (config.calibrationRatio != null && config.calibrationRatio > 0) {
+      this.calibrationRatio = config.calibrationRatio;
+    }
 
     const handlerRegistry = new HandlerRegistry();
 
@@ -133,6 +139,7 @@ export class Run<_T extends t.BaseGraphState> {
       agents: [agentConfig],
       tokenCounter: this.tokenCounter,
       indexTokenCountMap: this.indexTokenCountMap,
+      calibrationRatio: this.calibrationRatio,
     });
     /** Propagate compile options from graph config */
     standardGraph.compileOptions = config.compileOptions;
@@ -151,6 +158,7 @@ export class Run<_T extends t.BaseGraphState> {
       edges,
       tokenCounter: this.tokenCounter,
       indexTokenCountMap: this.indexTokenCountMap,
+      calibrationRatio: this.calibrationRatio,
     });
 
     if (compileOptions != null) {
@@ -184,6 +192,24 @@ export class Run<_T extends t.BaseGraphState> {
     return this.Graph.getRunMessages();
   }
 
+  /**
+   * Returns the current calibration ratio (EMA of provider-vs-estimate token ratios).
+   * Hosts should persist this value and pass it back as `RunConfig.calibrationRatio`
+   * on the next run for the same conversation so the pruner starts with an accurate
+   * scaling factor instead of the default (1).
+   */
+  getCalibrationRatio(): number {
+    return this.calibrationRatio;
+  }
+
+  getResolvedInstructionOverhead(): number | undefined {
+    return this.Graph?.getResolvedInstructionOverhead();
+  }
+
+  getToolCount(): number {
+    return this.Graph?.getToolCount() ?? 0;
+  }
+
   /**
    * Creates a custom event callback handler that intercepts custom events
    * and processes them through our handler registry instead of EventStreamCallbackHandler
@@ -196,6 +222,16 @@ export class Run<_T extends t.BaseGraphState> {
       tags?: string[],
       metadata?: Record<string, unknown>
     ): Promise<void> => {
+      // ON_RUN_STEP is dispatched directly via handler registry in
+      // Graph.dispatchRunStep (primary, reliable path).  Skip the
+      // callback-based dispatch to prevent double handling.
+      if (
+        eventName === GraphEvents.ON_RUN_STEP &&
+        this.Graph != null &&
+        this.Graph.handlerDispatchedStepIds.has((data as t.RunStep).id)
+      ) {
+        return;
+      }
       const handler = this.handlerRegistry?.getHandler(eventName);
       if (handler && this.Graph) {
         return await handler.handle(
@@ -217,7 +253,10 @@ export class Run<_T extends t.BaseGraphState> {
 
   async processStream(
     inputs: t.IState,
-    config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string },
+    callerConfig: Partial<RunnableConfig> & {
+      version: 'v1' | 'v2';
+      run_id?: string;
+    },
     streamOptions?: t.EventStreamOptions
   ): Promise<MessageContentComplex[] | undefined> {
     if (this.graphRunnable == null) {
@@ -231,6 +270,15 @@ export class Run<_T extends t.BaseGraphState> {
       );
     }
 
+    const config: Partial<RunnableConfig> & {
+      version: 'v1' | 'v2';
+      run_id?: string;
+    } = {
+      recursionLimit: 50,
+      ...callerConfig,
+      configurable: { ...callerConfig.configurable },
+    };
+
     this.Graph.resetValues(streamOptions?.keepContent);
 
     /** Custom event callback to intercept and handle custom events */
@@ -293,61 +341,68 @@ export class Run<_T extends t.BaseGraphState> {
       ignoreCustomEvent: true,
     });
 
-    for await (const event of stream) {
-      const { data, metadata, ...info } = event;
+    try {
+      for await (const event of stream) {
+        const { data, metadata, ...info } = event;
 
-      const eventName: t.EventName = info.event;
+        const eventName: t.EventName = info.event;
 
-      /** Skip custom events as they're handled by our callback */
-      if (eventName === GraphEvents.ON_CUSTOM_EVENT) {
-        continue;
-      }
+        /** Skip custom events as they're handled by our callback */
+        if (eventName === GraphEvents.ON_CUSTOM_EVENT) {
+          continue;
+        }
 
-      const handler = this.handlerRegistry?.getHandler(eventName);
-      if (handler) {
-        await handler.handle(eventName, data, metadata, this.Graph);
+        const handler = this.handlerRegistry?.getHandler(eventName);
+        if (handler) {
+          await handler.handle(eventName, data, metadata, this.Graph);
+        }
       }
-    }
-
-    /**
-     * Break the reference chain that keeps heavy data alive via
-     * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
-     * `@langchain/core` `RunTree.extra[lc:child_config]` →
-     * Node.js `AsyncLocalStorage` context captured by timers/promises.
-     *
-     * Without this, base64-encoded images/PDFs in message content remain
-     * reachable from lingering `Timeout` handles until GC runs.
-     */
-    if (!this.skipCleanup) {
-      if (
-        (config.configurable as Record<string, unknown> | undefined) != null
-      ) {
-        for (const key of Object.getOwnPropertySymbols(config.configurable)) {
-          const val = config.configurable[key as unknown as string] as
-            | Record<string, unknown>
-            | undefined;
-          if (
-            val != null &&
-            typeof val === 'object' &&
-            'currentTaskInput' in val
-          ) {
-            (val as Record<string, unknown>).currentTaskInput = undefined;
+    } finally {
+      /**
+       * Break the reference chain that keeps heavy data alive via
+       * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
+       * `@langchain/core` `RunTree.extra[lc:child_config]` →
+       * Node.js `AsyncLocalStorage` context captured by timers/promises.
+       *
+       * Without this, base64-encoded images/PDFs in message content remain
+       * reachable from lingering `Timeout` handles until GC runs.
+       */
+      if (!this.skipCleanup) {
+        if (
+          (config.configurable as Record<string, unknown> | undefined) != null
+        ) {
+          for (const key of Object.getOwnPropertySymbols(config.configurable)) {
+            const val = config.configurable[key as unknown as string] as
+              | Record<string, unknown>
+              | undefined;
+            if (
+              val != null &&
+              typeof val === 'object' &&
+              'currentTaskInput' in val
+            ) {
+              (val as Record<string, unknown>).currentTaskInput = undefined;
+            }
+            delete config.configurable[key as unknown as string];
           }
-          delete config.configurable[key as unknown as string];
+          config.configurable = undefined;
         }
-        config.configurable = undefined;
+        config.callbacks = undefined;
       }
-      config.callbacks = undefined;
-    }
 
-    const result = this.returnContent
-      ? this.Graph.getContentParts()
-      : undefined;
+      const result = this.returnContent
+        ? this.Graph.getContentParts()
+        : undefined;
+
+      this.calibrationRatio = this.Graph.getCalibrationRatio();
+
+      if (!this.skipCleanup) {
+        this.Graph.clearHeavyState();
+      }
 
-    if (!this.skipCleanup) {
-      this.Graph.clearHeavyState();
+      this._streamResult = result;
     }
-    return result;
+
+    return this._streamResult;
   }
 
   private createSystemCallback<K extends keyof t.ClientCallbacks>(
@@ -422,13 +477,11 @@ export class Run<_T extends t.BaseGraphState> {
       })
       .join('\n');
 
-    const model = this.Graph?.getNewModel({
+    const model = initializeModel({
       provider,
       clientOptions,
-    });
-    if (!model) {
-      return { language: '', title: '' };
-    }
+    }) as t.ChatModelInstance;
+
     if (
       isOpenAILike(provider) &&
       (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)

package/src/scripts/bedrock-merge-test.ts

@@ -9,7 +9,7 @@ import { Providers } from '@/common';
 
 async function testBedrockMerge(): Promise<void> {
   const model = new CustomChatBedrockConverse({
-    model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
     region: process.env.BEDROCK_AWS_REGION,
     credentials: {
       accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,

package/src/scripts/test-thinking-handoff-bedrock.ts

@@ -56,7 +56,7 @@ async function testBedrockThinkingHandoff() {
         provider: Providers.BEDROCK,
         clientOptions: {
           region: process.env.BEDROCK_AWS_REGION || 'us-east-1',
-          model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+          model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
           credentials: {
             accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
             secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,

package/src/scripts/test-thinking-handoff.ts

@@ -63,7 +63,7 @@ async function testThinkingHandoff() {
         agentId: 'code_reviewer',
         provider: Providers.ANTHROPIC,
         clientOptions: {
-          modelName: 'claude-3-7-sonnet-20250219',
+          modelName: 'claude-sonnet-4-5-20250929',
           apiKey: process.env.ANTHROPIC_API_KEY,
           thinking: {
             type: 'enabled',

package/src/scripts/thinking-bedrock.ts

@@ -75,7 +75,7 @@ async function testBedrockThinking(): Promise<void> {
   // Enable thinking with token budget for Bedrock
   const llmConfig = {
     ...baseLlmConfig,
-    model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
     maxTokens: 5000,
     additionalModelRequestFields: {
       thinking: { type: 'enabled', budget_tokens: 2000 },

package/src/scripts/thinking.ts

@@ -79,7 +79,7 @@ async function testThinking(): Promise<void> {
   // Enable thinking with token budget
   const llmConfig = {
     ...baseLlmConfig,
-    model: 'claude-3-7-sonnet-latest',
+    model: 'claude-sonnet-4-5-20250929',
     thinking: { type: 'enabled', budget_tokens: 2000 },
   };
 

package/src/specs/anthropic.simple.test.ts

@@ -24,7 +24,7 @@ import { Run } from '@/run';
 
 const provider = Providers.ANTHROPIC;
 describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
-  jest.setTimeout(60000);
+  jest.setTimeout(90000);
   let run: Run<t.IState>;
   let runningHistory: BaseMessage[];
   let collectedUsage: UsageMetadata[];