@langchain/langgraph-sdk 1.4.4 → 1.4.5

package/dist/types.d.ts

@@ -0,0 +1,187 @@
+import { Checkpoint, Config, Metadata } from "./schema.js";
+import { StreamMode } from "./types.stream.js";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+
+//#region src/types.d.ts
+type MultitaskStrategy = "reject" | "interrupt" | "rollback" | "enqueue";
+type OnConflictBehavior = "raise" | "do_nothing";
+type OnCompletionBehavior = "complete" | "continue";
+type DisconnectMode = "cancel" | "continue";
+type Durability = "exit" | "async" | "sync";
+type StreamEvent = "events" | "metadata" | "debug" | "updates" | "values" | "messages/partial" | "messages/metadata" | "messages/complete" | "messages" | (string & {});
+interface Send {
+  node: string;
+  input: unknown | null;
+}
+interface Command {
+  /**
+   * An object to update the thread state with.
+   */
+  update?: Record<string, unknown> | [string, unknown][] | null;
+  /**
+   * The value to return from an `interrupt` function call.
+   */
+  resume?: unknown;
+  /**
+   * Determine the next node to navigate to. Can be one of the following:
+   * - Name(s) of the node names to navigate to next.
+   * - `Send` command(s) to execute node(s) with provided input.
+   */
+  goto?: Send | Send[] | string | string[];
+}
+interface RunsInvokePayload {
+  /**
+   * Input to the run. Pass `null` to resume from the current state of the thread.
+   */
+  input?: Record<string, unknown> | null;
+  /**
+   * Metadata for the run.
+   */
+  metadata?: Metadata;
+  /**
+   * Additional configuration for the run.
+   */
+  config?: Config;
+  /**
+   * Static context to add to the assistant.
+   * @remarks Added in LangGraph.js 0.4
+   */
+  context?: unknown;
+  /**
+   * Checkpoint ID for when creating a new run.
+   */
+  checkpointId?: string;
+  /**
+   * Checkpoint for when creating a new run.
+   */
+  checkpoint?: Omit<Checkpoint, "thread_id">;
+  /**
+   * Whether to checkpoint during the run (or only at the end/interruption).
+   * @deprecated Use `durability` instead.
+   */
+  checkpointDuring?: boolean;
+  /**
+   * Whether to checkpoint during the run (or only at the end/interruption).
+   * - `"async"`: Save checkpoint asynchronously while the next step executes (default).
+   * - `"sync"`: Save checkpoint synchronously before the next step starts.
+   * - `"exit"`: Save checkpoint only when the graph exits.
+   * @default "async"
+   */
+  durability?: Durability;
+  /**
+   * Interrupt execution before entering these nodes.
+   */
+  interruptBefore?: "*" | string[];
+  /**
+   * Interrupt execution after leaving these nodes.
+   */
+  interruptAfter?: "*" | string[];
+  /**
+   * Strategy to handle concurrent runs on the same thread. Only relevant if
+   * there is a pending/inflight run on the same thread. One of:
+   * - "reject": Reject the new run.
+   * - "interrupt": Interrupt the current run, keeping steps completed until now,
+       and start a new one.
+   * - "rollback": Cancel and delete the existing run, rolling back the thread to
+      the state before it had started, then start the new run.
+   * - "enqueue": Queue up the new run to start after the current run finishes.
+   */
+  multitaskStrategy?: MultitaskStrategy;
+  /**
+   * Abort controller signal to cancel the run.
+   */
+  signal?: AbortController["signal"];
+  /**
+   * Behavior to handle run completion. Only relevant if
+   * there is a pending/inflight run on the same thread. One of:
+   * - "complete": Complete the run.
+   * - "continue": Continue the run.
+   */
+  onCompletion?: OnCompletionBehavior;
+  /**
+   * Webhook to call when the run is complete.
+   */
+  webhook?: string;
+  /**
+   * Behavior to handle disconnection. Only relevant if
+   * there is a pending/inflight run on the same thread. One of:
+   * - "cancel": Cancel the run.
+   * - "continue": Continue the run.
+   */
+  onDisconnect?: DisconnectMode;
+  /**
+   * The number of seconds to wait before starting the run.
+   * Use to schedule future runs.
+   */
+  afterSeconds?: number;
+  /**
+   * Behavior if the specified run doesn't exist. Defaults to "reject".
+   */
+  ifNotExists?: "create" | "reject";
+  /**
+   * One or more commands to invoke the graph with.
+   */
+  command?: Command;
+  /**
+   * Callback when a run is created.
+   */
+  onRunCreated?: (params: {
+    run_id: string;
+    thread_id?: string;
+  }) => void;
+  /**
+   * @internal
+   * For LangSmith tracing purposes only. Not part of the public API.
+   */
+  _langsmithTracer?: LangChainTracer;
+}
+interface RunsStreamPayload<TStreamMode extends StreamMode | StreamMode[] = [], TSubgraphs extends boolean = false> extends RunsInvokePayload {
+  /**
+   * One of `"values"`, `"messages"`, `"messages-tuple"`, `"updates"`, `"events"`, `"debug"`, `"custom"`.
+   */
+  streamMode?: TStreamMode;
+  /**
+   * Stream output from subgraphs. By default, streams only the top graph.
+   */
+  streamSubgraphs?: TSubgraphs;
+  /**
+   * Whether the stream is considered resumable.
+   * If true, the stream can be resumed and replayed in its entirety even after disconnection.
+   */
+  streamResumable?: boolean;
+  /**
+   * Pass one or more feedbackKeys if you want to request short-lived signed URLs
+   * for submitting feedback to LangSmith with this key for this run.
+   */
+  feedbackKeys?: string[];
+}
+interface RunsCreatePayload extends RunsInvokePayload {
+  /**
+   * One of `"values"`, `"messages"`, `"messages-tuple"`, `"updates"`, `"events"`, `"debug"`, `"custom"`.
+   */
+  streamMode?: StreamMode | Array<StreamMode>;
+  /**
+   * Stream output from subgraphs. By default, streams only the top graph.
+   */
+  streamSubgraphs?: boolean;
+  /**
+   * Whether the stream is considered resumable.
+   * If true, the stream can be resumed and replayed in its entirety even after disconnection.
+   */
+  streamResumable?: boolean;
+}
+interface CronsCreatePayload extends RunsCreatePayload {
+  /**
+   * Schedule for running the Cron Job
+   */
+  schedule: string;
+}
+interface RunsWaitPayload extends RunsStreamPayload {
+  /**
+   * Raise errors returned by the run. Default is `true`.
+   */
+  raiseError?: boolean;
+}
+//#endregion
+export { Command, CronsCreatePayload, DisconnectMode, Durability, MultitaskStrategy, OnCompletionBehavior, OnConflictBehavior, RunsCreatePayload, RunsInvokePayload, RunsStreamPayload, RunsWaitPayload, StreamEvent };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["LangChainTracer","Checkpoint","Config","Metadata","StreamMode","MultitaskStrategy","OnConflictBehavior","OnCompletionBehavior","DisconnectMode","Durability","StreamEvent","Send","Command","Record","RunsInvokePayload","Omit","AbortController","RunsStreamPayload","TStreamMode","TSubgraphs","RunsCreatePayload","Array","CronsCreatePayload","RunsWaitPayload"],"sources":["../src/types.d.ts"],"sourcesContent":["import { LangChainTracer } from \"@langchain/core/tracers/tracer_langchain\";\nimport { Checkpoint, Config, Metadata } from \"./schema.js\";\nimport { StreamMode } from \"./types.stream.js\";\nexport type MultitaskStrategy = \"reject\" | \"interrupt\" | \"rollback\" | \"enqueue\";\nexport type OnConflictBehavior = \"raise\" | \"do_nothing\";\nexport type OnCompletionBehavior = \"complete\" | \"continue\";\nexport type DisconnectMode = \"cancel\" | \"continue\";\nexport type Durability = \"exit\" | \"async\" | \"sync\";\nexport type StreamEvent = \"events\" | \"metadata\" | \"debug\" | \"updates\" | \"values\" | \"messages/partial\" | \"messages/metadata\" | \"messages/complete\" | \"messages\" | (string & {});\nexport interface Send {\n    node: string;\n    input: unknown | null;\n}\nexport interface Command {\n    /**\n     * An object to update the thread state with.\n     */\n    update?: Record<string, unknown> | [string, unknown][] | null;\n    /**\n     * The value to return from an `interrupt` function call.\n     */\n    resume?: unknown;\n    /**\n     * Determine the next node to navigate to. Can be one of the following:\n     * - Name(s) of the node names to navigate to next.\n     * - `Send` command(s) to execute node(s) with provided input.\n     */\n    goto?: Send | Send[] | string | string[];\n}\nexport interface RunsInvokePayload {\n    /**\n     * Input to the run. Pass `null` to resume from the current state of the thread.\n     */\n    input?: Record<string, unknown> | null;\n    /**\n     * Metadata for the run.\n     */\n    metadata?: Metadata;\n    /**\n     * Additional configuration for the run.\n     */\n    config?: Config;\n    /**\n     * Static context to add to the assistant.\n     * @remarks Added in LangGraph.js 0.4\n     */\n    context?: unknown;\n    /**\n     * Checkpoint ID for when creating a new run.\n     */\n    checkpointId?: string;\n    /**\n     * Checkpoint for when creating a new run.\n     */\n    checkpoint?: Omit<Checkpoint, \"thread_id\">;\n    /**\n     * Whether to checkpoint during the run (or only at the end/interruption).\n     * @deprecated Use `durability` instead.\n     */\n    checkpointDuring?: boolean;\n    /**\n     * Whether to checkpoint during the run (or only at the end/interruption).\n     * - `\"async\"`: Save checkpoint asynchronously while the next step executes (default).\n     * - `\"sync\"`: Save checkpoint synchronously before the next step starts.\n     * - `\"exit\"`: Save checkpoint only when the graph exits.\n     * @default \"async\"\n     */\n    durability?: Durability;\n    /**\n     * Interrupt execution before entering these nodes.\n     */\n    interruptBefore?: \"*\" | string[];\n    /**\n     * Interrupt execution after leaving these nodes.\n     */\n    interruptAfter?: \"*\" | string[];\n    /**\n     * Strategy to handle concurrent runs on the same thread. Only relevant if\n     * there is a pending/inflight run on the same thread. One of:\n     * - \"reject\": Reject the new run.\n     * - \"interrupt\": Interrupt the current run, keeping steps completed until now,\n         and start a new one.\n     * - \"rollback\": Cancel and delete the existing run, rolling back the thread to\n        the state before it had started, then start the new run.\n     * - \"enqueue\": Queue up the new run to start after the current run finishes.\n     */\n    multitaskStrategy?: MultitaskStrategy;\n    /**\n     * Abort controller signal to cancel the run.\n     */\n    signal?: AbortController[\"signal\"];\n    /**\n     * Behavior to handle run completion. Only relevant if\n     * there is a pending/inflight run on the same thread. One of:\n     * - \"complete\": Complete the run.\n     * - \"continue\": Continue the run.\n     */\n    onCompletion?: OnCompletionBehavior;\n    /**\n     * Webhook to call when the run is complete.\n     */\n    webhook?: string;\n    /**\n     * Behavior to handle disconnection. Only relevant if\n     * there is a pending/inflight run on the same thread. One of:\n     * - \"cancel\": Cancel the run.\n     * - \"continue\": Continue the run.\n     */\n    onDisconnect?: DisconnectMode;\n    /**\n     * The number of seconds to wait before starting the run.\n     * Use to schedule future runs.\n     */\n    afterSeconds?: number;\n    /**\n     * Behavior if the specified run doesn't exist. Defaults to \"reject\".\n     */\n    ifNotExists?: \"create\" | \"reject\";\n    /**\n     * One or more commands to invoke the graph with.\n     */\n    command?: Command;\n    /**\n     * Callback when a run is created.\n     */\n    onRunCreated?: (params: {\n        run_id: string;\n        thread_id?: string;\n    }) => void;\n    /**\n     * @internal\n     * For LangSmith tracing purposes only. Not part of the public API.\n     */\n    _langsmithTracer?: LangChainTracer;\n}\nexport interface RunsStreamPayload<TStreamMode extends StreamMode | StreamMode[] = [], TSubgraphs extends boolean = false> extends RunsInvokePayload {\n    /**\n     * One of `\"values\"`, `\"messages\"`, `\"messages-tuple\"`, `\"updates\"`, `\"events\"`, `\"debug\"`, `\"custom\"`.\n     */\n    streamMode?: TStreamMode;\n    /**\n     * Stream output from subgraphs. By default, streams only the top graph.\n     */\n    streamSubgraphs?: TSubgraphs;\n    /**\n     * Whether the stream is considered resumable.\n     * If true, the stream can be resumed and replayed in its entirety even after disconnection.\n     */\n    streamResumable?: boolean;\n    /**\n     * Pass one or more feedbackKeys if you want to request short-lived signed URLs\n     * for submitting feedback to LangSmith with this key for this run.\n     */\n    feedbackKeys?: string[];\n}\nexport interface RunsCreatePayload extends RunsInvokePayload {\n    /**\n     * One of `\"values\"`, `\"messages\"`, `\"messages-tuple\"`, `\"updates\"`, `\"events\"`, `\"debug\"`, `\"custom\"`.\n     */\n    streamMode?: StreamMode | Array<StreamMode>;\n    /**\n     * Stream output from subgraphs. By default, streams only the top graph.\n     */\n    streamSubgraphs?: boolean;\n    /**\n     * Whether the stream is considered resumable.\n     * If true, the stream can be resumed and replayed in its entirety even after disconnection.\n     */\n    streamResumable?: boolean;\n}\nexport interface CronsCreatePayload extends RunsCreatePayload {\n    /**\n     * Schedule for running the Cron Job\n     */\n    schedule: string;\n}\nexport interface RunsWaitPayload extends RunsStreamPayload {\n    /**\n     * Raise errors returned by the run. Default is `true`.\n     */\n    raiseError?: boolean;\n}\n"],"mappings":";;;;;KAGYK,iBAAAA;KACAC,kBAAAA;AADAD,KAEAE,oBAAAA,GAFiB,UAAA,GAAA,UAAA;AACjBD,KAEAE,cAAAA,GAFkB,QAAA,GAAA,UAAA;AAClBD,KAEAE,UAAAA,GAFAF,MAAoB,GAAA,OAAA,GAAA,MAAA;AACpBC,KAEAE,WAAAA,GAFc,QAAA,GAAA,UAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,GAAA,kBAAA,GAAA,mBAAA,GAAA,mBAAA,GAAA,UAAA,GAAA,CAAA,MAAA,GAAA,CAAA,CAAA,CAAA;AACdD,UAEKE,IAAAA,CAFK;EACVD,IAAAA,EAAAA,MAAAA;EACKC,KAAAA,EAAI,OAAA,GAAA,IAAA;AAIrB;AAAwB,UAAPC,OAAAA,CAAO;;;;EAcF,MAAA,CAAA,EAVTC,MAUS,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAAA;EAELC;;;QAQFX,CAAAA,EAAAA,OAAAA;;;;;;MAqDFa,CAAAA,EA/DFL,IA+DEK,GA/DKL,IA+DLK,EAAAA,GAAAA,MAAAA,GAAAA,MAAAA,EAAAA;;AAkBMR,UA/EFM,iBAAAA,CA+EEN;;;;EA2BFS,KAAAA,CAAAA,EAtGLJ,MAsGKI,CAAAA,MAAiB,EAAA,OAAA,CAAA,GAAA,IAAA;EAAA;;;UAIjBC,CAAAA,EAtGFf,QAsGEe;;;;EAgBAE,MAAAA,CAAAA,EAlHJlB,MAkHIkB;EAAiB;;;;SAASN,CAAAA,EAAAA,OAAAA;EAAiB;AAe5D;AAMA;;;;;eA1HiBC,KAAKd;;;;;;;;;;;;;eAaLQ;;;;;;;;;;;;;;;;;;;sBAmBOJ;;;;WAIXW;;;;;;;iBAOMT;;;;;;;;;;;iBAWAC;;;;;;;;;;;;;YAaLI;;;;;;;;;;;;qBAYSZ;;UAENiB,sCAAsCb,aAAaA,+DAA+DU;;;;eAIlHI;;;;oBAIKC;;;;;;;;;;;;UAYLC,iBAAAA,SAA0BN;;;;eAI1BV,aAAaiB,MAAMjB;;;;;;;;;;;UAWnBkB,kBAAAA,SAA2BF;;;;;;UAM3BG,eAAAA,SAAwBN"}

package/dist/types.messages.d.cts

@@ -0,0 +1,264 @@
+//#region src/types.messages.d.ts
+type ImageDetail = "auto" | "low" | "high";
+type MessageContentImageUrl = {
+  type: "image_url";
+  image_url: string | {
+    url: string;
+    detail?: ImageDetail | undefined;
+  };
+};
+type MessageContentText = {
+  type: "text";
+  text: string;
+};
+type MessageContentComplex = MessageContentText | MessageContentImageUrl;
+type MessageContent = string | MessageContentComplex[];
+/**
+ * Model-specific additional kwargs, which is passed back to the underlying LLM.
+ */
+type MessageAdditionalKwargs = Record<string, unknown>;
+type BaseMessage = {
+  additional_kwargs?: MessageAdditionalKwargs | undefined;
+  content: MessageContent;
+  id?: string | undefined;
+  name?: string | undefined;
+  response_metadata?: Record<string, unknown> | undefined;
+};
+type HumanMessage = BaseMessage & {
+  type: "human";
+  example?: boolean | undefined;
+};
+/**
+ * Default tool call type when no specific tool definitions are provided.
+ */
+type DefaultToolCall = {
+  name: string;
+  args: {
+    [x: string]: any;
+  };
+  id?: string | undefined;
+  type?: "tool_call" | undefined;
+};
+/**
+ * Invalid tool call type.
+ */
+type InvalidToolCall = {
+  name?: string | undefined;
+  args?: string | undefined;
+  id?: string | undefined;
+  error?: string | undefined;
+  type?: "invalid_tool_call" | undefined;
+};
+/**
+ * Usage metadata for AI messages.
+ */
+type UsageMetadata = {
+  input_tokens: number;
+  output_tokens: number;
+  total_tokens: number;
+  input_token_details?: {
+    audio?: number | undefined;
+    cache_read?: number | undefined;
+    cache_creation?: number | undefined;
+  } | undefined;
+  output_token_details?: {
+    audio?: number | undefined;
+    reasoning?: number | undefined;
+  } | undefined;
+};
+/**
+ * AI message type that can be parameterized with custom tool call types.
+ *
+ * @template ToolCall The type of tool calls, defaults to DefaultToolCall.
+ *                    Provide a discriminated union for type-safe tool call handling.
+ *
+ * @example
+ * ```ts
+ * // Define typed tool calls as a discriminated union
+ * type MyToolCalls =
+ *   | { name: "get_weather"; args: { location: string }; id?: string }
+ *   | { name: "search"; args: { query: string; limit?: number }; id?: string };
+ *
+ * // Use with AIMessage
+ * const message: AIMessage<MyToolCalls> = ...;
+ *
+ * // Now tool.name === "get_weather" narrows tool.args type
+ * if (message.tool_calls) {
+ *   for (const tool of message.tool_calls) {
+ *     if (tool.name === "get_weather") {
+ *       // tool.args is now { location: string }
+ *       console.log(tool.args.location);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+type AIMessage<ToolCall = DefaultToolCall> = BaseMessage & {
+  type: "ai";
+  example?: boolean | undefined;
+  tool_calls?: ToolCall[] | undefined;
+  invalid_tool_calls?: InvalidToolCall[] | undefined;
+  usage_metadata?: UsageMetadata | undefined;
+};
+type ToolMessage = BaseMessage & {
+  type: "tool";
+  status?: "error" | "success" | undefined;
+  tool_call_id: string;
+  /**
+   * Artifact of the Tool execution which is not meant to be sent to the model.
+   *
+   * Should only be specified if it is different from the message content, e.g. if only
+   * a subset of the full tool output is being passed as message content but the full
+   * output is needed in other parts of the code.
+   */
+  artifact?: any;
+};
+type SystemMessage = BaseMessage & {
+  type: "system";
+};
+type FunctionMessage = BaseMessage & {
+  type: "function";
+};
+type RemoveMessage = BaseMessage & {
+  type: "remove";
+};
+/**
+ * Union of all message types.
+ *
+ * @template ToolCall The type of tool calls for AIMessage, defaults to DefaultToolCall.
+ */
+type Message<ToolCall = DefaultToolCall> = HumanMessage | AIMessage<ToolCall> | ToolMessage | SystemMessage | FunctionMessage | RemoveMessage;
+/**
+ * Helper type to infer schema input type, supporting both Zod v3 and v4.
+ * - Zod v4 uses `_zod.input` property
+ * - Zod v3 uses `_input` property
+ *
+ * Note: Zod v4 is checked first as it's the more specific structure.
+ */
+type InferSchemaInput<S> = S extends {
+  _zod: {
+    input: infer Args;
+  };
+} ? Args : S extends {
+  _input: infer Args;
+} ? Args : never;
+/**
+ * Helper type to extract the input type from a DynamicStructuredTool's _call method.
+ * This is more reliable than trying to infer from the schema directly because
+ * DynamicStructuredTool has the input type baked into its _call signature.
+ */
+type InferToolInput<T> = T extends {
+  _call: (arg: infer Args, ...rest: any[]) => any;
+} ? Args : T extends {
+  schema: infer S;
+} ? InferSchemaInput<S> : never;
+/**
+ * Infer a tool call type from a single tool.
+ * Works with tools created via `tool()` from `@langchain/core/tools`.
+ *
+ * For DynamicStructuredTool, this extracts the input type from the _call method,
+ * which is the most reliable source as it's the pre-computed input type.
+ *
+ * @template T The tool type (e.g., DynamicStructuredTool)
+ *
+ * @example
+ * ```ts
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ *
+ * const getWeather = tool(
+ *   async ({ location }) => `Weather in ${location}`,
+ *   { name: "get_weather", schema: z.object({ location: z.string() }) }
+ * );
+ *
+ * // Infer: { name: "get_weather"; args: { location: string }; id?: string; type?: "tool_call" }
+ * type WeatherToolCall = ToolCallFromTool<typeof getWeather>;
+ * ```
+ */
+type ToolCallFromTool<T> = T extends {
+  name: infer N;
+} ? InferToolInput<T> extends infer Args ? Args extends never ? never : Args extends Record<string, any> ? {
+  name: N;
+  args: Args;
+  id?: string;
+  type?: "tool_call";
+} : never : never : never;
+/**
+ * Infer a union of tool call types from an array of tools.
+ * Works with tools created via `tool()` from `@langchain/core/tools`.
+ *
+ * @template T A tuple/array of tools
+ *
+ * @example
+ * ```ts
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ *
+ * const getWeather = tool(
+ *   async ({ location }) => `Weather in ${location}`,
+ *   { name: "get_weather", schema: z.object({ location: z.string() }) }
+ * );
+ *
+ * const search = tool(
+ *   async ({ query }) => `Results for ${query}`,
+ *   { name: "search", schema: z.object({ query: z.string() }) }
+ * );
+ *
+ * const tools = [getWeather, search] as const;
+ *
+ * // Infer union:
+ * // | { name: "get_weather"; args: { location: string }; id?: string; type?: "tool_call" }
+ * // | { name: "search"; args: { query: string }; id?: string; type?: "tool_call" }
+ * type MyToolCalls = ToolCallsFromTools<typeof tools>;
+ * ```
+ */
+type ToolCallsFromTools<T extends readonly unknown[]> = T extends readonly [infer First, ...infer Rest] ? ToolCallFromTool<First> | ToolCallsFromTools<Rest> : never;
+/**
+ * The lifecycle state of a tool call.
+ *
+ * - `pending`: Tool call received, awaiting result
+ * - `completed`: Tool execution finished successfully
+ * - `error`: Tool execution failed (result.status === "error")
+ */
+type ToolCallState = "pending" | "completed" | "error";
+/**
+ * Represents a tool call paired with its result.
+ * Useful for rendering tool invocations and their outputs together.
+ *
+ * @template ToolCall The type of the tool call.
+ */
+type ToolCallWithResult<ToolCall = DefaultToolCall> = {
+  /**
+   * Unique identifier for this tool call.
+   * Uses the tool call's id if available, otherwise generates one from aiMessage.id and index.
+   */
+  id: string;
+  /**
+   * The tool call from the AI message.
+   */
+  call: ToolCall;
+  /**
+   * The result message from tool execution.
+   * `undefined` if the tool is still being executed or no result was received.
+   */
+  result: ToolMessage | undefined;
+  /**
+   * The AI message that initiated this tool call.
+   */
+  aiMessage: AIMessage<ToolCall>;
+  /**
+   * Index of this tool call within the AI message's tool_calls array.
+   */
+  index: number;
+  /**
+   * The current lifecycle state of the tool call.
+   *
+   * - `pending`: No result yet
+   * - `completed`: Has result with success status
+   * - `error`: Has result with error status
+   */
+  state: ToolCallState;
+};
+//#endregion
+export { AIMessage, DefaultToolCall, FunctionMessage, HumanMessage, Message, RemoveMessage, SystemMessage, ToolCallFromTool, ToolCallState, ToolCallWithResult, ToolCallsFromTools, ToolMessage };
+//# sourceMappingURL=types.messages.d.cts.map

package/dist/types.messages.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.messages.d.cts","names":["ImageDetail","MessageContentImageUrl","MessageContentText","MessageContentComplex","MessageContent","MessageAdditionalKwargs","Record","BaseMessage","HumanMessage","DefaultToolCall","InvalidToolCall","UsageMetadata","AIMessage","ToolCall","ToolMessage","SystemMessage","FunctionMessage","RemoveMessage","Message","InferSchemaInput","S","Args","InferToolInput","T","ToolCallFromTool","N","ToolCallsFromTools","First","Rest","ToolCallState","ToolCallWithResult"],"sources":["../src/types.messages.d.ts"],"sourcesContent":["type ImageDetail = \"auto\" | \"low\" | \"high\";\ntype MessageContentImageUrl = {\n    type: \"image_url\";\n    image_url: string | {\n        url: string;\n        detail?: ImageDetail | undefined;\n    };\n};\ntype MessageContentText = {\n    type: \"text\";\n    text: string;\n};\ntype MessageContentComplex = MessageContentText | MessageContentImageUrl;\ntype MessageContent = string | MessageContentComplex[];\n/**\n * Model-specific additional kwargs, which is passed back to the underlying LLM.\n */\ntype MessageAdditionalKwargs = Record<string, unknown>;\ntype BaseMessage = {\n    additional_kwargs?: MessageAdditionalKwargs | undefined;\n    content: MessageContent;\n    id?: string | undefined;\n    name?: string | undefined;\n    response_metadata?: Record<string, unknown> | undefined;\n};\nexport type HumanMessage = BaseMessage & {\n    type: \"human\";\n    example?: boolean | undefined;\n};\n/**\n * Default tool call type when no specific tool definitions are provided.\n */\nexport type DefaultToolCall = {\n    name: string;\n    args: {\n        [x: string]: any;\n    };\n    id?: string | undefined;\n    type?: \"tool_call\" | undefined;\n};\n/**\n * Invalid tool call type.\n */\nexport type InvalidToolCall = {\n    name?: string | undefined;\n    args?: string | undefined;\n    id?: string | undefined;\n    error?: string | undefined;\n    type?: \"invalid_tool_call\" | undefined;\n};\n/**\n * Usage metadata for AI messages.\n */\nexport type UsageMetadata = {\n    input_tokens: number;\n    output_tokens: number;\n    total_tokens: number;\n    input_token_details?: {\n        audio?: number | undefined;\n        cache_read?: number | undefined;\n        cache_creation?: number | undefined;\n    } | undefined;\n    output_token_details?: {\n        audio?: number | undefined;\n        reasoning?: number | undefined;\n    } | undefined;\n};\n/**\n * AI message type that can be parameterized with custom tool call types.\n *\n * @template ToolCall The type of tool calls, defaults to DefaultToolCall.\n *                    Provide a discriminated union for type-safe tool call handling.\n *\n * @example\n * ```ts\n * // Define typed tool calls as a discriminated union\n * type MyToolCalls =\n *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n *   | { name: \"search\"; args: { query: string; limit?: number }; id?: string };\n *\n * // Use with AIMessage\n * const message: AIMessage<MyToolCalls> = ...;\n *\n * // Now tool.name === \"get_weather\" narrows tool.args type\n * if (message.tool_calls) {\n *   for (const tool of message.tool_calls) {\n *     if (tool.name === \"get_weather\") {\n *       // tool.args is now { location: string }\n *       console.log(tool.args.location);\n *     }\n *   }\n * }\n * ```\n */\nexport type AIMessage<ToolCall = DefaultToolCall> = BaseMessage & {\n    type: \"ai\";\n    example?: boolean | undefined;\n    tool_calls?: ToolCall[] | undefined;\n    invalid_tool_calls?: InvalidToolCall[] | undefined;\n    usage_metadata?: UsageMetadata | undefined;\n};\nexport type ToolMessage = BaseMessage & {\n    type: \"tool\";\n    status?: \"error\" | \"success\" | undefined;\n    tool_call_id: string;\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n};\nexport type SystemMessage = BaseMessage & {\n    type: \"system\";\n};\nexport type FunctionMessage = BaseMessage & {\n    type: \"function\";\n};\nexport type RemoveMessage = BaseMessage & {\n    type: \"remove\";\n};\n/**\n * Union of all message types.\n *\n * @template ToolCall The type of tool calls for AIMessage, defaults to DefaultToolCall.\n */\nexport type Message<ToolCall = DefaultToolCall> = HumanMessage | AIMessage<ToolCall> | ToolMessage | SystemMessage | FunctionMessage | RemoveMessage;\n/**\n * Helper type to infer schema input type, supporting both Zod v3 and v4.\n * - Zod v4 uses `_zod.input` property\n * - Zod v3 uses `_input` property\n *\n * Note: Zod v4 is checked first as it's the more specific structure.\n */\ntype InferSchemaInput<S> = S extends {\n    _zod: {\n        input: infer Args;\n    };\n} ? Args : S extends {\n    _input: infer Args;\n} ? Args : never;\n/**\n * Helper type to extract the input type from a DynamicStructuredTool's _call method.\n * This is more reliable than trying to infer from the schema directly because\n * DynamicStructuredTool has the input type baked into its _call signature.\n */\ntype InferToolInput<T> = T extends {\n    _call: (arg: infer Args, ...rest: any[]) => any;\n} ? Args : T extends {\n    schema: infer S;\n} ? InferSchemaInput<S> : never;\n/**\n * Infer a tool call type from a single tool.\n * Works with tools created via `tool()` from `@langchain/core/tools`.\n *\n * For DynamicStructuredTool, this extracts the input type from the _call method,\n * which is the most reliable source as it's the pre-computed input type.\n *\n * @template T The tool type (e.g., DynamicStructuredTool)\n *\n * @example\n * ```ts\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) }\n * );\n *\n * // Infer: { name: \"get_weather\"; args: { location: string }; id?: string; type?: \"tool_call\" }\n * type WeatherToolCall = ToolCallFromTool<typeof getWeather>;\n * ```\n */\nexport type ToolCallFromTool<T> = T extends {\n    name: infer N;\n} ? InferToolInput<T> extends infer Args ? Args extends never ? never : Args extends Record<string, any> ? {\n    name: N;\n    args: Args;\n    id?: string;\n    type?: \"tool_call\";\n} : never : never : never;\n/**\n * Infer a union of tool call types from an array of tools.\n * Works with tools created via `tool()` from `@langchain/core/tools`.\n *\n * @template T A tuple/array of tools\n *\n * @example\n * ```ts\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) }\n * );\n *\n * const search = tool(\n *   async ({ query }) => `Results for ${query}`,\n *   { name: \"search\", schema: z.object({ query: z.string() }) }\n * );\n *\n * const tools = [getWeather, search] as const;\n *\n * // Infer union:\n * // | { name: \"get_weather\"; args: { location: string }; id?: string; type?: \"tool_call\" }\n * // | { name: \"search\"; args: { query: string }; id?: string; type?: \"tool_call\" }\n * type MyToolCalls = ToolCallsFromTools<typeof tools>;\n * ```\n */\nexport type ToolCallsFromTools<T extends readonly unknown[]> = T extends readonly [infer First, ...infer Rest] ? ToolCallFromTool<First> | ToolCallsFromTools<Rest> : never;\n/**\n * The lifecycle state of a tool call.\n *\n * - `pending`: Tool call received, awaiting result\n * - `completed`: Tool execution finished successfully\n * - `error`: Tool execution failed (result.status === \"error\")\n */\nexport type ToolCallState = \"pending\" | \"completed\" | \"error\";\n/**\n * Represents a tool call paired with its result.\n * Useful for rendering tool invocations and their outputs together.\n *\n * @template ToolCall The type of the tool call.\n */\nexport type ToolCallWithResult<ToolCall = DefaultToolCall> = {\n    /**\n     * Unique identifier for this tool call.\n     * Uses the tool call's id if available, otherwise generates one from aiMessage.id and index.\n     */\n    id: string;\n    /**\n     * The tool call from the AI message.\n     */\n    call: ToolCall;\n    /**\n     * The result message from tool execution.\n     * `undefined` if the tool is still being executed or no result was received.\n     */\n    result: ToolMessage | undefined;\n    /**\n     * The AI message that initiated this tool call.\n     */\n    aiMessage: AIMessage<ToolCall>;\n    /**\n     * Index of this tool call within the AI message's tool_calls array.\n     */\n    index: number;\n    /**\n     * The current lifecycle state of the tool call.\n     *\n     * - `pending`: No result yet\n     * - `completed`: Has result with success status\n     * - `error`: Has result with error status\n     */\n    state: ToolCallState;\n};\nexport {};\n"],"mappings":"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"}