@librechat/agents 3.1.78-dev.0 → 3.1.79

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

@@ -1,7 +1,7 @@
 import { ChatAnthropicMessages } from '@langchain/anthropic';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { BaseChatModelParams } from '@langchain/core/language_models/chat_models';
-import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { AnthropicInput } from '@langchain/anthropic';
 import type { Anthropic } from '@anthropic-ai/sdk';
@@ -31,10 +31,7 @@ type CustomAnthropicInvocationParams = {
 };
 export declare class CustomAnthropic extends ChatAnthropicMessages {
     _lc_stream_delay: number;
-    private message_start;
-    private message_delta;
     private tools_in_params?;
-    private emitted_usage?;
     top_k: number | undefined;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
@@ -45,11 +42,6 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
      * Get the parameters used to invoke the model
      */
     invocationParams(options?: this['ParsedCallOptions'] & CustomAnthropicCallOptions): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & CustomAnthropicInvocationParams;
-    /**
-     * Get stream usage as returned by this client's API response.
-     * @returns The stream usage object.
-     */
-    getStreamUsage(): UsageMetadata | undefined;
     resetTokenEvents(): void;
     setDirectFields(fields?: CustomAnthropicInput): void;
     private createGenerationChunk;

package/dist/types/messages/anthropicToolCache.d.ts

@@ -19,9 +19,9 @@
  * the breakpoint.
  *
  * LangChain's Anthropic adapter passes the marker through via
- * `tool.extras.cache_control` (`AnthropicToolExtrasSchema`), so we set
- * it as an `extras` field on a fresh wrapper around the tool — never
- * mutating the original tool instance, since callers may share them
+ * `tool.extras.cache_control` for custom tools, while Anthropic built-ins
+ * require direct `cache_control`. Either way, we stamp a fresh wrapper —
+ * never mutating the original tool instance, since callers may share them
  * across runs.
  */
 import type { GraphTools } from '@/types';
@@ -45,7 +45,7 @@ export declare function makeIsDeferred(toolDefinitions: ReadonlyArray<{
  *
  * The original tool instances are never mutated. The marked entry is a
  * shallow wrapper that preserves the prototype chain so downstream
- * `instanceof` checks still pass. `extras` is merged so any existing
- * `providerToolDefinition` / other extras the host attached are kept.
+ * `instanceof` checks still pass. For custom tools, `extras` is merged
+ * so any existing `providerToolDefinition` / other extras are kept.
  */
 export declare function partitionAndMarkAnthropicToolCache(tools: GraphTools | undefined, isDeferred: (toolName: string) => boolean): GraphTools | undefined;

package/dist/types/tools/subagent/SubagentExecutor.d.ts

@@ -15,6 +15,35 @@ export type SubagentExecuteParams = {
      * without relying on event ordering heuristics.
      */
     parentToolCallId?: string;
+    /**
+     * Snapshot of the parent invocation's `config.configurable` at the
+     * spawn-tool call site. Inherited verbatim into the child workflow's
+     * `configurable` so host-set fields (`requestBody`, `user`,
+     * `userMCPAuthMap`, etc.) propagate — fixing MCP body-placeholder
+     * substitution and per-user lookups for subagent tool calls.
+     *
+     * Inheritance details (verified empirically against LangGraph):
+     *   - host-set keys propagate as-is into the child's tool dispatches;
+     *   - `thread_id` propagates (with `childRunId` as a fallback when
+     *     parent did not supply one) — matches the "subagent is part of
+     *     the same conversation" mental model and aligns with the
+     *     `sessionId: this.parentRunId` convention this executor already
+     *     uses for `SubagentStart` / `SubagentStop` hooks;
+     *   - `parent_run_id` propagates when the host put it on parent's
+     *     configurable;
+     *   - `run_id` is *overwritten by the LangGraph runtime* at child
+     *     invoke time regardless of what we forward — child's tool
+     *     dispatches see the child graph's runtime runId in
+     *     `configurable.run_id`, not the parent's. Hosts that need
+     *     parent-scoped run identity for downstream consumers should
+     *     plumb it via a host-defined key (e.g. `requestBody.messageId`),
+     *     not `run_id`.
+     *
+     * A future revision will likely make this inheritance configurable
+     * per spawn type — background / async subagents may want isolation
+     * rather than sharing parent's host context.
+     */
+    parentConfigurable?: Record<string, unknown>;
 };
 export type SubagentExecuteResult = {
     content: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.78-dev.0",
+  "version": "3.1.79",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/graphs/Graph.ts

@@ -1471,6 +1471,15 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             subagentType,
             threadId,
             parentToolCallId,
+            /**
+             * Forward the parent's `configurable` so host-set fields
+             * (`requestBody`, `user`, etc.) propagate into the child
+             * workflow. The executor scrubs run-identity fields before
+             * forwarding — see `SubagentExecuteParams.parentConfigurable`.
+             */
+            parentConfigurable: config.configurable as
+              | Record<string, unknown>
+              | undefined,
           });
           return result.content;
         }, buildSubagentToolParams(resolvedConfigs));

package/src/llm/anthropic/index.ts

@@ -4,7 +4,6 @@ import { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { BaseChatModelParams } from '@langchain/core/language_models/chat_models';
 import type {
   BaseMessage,
-  UsageMetadata,
   MessageContentComplex,
 } from '@langchain/core/messages';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
@@ -13,18 +12,13 @@ import type { Anthropic } from '@anthropic-ai/sdk';
 import type {
   AnthropicMessageCreateParams,
   AnthropicStreamingMessageCreateParams,
-  AnthropicMessageStartEvent,
-  AnthropicMessageDeltaEvent,
   AnthropicOutputConfig,
   AnthropicBeta,
   ChatAnthropicToolType,
   AnthropicMCPServerURLDefinition,
   AnthropicContextManagementConfigParam,
 } from '@/llm/anthropic/types';
-import {
-  _makeMessageChunkFromAnthropicEvent,
-  getAnthropicUsageMetadata,
-} from './utils/message_outputs';
+import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs';
 import { _convertMessagesToAnthropicPayload } from './utils/message_inputs';
 import { handleToolChoice } from './utils/tools';
 import { TextStream } from '@/llm/text';
@@ -53,13 +47,17 @@ export function _documentsInParams(
       continue;
     }
     for (const block of message.content) {
+      const maybeBlock: unknown = block;
       if (
-        typeof block === 'object' &&
-        block !== null &&
-        block.type === 'document' &&
-        block.citations != null &&
-        typeof block.citations === 'object' &&
-        block.citations.enabled === true
+        typeof maybeBlock === 'object' &&
+        maybeBlock !== null &&
+        'type' in maybeBlock &&
+        maybeBlock.type === 'document' &&
+        'citations' in maybeBlock &&
+        maybeBlock.citations != null &&
+        typeof maybeBlock.citations === 'object' &&
+        'enabled' in maybeBlock.citations &&
+        maybeBlock.citations.enabled === true
       ) {
         return true;
       }
@@ -307,6 +305,30 @@ function cloneChunk(
   return chunk;
 }
 
+function withIncrementalMessageDeltaUsage(
+  chunk: AIMessageChunk,
+  previousOutputTokens: number
+): { chunk: AIMessageChunk; outputTokens: number } {
+  const usage = chunk.usage_metadata;
+  if (usage == null) {
+    return { chunk, outputTokens: previousOutputTokens };
+  }
+
+  const outputTokens = Math.max(0, usage.output_tokens - previousOutputTokens);
+  return {
+    chunk: new AIMessageChunk(
+      Object.assign({}, chunk, {
+        usage_metadata: {
+          ...usage,
+          output_tokens: outputTokens,
+          total_tokens: usage.input_tokens + outputTokens,
+        },
+      })
+    ),
+    outputTokens: usage.output_tokens,
+  };
+}
+
 export type CustomAnthropicInput = AnthropicInput & {
   _lc_stream_delay?: number;
   outputConfig?: AnthropicOutputConfig;
@@ -334,10 +356,7 @@ type CustomAnthropicInvocationParams = {
 
 export class CustomAnthropic extends ChatAnthropicMessages {
   _lc_stream_delay: number;
-  private message_start: AnthropicMessageStartEvent | undefined;
-  private message_delta: AnthropicMessageDeltaEvent | undefined;
   private tools_in_params?: boolean;
-  private emitted_usage?: boolean;
   top_k: number | undefined;
   outputConfig?: AnthropicOutputConfig;
   inferenceGeo?: string;
@@ -436,33 +455,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     };
   }
 
-  /**
-   * Get stream usage as returned by this client's API response.
-   * @returns The stream usage object.
-   */
-  getStreamUsage(): UsageMetadata | undefined {
-    if (this.emitted_usage === true) {
-      return;
-    }
-    const inputUsage = this.message_start?.message.usage;
-    const outputUsage = this.message_delta?.usage;
-    if (!outputUsage) {
-      return;
-    }
-
-    this.emitted_usage = true;
-    return getAnthropicUsageMetadata({
-      input_tokens: inputUsage?.input_tokens,
-      output_tokens: outputUsage.output_tokens,
-      cache_creation_input_tokens: inputUsage?.cache_creation_input_tokens,
-      cache_read_input_tokens: inputUsage?.cache_read_input_tokens,
-    });
-  }
-
   resetTokenEvents(): void {
-    this.message_start = undefined;
-    this.message_delta = undefined;
-    this.emitted_usage = undefined;
     this.tools_in_params = undefined;
   }
 
@@ -484,17 +477,13 @@ export class CustomAnthropic extends ChatAnthropicMessages {
   private createGenerationChunk({
     token,
     chunk,
-    usageMetadata,
     shouldStreamUsage,
   }: {
     token?: string;
     chunk: AIMessageChunk;
     shouldStreamUsage: boolean;
-    usageMetadata?: UsageMetadata;
   }): ChatGenerationChunk {
-    const usage_metadata = shouldStreamUsage
-      ? (usageMetadata ?? chunk.usage_metadata)
-      : undefined;
+    const usage_metadata = shouldStreamUsage ? chunk.usage_metadata : undefined;
     return new ChatGenerationChunk({
       message: new AIMessageChunk({
         // Just yield chunk as it is and tool_use will be concat by BaseChatModel._generateUncached().
@@ -534,6 +523,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     });
 
     const shouldStreamUsage = options.streamUsage ?? this.streamUsage;
+    let messageDeltaOutputTokens = 0;
 
     for await (const data of stream) {
       if (options.signal?.aborted === true) {
@@ -541,17 +531,6 @@ export class CustomAnthropic extends ChatAnthropicMessages {
         throw new Error('AbortError: User aborted the request.');
       }
 
-      if (data.type === 'message_start') {
-        this.message_start = data as AnthropicMessageStartEvent;
-      } else if (data.type === 'message_delta') {
-        this.message_delta = data as AnthropicMessageDeltaEvent;
-      }
-
-      let usageMetadata: UsageMetadata | undefined;
-      if (this.tools_in_params !== true && this.emitted_usage !== true) {
-        usageMetadata = this.getStreamUsage();
-      }
-
       const result = _makeMessageChunkFromAnthropicEvent(
         data as Anthropic.Beta.Messages.BetaRawMessageStreamEvent,
         {
@@ -561,18 +540,25 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       );
       if (!result) continue;
 
-      const { chunk } = result;
+      let { chunk } = result;
+      if (data.type === 'message_delta') {
+        const incremental = withIncrementalMessageDeltaUsage(
+          chunk,
+          messageDeltaOutputTokens
+        );
+        chunk = incremental.chunk;
+        messageDeltaOutputTokens = incremental.outputTokens;
+      }
       const [token = '', tokenType] = extractToken(chunk);
 
       if (
         !tokenType ||
         tokenType === 'input' ||
-        (token === '' && (usageMetadata != null || chunk.id != null))
+        (token === '' && (chunk.usage_metadata != null || chunk.id != null))
       ) {
         const generationChunk = this.createGenerationChunk({
           token,
           chunk,
-          usageMetadata,
           shouldStreamUsage,
         });
         yield generationChunk;
@@ -602,15 +588,20 @@ export class CustomAnthropic extends ChatAnthropicMessages {
             break;
           }
           const newChunk = cloneChunk(currentToken, tokenType, chunk);
+          const chunkForToken =
+            emittedUsage && newChunk.usage_metadata != null
+              ? new AIMessageChunk(
+                Object.assign({}, newChunk, { usage_metadata: undefined })
+              )
+              : newChunk;
 
           const generationChunk = this.createGenerationChunk({
             token: currentToken,
-            chunk: newChunk,
-            usageMetadata: emittedUsage ? undefined : usageMetadata,
+            chunk: chunkForToken,
             shouldStreamUsage,
           });
 
-          if (usageMetadata && !emittedUsage) {
+          if (newChunk.usage_metadata != null && !emittedUsage) {
             emittedUsage = true;
           }
           yield generationChunk;