langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/agents/types.d.ts

@@ -1,55 +1,119 @@
-import { AnyAnnotationRoot, PreHookAnnotation, ResponseFormatUndefined, ToAnnotationRoot } from "./annotation.js";
-import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ToolStrategy, TypedToolStrategy } from "./responses.js";
-import { ToolNode } from "./nodes/ToolNode.js";
-import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
-import { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
-import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
-import { LangGraphRunnableConfig, START, StateGraph } from "@langchain/langgraph";
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy } from "./responses.js";
+import { JumpToTarget } from "./constants.js";
+import { ClientTool, ServerTool } from "./tools.js";
+import { AgentMiddleware, AnyAnnotationRoot } from "./middleware/types.js";
+import { BaseMessage } from "@langchain/core/messages";
+import { END, START, StateGraph } from "@langchain/langgraph";
 import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
+import { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { LanguageModelLike } from "@langchain/core/language_models/base";
-import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { Messages } from "@langchain/langgraph/";
 
 //#region src/agents/types.d.ts
-type N = typeof START | "agent" | "tools";
+type N = typeof START | "model_request" | "tools";
+/**
+ * Represents information about an interrupt.
+ */
+interface Interrupt<TValue = unknown> {
+  /**
+   * The ID of the interrupt.
+   */
+  id: string;
+  /**
+   * The requests for human input.
+   */
+  value: TValue;
+}
+interface BuiltInState {
+  messages: BaseMessage[];
+  __interrupt__?: Interrupt[];
+  /**
+   * Optional property to control routing after afterModel middleware execution.
+   * When set by middleware, the agent will jump to the specified node instead of
+   * following normal routing logic. The property is automatically cleared after use.
+   *
+   * - "model_request": Jump back to the model for another LLM call
+   * - "tools": Jump to tool execution (requires tools to be available)
+   */
+  jumpTo?: JumpToTarget;
+}
+/**
+ * Base input type for `.invoke` and `.stream` methods.
+ */
+type UserInput = {
+  messages: Messages;
+};
 /**
  * Information about a tool call that has been executed.
  */
-
+interface ToolCall$1 {
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+  /**
+   * The name of the tool that was called.
+   */
+  name: string;
+  /**
+   * The arguments that were passed to the tool.
+   */
+  args: Record<string, any>;
+  /**
+   * The result of the tool call.
+   */
+  result?: unknown;
+  /**
+   * An optional error message if the tool call failed.
+   */
+  error?: string;
+}
 /**
- * Type helper to extract union type from an array of Zod schemas
+ * Information about a tool result from a tool execution.
  */
-type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;
+interface ToolResult {
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+  /**
+   * The result of the tool call.
+   */
+  result: any;
+  /**
+   * An optional error message if the tool call failed.
+   */
+  error?: string;
+}
 /**
- * Type helper to extract the structured response type from responseFormat
+ * jump targets (internal)
  */
-
-type ServerTool = Record<string, unknown>;
-type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
-type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;
-type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>["State"] & PreHookAnnotation["State"];
-interface AgentRuntime<ContextType = Record<string, unknown>> {
+type JumpTo = "model_request" | "tools" | typeof END;
+/**
+ * Information about a tool call that has been executed.
+ */
+interface ExecutedToolCall {
   /**
-   * The context of the agent.
+   * The name of the tool that was called.
    */
-  context?: ContextType;
+  name: string;
   /**
-   * The store passed to the agent.
+   * The arguments that were passed to the tool.
    */
-  store?: BaseStore;
+  args: Record<string, unknown>;
   /**
-   * The writer of the agent to write to the output stream.
+   * The ID of the tool call.
    */
-  writer?: (chunk: unknown) => void;
+  tool_id: string;
   /**
-   * An optional abort signal that indicates that the overall operation should be aborted.
+   * The result of the tool call (if available).
    */
-  signal?: AbortSignal;
+  result?: unknown;
 }
-type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, unknown> = Record<string, unknown>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
-  /** The chat model that can utilize OpenAI-style tool calling. */
-  llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;
+type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
   /**
-   * Initializes a ChatModel based on the provided model name and provider.
+   * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model
+   * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.
    * It supports various model providers and allows for runtime configuration of model parameters.
    *
    * @uses {@link initChatModel}
@@ -60,76 +124,46 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    *   // ...
    * });
    * ```
-   */
-  model?: string;
-  /** A list of tools or a ToolNode. */
-  tools: ToolNode | (ServerTool | ClientTool)[];
-  /**
-   * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.
-   *
-   * Can take a few different forms:
    *
-   * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state["messages"].
-   * - SystemMessage: this is added to the beginning of the list of messages in state["messages"].
-   * - Function: This function should take in full graph state and the output is then passed to the language model.
-   * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
-   *
-   * Note:
-   * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.
-   * This is now deprecated and will be removed in a future release.
-   *
-   * Cannot be used together with `prepareCall`.
+   * @example
+   * ```ts
+   * import { ChatOpenAI } from "@langchain/openai";
+   * const agent = createAgent({
+   *   model: new ChatOpenAI({ model: "gpt-4o" }),
+   *   // ...
+   * });
+   * ```
    */
-  prompt?: Prompt<StateSchema, ContextSchema>;
+  model: string | LanguageModelLike;
   /**
-   * Additional state schema for the agent. It allows to define additional state keys that will be
-   * persisted between agent invocations.
+   * A list of tools or a ToolNode.
    *
    * @example
    * ```ts
-   * // State schema defines data that persists across agent invocations
-   * const stateSchema = z.object({
-   *   userPreferences: z.object({
-   *     theme: z.enum(["light", "dark"]),
-   *     language: z.string(),
+   * import { tool } from "langchain";
+   *
+   * const weatherTool = tool(() => "Sunny!", {
+   *   name: "get_weather",
+   *   description: "Get the weather for a location",
+   *   schema: z.object({
+   *     location: z.string().describe("The location to get weather for"),
    *   }),
-   *   taskHistory: z.array(z.string()),
-   *   currentWorkflow: z.string().optional(),
    * });
    *
-   * // Context schema defines runtime parameters passed per invocation
-   * const contextSchema = z.object({ ... });
-   *
    * const agent = createAgent({
-   *   llm: model,
-   *   tools: [updatePreferences, addTask],
-   *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state
-   *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.
-   *   prompt: (state, config) => {
-   *     // ...
-   *   },
-   * });
-   *
-   * // First invocation - state starts empty, context provided
-   * await agent.invoke({
-   *   messages: [new HumanMessage("Set my theme to dark")],
-   * }, {
-   *   context: { userId: "user123", sessionId: "sess456", apiKeys: {...} }
-   * });
-   *
-   * // Second invocation - state persists, new context
-   * await agent.invoke({
-   *   messages: [new HumanMessage("Add a task to review code")],
-   * }, {
-   *   context: { userId: "user123", sessionId: "sess789", apiKeys: {...} }
+   *   tools: [weatherTool],
+   *   // ...
    * });
-   * // State now contains: userPreferences.theme="dark", taskHistory=["review code"]
    * ```
    */
-  stateSchema?: StateSchema;
+  tools?: (ServerTool | ClientTool)[];
+  /**
+   * An optional system message for the model.
+   */
+  systemPrompt?: string;
   /**
    * An optional schema for the context. It allows to pass in a typed context object into the agent
-   * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.
+   * invocation and allows to access it in hooks such as `prompt` and middleware.
    * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between
    * agent invocations.
    *
@@ -161,14 +195,15 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    * ```
    */
   contextSchema?: ContextSchema;
-  /** An optional checkpoint saver to persist the agent's state. */
-  checkpointSaver?: BaseCheckpointSaver | boolean;
-  /** An optional checkpoint saver to persist the agent's state. Alias of "checkpointSaver". */
+  /**
+   * An optional checkpoint saver to persist the agent's state.
+   * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}
+   */
   checkpointer?: BaseCheckpointSaver | boolean;
-  /** An optional list of node names to interrupt before running. */
-  interruptBefore?: N[] | All;
-  /** An optional list of node names to interrupt after running. */
-  interruptAfter?: N[] | All;
+  /**
+   * An optional store to persist the agent's state.
+   * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}
+   */
   store?: BaseStore;
   /**
    * An optional schema for the final agent output.
@@ -224,6 +259,13 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).
    */
   responseFormat?: ResponseFormatType;
+  /**
+   * Middleware instances to run during agent execution.
+   * Each middleware can define its own state schema and hook into the agent lifecycle.
+   *
+   * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}
+   */
+  middleware?: readonly AgentMiddleware<any, any, any>[];
   /**
    * An optional name for the agent.
    */
@@ -240,16 +282,6 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    *       Example: `"How can I help you"` -> `"<name>agent_name</name><content>How can I help you?</content>"`
    */
   includeAgentName?: "inline" | undefined;
-  /**
-   * An optional node to add before the `agent` node (i.e., the node that calls the LLM).
-   * Useful for managing long message histories (e.g., message trimming, summarization, etc.).
-   */
-  preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
-  /**
-   * An optional node to add after the `agent` node (i.e., the node that calls the LLM).
-   * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.
-   */
-  postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
   /**
    * An optional abort signal that indicates that the overall operation should be aborted.
    */
@@ -268,9 +300,10 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
   version?: "v1" | "v2";
 };
 /**
- * @deprecated likely to be removed in the next version of the agent
+ * Type helper to extract union type from an array of Zod schemas
  */
-type DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike;
+type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;
+type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;
 //#endregion
-export { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExtractZodArrayTypes, N, Prompt, ServerTool };
+export { BuiltInState, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, Interrupt, JumpTo, N, ToolCall$1 as ToolCall, ToolResult, UserInput, WithStateGraphNodes };
 //# sourceMappingURL=types.d.ts.map

package/dist/agents/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodType","LangGraphRunnableConfig","START","StateGraph","LanguageModelLike","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","DynamicTool","StructuredToolInterface","Runnable","RunnableLike","RunnableToolLike","ToolNode","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormatUndefined","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","META_EXTRAS_DESCRIPTION_PREFIX","N","ExecutedToolCall","Record","LLMCall","ExtractZodType","T","U","ExtractZodArrayTypes","Rest","A","InferResponseFormatType","ReducedZodChannel","TReducerSchema","ServerTool","ClientTool","Prompt","StateSchema","ContextSchema","Promise","AgentState","AnnotationRoot","AgentRuntime","ContextType","AbortSignal","CreateAgentParams","StructuredResponseType","DynamicLLMFunction","ResponseFormatType","InternalAgentState","WithStateGraphNodes","Graph","SD","S","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { SystemMessage, BaseMessageLike, BaseMessage } from \"@langchain/core/messages\";\nimport type { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { Runnable, RunnableLike, RunnableToolLike } from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot, ResponseFormatUndefined } from \"./annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat } from \"./responses.js\";\nexport declare const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\nexport type N = typeof START | \"agent\" | \"tools\";\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\n/**\n * Information about an LLM invocation.\n */\nexport interface LLMCall {\n    /**\n     * The messages that were sent to the LLM.\n     */\n    messages: BaseMessage[];\n    /**\n     * The response from the LLM.\n     */\n    response?: BaseMessage;\n}\n/**\n * Type helper to extract the inferred type from a single Zod schema or array of schemas\n */\nexport type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U> ? U extends Record<string, any> ? U : Record<string, any> : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : T extends ToolStrategy[] ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n : T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime\n : Record<string, any>;\n/** @internal */\nexport type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {\n    lg_reducer_schema: TReducerSchema;\n};\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\nexport type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\nexport interface AgentRuntime<ContextType = Record<string, unknown>> {\n    /**\n     * The context of the agent.\n     */\n    context?: ContextType;\n    /**\n     * The store passed to the agent.\n     */\n    store?: BaseStore;\n    /**\n     * The writer of the agent to write to the output stream.\n     */\n    writer?: (chunk: unknown) => void;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n}\nexport type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, unknown> = Record<string, unknown>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n    /**\n     * Initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     */\n    model?: string;\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     *\n     * Cannot be used together with `prepareCall`.\n     */\n    prompt?: Prompt<StateSchema, ContextSchema>;\n    /**\n     * Additional state schema for the agent. It allows to define additional state keys that will be\n     * persisted between agent invocations.\n     *\n     * @example\n     * ```ts\n     * // State schema defines data that persists across agent invocations\n     * const stateSchema = z.object({\n     *   userPreferences: z.object({\n     *     theme: z.enum([\"light\", \"dark\"]),\n     *     language: z.string(),\n     *   }),\n     *   taskHistory: z.array(z.string()),\n     *   currentWorkflow: z.string().optional(),\n     * });\n     *\n     * // Context schema defines runtime parameters passed per invocation\n     * const contextSchema = z.object({ ... });\n     *\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [updatePreferences, addTask],\n     *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state\n     *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.\n     *   prompt: (state, config) => {\n     *     // ...\n     *   },\n     * });\n     *\n     * // First invocation - state starts empty, context provided\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Set my theme to dark\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess456\", apiKeys: {...} }\n     * });\n     *\n     * // Second invocation - state persists, new context\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Add a task to review code\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess789\", apiKeys: {...} }\n     * });\n     * // State now contains: userPreferences.theme=\"dark\", taskHistory=[\"review code\"]\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","BaseCheckpointSaver","BaseStore","Messages","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","ServerTool","ClientTool","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","Graph","SD","S","U","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot } from \"./middleware/types.js\";\nimport type { ServerTool, ClientTool } from \"./tools.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput = {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     */\n    systemPrompt?: string;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt` and middleware.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n"],"mappings":";;;;;;;;;;;;KAWYqB,CAAAA,UAAWnB;AAAvB;AAIA;AAUA;AAA6B,UAVZoB,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EAAA;;;EAWJ,EAAA,EAAA,MAAA;EAKbG;AAMZ;AAyBA;EAiBYI,KAAAA,EAlEDN,MAkEO;AAIlB;AAkBYQ,UAtFKP,YAAAA,CAsFY;EAAA,QAAA,EArFflB,WAqFe,EAAA;EAAA,aAAgCqB,CAAAA,EApFzCL,SAoFyCK,EAAAA;EAAM;;;;;;;;EAA+N,MAAGb,CAAAA,EA3ExRM,YA2EwRN;;;;;AAAkFH,KAtE3Wc,SAAAA,GAsE2Wd;EAAY,QAA4CqB,EArEjavB,QAqEiauB;CAAsB;;;;AA8C3ab,UA9GTO,UAAAA,CA8GSP;EAAU;;;EAgDf,EAAA,EAsDAe,MAAAA;EAAkB;;AA2Bf;EAiBZE,IAAAA,EAAAA,MAAAA;EAAoB;;;EAA8C,IAAmBnC,EApPvF0B,MAoPuF1B,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAc;;;EAA2E,MAAwBqC,CAAAA,EAAAA,OAAAA;EAAI;;AAAK;EAC/ME,KAAAA,CAAAA,EAAAA,MAAAA;;;;;AAAyJG,UAxOpJf,UAAAA,CAwOoJe;EAAC;;;EAAU,EAAA,EAAEG,MAAAA;EAAC;;;EAAnB,MAAA,EAAA,GAAA;;;;;;;;;KAvNpJjB,MAAAA,sCAA4C1B;;;;UAIvC2B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,2CAA2CV,oBAAoBjB,mBAAmBiB,wCAAwChB,eAAe+B,0BAA0B/B,4BAA4Ba,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBoB,0BAA0BrB,aAAaqB,0BAA0BnB,iBAAiBmB,0BAA0BjB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBrbV;;;;;;;;;;;;;;;;;;;;;;WAsBPa,aAAaC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsCNc;;;;;iBAKD1B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS0B;;;;;;;wBAOKlB;;;;;;;;;;;;;;;;;;;;WAoBbmB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCnC,yBAAyBoC,oBAAoBpC,0CAA0CqC,sBAAsBrC,wBAAwBsC,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CC,cAAcrC,6EAA6EA,WAAWsC,IAAIC,GAAGC,GAAGvB,IAAIwB,GAAGC,GAAGC,GAAGC"}

package/dist/agents/utils.cjs

@@ -1,9 +1,10 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_model = require('./model.cjs');
 const require_errors = require('./errors.cjs');
 const require_constants = require('./constants.cjs');
-const require_model = require('./model.cjs');
 const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
 const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
+const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));
 
 //#region src/agents/utils.ts
 const NAME_PATTERN = /<name>(.*?)<\/name>/s;
@@ -114,24 +115,22 @@ function _removeInlineAgentName(message) {
 function isClientTool(tool) {
 	return __langchain_core_runnables.Runnable.isRunnable(tool);
 }
+/**
+* Helper function to check if a language model has a bindTools method.
+* @param llm - The language model to check if it has a bindTools method.
+* @returns True if the language model has a bindTools method, false otherwise.
+*/
 function _isChatModelWithBindTools(llm) {
 	if (!require_model.isBaseChatModel(llm)) return false;
 	return "bindTools" in llm && typeof llm.bindTools === "function";
 }
-function getPromptRunnable(prompt) {
-	let promptRunnable;
-	if (prompt == null) promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => state.messages).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
-	else if (typeof prompt === "string") {
-		const systemMessage = new __langchain_core_messages.SystemMessage(prompt);
-		promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => {
-			return [systemMessage, ...state.messages ?? []];
-		}).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
-	} else if (__langchain_core_messages.SystemMessage.isInstance(prompt)) promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
-	else if (typeof prompt === "function") promptRunnable = __langchain_core_runnables.RunnableLambda.from(prompt).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
-	else if (__langchain_core_runnables.Runnable.isRunnable(prompt)) promptRunnable = prompt;
-	else throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
-	return promptRunnable;
-}
+/**
+* Helper function to bind tools to a language model.
+* @param llm - The language model to bind tools to.
+* @param toolClasses - The tools to bind to the language model.
+* @param options - The options to pass to the language model.
+* @returns The language model with the tools bound to it.
+*/
 const _simpleBindTools = (llm, toolClasses, options = {}) => {
 	if (_isChatModelWithBindTools(llm)) return llm.bindTools(toolClasses, options);
 	if (__langchain_core_runnables.RunnableBinding.isRunnableBinding(llm) && _isChatModelWithBindTools(llm.bound)) {
@@ -157,26 +156,6 @@ const _simpleBindTools = (llm, toolClasses, options = {}) => {
 	}
 	return null;
 };
-async function bindTools(llm, toolClasses, options = {}) {
-	const model = _simpleBindTools(llm, toolClasses, options);
-	if (model) return model;
-	if (require_model.isConfigurableModel(llm)) {
-		const model$1 = _simpleBindTools(await llm._model(), toolClasses, options);
-		if (model$1) return model$1;
-	}
-	if (__langchain_core_runnables.RunnableSequence.isRunnableSequence(llm)) {
-		const modelStep = llm.steps.findIndex((step) => __langchain_core_runnables.RunnableBinding.isRunnableBinding(step) || require_model.isBaseChatModel(step) || require_model.isConfigurableModel(step));
-		if (modelStep >= 0) {
-			const model$1 = _simpleBindTools(llm.steps[modelStep], toolClasses, options);
-			if (model$1) {
-				const nextSteps = llm.steps.slice();
-				nextSteps.splice(modelStep, 1, model$1);
-				return __langchain_core_runnables.RunnableSequence.from(nextSteps);
-			}
-		}
-	}
-	throw new Error(`llm ${llm} must define bindTools method.`);
-}
 /**
 * Check if the LLM already has bound tools and throw if it does.
 *
@@ -220,9 +199,132 @@ function validateLLMHasNoBoundTools(llm) {
 * @param messages - The messages to check.
 * @returns True if the last message has tool calls, false otherwise.
 */
-function hasToolCalls(messages) {
-	const lastMessage = messages.at(-1);
-	return Boolean(__langchain_core_messages.AIMessage.isInstance(lastMessage) && lastMessage.tool_calls && lastMessage.tool_calls.length > 0);
+function hasToolCalls(message) {
+	return Boolean(__langchain_core_messages.AIMessage.isInstance(message) && message.tool_calls && message.tool_calls.length > 0);
+}
+function getPromptRunnable(prompt) {
+	let promptRunnable;
+	if (prompt == null) promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => state.messages).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
+	else if (typeof prompt === "string") {
+		const systemMessage = new __langchain_core_messages.SystemMessage(prompt);
+		promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => {
+			return [systemMessage, ...state.messages ?? []];
+		}).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
+	} else throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
+	return promptRunnable;
+}
+/**
+* Helper function to bind tools to a language model.
+* @param llm - The language model to bind tools to.
+* @param toolClasses - The tools to bind to the language model.
+* @param options - The options to pass to the language model.
+* @returns The language model with the tools bound to it.
+*/
+async function bindTools(llm, toolClasses, options = {}) {
+	const model = _simpleBindTools(llm, toolClasses, options);
+	if (model) return model;
+	if (require_model.isConfigurableModel(llm)) {
+		const model$1 = _simpleBindTools(await llm._model(), toolClasses, options);
+		if (model$1) return model$1;
+	}
+	if (__langchain_core_runnables.RunnableSequence.isRunnableSequence(llm)) {
+		const modelStep = llm.steps.findIndex((step) => __langchain_core_runnables.RunnableBinding.isRunnableBinding(step) || require_model.isBaseChatModel(step) || require_model.isConfigurableModel(step));
+		if (modelStep >= 0) {
+			const model$1 = _simpleBindTools(llm.steps[modelStep], toolClasses, options);
+			if (model$1) {
+				const nextSteps = llm.steps.slice();
+				nextSteps.splice(modelStep, 1, model$1);
+				return __langchain_core_runnables.RunnableSequence.from(nextSteps);
+			}
+		}
+	}
+	throw new Error(`llm ${llm} must define bindTools method.`);
+}
+/**
+* Compose multiple wrapToolCall handlers into a single middleware stack.
+*
+* Composes handlers so the first in the list becomes the outermost layer.
+* Each handler receives a handler callback to execute inner layers.
+*
+* @param handlers - List of handlers. First handler wraps all others.
+* @returns Composed handler, or undefined if handlers array is empty.
+*
+* @example
+* ```typescript
+* // handlers=[auth, retry] means: auth wraps retry
+* // Flow: auth calls retry, retry calls base handler
+* const auth: ToolCallWrapper = async (request, handler) => {
+*   try {
+*     return await handler(request.toolCall);
+*   } catch (error) {
+*     if (error.message === "Unauthorized") {
+*       await refreshToken();
+*       return await handler(request.toolCall);
+*     }
+*     throw error;
+*   }
+* };
+*
+* const retry: ToolCallWrapper = async (request, handler) => {
+*   for (let attempt = 0; attempt < 3; attempt++) {
+*     try {
+*       return await handler(request.toolCall);
+*     } catch (error) {
+*       if (attempt === 2) throw error;
+*     }
+*   }
+*   throw new Error("Unreachable");
+* };
+*
+* const composedHandler = chainToolCallHandlers([auth, retry]);
+* ```
+*/
+function chainToolCallHandlers(handlers) {
+	if (handlers.length === 0) return void 0;
+	if (handlers.length === 1) return handlers[0];
+	function composeTwo(outer, inner) {
+		return async (request, handler) => {
+			const innerHandler = async () => inner(request, async (tc) => handler(tc));
+			return outer(request, innerHandler);
+		};
+	}
+	let result = handlers[handlers.length - 1];
+	for (let i = handlers.length - 2; i >= 0; i--) result = composeTwo(handlers[i], result);
+	return result;
+}
+/**
+* Wrapping `wrapToolCall` invocation so we can inject middleware name into
+* the error message.
+*
+* @param middleware list of middleware passed to the agent
+* @returns single wrap function
+*/
+function wrapToolCall(middleware) {
+	const middlewareWithWrapToolCall = middleware.filter((m) => m.wrapToolCall);
+	if (middlewareWithWrapToolCall.length === 0) return;
+	return chainToolCallHandlers(middlewareWithWrapToolCall.map((m) => {
+		const originalHandler = m.wrapToolCall;
+		/**
+		* Wrap with error handling and validation
+		*/
+		const wrappedHandler = async (request, handler) => {
+			try {
+				const result = await originalHandler(request, handler);
+				/**
+				* Validate return type
+				*/
+				if (!__langchain_core_messages.ToolMessage.isInstance(result) && !(0, __langchain_langgraph.isCommand)(result)) throw new Error(`Invalid response from "wrapToolCall" in middleware "${m.name}": expected ToolMessage or Command, got ${typeof result}`);
+				return result;
+			} catch (error) {
+				/**
+				* Add middleware context to error if not already added
+				*/
+				if (error instanceof Error && !error.message.includes(`middleware "${m.name}"`)) error.message = `Error in middleware "${m.name}": ${error.message}`;
+				throw error;
+			}
+		};
+		return wrappedHandler;
+	}));
 }
 
 //#endregion
@@ -233,4 +335,5 @@ exports.getPromptRunnable = getPromptRunnable;
 exports.hasToolCalls = hasToolCalls;
 exports.isClientTool = isClientTool;
 exports.validateLLMHasNoBoundTools = validateLLMHasNoBoundTools;
+exports.wrapToolCall = wrapToolCall;
 //# sourceMappingURL=utils.cjs.map