@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/language_models/chat_models.d.ts

@@ -3,17 +3,18 @@ import { AIMessageChunk } from "../messages/ai.js";
 import { MessageOutputVersion } from "../messages/message.js";
 import { ChatGenerationChunk, ChatResult, Generation, LLMResult } from "../outputs.js";
 import { BaseCache } from "../caches/index.js";
+import { SerializableSchema } from "../utils/standard_schema.js";
+import { ZodV3Like, ZodV4Like } from "../utils/types/zod.js";
+import { ChatModelStreamEvent } from "./event.js";
 import { CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
 import { RunnableConfig } from "../runnables/types.js";
-import "../runnables/config.js";
+import { IterableReadableStream } from "../utils/stream.js";
+import { EventStreamCallbackHandlerInput, StreamEvent } from "../tracers/event_stream.js";
 import { Runnable, RunnableToolLike } from "../runnables/base.js";
 import { BasePromptValueInterface } from "../prompt_values.js";
 import { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelInput, BaseLanguageModelParams, StructuredOutputMethodOptions, ToolDefinition } from "./base.js";
-import "../messages/index.js";
 import { StructuredToolInterface, StructuredToolParams } from "../tools/types.js";
-import "../tools/index.js";
-import { ZodType } from "zod/v3";
-import { $ZodType } from "zod/v4/core";
+import { ChatModelStream } from "./stream.js";
 
 //#region src/language_models/chat_models.d.ts
 type ToolChoice = string | Record<string, any> | "auto" | "any";
@@ -105,6 +106,7 @@ type LangSmithParams = {
   ls_temperature?: number;
   ls_max_tokens?: number;
   ls_stop?: Array<string>;
+  ls_integration?: string;
 };
 type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
 /**
@@ -135,10 +137,137 @@ declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOption
    * @param options The call options.
    * @returns A Promise that resolves to a BaseMessageChunk.
    */
-  invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;
+  invoke(input: BaseLanguageModelInput, options?: Partial<CallOptions>): Promise<OutputMessageType>;
   _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-  _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
+  /**
+   * Stream chat model events using the new content-block-centric protocol.
+   *
+   * Override this method to provide native event streaming from the provider SDK.
+   * The default implementation bridges from `_streamResponseChunks` by
+   * synthesizing lifecycle events from `ChatGenerationChunk` objects.
+   *
+   * ## Event lifecycle
+   *
+   * ```
+   * MessageStart
+   *   -> ContentBlockStart(index, contentBlock)
+   *     -> ContentBlockDelta(index, delta) ...
+   *   -> ContentBlockFinish(index, contentBlock)
+   * -> MessageFinish(reason, usage?)
+   * ```
+   *
+   * Content blocks may interleave (e.g., parallel tool calls). The only
+   * invariant: a block's start precedes its deltas, and its deltas precede
+   * its finish.
+   *
+   * @param messages - The input messages.
+   * @param options - Parsed call options.
+   * @param runManager - Optional callback manager for the run.
+   * @returns An async generator of {@link ChatModelStreamEvent}.
+   */
+  _streamChatModelEvents(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatModelStreamEvent>;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} without a `version`
+   * option for content-block streaming instead.
+   */
+  streamEvents(input: BaseLanguageModelInput, options: Partial<CallOptions> & {
+    version: "v2";
+  }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} without a `version`
+   * option for content-block streaming instead.
+   */
+  streamEvents(input: BaseLanguageModelInput, options: Partial<CallOptions> & {
+    version: "v2";
+    encoding: "text/event-stream";
+  }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} without a `version`
+   * option for content-block streaming instead.
+   */
+  streamEvents(input: BaseLanguageModelInput, options: Partial<CallOptions> & {
+    version: "v1";
+  }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} without a `version`
+   * option for content-block streaming instead.
+   */
+  streamEvents(input: BaseLanguageModelInput, options: Partial<CallOptions> & {
+    version: "v1";
+    encoding: "text/event-stream";
+  }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} without a `version`
+   * option for content-block streaming instead.
+   */
+  streamEvents(input: BaseLanguageModelInput, options: Partial<CallOptions> & {
+    version: "v1" | "v2";
+  }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} without a `version`
+   * option for content-block streaming instead.
+   */
+  streamEvents(input: BaseLanguageModelInput, options: Partial<CallOptions> & {
+    version: "v1" | "v2";
+    encoding: "text/event-stream";
+  }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
+  /**
+   * Create a {@link ChatModelStream} for the given input.
+   *
+   * Returns a stream object that is both `AsyncIterable<ChatModelStreamEvent>`
+   * and `PromiseLike<AIMessage>`, with typed sub-stream accessors for
+   * `.text`, `.toolCalls`, `.reasoning`, and `.usage`.
+   *
+   * @param input - The input messages.
+   * @param options - Optional call options.
+   * @returns A {@link ChatModelStream}.
+   *
+   * When `options.version` is `"v1"` or `"v2"`, this delegates to
+   * {@link Runnable.streamEvents} for callback-based tracing events instead.
+   * That path is deprecated on chat models; prefer calling `streamEvents()`
+   * without a `version` option.
+   *
+   * @example
+   * ```ts
+   * const stream = model.streamEvents([{ role: "user", content: "Hello" }]);
+   *
+   * // Stream text
+   * for await (const token of stream.text) {
+   *   process.stdout.write(token);
+   * }
+   *
+   * // Stream tool calls
+   * for await (const toolCall of stream.toolCalls) {
+   *   console.log(toolCall);
+   * }
+   *
+   * // Stream reasoning
+   * for await (const reasoning of stream.reasoning) {
+   *   console.log(reasoning);
+   * }
+   *
+   * // Stream usage
+   * for await (const usage of stream.usage) {
+   *   console.log(usage);
+   * }
+   *
+   * // Or await the full message
+   * const message = await stream;
+   * ```
+   */
+  streamEvents(input: BaseLanguageModelInput, options?: Partial<CallOptions>): ChatModelStream;
+  /**
+   * @deprecated Use {@link BaseChatModel.streamEvents} instead. This method will be removed in the next major version.
+   */
+  streamV2(input: BaseLanguageModelInput, options?: Partial<CallOptions>): ChatModelStream;
+  _streamIterator(input: BaseLanguageModelInput, options?: Partial<CallOptions>): AsyncGenerator<OutputMessageType>;
   getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
+  /**
+   * Wraps getLsParams() and always appends ls_integration.
+   * This ensures the integration tag is present even when
+   * partner packages fully override getLsParams().
+   */
+  getLsParamsWithDefaults(options: this["ParsedCallOptions"]): LangSmithParams;
   /** @ignore */
   _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;
   _generateCached({
@@ -164,7 +293,7 @@ declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOption
    * @param callbacks The callbacks for the language model.
    * @returns A Promise that resolves to an LLMResult.
    */
-  generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
+  generate(messages: BaseMessageLike[][], options?: string[] | Partial<CallOptions>, callbacks?: Callbacks): Promise<LLMResult>;
   /**
    * Get the parameters used to invoke the model
    */
@@ -178,15 +307,20 @@ declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOption
    * @param callbacks The callbacks for the language model.
    * @returns A Promise that resolves to an LLMResult.
    */
-  generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
+  generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | Partial<CallOptions>, callbacks?: Callbacks): Promise<LLMResult>;
   abstract _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: SerializableSchema<RunOutput>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: SerializableSchema<RunOutput>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    raw: BaseMessage;
+    parsed: RunOutput;
+  }>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodV4Like<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodV4Like<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
     raw: BaseMessage;
     parsed: RunOutput;
   }>;
-  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodV3Like<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodV3Like<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
     raw: BaseMessage;
     parsed: RunOutput;
   }>;

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

@@ -1 +1 @@
-{"version":3,"file":"chat_models.d.ts","names":["ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","BasePromptValueInterface","LLMResult","ChatGenerationChunk","ChatResult","Generation","BaseLanguageModel","StructuredOutputMethodOptions","ToolDefinition","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","CallbackManagerForLLMRun","Callbacks","RunnableConfig","BaseCache","StructuredToolInterface","StructuredToolParams","Runnable","RunnableToolLike","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","RunOutput","CallOptions","OutputMessageType","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","SimpleChatModel"],"sources":["../../src/language_models/chat_models.d.ts"],"sourcesContent":["import type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseMessage, BaseMessageChunk, type BaseMessageLike, AIMessageChunk, MessageOutputVersion } from \"../messages/index.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from \"../outputs.js\";\nimport { BaseLanguageModel, type StructuredOutputMethodOptions, type ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport { type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/index.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/index.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\nexport type ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\nexport type SerializedChatModel = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents a serialized large language model.\n */\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\nexport type BaseChatModelParams = BaseLanguageModelParams & {\n    /**\n     * Whether to disable streaming.\n     *\n     * If streaming is bypassed, then `stream()` will defer to\n     * `invoke()`.\n     *\n     * - If true, will always bypass streaming case.\n     * - If false (default), will always use streaming case if available.\n     */\n    disableStreaming?: boolean;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\nexport type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n    /**\n     * Specifies how the chat model should use tools.\n     * @default undefined\n     *\n     * Possible values:\n     * - \"auto\": The model may choose to use any of the provided tools, or none.\n     * - \"any\": The model must use one of the provided tools.\n     * - \"none\": The model must not use any tools.\n     * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n     *\n     * Note: Not all providers support tool_choice. An error will be thrown\n     * if used with an unsupported model.\n     */\n    tool_choice?: ToolChoice;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\nexport type LangSmithParams = {\n    ls_provider?: string;\n    ls_model_name?: string;\n    ls_model_type: \"chat\";\n    ls_temperature?: number;\n    ls_max_tokens?: number;\n    ls_stop?: Array<string>;\n};\nexport type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\nexport declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    lc_namespace: string[];\n    disableStreaming: boolean;\n    outputVersion?: MessageOutputVersion;\n    get callKeys(): string[];\n    constructor(fields: BaseChatModelParams);\n    _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    /**\n     * Bind tool-like objects to this chat model.\n     *\n     * @param tools A list of tool definitions to bind to this chat model.\n     * Can be a structured tool, an OpenAI formatted tool, or an object\n     * matching the provider's specific tool schema.\n     * @param kwargs Any additional parameters to bind.\n     */\n    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n    /**\n     * Invokes the chat model with a single input.\n     * @param input The input for the language model.\n     * @param options The call options.\n     * @returns A Promise that resolves to a BaseMessageChunk.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n    _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n    getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n    /** @ignore */\n    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions }: {\n        messages: BaseMessageLike[][];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Generates chat based on the input messages.\n     * @param messages An array of arrays of BaseMessage instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _modelType(): string;\n    abstract _llmType(): string;\n    /**\n     * Generates a prompt based on the input prompt values.\n     * @param promptValues An array of BasePromptValue instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\nexport declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n    abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n//# sourceMappingURL=chat_models.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"chat_models.d.ts","names":[],"sources":["../../src/language_models/chat_models.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KAgFY,UAAA,YAAsB,MAAA;;;;KAKtB,mBAAA;EACV,MAAA;EACA,KAAA;AAAA,IAEE,MAAA;;;;KAMQ,aAAA;EACV,MAAA;EACA,KAAA;AAAA,IAEE,MAAA;;;;KAKQ,mBAAA,GAAsB,uBAAA;EAfxB;;AAMV;;;;;;;EAmBE,gBAAA;EAfQ;AAKV;;;;;;;;;;AAgCA;;;;EANE,aAAA,GAAgB,oBAAA;AAAA;;;;KAMN,wBAAA,GAA2B,4BAAA;EAevB;;;;;AA+ChB;;;;;;;;;EA/CE,WAAA,GAAc,UAAA;EAqDJ;;;;AAIZ;;;;;;;;;;;EAzCE,aAAA,GAAgB,oBAAA;AAAA;AAAA,KA+BN,eAAA;EACV,WAAA;EACA,aAAA;EACA,aAAA;EACA,cAAA;EACA,aAAA;EACA,OAAA,GAAU,KAAA;EACV,cAAA;AAAA;AAAA,KAGU,cAAA,GACR,uBAAA,GAEA,MAAA,gBACA,cAAA,GACA,gBAAA,GACA,oBAAA;;;;;uBAMkB,aAAA,qBACA,wBAAA,GAA2B,wBAAA,4BAErB,gBAAA,GAAmB,cAAA,UACrC,iBAAA,CAAkB,iBAAA,EAAmB,WAAA;EAErC,iBAAA,EAAmB,IAAA,CACzB,WAAA,EACA,OAAA,OAAc,cAAA;EAIhB,YAAA;EAEA,gBAAA;EAEA,aAAA,GAAgB,oBAAA;EAAA,IAEZ,QAAA,CAAA;EAIJ,WAAA,CAAY,MAAA,EAAQ,mBAAA;EAYpB,iBAAA,CAAA,CAAA,GACK,UAAA,EAAY,SAAA,kBACd,SAAA;EAAA,UAEO,4CAAA,CACR,OAAA,GAAU,OAAA,CAAQ,WAAA,KAChB,cAAA;EAAA;;;;;;;;EAgBJ,SAAA,CAAA,CACE,KAAA,EAAO,cAAA,IACP,MAAA,GAAS,OAAA,CAAQ,WAAA,IAChB,QAAA,CAAS,sBAAA,EAAwB,iBAAA,EAAmB,WAAA;EAUnC;;;;;;EAFd,MAAA,CACJ,KAAA,EAAO,sBAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,OAAA,CAAQ,iBAAA;EAaJ,qBAAA,CACL,SAAA,EAAW,WAAA,IACX,QAAA,6BACA,WAAA,GAAc,wBAAA,GACb,cAAA,CAAe,mBAAA;EA+BN;;;;;;;;;;;;;;;;;;;;;;;;;;EADL,sBAAA,CACL,QAAA,EAAU,WAAA,IACV,OAAA,6BACA,UAAA,GAAa,wBAAA,GACZ,cAAA,CAAe,oBAAA;EA6CP;;;;EAnCX,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,EAAS,OAAA,CAAQ,WAAA;IAAiB,OAAA;EAAA,GAClC,aAAA,GAAgB,IAAA,CAAK,+BAAA,iBACpB,sBAAA,CAAuB,WAAA;EA4Cf;;;;EAtCX,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,EAAS,OAAA,CAAQ,WAAA;IACf,OAAA;IACA,QAAA;EAAA,GAEF,aAAA,GAAgB,IAAA,CAAK,+BAAA,iBACpB,sBAAA,CAAuB,UAAA;EA6CH;;;;EAvCvB,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,EAAS,OAAA,CAAQ,WAAA;IAAiB,OAAA;EAAA,GAClC,aAAA,GAAgB,IAAA,CAAK,+BAAA,iBACpB,sBAAA,CAAuB,WAAA;EAqFvB;;;;EA/EH,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,EAAS,OAAA,CAAQ,WAAA;IACf,OAAA;IACA,QAAA;EAAA,GAEF,aAAA,GAAgB,IAAA,CAAK,+BAAA,iBACpB,sBAAA,CAAuB,UAAA;EAoHR;;;;EA9GlB,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,EAAS,OAAA,CAAQ,WAAA;IAAiB,OAAA;EAAA,GAClC,aAAA,GAAgB,IAAA,CAAK,+BAAA,iBACpB,sBAAA,CAAuB,WAAA;EAyPf;;;;EAnPX,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,EAAS,OAAA,CAAQ,WAAA;IACf,OAAA;IACA,QAAA;EAAA,GAEF,aAAA,GAAgB,IAAA,CAAK,+BAAA,iBACpB,sBAAA,CAAuB,UAAA;EAigBP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAndnB,YAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,eAAA;EAkvBS;;;EAhtBZ,QAAA,CACE,KAAA,EAAO,sBAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,eAAA;EAII,eAAA,CACL,KAAA,EAAO,sBAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,cAAA,CAAe,iBAAA;EAiHlB,WAAA,CAAY,OAAA,8BAAqC,eAAA;EA4lB3C;;;;;EA3kBN,uBAAA,CAAwB,OAAA,8BAAqC,eAAA;EA+kB1D;EAvkBG,iBAAA,CACJ,QAAA,EAAU,eAAA,MACV,aAAA,6BACA,cAAA,EAAgB,cAAA,EAChB,kBAAA,GAAqB,wBAAA,KACpB,OAAA,CAAQ,SAAA;EA6QL,eAAA,CAAA;IACJ,QAAA;IACA,KAAA;IACA,YAAA;IACA,aAAA;IACA;EAAA;IAEA,QAAA,EAAU,eAAA;IACV,KAAA,EAAO,SAAA,CAAU,UAAA;IACjB,YAAA;IAEA,aAAA;IACA,cAAA,EAAgB,cAAA;EAAA,IACd,OAAA,CACF,SAAA;IACE,oBAAA;IACA,kBAAA,GAAqB,wBAAA;EAAA;EAuTT;;;;;;;EA9JV,QAAA,CACJ,QAAA,EAAU,eAAA,MACV,OAAA,cAAqB,OAAA,CAAQ,WAAA,GAC7B,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,SAAA;EAp2BH;;;EAs6BR,gBAAA,CAAiB,QAAA;EAIjB,UAAA,CAAA;EAAA,SAIS,QAAA,CAAA;EA/6BT;;;;;;;EAw7BM,cAAA,CACJ,YAAA,EAAc,wBAAA,IACd,OAAA,cAAqB,OAAA,CAAQ,WAAA,GAC7B,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,SAAA;EAAA,SAOF,SAAA,CACP,QAAA,EAAU,WAAA,IACV,OAAA,6BACA,UAAA,GAAa,wBAAA,GACZ,OAAA,CAAQ,UAAA;EAEX,oBAAA,mBAEoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,YAAA,EAAc,kBAAA,CAAmB,SAAA,GACjC,MAAA,GAAS,6BAAA,UACR,QAAA,CAAS,sBAAA,EAAwB,SAAA;EAEpC,oBAAA,mBAEoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,YAAA,EAAc,kBAAA,CAAmB,SAAA,GACjC,MAAA,GAAS,6BAAA,SACR,QAAA,CAAS,sBAAA;IAA0B,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;EAEhE,oBAAA,mBAEoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,YAAA,EACI,SAAA,CAAU,SAAA,IAEV,MAAA,eACJ,MAAA,GAAS,6BAAA,UACR,QAAA,CAAS,sBAAA,EAAwB,SAAA;EAEpC,oBAAA,mBAEoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,YAAA,EACI,SAAA,CAAU,SAAA,IAEV,MAAA,eACJ,MAAA,GAAS,6BAAA,SACR,QAAA,CAAS,sBAAA;IAA0B,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;EAEhE,oBAAA,mBAEoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,YAAA,EACI,SAAA,CAAU,SAAA,IAEV,MAAA,eACJ,MAAA,GAAS,6BAAA,UACR,QAAA,CAAS,sBAAA,EAAwB,SAAA;EAEpC,oBAAA,mBAEoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,YAAA,EACI,SAAA,CAAU,SAAA,IAEV,MAAA,eACJ,MAAA,GAAS,6BAAA,SACR,QAAA,CAAS,sBAAA;IAA0B,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;AAAA;;;;;uBAqG5C,eAAA,qBACA,wBAAA,GAA2B,wBAAA,UACvC,aAAA,CAAc,WAAA;EAAA,SACb,KAAA,CACP,QAAA,EAAU,WAAA,IACV,OAAA,6BACA,UAAA,GAAa,wBAAA,GACZ,OAAA;EAEG,SAAA,CACJ,QAAA,EAAU,WAAA,IACV,OAAA,6BACA,UAAA,GAAa,wBAAA,GACZ,OAAA,CAAQ,UAAA;AAAA"}

package/dist/language_models/chat_models.js

@@ -1,24 +1,26 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { ModelAbortError } from "../errors/index.js";
 import { convertToOpenAIImageBlock, isBase64ContentBlock, isURLContentBlock } from "../messages/content/data.js";
 import { isBaseMessage } from "../messages/base.js";
-import { coerceMessageLikeToMessage } from "../messages/utils.js";
 import { AIMessage, AIMessageChunk, isAIMessage, isAIMessageChunk } from "../messages/ai.js";
+import { coerceMessageLikeToMessage } from "../messages/utils.js";
 import { getEnvironmentVariable } from "../utils/env.js";
-import { callbackHandlerPrefersStreaming } from "../callbacks/base.js";
+import { callbackHandlerPrefersChatModelStreamEvents, callbackHandlerPrefersStreaming } from "../callbacks/base.js";
 import { CallbackManager } from "../callbacks/manager.js";
 import { concat } from "../utils/stream.js";
 import { RUN_KEY } from "../outputs.js";
 import { getSchemaDescription, isInteropZodSchema } from "../utils/types/zod.js";
+import { isSerializableSchema } from "../utils/standard_schema.js";
 import { toJsonSchema } from "../utils/json_schema.js";
-import { RunnableLambda, RunnableSequence } from "../runnables/base.js";
+import { RunnableLambda } from "../runnables/base.js";
 import "../messages/index.js";
 import { BaseLanguageModel } from "./base.js";
-import { RunnablePassthrough } from "../runnables/passthrough.js";
 import { castStandardMessageContent, iife } from "./utils.js";
-
+import { assembleStructuredOutputPipeline } from "./structured_output.js";
+import { ChatModelStream } from "./stream.js";
+import { convertChunksToEvents } from "./compat.js";
 //#region src/language_models/chat_models.ts
-var chat_models_exports = {};
-__export(chat_models_exports, {
+var chat_models_exports = /* @__PURE__ */ __exportAll({
 	BaseChatModel: () => BaseChatModel,
 	SimpleChatModel: () => SimpleChatModel
 });
@@ -79,27 +81,69 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 	*/
 	async invoke(input, options) {
 		const promptValue = BaseChatModel._convertInputToPromptValue(input);
-		const result = await this.generatePrompt([promptValue], options, options?.callbacks);
-		const chatGeneration = result.generations[0][0];
-		return chatGeneration.message;
+		return (await this.generatePrompt([promptValue], options, options?.callbacks)).generations[0][0].message;
 	}
 	async *_streamResponseChunks(_messages, _options, _runManager) {
 		throw new Error("Not implemented.");
 	}
+	/**
+	* Stream chat model events using the new content-block-centric protocol.
+	*
+	* Override this method to provide native event streaming from the provider SDK.
+	* The default implementation bridges from `_streamResponseChunks` by
+	* synthesizing lifecycle events from `ChatGenerationChunk` objects.
+	*
+	* ## Event lifecycle
+	*
+	* ```
+	* MessageStart
+	*   -> ContentBlockStart(index, contentBlock)
+	*     -> ContentBlockDelta(index, delta) ...
+	*   -> ContentBlockFinish(index, contentBlock)
+	* -> MessageFinish(reason, usage?)
+	* ```
+	*
+	* Content blocks may interleave (e.g., parallel tool calls). The only
+	* invariant: a block's start precedes its deltas, and its deltas precede
+	* its finish.
+	*
+	* @param messages - The input messages.
+	* @param options - Parsed call options.
+	* @param runManager - Optional callback manager for the run.
+	* @returns An async generator of {@link ChatModelStreamEvent}.
+	*/
+	async *_streamChatModelEvents(messages, options, runManager) {
+		yield* convertChunksToEvents(this._streamResponseChunks(messages, options, runManager), { signal: options.signal });
+	}
+	streamEvents(input, options, streamOptions) {
+		if (options?.version === "v1" || options?.version === "v2") return super.streamEvents(input, options, streamOptions);
+		const messages = BaseChatModel._convertInputToPromptValue(input).toChatMessages();
+		const [, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
+		return new ChatModelStream(this._streamChatModelEvents(messages, callOptions));
+	}
+	/**
+	* @deprecated Use {@link BaseChatModel.streamEvents} instead. This method will be removed in the next major version.
+	*/
+	streamV2(input, options) {
+		return this.streamEvents(input, options);
+	}
 	async *_streamIterator(input, options) {
 		if (this._streamResponseChunks === BaseChatModel.prototype._streamResponseChunks || this.disableStreaming) yield this.invoke(input, options);
 		else {
-			const prompt = BaseChatModel._convertInputToPromptValue(input);
-			const messages = prompt.toChatMessages();
+			const messages = BaseChatModel._convertInputToPromptValue(input).toChatMessages();
 			const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
 			const inheritableMetadata = {
 				...runnableConfig.metadata,
-				...this.getLsParams(callOptions)
+				...this.getLsParamsWithDefaults(callOptions)
 			};
-			const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
+			const invocationParams = this.invocationParams(callOptions);
+			const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, inheritableMetadata, 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 outputVersion = callOptions.outputVersion ?? this.outputVersion;
@@ -108,6 +152,7 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 			let llmOutput;
 			try {
 				for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
+					callOptions.signal?.throwIfAborted();
 					if (chunk.message.id == null) {
 						const runId = runManagers?.at(0)?.runId;
 						if (runId != null) chunk.message._updateId(`run-${runId}`);
@@ -126,6 +171,7 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 						totalTokens: chunk.message.usage_metadata.total_tokens
 					} };
 				}
+				callOptions.signal?.throwIfAborted();
 			} catch (err) {
 				await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
 				throw err;
@@ -144,6 +190,17 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 			ls_provider: providerName
 		};
 	}
+	/**
+	* Wraps getLsParams() and always appends ls_integration.
+	* This ensures the integration tag is present even when
+	* partner packages fully override getLsParams().
+	*/
+	getLsParamsWithDefaults(options) {
+		return {
+			...this.getLsParams(options),
+			ls_integration: "langchain_chat_model"
+		};
+	}
 	/** @ignore */
 	async _generateUncached(messages, parsedOptions, handledOptions, startedRunManagers) {
 		const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
@@ -152,12 +209,16 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 		else {
 			const inheritableMetadata = {
 				...handledOptions.metadata,
-				...this.getLsParams(parsedOptions)
+				...this.getLsParamsWithDefaults(parsedOptions)
 			};
-			const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
+			const invocationParams = this.invocationParams(parsedOptions);
+			const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, {
+				verbose: this.verbose,
+				tracerInheritableMetadata: this._filterInvocationParamsForTracing(invocationParams)
+			});
 			const extra = {
 				options: parsedOptions,
-				invocation_params: this?.invocationParams(parsedOptions),
+				invocation_params: invocationParams,
 				batch_size: 1
 			};
 			runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages.map(_formatForTracing), handledOptions.runId, void 0, extra, void 0, void 0, handledOptions.runName);
@@ -165,12 +226,57 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 		const outputVersion = parsedOptions.outputVersion ?? this.outputVersion;
 		const generations = [];
 		const llmOutputs = [];
+		const hasChatModelStreamEventHandler = !!runManagers?.[0].handlers.find(callbackHandlerPrefersChatModelStreamEvents);
 		const hasStreamingHandler = !!runManagers?.[0].handlers.find(callbackHandlerPrefersStreaming);
-		if (hasStreamingHandler && !this.disableStreaming && baseMessages.length === 1 && this._streamResponseChunks !== BaseChatModel.prototype._streamResponseChunks) try {
+		if (hasChatModelStreamEventHandler && !this.disableStreaming && baseMessages.length === 1 && (this._streamChatModelEvents !== BaseChatModel.prototype._streamChatModelEvents || this._streamResponseChunks !== BaseChatModel.prototype._streamResponseChunks)) try {
+			let sawEvent = false;
+			const runManager = runManagers?.[0];
+			const events = this._streamChatModelEvents(baseMessages[0], parsedOptions);
+			const message = await new ChatModelStream({ async *[Symbol.asyncIterator]() {
+				for await (const event of events) {
+					parsedOptions.signal?.throwIfAborted();
+					sawEvent = true;
+					const streamEvent = event.event === "message-start" && event.id == null && runManager?.runId != null ? {
+						...event,
+						id: `run-${runManager.runId}`
+					} : event;
+					await runManager?.handleChatModelStreamEvent(streamEvent);
+					yield streamEvent;
+				}
+			} });
+			parsedOptions.signal?.throwIfAborted();
+			if (!sawEvent) throw new Error("Received empty response from chat model call.");
+			if (message.id == null) {
+				const runId = runManagers?.at(0)?.runId;
+				if (runId != null) message._updateId(`run-${runId}`);
+			}
+			const generation = {
+				text: message.text,
+				message
+			};
+			generations.push([generation]);
+			const llmOutput = message.usage_metadata !== void 0 ? { tokenUsage: {
+				promptTokens: message.usage_metadata.input_tokens,
+				completionTokens: message.usage_metadata.output_tokens,
+				totalTokens: message.usage_metadata.total_tokens
+			} } : void 0;
+			await runManagers?.[0].handleLLMEnd({
+				generations,
+				llmOutput
+			});
+		} catch (e) {
+			await runManagers?.[0].handleLLMError(e);
+			throw e;
+		}
+		else if (hasStreamingHandler && !this.disableStreaming && baseMessages.length === 1 && this._streamResponseChunks !== BaseChatModel.prototype._streamResponseChunks) try {
 			const stream = await this._streamResponseChunks(baseMessages[0], parsedOptions, runManagers?.[0]);
 			let aggregated;
 			let llmOutput;
 			for await (const chunk of stream) {
+				if (parsedOptions.signal?.aborted) {
+					const partialMessage = aggregated?.message;
+					throw new ModelAbortError("Model invocation was aborted.", partialMessage);
+				}
 				if (chunk.message.id == null) {
 					const runId = runManagers?.at(0)?.runId;
 					if (runId != null) chunk.message._updateId(`run-${runId}`);
@@ -183,7 +289,12 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 					totalTokens: chunk.message.usage_metadata.total_tokens
 				} };
 			}
+			if (parsedOptions.signal?.aborted) {
+				const partialMessage = aggregated?.message;
+				throw new ModelAbortError("Model invocation was aborted.", partialMessage);
+			}
 			if (aggregated === void 0) throw new Error("Received empty response from chat model call.");
+			if (outputVersion === "v1") aggregated.message = castStandardMessageContent(aggregated.message);
 			generations.push([aggregated]);
 			await runManagers?.[0].handleLLMEnd({
 				generations,
@@ -245,23 +356,26 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 		const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
 		const inheritableMetadata = {
 			...handledOptions.metadata,
-			...this.getLsParams(parsedOptions)
+			...this.getLsParamsWithDefaults(parsedOptions)
 		};
-		const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
+		const invocationParams = this.invocationParams(parsedOptions);
+		const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, {
+			verbose: this.verbose,
+			tracerInheritableMetadata: this._filterInvocationParamsForTracing(invocationParams)
+		});
 		const extra = {
 			options: parsedOptions,
-			invocation_params: this?.invocationParams(parsedOptions),
+			invocation_params: invocationParams,
 			batch_size: 1
 		};
 		const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages.map(_formatForTracing), handledOptions.runId, void 0, extra, void 0, void 0, handledOptions.runName);
 		const missingPromptIndices = [];
-		const results = await Promise.allSettled(baseMessages.map(async (baseMessage, index) => {
+		const cachedResults = (await Promise.allSettled(baseMessages.map(async (baseMessage, index) => {
 			const prompt = BaseChatModel._convertInputToPromptValue(baseMessage).toString();
 			const result = await cache.lookup(prompt, llmStringKey);
 			if (result == null) missingPromptIndices.push(index);
 			return result;
-		}));
-		const cachedResults = results.map((result, index) => ({
+		}))).map((result, index) => ({
 			result,
 			runManager: runManagers?.[index]
 		})).filter(({ result }) => result.status === "fulfilled" && result.value != null || result.status === "rejected");
@@ -270,20 +384,20 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 		await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
 			if (promiseResult.status === "fulfilled") {
 				const result = promiseResult.value;
-				generations[i] = result.map((result$1) => {
-					if ("message" in result$1 && isBaseMessage(result$1.message) && isAIMessage(result$1.message)) {
-						result$1.message.usage_metadata = {
+				generations[i] = result.map((result) => {
+					if ("message" in result && isBaseMessage(result.message) && isAIMessage(result.message)) {
+						result.message.usage_metadata = {
 							input_tokens: 0,
 							output_tokens: 0,
 							total_tokens: 0
 						};
-						if (outputVersion === "v1") result$1.message = castStandardMessageContent(result$1.message);
+						if (outputVersion === "v1") result.message = castStandardMessageContent(result.message);
 					}
-					result$1.generationInfo = {
-						...result$1.generationInfo,
+					result.generationInfo = {
+						...result.generationInfo,
 						tokenUsage: {}
 					};
-					return result$1;
+					return result;
 				});
 				if (result.length) await runManager?.handleLLMNewToken(result[0].text);
 				return runManager?.handleLLMEnd({ generations: [result] }, void 0, void 0, void 0, { cached: true });
@@ -373,39 +487,23 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 		const includeRaw = config?.includeRaw;
 		if (method === "jsonMode") throw new Error(`Base withStructuredOutput implementation only supports "functionCalling" as a method.`);
 		let functionName = name ?? "extract";
-		let tools;
-		if (isInteropZodSchema(schema)) tools = [{
+		if (!isInteropZodSchema(schema) && !isSerializableSchema(schema) && "name" in schema) functionName = schema.name;
+		const asJsonSchema = isInteropZodSchema(schema) || isSerializableSchema(schema) ? toJsonSchema(schema) : schema;
+		const tools = [{
 			type: "function",
 			function: {
 				name: functionName,
 				description,
-				parameters: toJsonSchema(schema)
+				parameters: asJsonSchema
 			}
 		}];
-		else {
-			if ("name" in schema) functionName = schema.name;
-			tools = [{
-				type: "function",
-				function: {
-					name: functionName,
-					description,
-					parameters: schema
-				}
-			}];
-		}
-		const llm = this.bindTools(tools);
-		const outputParser = RunnableLambda.from((input) => {
+		return assembleStructuredOutputPipeline(this.bindTools(tools), RunnableLambda.from((input) => {
 			if (!AIMessageChunk.isInstance(input)) throw new Error("Input is not an AIMessageChunk.");
 			if (!input.tool_calls || input.tool_calls.length === 0) throw new Error("No tool calls found in the response.");
 			const toolCall = input.tool_calls.find((tc) => tc.name === functionName);
 			if (!toolCall) throw new Error(`No tool call found with name ${functionName}.`);
 			return toolCall.args;
-		});
-		if (!includeRaw) return llm.pipe(outputParser).withConfig({ runName: "StructuredOutput" });
-		const parserAssign = RunnablePassthrough.assign({ parsed: (input, config$1) => outputParser.invoke(input.raw, config$1) });
-		const parserNone = RunnablePassthrough.assign({ parsed: () => null });
-		const parsedWithFallback = parserAssign.withFallbacks({ fallbacks: [parserNone] });
-		return RunnableSequence.from([{ raw: llm }, parsedWithFallback]).withConfig({ runName: "StructuredOutputRunnable" });
+		}), includeRaw, includeRaw ? "StructuredOutputRunnable" : "StructuredOutput");
 	}
 };
 /**
@@ -414,8 +512,7 @@ var BaseChatModel = class BaseChatModel extends BaseLanguageModel {
 */
 var SimpleChatModel = class extends BaseChatModel {
 	async _generate(messages, options, runManager) {
-		const text = await this._call(messages, options, runManager);
-		const message = new AIMessage(text);
+		const message = new AIMessage(await this._call(messages, options, runManager));
 		if (typeof message.content !== "string") throw new Error("Cannot generate with a simple chat model when output is not a string.");
 		return { generations: [{
 			text: message.content,
@@ -423,7 +520,7 @@ var SimpleChatModel = class extends BaseChatModel {
 		}] };
 	}
 };
-
 //#endregion
 export { BaseChatModel, SimpleChatModel, chat_models_exports };
+
 //# sourceMappingURL=chat_models.js.map