@langchain/core 1.2.0-dev-1775763803878 → 1.2.0

package/dist/language_models/event.d.cts

@@ -1,4 +1,4 @@
-import { ContentBlock, PartialContentBlock } from "../messages/content/index.cjs";
+import { ContentBlock } from "../messages/content/index.cjs";
 import { UsageMetadata } from "../messages/metadata.cjs";
 
 //#region src/language_models/event.d.ts
@@ -6,14 +6,14 @@ import { UsageMetadata } from "../messages/metadata.cjs";
  * Emitted once at the start of a model response.
  */
 interface MessageStartEvent {
-  type: "message-start";
+  event: "message-start";
   /** Optional message ID assigned by the provider. */
   id?: string;
   /**
    * Initial usage snapshot, if the provider reports input token counts
    * before content begins streaming (e.g., Anthropic's `message_start`).
    */
-  usage?: UsageMetadata;
+  usage?: Partial<UsageMetadata>;
 }
 /**
  * Finish reason for a model response.
@@ -28,11 +28,11 @@ type FinishReason = "stop" | "length" | "tool_use" | "content_filter";
  * Emitted once when the model response is complete.
  */
 interface MessageFinishEvent {
-  type: "message-finish";
+  event: "message-finish";
   /** Why the model stopped generating. */
-  reason: FinishReason;
+  reason?: FinishReason;
   /** Final usage snapshot. */
-  usage?: UsageMetadata;
+  usage?: Partial<UsageMetadata>;
   /** Provider-specific response metadata (model name, response ID, headers, etc.). */
   responseMetadata?: Record<string, unknown>;
 }
@@ -41,82 +41,105 @@ interface MessageFinishEvent {
  *
  * @example
  * ```ts
- * // Text block starting
- * { type: "content-block-start", index: 0,
+ * { event: "content-block-start", index: 0,
  *   content: { type: "text", text: "" } }
- *
- * // Tool call starting
- * { type: "content-block-start", index: 1,
- *   content: { type: "tool_call", id: "call_1", name: "search", args: "" } }
- *
- * // Reasoning starting
- * { type: "content-block-start", index: 2,
- *   content: { type: "reasoning", reasoning: "" } }
  * ```
  */
 interface ContentBlockStartEvent {
-  type: "content-block-start";
+  event: "content-block-start";
   /** Positional index of this block within the message. */
   index: number;
   /** Initial state of the content block. */
   content: ContentBlock;
 }
+/**
+ * Incremental text content. Append `text` to the active block's `text` field.
+ */
+interface TextDelta {
+  type: "text-delta";
+  /** The new text to append. */
+  text: string;
+}
+/**
+ * Incremental reasoning content. Append `reasoning` to the active block's
+ * `reasoning` field.
+ */
+interface ReasoningDelta {
+  type: "reasoning-delta";
+  /** The new reasoning text to append. */
+  reasoning: string;
+}
+/**
+ * Incremental encoded data. Append `data` to the active multimodal block's
+ * data field.
+ */
+interface DataDelta {
+  type: "data-delta";
+  /** Encoded data chunk to append. */
+  data: string;
+  /** Encoding for the data chunk. Defaults to `"base64"` when omitted. */
+  encoding?: "base64";
+}
+/**
+ * Generic content block field update. Shallow-merge `fields` onto the active
+ * content block.
+ */
+interface BlockDelta {
+  type: "block-delta";
+  /** Fields to shallow-merge onto the active content block. */
+  fields: {
+    type: string;
+  } & Record<string, unknown>;
+}
+/**
+ * Union of all content block delta types.
+ */
+type ContentBlockDelta = TextDelta | ReasoningDelta | DataDelta | BlockDelta;
 /**
  * Emitted for each incremental update within a content block.
  *
- * Carries the **accumulated state** of the content block so far.
- * The content is deeply partial — not all fields may be populated during
- * streaming (e.g., a tool call may have `name` but `args` is still being
- * streamed as a partial JSON string).
- *
- * Consumers who need incremental deltas (e.g., new tokens only) should
- * track the previous state and diff against the new accumulated state.
- *
- * Aggregation into `AIMessage` is trivial:
- * `message.content[event.index] = event.content`
+ * The `delta` field carries the incremental content block update.
+ * Accumulation rules:
+ * - `text-delta` → append `text` to the active block's text field
+ * - `reasoning-delta` → append `reasoning` to the active block's reasoning field
+ * - `data-delta` → append `data` to the active block's data field
+ * - `block-delta` → shallow-merge `fields` onto the active block
  *
  * @example
  * ```ts
- * // First text delta — accumulated so far
- * { type: "content-block-delta", index: 0,
- *   content: { type: "text", text: "Hello" } }
- *
- * // Second text delta — accumulated so far
- * { type: "content-block-delta", index: 0,
- *   content: { type: "text", text: "Hello world" } }
- *
- * // Tool call args — accumulated so far
- * { type: "content-block-delta", index: 1,
- *   content: { type: "tool_call", id: "call_1", name: "search", args: '{"q":"wea' } }
+ * // Text token
+ * { event: "content-block-delta", index: 0,
+ *   delta: { type: "text-delta", text: " world" } }
+ *
+ * // Tool call args snapshot
+ * { event: "content-block-delta", index: 1,
+ *   delta: { type: "block-delta",
+ *     fields: { type: "tool_call_chunk", args: '{"q":"wea' } } } }
+ *
+ * // Provider-specific field (e.g., signature)
+ * { event: "content-block-delta", index: 0,
+ *   delta: { type: "block-delta",
+ *     fields: { type: "reasoning", signature: "sig_abc" } } }
  * ```
  */
 interface ContentBlockDeltaEvent {
-  type: "content-block-delta";
+  event: "content-block-delta";
   /** Positional index of the block being updated. */
   index: number;
-  /** Accumulated state of the content block after this update. Deeply partial. */
-  content: PartialContentBlock;
+  /** Incremental content block delta. */
+  delta: ContentBlockDelta;
 }
 /**
  * Emitted when a content block is complete.
  *
- * The `content` carries the **finalized** block. For tool calls, this means
- * args have been parsed from a JSON string into an object.
- *
  * @example
  * ```ts
- * // Finalized text block
- * { type: "content-block-finish", index: 0,
- *   content: { type: "text", text: "The weather is sunny." } }
- *
- * // Finalized tool call (args parsed)
- * { type: "content-block-finish", index: 1,
- *   content: { type: "tool_call", id: "call_1", name: "search",
- *              args: { q: "weather" } } }
+ * { event: "content-block-finish", index: 0,
+ *   content: { type: "text", text: "Hello world" } }
  * ```
  */
 interface ContentBlockFinishEvent {
-  type: "content-block-finish";
+  event: "content-block-finish";
   /** Positional index of the completed block. */
   index: number;
   /** Finalized content block. */
@@ -124,47 +147,18 @@ interface ContentBlockFinishEvent {
 }
 /**
  * Emitted whenever the provider reports updated usage information.
- *
- * May appear at any point during streaming. Each event carries a
- * **running snapshot** of usage (not an additive delta), so consumers
- * can simply take the latest value.
- *
- * @example
- * ```ts
- * // After message_start (Anthropic: input tokens known)
- * { type: "usage", usage: { input_tokens: 1234, output_tokens: 0, total_tokens: 1234 } }
- *
- * // After streaming completes
- * { type: "usage", usage: { input_tokens: 1234, output_tokens: 567, total_tokens: 1801 } }
- * ```
+ * Each event carries a **running snapshot** (not an additive delta).
  */
 interface UsageUpdateEvent {
-  type: "usage";
+  event: "usage";
   /** Current usage snapshot. */
-  usage: UsageMetadata;
+  usage: Partial<UsageMetadata>;
 }
 /**
  * Passthrough for native provider events that don't map to standard types.
- *
- * Provider adapters map recognized events to standard {@link ChatModelStreamEvent}
- * types and forward everything else as `ProviderEvent`. This ensures no information
- * is silently dropped.
- *
- * @example
- * ```ts
- * // OpenAI server-side web search in progress
- * { type: "provider", provider: "openai",
- *   name: "response.web_search_call.searching",
- *   payload: { item_id: "ws_123", output_index: 0 } }
- *
- * // Anthropic context management signal
- * { type: "provider", provider: "anthropic",
- *   name: "context_management",
- *   payload: { ... } }
- * ```
  */
 interface ProviderEvent {
-  type: "provider";
+  event: "provider";
   /** Provider identifier (e.g., `"openai"`, `"anthropic"`, `"google"`). */
   provider: string;
   /** Raw event type name from the provider SDK. */
@@ -176,7 +170,7 @@ interface ProviderEvent {
  * Emitted on unrecoverable stream errors.
  */
 interface StreamErrorEvent {
-  type: "error";
+  event: "error";
   /** Human-readable error message. */
   message: string;
   /** Optional error code for programmatic handling. */
@@ -184,10 +178,8 @@ interface StreamErrorEvent {
 }
 /**
  * Union of all chat model stream event types.
- *
- * This is the type yielded by `ChatModelStream[Symbol.asyncIterator]()`.
  */
 type ChatModelStreamEvent = MessageStartEvent | MessageFinishEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockFinishEvent | UsageUpdateEvent | ProviderEvent | StreamErrorEvent;
 //#endregion
-export { ChatModelStreamEvent, ContentBlockDeltaEvent, ContentBlockFinishEvent, ContentBlockStartEvent, FinishReason, MessageFinishEvent, MessageStartEvent, ProviderEvent, StreamErrorEvent, UsageUpdateEvent };
+export { BlockDelta, ChatModelStreamEvent, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockFinishEvent, ContentBlockStartEvent, DataDelta, FinishReason, MessageFinishEvent, MessageStartEvent, ProviderEvent, ReasoningDelta, StreamErrorEvent, TextDelta, UsageUpdateEvent };
 //# sourceMappingURL=event.d.cts.map

package/dist/language_models/event.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"event.d.cts","names":[],"sources":["../../src/language_models/event.ts"],"mappings":";;;;;;;UAuDiB,iBAAA;EACf,IAAA;EA6FA;EA3FA,EAAA;EA2F4B;;AAqB9B;;EA3GE,KAAA,GAAQ,aAAA;AAAA;;;;;;;AAmIV;;KAxHY,YAAA;;;;UAKK,kBAAA;EACf,IAAA;EAqHoB;EAnHpB,MAAA,EAAQ,YAAA;EA0IoB;EAxI5B,KAAA,GAAQ,aAAA;EAwIoB;EAtI5B,gBAAA,GAAmB,MAAA;AAAA;;;;;AAmJrB;;;;;;;;;AAaA;;;;;UA3IiB,sBAAA;EACf,IAAA;EA+IE;EA7IF,KAAA;EA+IE;EA7IF,OAAA,EAAS,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCM,sBAAA;EACf,IAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,mBAAA;AAAA;;;;;;;;;;;;;;;;;;;UAqBM,uBAAA;EACf,IAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,YAAA;AAAA;;;;;;;;;;;;;;;;;UAmBM,gBAAA;EACf,IAAA;;EAEA,KAAA,EAAO,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;UAuBQ,aAAA;EACf,IAAA;;EAEA,QAAA;;EAEA,IAAA;;EAEA,OAAA;AAAA;;;;UAMe,gBAAA;EACf,IAAA;;EAEA,OAAA;;EAEA,IAAA;AAAA;;;;;;KAQU,oBAAA,GACR,iBAAA,GACA,kBAAA,GACA,sBAAA,GACA,sBAAA,GACA,uBAAA,GACA,gBAAA,GACA,aAAA,GACA,gBAAA"}
+{"version":3,"file":"event.d.cts","names":[],"sources":["../../src/language_models/event.ts"],"mappings":";;;;AA4FA;;;AAAA,UA9CiB,iBAAA;EACf,KAAA;EAgDA;EA9CA,EAAA;EAgDS;;;AAQX;EAnDE,KAAA,GAAQ,OAAA,CAAQ,aAAA;AAAA;;;AA6DlB;;;;;AAUA;KA5DY,YAAA;;;;UAKK,kBAAA;EACf,KAAA;EA2DQ;EAzDR,MAAA,GAAS,YAAA;EAgEM;EA9Df,KAAA,GAAQ,OAAA,CAAQ,aAAA;;EAEhB,gBAAA,GAAmB,MAAA;AAAA;;;;;;AAqErB;;;;UAtDiB,sBAAA;EACf,KAAA;EAyDE;EAvDF,KAAA;EAuDY;EArDZ,OAAA,EAAS,YAAA;AAAA;;;;UAQM,SAAA;EACf,IAAA;EAyEqC;EAvErC,IAAA;AAAA;;;;;UAOe,cAAA;EACf,IAAA;EAgFe;EA9Ef,SAAA;AAAA;;;;;UAOe,SAAA;EACf,IAAA;EA2EqB;EAzErB,IAAA;EAkF+B;EAhF/B,QAAA;AAAA;;;;;UAOe,UAAA;EACf,IAAA;EAmFe;EAjFf,MAAA;IAAU,IAAA;EAAA,IAAiB,MAAA;AAAA;;;;KAMjB,iBAAA,GACR,SAAA,GACA,cAAA,GACA,SAAA,GACA,UAAA;;AAsFJ;;;;;;;;;AAaA;;;;;;;;;;;;;;;;;UAtEiB,sBAAA;EACf,KAAA;EA4EE;EA1EF,KAAA;EA2EkB;EAzElB,KAAA,EAAO,iBAAA;AAAA;;;;;;;;;;UAYQ,uBAAA;EACf,KAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,YAAA;AAAA;;;;;UASM,gBAAA;EACf,KAAA;;EAEA,KAAA,EAAO,OAAA,CAAQ,aAAA;AAAA;;;;UAQA,aAAA;EACf,KAAA;;EAEA,QAAA;;EAEA,IAAA;;EAEA,OAAA;AAAA;;;;UAQe,gBAAA;EACf,KAAA;;EAEA,OAAA;;EAEA,IAAA;AAAA;;;;KAQU,oBAAA,GACR,iBAAA,GACA,kBAAA,GACA,sBAAA,GACA,sBAAA,GACA,uBAAA,GACA,gBAAA,GACA,aAAA,GACA,gBAAA"}

package/dist/language_models/event.d.ts

@@ -1,4 +1,4 @@
-import { ContentBlock, PartialContentBlock } from "../messages/content/index.js";
+import { ContentBlock } from "../messages/content/index.js";
 import { UsageMetadata } from "../messages/metadata.js";
 
 //#region src/language_models/event.d.ts
@@ -6,14 +6,14 @@ import { UsageMetadata } from "../messages/metadata.js";
  * Emitted once at the start of a model response.
  */
 interface MessageStartEvent {
-  type: "message-start";
+  event: "message-start";
   /** Optional message ID assigned by the provider. */
   id?: string;
   /**
    * Initial usage snapshot, if the provider reports input token counts
    * before content begins streaming (e.g., Anthropic's `message_start`).
    */
-  usage?: UsageMetadata;
+  usage?: Partial<UsageMetadata>;
 }
 /**
  * Finish reason for a model response.
@@ -28,11 +28,11 @@ type FinishReason = "stop" | "length" | "tool_use" | "content_filter";
  * Emitted once when the model response is complete.
  */
 interface MessageFinishEvent {
-  type: "message-finish";
+  event: "message-finish";
   /** Why the model stopped generating. */
-  reason: FinishReason;
+  reason?: FinishReason;
   /** Final usage snapshot. */
-  usage?: UsageMetadata;
+  usage?: Partial<UsageMetadata>;
   /** Provider-specific response metadata (model name, response ID, headers, etc.). */
   responseMetadata?: Record<string, unknown>;
 }
@@ -41,82 +41,105 @@ interface MessageFinishEvent {
  *
  * @example
  * ```ts
- * // Text block starting
- * { type: "content-block-start", index: 0,
+ * { event: "content-block-start", index: 0,
  *   content: { type: "text", text: "" } }
- *
- * // Tool call starting
- * { type: "content-block-start", index: 1,
- *   content: { type: "tool_call", id: "call_1", name: "search", args: "" } }
- *
- * // Reasoning starting
- * { type: "content-block-start", index: 2,
- *   content: { type: "reasoning", reasoning: "" } }
  * ```
  */
 interface ContentBlockStartEvent {
-  type: "content-block-start";
+  event: "content-block-start";
   /** Positional index of this block within the message. */
   index: number;
   /** Initial state of the content block. */
   content: ContentBlock;
 }
+/**
+ * Incremental text content. Append `text` to the active block's `text` field.
+ */
+interface TextDelta {
+  type: "text-delta";
+  /** The new text to append. */
+  text: string;
+}
+/**
+ * Incremental reasoning content. Append `reasoning` to the active block's
+ * `reasoning` field.
+ */
+interface ReasoningDelta {
+  type: "reasoning-delta";
+  /** The new reasoning text to append. */
+  reasoning: string;
+}
+/**
+ * Incremental encoded data. Append `data` to the active multimodal block's
+ * data field.
+ */
+interface DataDelta {
+  type: "data-delta";
+  /** Encoded data chunk to append. */
+  data: string;
+  /** Encoding for the data chunk. Defaults to `"base64"` when omitted. */
+  encoding?: "base64";
+}
+/**
+ * Generic content block field update. Shallow-merge `fields` onto the active
+ * content block.
+ */
+interface BlockDelta {
+  type: "block-delta";
+  /** Fields to shallow-merge onto the active content block. */
+  fields: {
+    type: string;
+  } & Record<string, unknown>;
+}
+/**
+ * Union of all content block delta types.
+ */
+type ContentBlockDelta = TextDelta | ReasoningDelta | DataDelta | BlockDelta;
 /**
  * Emitted for each incremental update within a content block.
  *
- * Carries the **accumulated state** of the content block so far.
- * The content is deeply partial — not all fields may be populated during
- * streaming (e.g., a tool call may have `name` but `args` is still being
- * streamed as a partial JSON string).
- *
- * Consumers who need incremental deltas (e.g., new tokens only) should
- * track the previous state and diff against the new accumulated state.
- *
- * Aggregation into `AIMessage` is trivial:
- * `message.content[event.index] = event.content`
+ * The `delta` field carries the incremental content block update.
+ * Accumulation rules:
+ * - `text-delta` → append `text` to the active block's text field
+ * - `reasoning-delta` → append `reasoning` to the active block's reasoning field
+ * - `data-delta` → append `data` to the active block's data field
+ * - `block-delta` → shallow-merge `fields` onto the active block
  *
  * @example
  * ```ts
- * // First text delta — accumulated so far
- * { type: "content-block-delta", index: 0,
- *   content: { type: "text", text: "Hello" } }
- *
- * // Second text delta — accumulated so far
- * { type: "content-block-delta", index: 0,
- *   content: { type: "text", text: "Hello world" } }
- *
- * // Tool call args — accumulated so far
- * { type: "content-block-delta", index: 1,
- *   content: { type: "tool_call", id: "call_1", name: "search", args: '{"q":"wea' } }
+ * // Text token
+ * { event: "content-block-delta", index: 0,
+ *   delta: { type: "text-delta", text: " world" } }
+ *
+ * // Tool call args snapshot
+ * { event: "content-block-delta", index: 1,
+ *   delta: { type: "block-delta",
+ *     fields: { type: "tool_call_chunk", args: '{"q":"wea' } } } }
+ *
+ * // Provider-specific field (e.g., signature)
+ * { event: "content-block-delta", index: 0,
+ *   delta: { type: "block-delta",
+ *     fields: { type: "reasoning", signature: "sig_abc" } } }
  * ```
  */
 interface ContentBlockDeltaEvent {
-  type: "content-block-delta";
+  event: "content-block-delta";
   /** Positional index of the block being updated. */
   index: number;
-  /** Accumulated state of the content block after this update. Deeply partial. */
-  content: PartialContentBlock;
+  /** Incremental content block delta. */
+  delta: ContentBlockDelta;
 }
 /**
  * Emitted when a content block is complete.
  *
- * The `content` carries the **finalized** block. For tool calls, this means
- * args have been parsed from a JSON string into an object.
- *
  * @example
  * ```ts
- * // Finalized text block
- * { type: "content-block-finish", index: 0,
- *   content: { type: "text", text: "The weather is sunny." } }
- *
- * // Finalized tool call (args parsed)
- * { type: "content-block-finish", index: 1,
- *   content: { type: "tool_call", id: "call_1", name: "search",
- *              args: { q: "weather" } } }
+ * { event: "content-block-finish", index: 0,
+ *   content: { type: "text", text: "Hello world" } }
  * ```
  */
 interface ContentBlockFinishEvent {
-  type: "content-block-finish";
+  event: "content-block-finish";
   /** Positional index of the completed block. */
   index: number;
   /** Finalized content block. */
@@ -124,47 +147,18 @@ interface ContentBlockFinishEvent {
 }
 /**
  * Emitted whenever the provider reports updated usage information.
- *
- * May appear at any point during streaming. Each event carries a
- * **running snapshot** of usage (not an additive delta), so consumers
- * can simply take the latest value.
- *
- * @example
- * ```ts
- * // After message_start (Anthropic: input tokens known)
- * { type: "usage", usage: { input_tokens: 1234, output_tokens: 0, total_tokens: 1234 } }
- *
- * // After streaming completes
- * { type: "usage", usage: { input_tokens: 1234, output_tokens: 567, total_tokens: 1801 } }
- * ```
+ * Each event carries a **running snapshot** (not an additive delta).
  */
 interface UsageUpdateEvent {
-  type: "usage";
+  event: "usage";
   /** Current usage snapshot. */
-  usage: UsageMetadata;
+  usage: Partial<UsageMetadata>;
 }
 /**
  * Passthrough for native provider events that don't map to standard types.
- *
- * Provider adapters map recognized events to standard {@link ChatModelStreamEvent}
- * types and forward everything else as `ProviderEvent`. This ensures no information
- * is silently dropped.
- *
- * @example
- * ```ts
- * // OpenAI server-side web search in progress
- * { type: "provider", provider: "openai",
- *   name: "response.web_search_call.searching",
- *   payload: { item_id: "ws_123", output_index: 0 } }
- *
- * // Anthropic context management signal
- * { type: "provider", provider: "anthropic",
- *   name: "context_management",
- *   payload: { ... } }
- * ```
  */
 interface ProviderEvent {
-  type: "provider";
+  event: "provider";
   /** Provider identifier (e.g., `"openai"`, `"anthropic"`, `"google"`). */
   provider: string;
   /** Raw event type name from the provider SDK. */
@@ -176,7 +170,7 @@ interface ProviderEvent {
  * Emitted on unrecoverable stream errors.
  */
 interface StreamErrorEvent {
-  type: "error";
+  event: "error";
   /** Human-readable error message. */
   message: string;
   /** Optional error code for programmatic handling. */
@@ -184,10 +178,8 @@ interface StreamErrorEvent {
 }
 /**
  * Union of all chat model stream event types.
- *
- * This is the type yielded by `ChatModelStream[Symbol.asyncIterator]()`.
  */
 type ChatModelStreamEvent = MessageStartEvent | MessageFinishEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockFinishEvent | UsageUpdateEvent | ProviderEvent | StreamErrorEvent;
 //#endregion
-export { ChatModelStreamEvent, ContentBlockDeltaEvent, ContentBlockFinishEvent, ContentBlockStartEvent, FinishReason, MessageFinishEvent, MessageStartEvent, ProviderEvent, StreamErrorEvent, UsageUpdateEvent };
+export { BlockDelta, ChatModelStreamEvent, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockFinishEvent, ContentBlockStartEvent, DataDelta, FinishReason, MessageFinishEvent, MessageStartEvent, ProviderEvent, ReasoningDelta, StreamErrorEvent, TextDelta, UsageUpdateEvent };
 //# sourceMappingURL=event.d.ts.map

package/dist/language_models/event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event.d.ts","names":[],"sources":["../../src/language_models/event.ts"],"mappings":";;;;;;;UAuDiB,iBAAA;EACf,IAAA;EA6FA;EA3FA,EAAA;EA2F4B;;AAqB9B;;EA3GE,KAAA,GAAQ,aAAA;AAAA;;;;;;;AAmIV;;KAxHY,YAAA;;;;UAKK,kBAAA;EACf,IAAA;EAqHoB;EAnHpB,MAAA,EAAQ,YAAA;EA0IoB;EAxI5B,KAAA,GAAQ,aAAA;EAwIoB;EAtI5B,gBAAA,GAAmB,MAAA;AAAA;;;;;AAmJrB;;;;;;;;;AAaA;;;;;UA3IiB,sBAAA;EACf,IAAA;EA+IE;EA7IF,KAAA;EA+IE;EA7IF,OAAA,EAAS,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCM,sBAAA;EACf,IAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,mBAAA;AAAA;;;;;;;;;;;;;;;;;;;UAqBM,uBAAA;EACf,IAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,YAAA;AAAA;;;;;;;;;;;;;;;;;UAmBM,gBAAA;EACf,IAAA;;EAEA,KAAA,EAAO,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;UAuBQ,aAAA;EACf,IAAA;;EAEA,QAAA;;EAEA,IAAA;;EAEA,OAAA;AAAA;;;;UAMe,gBAAA;EACf,IAAA;;EAEA,OAAA;;EAEA,IAAA;AAAA;;;;;;KAQU,oBAAA,GACR,iBAAA,GACA,kBAAA,GACA,sBAAA,GACA,sBAAA,GACA,uBAAA,GACA,gBAAA,GACA,aAAA,GACA,gBAAA"}
+{"version":3,"file":"event.d.ts","names":[],"sources":["../../src/language_models/event.ts"],"mappings":";;;;AA4FA;;;AAAA,UA9CiB,iBAAA;EACf,KAAA;EAgDA;EA9CA,EAAA;EAgDS;;;AAQX;EAnDE,KAAA,GAAQ,OAAA,CAAQ,aAAA;AAAA;;;AA6DlB;;;;;AAUA;KA5DY,YAAA;;;;UAKK,kBAAA;EACf,KAAA;EA2DQ;EAzDR,MAAA,GAAS,YAAA;EAgEM;EA9Df,KAAA,GAAQ,OAAA,CAAQ,aAAA;;EAEhB,gBAAA,GAAmB,MAAA;AAAA;;;;;;AAqErB;;;;UAtDiB,sBAAA;EACf,KAAA;EAyDE;EAvDF,KAAA;EAuDY;EArDZ,OAAA,EAAS,YAAA;AAAA;;;;UAQM,SAAA;EACf,IAAA;EAyEqC;EAvErC,IAAA;AAAA;;;;;UAOe,cAAA;EACf,IAAA;EAgFe;EA9Ef,SAAA;AAAA;;;;;UAOe,SAAA;EACf,IAAA;EA2EqB;EAzErB,IAAA;EAkF+B;EAhF/B,QAAA;AAAA;;;;;UAOe,UAAA;EACf,IAAA;EAmFe;EAjFf,MAAA;IAAU,IAAA;EAAA,IAAiB,MAAA;AAAA;;;;KAMjB,iBAAA,GACR,SAAA,GACA,cAAA,GACA,SAAA,GACA,UAAA;;AAsFJ;;;;;;;;;AAaA;;;;;;;;;;;;;;;;;UAtEiB,sBAAA;EACf,KAAA;EA4EE;EA1EF,KAAA;EA2EkB;EAzElB,KAAA,EAAO,iBAAA;AAAA;;;;;;;;;;UAYQ,uBAAA;EACf,KAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,YAAA;AAAA;;;;;UASM,gBAAA;EACf,KAAA;;EAEA,KAAA,EAAO,OAAA,CAAQ,aAAA;AAAA;;;;UAQA,aAAA;EACf,KAAA;;EAEA,QAAA;;EAEA,IAAA;;EAEA,OAAA;AAAA;;;;UAQe,gBAAA;EACf,KAAA;;EAEA,OAAA;;EAEA,IAAA;AAAA;;;;KAQU,oBAAA,GACR,iBAAA,GACA,kBAAA,GACA,sBAAA,GACA,sBAAA,GACA,uBAAA,GACA,gBAAA,GACA,aAAA,GACA,gBAAA"}

package/dist/language_models/event.js.map

@@ -1 +1 @@
-{"version":3,"file":"event.js","names":[],"sources":["../../src/language_models/event.ts"],"sourcesContent":["/**\n * Chat model streaming event protocol.\n *\n * Defines a content-block-centric event model for streaming chat model responses.\n * Events carry LangChain {@link ContentBlock} types directly as accumulated\n * snapshots.\n *\n * ## Design Principles\n *\n * 1. **Content blocks are the universal carrier.** Events carry {@link ContentBlock}\n *    instances directly — the block's `type` field is the discriminant. New content\n *    block types automatically work without protocol changes.\n *\n * 2. **Lifecycle completeness.** Every streamable entity has explicit start and finish\n *    events. Consumers never need to infer boundaries from absence of events.\n *\n * 3. **Accumulated snapshots.** Each {@link ContentBlockDeltaEvent} carries the\n *    accumulated state of the content block so far. Aggregation logic lives in the\n *    provider adapter, not the consumer. Consumers who need incremental deltas\n *    track previous state and diff.\n *\n * 4. **Interleaving allowed.** Content blocks may interleave (e.g., parallel tool calls).\n *    The only invariant: a block's start precedes its deltas, and its deltas precede\n *    its finish. No ordering constraint between different blocks.\n *\n * 5. **Provider passthrough.** Native provider events that don't map to standard types\n *    are forwarded as {@link ProviderEvent} rather than silently dropped.\n *\n * ## Lifecycle Contract\n *\n * ```\n * MessageStart\n *   -> ContentBlockStart(index=0, ...)\n *   -> ContentBlockStart(index=1, ...)        // can start before 0 finishes\n *   -> ContentBlockDelta(index=0, ...)\n *   -> ContentBlockDelta(index=1, ...)        // interleaved\n *   -> ContentBlockFinish(index=0, ...)       // blocks finish independently\n *   -> ContentBlockDelta(index=1, ...)\n *   -> ContentBlockFinish(index=1, ...)\n *   -> UsageUpdate(...)                       // may appear at any point\n * -> MessageFinish(reason, usage?)\n * ```\n *\n * @module\n */\n\nimport type {\n  ContentBlock,\n  PartialContentBlock,\n} from \"../messages/content/index.js\";\nimport type { UsageMetadata } from \"../messages/metadata.js\";\n\n/**\n * Emitted once at the start of a model response.\n */\nexport interface MessageStartEvent {\n  type: \"message-start\";\n  /** Optional message ID assigned by the provider. */\n  id?: string;\n  /**\n   * Initial usage snapshot, if the provider reports input token counts\n   * before content begins streaming (e.g., Anthropic's `message_start`).\n   */\n  usage?: UsageMetadata;\n}\n\n/**\n * Finish reason for a model response.\n *\n * - `\"stop\"`: Natural end of generation.\n * - `\"length\"`: Hit max token limit.\n * - `\"tool_use\"`: Model is requesting tool execution.\n * - `\"content_filter\"`: Content was filtered by safety systems.\n */\nexport type FinishReason = \"stop\" | \"length\" | \"tool_use\" | \"content_filter\";\n\n/**\n * Emitted once when the model response is complete.\n */\nexport interface MessageFinishEvent {\n  type: \"message-finish\";\n  /** Why the model stopped generating. */\n  reason: FinishReason;\n  /** Final usage snapshot. */\n  usage?: UsageMetadata;\n  /** Provider-specific response metadata (model name, response ID, headers, etc.). */\n  responseMetadata?: Record<string, unknown>;\n}\n\n/**\n * Emitted when a new content block begins streaming.\n *\n * @example\n * ```ts\n * // Text block starting\n * { type: \"content-block-start\", index: 0,\n *   content: { type: \"text\", text: \"\" } }\n *\n * // Tool call starting\n * { type: \"content-block-start\", index: 1,\n *   content: { type: \"tool_call\", id: \"call_1\", name: \"search\", args: \"\" } }\n *\n * // Reasoning starting\n * { type: \"content-block-start\", index: 2,\n *   content: { type: \"reasoning\", reasoning: \"\" } }\n * ```\n */\nexport interface ContentBlockStartEvent {\n  type: \"content-block-start\";\n  /** Positional index of this block within the message. */\n  index: number;\n  /** Initial state of the content block. */\n  content: ContentBlock;\n}\n\n/**\n * Emitted for each incremental update within a content block.\n *\n * Carries the **accumulated state** of the content block so far.\n * The content is deeply partial — not all fields may be populated during\n * streaming (e.g., a tool call may have `name` but `args` is still being\n * streamed as a partial JSON string).\n *\n * Consumers who need incremental deltas (e.g., new tokens only) should\n * track the previous state and diff against the new accumulated state.\n *\n * Aggregation into `AIMessage` is trivial:\n * `message.content[event.index] = event.content`\n *\n * @example\n * ```ts\n * // First text delta — accumulated so far\n * { type: \"content-block-delta\", index: 0,\n *   content: { type: \"text\", text: \"Hello\" } }\n *\n * // Second text delta — accumulated so far\n * { type: \"content-block-delta\", index: 0,\n *   content: { type: \"text\", text: \"Hello world\" } }\n *\n * // Tool call args — accumulated so far\n * { type: \"content-block-delta\", index: 1,\n *   content: { type: \"tool_call\", id: \"call_1\", name: \"search\", args: '{\"q\":\"wea' } }\n * ```\n */\nexport interface ContentBlockDeltaEvent {\n  type: \"content-block-delta\";\n  /** Positional index of the block being updated. */\n  index: number;\n  /** Accumulated state of the content block after this update. Deeply partial. */\n  content: PartialContentBlock;\n}\n\n/**\n * Emitted when a content block is complete.\n *\n * The `content` carries the **finalized** block. For tool calls, this means\n * args have been parsed from a JSON string into an object.\n *\n * @example\n * ```ts\n * // Finalized text block\n * { type: \"content-block-finish\", index: 0,\n *   content: { type: \"text\", text: \"The weather is sunny.\" } }\n *\n * // Finalized tool call (args parsed)\n * { type: \"content-block-finish\", index: 1,\n *   content: { type: \"tool_call\", id: \"call_1\", name: \"search\",\n *              args: { q: \"weather\" } } }\n * ```\n */\nexport interface ContentBlockFinishEvent {\n  type: \"content-block-finish\";\n  /** Positional index of the completed block. */\n  index: number;\n  /** Finalized content block. */\n  content: ContentBlock;\n}\n\n/**\n * Emitted whenever the provider reports updated usage information.\n *\n * May appear at any point during streaming. Each event carries a\n * **running snapshot** of usage (not an additive delta), so consumers\n * can simply take the latest value.\n *\n * @example\n * ```ts\n * // After message_start (Anthropic: input tokens known)\n * { type: \"usage\", usage: { input_tokens: 1234, output_tokens: 0, total_tokens: 1234 } }\n *\n * // After streaming completes\n * { type: \"usage\", usage: { input_tokens: 1234, output_tokens: 567, total_tokens: 1801 } }\n * ```\n */\nexport interface UsageUpdateEvent {\n  type: \"usage\";\n  /** Current usage snapshot. */\n  usage: UsageMetadata;\n}\n\n/**\n * Passthrough for native provider events that don't map to standard types.\n *\n * Provider adapters map recognized events to standard {@link ChatModelStreamEvent}\n * types and forward everything else as `ProviderEvent`. This ensures no information\n * is silently dropped.\n *\n * @example\n * ```ts\n * // OpenAI server-side web search in progress\n * { type: \"provider\", provider: \"openai\",\n *   name: \"response.web_search_call.searching\",\n *   payload: { item_id: \"ws_123\", output_index: 0 } }\n *\n * // Anthropic context management signal\n * { type: \"provider\", provider: \"anthropic\",\n *   name: \"context_management\",\n *   payload: { ... } }\n * ```\n */\nexport interface ProviderEvent {\n  type: \"provider\";\n  /** Provider identifier (e.g., `\"openai\"`, `\"anthropic\"`, `\"google\"`). */\n  provider: string;\n  /** Raw event type name from the provider SDK. */\n  name: string;\n  /** Raw event payload from the provider SDK. */\n  payload: unknown;\n}\n\n/**\n * Emitted on unrecoverable stream errors.\n */\nexport interface StreamErrorEvent {\n  type: \"error\";\n  /** Human-readable error message. */\n  message: string;\n  /** Optional error code for programmatic handling. */\n  code?: string;\n}\n\n/**\n * Union of all chat model stream event types.\n *\n * This is the type yielded by `ChatModelStream[Symbol.asyncIterator]()`.\n */\nexport type ChatModelStreamEvent =\n  | MessageStartEvent\n  | MessageFinishEvent\n  | ContentBlockStartEvent\n  | ContentBlockDeltaEvent\n  | ContentBlockFinishEvent\n  | UsageUpdateEvent\n  | ProviderEvent\n  | StreamErrorEvent;\n"],"mappings":""}
+{"version":3,"file":"event.js","names":[],"sources":["../../src/language_models/event.ts"],"sourcesContent":["/**\n * Chat model streaming event protocol.\n *\n * Defines a content-block-centric event model for streaming chat model responses.\n * Events carry LangChain {@link ContentBlock} types on lifecycle boundaries\n * and explicit delta variants for incremental updates during streaming.\n *\n * ## Design Principles\n *\n * 1. **Content-block deltas have explicit merge semantics.** Text,\n *    reasoning, and data deltas append to named fields. Generic block deltas\n *    shallow-merge fields onto the active content block.\n *\n * 2. **Lifecycle completeness.** Every streamable entity has explicit start and finish\n *    events. Consumers never need to infer boundaries from absence of events.\n *\n * 3. **Interleaving allowed.** Content blocks may interleave (e.g., parallel tool calls).\n *    The only invariant: a block's start precedes its deltas, and its deltas precede\n *    its finish. No ordering constraint between different blocks.\n *\n * 4. **Provider passthrough.** Native provider events that don't map to standard types\n *    are forwarded as {@link ProviderEvent} rather than silently dropped.\n *\n * ## Lifecycle Contract\n *\n * ```\n * MessageStart\n *   -> ContentBlockStart(index=0, content=...)\n *   -> ContentBlockDelta(index=0, delta={ type: \"text-delta\", text: \"Hello\" })\n *   -> ContentBlockDelta(index=0, delta={ type: \"text-delta\", text: \" world\" })\n *   -> ContentBlockFinish(index=0, content=...)\n *   -> UsageUpdate(...)\n * -> MessageFinish(reason, usage?)\n * ```\n *\n * @module\n */\n\nimport type { ContentBlock } from \"../messages/content/index.js\";\nimport type { UsageMetadata } from \"../messages/metadata.js\";\n\n// ─── Message Lifecycle ──────────────────────────────────────────\n\n/**\n * Emitted once at the start of a model response.\n */\nexport interface MessageStartEvent {\n  event: \"message-start\";\n  /** Optional message ID assigned by the provider. */\n  id?: string;\n  /**\n   * Initial usage snapshot, if the provider reports input token counts\n   * before content begins streaming (e.g., Anthropic's `message_start`).\n   */\n  usage?: Partial<UsageMetadata>;\n}\n\n/**\n * Finish reason for a model response.\n *\n * - `\"stop\"`: Natural end of generation.\n * - `\"length\"`: Hit max token limit.\n * - `\"tool_use\"`: Model is requesting tool execution.\n * - `\"content_filter\"`: Content was filtered by safety systems.\n */\nexport type FinishReason = \"stop\" | \"length\" | \"tool_use\" | \"content_filter\";\n\n/**\n * Emitted once when the model response is complete.\n */\nexport interface MessageFinishEvent {\n  event: \"message-finish\";\n  /** Why the model stopped generating. */\n  reason?: FinishReason;\n  /** Final usage snapshot. */\n  usage?: Partial<UsageMetadata>;\n  /** Provider-specific response metadata (model name, response ID, headers, etc.). */\n  responseMetadata?: Record<string, unknown>;\n}\n\n// ─── Content Block Lifecycle ────────────────────────────────────\n// See https://github.com/langchain-ai/agent-protocol/blob/main/streaming/protocol.cddl\n\n/**\n * Emitted when a new content block begins streaming.\n *\n * @example\n * ```ts\n * { event: \"content-block-start\", index: 0,\n *   content: { type: \"text\", text: \"\" } }\n * ```\n */\nexport interface ContentBlockStartEvent {\n  event: \"content-block-start\";\n  /** Positional index of this block within the message. */\n  index: number;\n  /** Initial state of the content block. */\n  content: ContentBlock;\n}\n\n// ─── Content Block Deltas ───────────────────────────────────────\n\n/**\n * Incremental text content. Append `text` to the active block's `text` field.\n */\nexport interface TextDelta {\n  type: \"text-delta\";\n  /** The new text to append. */\n  text: string;\n}\n\n/**\n * Incremental reasoning content. Append `reasoning` to the active block's\n * `reasoning` field.\n */\nexport interface ReasoningDelta {\n  type: \"reasoning-delta\";\n  /** The new reasoning text to append. */\n  reasoning: string;\n}\n\n/**\n * Incremental encoded data. Append `data` to the active multimodal block's\n * data field.\n */\nexport interface DataDelta {\n  type: \"data-delta\";\n  /** Encoded data chunk to append. */\n  data: string;\n  /** Encoding for the data chunk. Defaults to `\"base64\"` when omitted. */\n  encoding?: \"base64\";\n}\n\n/**\n * Generic content block field update. Shallow-merge `fields` onto the active\n * content block.\n */\nexport interface BlockDelta {\n  type: \"block-delta\";\n  /** Fields to shallow-merge onto the active content block. */\n  fields: { type: string } & Record<string, unknown>;\n}\n\n/**\n * Union of all content block delta types.\n */\nexport type ContentBlockDelta =\n  | TextDelta\n  | ReasoningDelta\n  | DataDelta\n  | BlockDelta;\n\n/**\n * Emitted for each incremental update within a content block.\n *\n * The `delta` field carries the incremental content block update.\n * Accumulation rules:\n * - `text-delta` → append `text` to the active block's text field\n * - `reasoning-delta` → append `reasoning` to the active block's reasoning field\n * - `data-delta` → append `data` to the active block's data field\n * - `block-delta` → shallow-merge `fields` onto the active block\n *\n * @example\n * ```ts\n * // Text token\n * { event: \"content-block-delta\", index: 0,\n *   delta: { type: \"text-delta\", text: \" world\" } }\n *\n * // Tool call args snapshot\n * { event: \"content-block-delta\", index: 1,\n *   delta: { type: \"block-delta\",\n *     fields: { type: \"tool_call_chunk\", args: '{\"q\":\"wea' } } } }\n *\n * // Provider-specific field (e.g., signature)\n * { event: \"content-block-delta\", index: 0,\n *   delta: { type: \"block-delta\",\n *     fields: { type: \"reasoning\", signature: \"sig_abc\" } } }\n * ```\n */\nexport interface ContentBlockDeltaEvent {\n  event: \"content-block-delta\";\n  /** Positional index of the block being updated. */\n  index: number;\n  /** Incremental content block delta. */\n  delta: ContentBlockDelta;\n}\n\n/**\n * Emitted when a content block is complete.\n *\n * @example\n * ```ts\n * { event: \"content-block-finish\", index: 0,\n *   content: { type: \"text\", text: \"Hello world\" } }\n * ```\n */\nexport interface ContentBlockFinishEvent {\n  event: \"content-block-finish\";\n  /** Positional index of the completed block. */\n  index: number;\n  /** Finalized content block. */\n  content: ContentBlock;\n}\n\n// ─── Usage ──────────────────────────────────────────────────────\n\n/**\n * Emitted whenever the provider reports updated usage information.\n * Each event carries a **running snapshot** (not an additive delta).\n */\nexport interface UsageUpdateEvent {\n  event: \"usage\";\n  /** Current usage snapshot. */\n  usage: Partial<UsageMetadata>;\n}\n\n// ─── Provider Passthrough ───────────────────────────────────────\n\n/**\n * Passthrough for native provider events that don't map to standard types.\n */\nexport interface ProviderEvent {\n  event: \"provider\";\n  /** Provider identifier (e.g., `\"openai\"`, `\"anthropic\"`, `\"google\"`). */\n  provider: string;\n  /** Raw event type name from the provider SDK. */\n  name: string;\n  /** Raw event payload from the provider SDK. */\n  payload: unknown;\n}\n\n// ─── Error ──────────────────────────────────────────────────────\n\n/**\n * Emitted on unrecoverable stream errors.\n */\nexport interface StreamErrorEvent {\n  event: \"error\";\n  /** Human-readable error message. */\n  message: string;\n  /** Optional error code for programmatic handling. */\n  code?: string;\n}\n\n// ─── Union ──────────────────────────────────────────────────────\n\n/**\n * Union of all chat model stream event types.\n */\nexport type ChatModelStreamEvent =\n  | MessageStartEvent\n  | MessageFinishEvent\n  | ContentBlockStartEvent\n  | ContentBlockDeltaEvent\n  | ContentBlockFinishEvent\n  | UsageUpdateEvent\n  | ProviderEvent\n  | StreamErrorEvent;\n"],"mappings":""}

package/dist/language_models/llms.cjs

@@ -44,10 +44,14 @@ var BaseLLM = class BaseLLM extends require_language_models_base.BaseLanguageMod
 		else {
 			const prompt = BaseLLM._convertInputToPromptValue(input);
 			const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
-			const callbackManager_ = await require_callbacks_manager.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+			const invocationParams = this.invocationParams(callOptions);
+			const callbackManager_ = await require_callbacks_manager.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, {
+				verbose: this.verbose,
+				tracerInheritableMetadata: this._filterInvocationParamsForTracing(invocationParams)
+			});
 			const extra = {
 				options: callOptions,
-				invocation_params: this?.invocationParams(callOptions),
+				invocation_params: invocationParams,
 				batch_size: 1
 			};
 			const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], runnableConfig.runId, void 0, extra, void 0, void 0, runnableConfig.runName);
@@ -109,10 +113,14 @@ var BaseLLM = class BaseLLM extends require_language_models_base.BaseLanguageMod
 		let runManagers;
 		if (startedRunManagers !== void 0 && startedRunManagers.length === prompts.length) runManagers = startedRunManagers;
 		else {
-			const callbackManager_ = await require_callbacks_manager.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+			const invocationParams = this.invocationParams(parsedOptions);
+			const callbackManager_ = await require_callbacks_manager.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, {
+				verbose: this.verbose,
+				tracerInheritableMetadata: this._filterInvocationParamsForTracing(invocationParams)
+			});
 			const extra = {
 				options: parsedOptions,
-				invocation_params: this?.invocationParams(parsedOptions),
+				invocation_params: invocationParams,
 				batch_size: prompts.length
 			};
 			runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, void 0, extra, void 0, void 0, handledOptions?.runName);
@@ -152,10 +160,14 @@ var BaseLLM = class BaseLLM extends require_language_models_base.BaseLanguageMod
 		return output;
 	}
 	async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId }) {
-		const callbackManager_ = await require_callbacks_manager.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+		const invocationParams = this.invocationParams(parsedOptions);
+		const callbackManager_ = await require_callbacks_manager.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, {
+			verbose: this.verbose,
+			tracerInheritableMetadata: this._filterInvocationParamsForTracing(invocationParams)
+		});
 		const extra = {
 			options: parsedOptions,
-			invocation_params: this?.invocationParams(parsedOptions),
+			invocation_params: invocationParams,
 			batch_size: prompts.length
 		};
 		const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, void 0, extra, void 0, void 0, handledOptions?.runName);