@librechat/agents 3.2.33 → 3.2.34

package/dist/esm/tools/streamedToolCallSeals.mjs

@@ -1,7 +1,30 @@
+//#region src/tools/streamedToolCallSeals.ts
+const STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY = "lc_streamed_tool_call_adapter";
 const STREAMED_TOOL_CALL_SEAL_METADATA_KEY = "lc_streamed_tool_call_seal";
 const OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER = "openai_responses";
+const BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER = "bedrock_converse";
+const GOOGLE_STREAMED_TOOL_CALL_ADAPTER = "google_genai";
+const OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER = "openai_chat_sequential";
+const STREAMED_TOOL_CALL_ADAPTERS = new Set([
+	OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
+	BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+	GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+	OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+]);
+/**
+* Adapters whose wire protocol streams tool calls strictly sequentially by
+* index, so a prior call is sealed the moment a later index begins. Used by
+* the stream handler to extend next-index sealing beyond the provider-keyed
+* Anthropic allowlist.
+*/
+const SEQUENTIAL_SEAL_STREAMED_TOOL_CALL_ADAPTERS = new Set([OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER]);
+function streamedToolCallAdapterAllowsSequentialSeal(metadata) {
+	const adapter = getStreamedToolCallAdapter(metadata);
+	return adapter != null && SEQUENTIAL_SEAL_STREAMED_TOOL_CALL_ADAPTERS.has(adapter);
+}
 function getStreamedToolCallAdapter(metadata) {
-	if (metadata?.["lc_streamed_tool_call_adapter"] === "openai_responses") return OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER;
+	const adapter = metadata?.[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY];
+	if (typeof adapter === "string" && STREAMED_TOOL_CALL_ADAPTERS.has(adapter)) return adapter;
 }
 function getStreamedToolCallSeal(metadata) {
 	const seal = metadata?.[STREAMED_TOOL_CALL_SEAL_METADATA_KEY];
@@ -19,6 +42,6 @@ function getStreamedToolCallSeal(metadata) {
 	};
 }
 //#endregion
-export { getStreamedToolCallAdapter, getStreamedToolCallSeal };
+export { BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER, GOOGLE_STREAMED_TOOL_CALL_ADAPTER, OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER, STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY, STREAMED_TOOL_CALL_SEAL_METADATA_KEY, getStreamedToolCallAdapter, getStreamedToolCallSeal, streamedToolCallAdapterAllowsSequentialSeal };
 
 //# sourceMappingURL=streamedToolCallSeals.mjs.map

package/dist/esm/tools/streamedToolCallSeals.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"streamedToolCallSeals.mjs","names":[],"sources":["../../../src/tools/streamedToolCallSeals.ts"],"sourcesContent":["export const STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY =\n  'lc_streamed_tool_call_adapter';\nexport const STREAMED_TOOL_CALL_SEAL_METADATA_KEY =\n  'lc_streamed_tool_call_seal';\nexport const OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER = 'openai_responses';\n\nexport type StreamedToolCallAdapter =\n  typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER;\n\nexport type StreamedToolCallSeal =\n  | {\n      kind: 'single';\n      id?: string;\n      index?: number;\n    }\n  | {\n      kind: 'all';\n    };\n\nexport function getStreamedToolCallAdapter(\n  metadata: Record<string, unknown> | undefined\n): StreamedToolCallAdapter | undefined {\n  if (\n    metadata?.[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY] ===\n    OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER\n  ) {\n    return OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER;\n  }\n  return undefined;\n}\n\nexport function getStreamedToolCallSeal(\n  metadata: Record<string, unknown> | undefined\n): StreamedToolCallSeal | undefined {\n  const seal = metadata?.[STREAMED_TOOL_CALL_SEAL_METADATA_KEY];\n  if (seal == null || typeof seal !== 'object') {\n    return undefined;\n  }\n  if (!('kind' in seal)) {\n    return undefined;\n  }\n  if (seal.kind === 'all') {\n    return { kind: 'all' };\n  }\n  if (seal.kind !== 'single') {\n    return undefined;\n  }\n  const id = 'id' in seal && typeof seal.id === 'string' ? seal.id : undefined;\n  const index =\n    'index' in seal && typeof seal.index === 'number'\n      ? seal.index\n      : undefined;\n  if (id == null && index == null) {\n    return undefined;\n  }\n  return { kind: 'single', id, index };\n}\n"],"mappings":"AAEA,MAAa,uCACX;AACF,MAAa,8CAA8C;AAe3D,SAAgB,2BACd,UACqC;CACrC,IACE,WAAA,qCAAA,oBAGA,OAAO;AAGX;AAEA,SAAgB,wBACd,UACkC;CAClC,MAAM,OAAO,WAAW;CACxB,IAAI,QAAQ,QAAQ,OAAO,SAAS,UAClC;CAEF,IAAI,EAAE,UAAU,OACd;CAEF,IAAI,KAAK,SAAS,OAChB,OAAO,EAAE,MAAM,MAAM;CAEvB,IAAI,KAAK,SAAS,UAChB;CAEF,MAAM,KAAK,QAAQ,QAAQ,OAAO,KAAK,OAAO,WAAW,KAAK,KAAK,KAAA;CACnE,MAAM,QACJ,WAAW,QAAQ,OAAO,KAAK,UAAU,WACrC,KAAK,QACL,KAAA;CACN,IAAI,MAAM,QAAQ,SAAS,MACzB;CAEF,OAAO;EAAE,MAAM;EAAU;EAAI;CAAM;AACrC"}
+{"version":3,"file":"streamedToolCallSeals.mjs","names":[],"sources":["../../../src/tools/streamedToolCallSeals.ts"],"sourcesContent":["export const STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY =\n  'lc_streamed_tool_call_adapter';\nexport const STREAMED_TOOL_CALL_SEAL_METADATA_KEY =\n  'lc_streamed_tool_call_seal';\nexport const OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER = 'openai_responses';\nexport const BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER = 'bedrock_converse';\nexport const GOOGLE_STREAMED_TOOL_CALL_ADAPTER = 'google_genai';\nexport const OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER =\n  'openai_chat_sequential';\n\nexport type StreamedToolCallAdapter =\n  | typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER\n  | typeof BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER\n  | typeof GOOGLE_STREAMED_TOOL_CALL_ADAPTER\n  | typeof OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER;\n\nconst STREAMED_TOOL_CALL_ADAPTERS: ReadonlySet<string> = new Set([\n  OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,\n  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,\n  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,\n  OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,\n]);\n\n/**\n * Adapters whose wire protocol streams tool calls strictly sequentially by\n * index, so a prior call is sealed the moment a later index begins. Used by\n * the stream handler to extend next-index sealing beyond the provider-keyed\n * Anthropic allowlist.\n */\nconst SEQUENTIAL_SEAL_STREAMED_TOOL_CALL_ADAPTERS: ReadonlySet<string> =\n  new Set([OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER]);\n\nexport function streamedToolCallAdapterAllowsSequentialSeal(\n  metadata: Record<string, unknown> | undefined\n): boolean {\n  const adapter = getStreamedToolCallAdapter(metadata);\n  return (\n    adapter != null && SEQUENTIAL_SEAL_STREAMED_TOOL_CALL_ADAPTERS.has(adapter)\n  );\n}\n\nexport type StreamedToolCallSeal =\n  | {\n      kind: 'single';\n      id?: string;\n      index?: number;\n    }\n  | {\n      kind: 'all';\n    };\n\nexport function getStreamedToolCallAdapter(\n  metadata: Record<string, unknown> | undefined\n): StreamedToolCallAdapter | undefined {\n  const adapter = metadata?.[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY];\n  if (typeof adapter === 'string' && STREAMED_TOOL_CALL_ADAPTERS.has(adapter)) {\n    return adapter as StreamedToolCallAdapter;\n  }\n  return undefined;\n}\n\nexport function getStreamedToolCallSeal(\n  metadata: Record<string, unknown> | undefined\n): StreamedToolCallSeal | undefined {\n  const seal = metadata?.[STREAMED_TOOL_CALL_SEAL_METADATA_KEY];\n  if (seal == null || typeof seal !== 'object') {\n    return undefined;\n  }\n  if (!('kind' in seal)) {\n    return undefined;\n  }\n  if (seal.kind === 'all') {\n    return { kind: 'all' };\n  }\n  if (seal.kind !== 'single') {\n    return undefined;\n  }\n  const id = 'id' in seal && typeof seal.id === 'string' ? seal.id : undefined;\n  const index =\n    'index' in seal && typeof seal.index === 'number' ? seal.index : undefined;\n  if (id == null && index == null) {\n    return undefined;\n  }\n  return { kind: 'single', id, index };\n}\n"],"mappings":";AAAA,MAAa,0CACX;AACF,MAAa,uCACX;AACF,MAAa,8CAA8C;AAC3D,MAAa,8CAA8C;AAC3D,MAAa,oCAAoC;AACjD,MAAa,oDACX;AAQF,MAAM,8BAAmD,IAAI,IAAI;CAC/D;CACA;CACA;CACA;AACF,CAAC;;;;;;;AAQD,MAAM,8CACJ,IAAI,IAAI,CAAC,iDAAiD,CAAC;AAE7D,SAAgB,4CACd,UACS;CACT,MAAM,UAAU,2BAA2B,QAAQ;CACnD,OACE,WAAW,QAAQ,4CAA4C,IAAI,OAAO;AAE9E;AAYA,SAAgB,2BACd,UACqC;CACrC,MAAM,UAAU,WAAW;CAC3B,IAAI,OAAO,YAAY,YAAY,4BAA4B,IAAI,OAAO,GACxE,OAAO;AAGX;AAEA,SAAgB,wBACd,UACkC;CAClC,MAAM,OAAO,WAAW;CACxB,IAAI,QAAQ,QAAQ,OAAO,SAAS,UAClC;CAEF,IAAI,EAAE,UAAU,OACd;CAEF,IAAI,KAAK,SAAS,OAChB,OAAO,EAAE,MAAM,MAAM;CAEvB,IAAI,KAAK,SAAS,UAChB;CAEF,MAAM,KAAK,QAAQ,QAAQ,OAAO,KAAK,OAAO,WAAW,KAAK,KAAK,KAAA;CACnE,MAAM,QACJ,WAAW,QAAQ,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ,KAAA;CACnE,IAAI,MAAM,QAAQ,SAAS,MACzB;CAEF,OAAO;EAAE,MAAM;EAAU;EAAI;CAAM;AACrC"}

package/dist/types/llm/bedrock/utils/index.d.ts

@@ -2,4 +2,4 @@
  * Bedrock Converse utility exports.
  */
 export { convertToConverseMessages, extractImageInfo, langchainReasoningBlockToBedrockReasoningBlock, concatenateLangchainReasoningBlocks, } from './message_inputs';
-export { convertConverseMessageToLangChainMessage, handleConverseStreamContentBlockStart, handleConverseStreamContentBlockDelta, handleConverseStreamMetadata, bedrockReasoningBlockToLangchainReasoningBlock, bedrockReasoningDeltaToLangchainPartialReasoningBlock, } from './message_outputs';
+export { convertConverseMessageToLangChainMessage, createConverseToolUseStopChunk, handleConverseStreamContentBlockStart, handleConverseStreamContentBlockDelta, handleConverseStreamMetadata, bedrockReasoningBlockToLangchainReasoningBlock, bedrockReasoningDeltaToLangchainPartialReasoningBlock, } from './message_outputs';

package/dist/types/llm/bedrock/utils/message_outputs.d.ts

@@ -25,6 +25,15 @@ export declare function handleConverseStreamContentBlockDelta(contentBlockDelta:
  * Handle a content block start event from Bedrock Converse stream.
  */
 export declare function handleConverseStreamContentBlockStart(contentBlockStart: ContentBlockStartEvent): ChatGenerationChunk | null;
+/**
+ * Build the chunk emitted when a Converse `contentBlockStop` event closes a
+ * toolUse block. The Converse protocol guarantees a block's input is complete
+ * at `contentBlockStop`, so this chunk carries an explicit streamed tool-call
+ * seal for that block index. The empty `args` delta merges as a no-op into the
+ * accumulated tool call; id/name are omitted so the chunk matches the existing
+ * entry purely by index.
+ */
+export declare function createConverseToolUseStopChunk(contentBlockIndex: number): ChatGenerationChunk;
 /**
  * Handle a metadata event from Bedrock Converse stream.
  */

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

@@ -1,4 +1,5 @@
 import { ChatGoogle } from '@langchain/google-gauth';
+import { AIMessageChunk } from '@langchain/core/messages';
 import type { GeminiContent, GoogleAIModelRequestParams, GoogleAbstractedClient } from '@langchain/google-common';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
@@ -29,6 +30,15 @@ import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
  * overriding `_convertToUsageMetadata`.
  */
 export declare function repairStreamUsageMetadata(current: UsageMetadata | undefined, generationInfoUsage: UsageMetadata | undefined): UsageMetadata | undefined;
+/**
+ * The Gemini API delivers function calls as complete objects — never as
+ * partial arg deltas. `@langchain/google-common` pre-parses each streamed
+ * functionCall part into `tool_calls` (invalid args land in
+ * `invalid_tool_calls` instead), so a chunk whose tool-call chunks all parsed
+ * cleanly is sealed on arrival for eager tool execution. Anything that fails
+ * the parse check is left unstamped and falls back to the lazy path.
+ */
+export declare function sealCompleteStreamedToolCalls(message: AIMessageChunk): void;
 /**
  * Fixes thought signatures on functionCall parts in the formatted Gemini request.
  *

package/dist/types/tools/ToolNode.d.ts

@@ -350,6 +350,14 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      */
     private dispatchPostToolBatchAndInjectContext;
     private dispatchStepCompleted;
+    /**
+     * Emits the completed run step for a single host-reported result before
+     * the batch resolves. Mirrors the batch loop's output formatting exactly;
+     * callers gate on the no-hooks/no-HITL configuration, so the raw result
+     * content here is also the final content. Returns whether the event was
+     * actually dispatched so the caller can fall back to batch-time emission.
+     */
+    private dispatchEarlyToolCompletion;
     /**
      * Converts InjectedMessage instances to LangChain HumanMessage objects.
      * Both 'user' and 'system' roles become HumanMessage to avoid provider

package/dist/types/tools/streamedToolCallSeals.d.ts

@@ -1,7 +1,11 @@
 export declare const STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY = "lc_streamed_tool_call_adapter";
 export declare const STREAMED_TOOL_CALL_SEAL_METADATA_KEY = "lc_streamed_tool_call_seal";
 export declare const OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER = "openai_responses";
-export type StreamedToolCallAdapter = typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER;
+export declare const BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER = "bedrock_converse";
+export declare const GOOGLE_STREAMED_TOOL_CALL_ADAPTER = "google_genai";
+export declare const OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER = "openai_chat_sequential";
+export type StreamedToolCallAdapter = typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER | typeof BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER | typeof GOOGLE_STREAMED_TOOL_CALL_ADAPTER | typeof OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER;
+export declare function streamedToolCallAdapterAllowsSequentialSeal(metadata: Record<string, unknown> | undefined): boolean;
 export type StreamedToolCallSeal = {
     kind: 'single';
     id?: string;

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

@@ -382,6 +382,16 @@ export type ToolExecuteBatchRequest = {
     resolve: (results: ToolExecuteResult[]) => void;
     /** Promise rejector - handler calls this on fatal error */
     reject: (error: Error) => void;
+    /**
+     * Optional per-call result channel. When present, the handler MAY invoke
+     * this as each tool call settles (before the final `resolve`) so the
+     * graph can emit that call's completion event without waiting for the
+     * slowest call in the batch. Purely an emission fast-path: the handler
+     * must still pass every result to `resolve`, which remains the
+     * authoritative batch outcome. Only provided when no post-tool hooks or
+     * human-in-the-loop flows could change a result after execution.
+     */
+    onResult?: (result: ToolExecuteResult) => void;
 };
 /**
  * A message injected into graph state by any tool execution handler.

package/package.json

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