langchain 1.0.0-alpha.4 → 1.0.0-alpha.6

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

@@ -0,0 +1,380 @@
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy } from "../responses.js";
+import { AnyAnnotationRoot, PreHookAnnotation, ToAnnotationRoot } from "../annotation.js";
+import { ToolNode } from "../nodes/ToolNode.js";
+import { AgentRuntime, ClientTool, ServerTool } from "../types.js";
+import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
+import { Runnable } from "@langchain/core/runnables";
+import { LangGraphRunnableConfig, START } from "@langchain/langgraph";
+import { InferInteropZodInput, InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+
+//#region src/agents/middlewareAgent/types.d.ts
+type N = typeof START | "model_request" | "tools";
+interface BuiltInState {
+  messages: BaseMessage[];
+}
+/**
+ * Information about a tool call that has been executed.
+ */
+interface ToolCall {
+  /**
+   * 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>;
+}
+/**
+ * Information about a tool result from a tool execution.
+ */
+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;
+}
+/**
+ * Configuration for modifying a model call at runtime.
+ * All fields are optional and only provided fields will override defaults.
+ */
+interface ModelRequest {
+  /**
+   * The model to use for this step.
+   */
+  model: LanguageModelLike;
+  /**
+   * The messages to send to the model.
+   */
+  messages: BaseMessage[];
+  /**
+   * The system message for this step.
+   */
+  systemMessage?: BaseMessage;
+  /**
+   * Tool choice configuration (model-specific format).
+   * Can be one of:
+   * - `"auto"`: means the model can pick between generating a message or calling one or more tools.
+   * - `"none"`: means the model will not call any tool and instead generates a message.
+   * - `"required"`: means the model must call one or more tools.
+   * - `{ type: "function", function: { name: string } }`: The model will use the specified function.
+   */
+  toolChoice?: "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+      name: string;
+    };
+  };
+  /**
+   * The tools to make available for this step.
+   * Can be tool names (strings) or tool instances.
+   */
+  tools: (ClientTool | ServerTool)[];
+}
+/**
+ * Runtime information available to middleware (readonly).
+ */
+interface Runtime<TContext = unknown> {
+  readonly toolCalls: ToolCall[];
+  readonly toolResults: ToolResult[];
+  // readonly tokenUsage: {
+  //   readonly inputTokens: number;
+  //   readonly outputTokens: number;
+  //   readonly totalTokens: number;
+  // };
+  readonly context: TContext;
+}
+/**
+ * Control flow interface for middleware.
+ */
+interface Controls<TState = unknown> {
+  jumpTo(target: "model" | "tools", stateUpdate?: Partial<TState>): ControlAction<TState>;
+  terminate(result?: Partial<TState> | Error): ControlAction<TState>;
+}
+/**
+ * Control action type returned by control methods.
+ */
+type ControlAction<TStateSchema> = {
+  type: "jump" | "terminate" | "retry";
+  target?: string;
+  stateUpdate?: Partial<TStateSchema>;
+  result?: any;
+  error?: Error;
+};
+/**
+ * Result type for middleware functions.
+ */
+type MiddlewareResult<TState> = TState | void;
+/**
+ * Type for the agent's built-in state properties.
+ */
+type AgentBuiltInState = {
+  messages: BaseMessage[];
+};
+/**
+ * Helper type to filter out properties that start with underscore (private properties)
+ */
+type FilterPrivateProps<T> = { [K in keyof T as K extends `_${string}` ? never : K]: T[K] };
+/**
+ * Helper type to infer the state schema type from a middleware
+ * This filters out private properties (those starting with underscore)
+ */
+type InferMiddlewareState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends z.ZodObject<any> ? FilterPrivateProps<z.infer<S>> : {} : {};
+/**
+ * Helper type to infer the input state schema type from a middleware (all properties optional)
+ * This filters out private properties (those starting with underscore)
+ */
+type InferMiddlewareInputState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends z.ZodObject<any> ? FilterPrivateProps<z.input<S>> : {} : {};
+/**
+ * Helper type to infer merged state from an array of middleware (just the middleware states)
+ */
+type InferMiddlewareStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};
+/**
+ * Helper type to infer merged input state from an array of middleware (with optional defaults)
+ */
+type InferMiddlewareInputStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};
+/**
+ * Helper type to infer merged state from an array of middleware (includes built-in state)
+ */
+
+/**
+ * Helper type to infer the input context schema type from a middleware (with optional defaults)
+ */
+type InferMiddlewareContextInput<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends z.ZodObject<any> ? z.input<C> : {} : {};
+/**
+ * Helper type to infer merged context from an array of middleware
+ */
+
+/**
+ * Helper type to infer merged input context from an array of middleware (with optional defaults)
+ */
+type InferMiddlewareContextInputs<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareContextInput<First> & InferMiddlewareContextInputs<Rest> : InferMiddlewareContextInput<First> : {} : {};
+/**
+ * Base middleware interface.
+ */
+interface AgentMiddleware<TSchema extends z.ZodObject<z.ZodRawShape> | undefined = undefined, TContextSchema extends z.ZodObject<z.ZodRawShape> | undefined = undefined, TFullContext = any> {
+  stateSchema?: TSchema;
+  contextSchema?: TContextSchema;
+  name: string;
+  /**
+   * Runs before each LLM call, can modify call parameters, changes are not persistent
+   * e.g. if you change `model`, it will only be changed for the next model call
+   *
+   * @param options - Current call options (can be modified by previous middleware)
+   * @param state - Current state (read-only in this phase)
+   * @param runtime - Runtime context and metadata
+   * @returns Modified options or undefined to pass through
+   */
+  prepareModelRequest?(request: ModelRequest, state: (TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<Partial<ModelRequest> | void> | Partial<ModelRequest> | void;
+  beforeModel?(state: (TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>, controls: Controls<(TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState>): Promise<MiddlewareResult<Partial<TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}>>>;
+  afterModel?(state: (TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>, controls: Controls<(TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState>): Promise<MiddlewareResult<Partial<TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}>>>;
+}
+/**
+ * Information about a tool call that has been executed.
+ */
+
+/**
+ * Duplicate of the Prompt type from ../types.ts
+ */
+type Prompt<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: AgentBuiltInState, config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;
+type DynamicLLMFunction<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: AgentBuiltInState & PreHookAnnotation["State"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike;
+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> = {
+  /** The chat model that can utilize OpenAI-style tool calling. */
+  llm?: LanguageModelLike | DynamicLLMFunction<ContextSchema>;
+  /**
+   * 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}
+   * @example
+   * ```ts
+   * const agent = createAgent({
+   *   model: "anthropic:claude-3-7-sonnet-latest",
+   *   // ...
+   * });
+   * ```
+   */
+  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 `prepareModelRequest`.
+   */
+  prompt?: Prompt<ContextSchema>;
+  /**
+   * 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` and middleware.
+   * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between
+   * agent invocations.
+   *
+   * @example
+   * ```ts
+   * const agent = createAgent({
+   *   llm: model,
+   *   tools: [getWeather],
+   *   contextSchema: z.object({
+   *     capital: z.string(),
+   *   }),
+   *   prompt: (state, config) => {
+   *     return [
+   *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),
+   *     ];
+   *   },
+   * });
+   *
+   * const result = await agent.invoke({
+   *   messages: [
+   *     new SystemMessage("You are a helpful assistant."),
+   *     new HumanMessage("What is the capital of France?"),
+   *   ],
+   * }, {
+   *   context: {
+   *     capital: "Paris",
+   *   },
+   * });
+   * ```
+   */
+  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". */
+  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;
+  store?: BaseStore;
+  /**
+   * An optional schema for the final agent output.
+   *
+   * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.
+   * If not provided, `structuredResponse` will not be present in the output state.
+   *
+   * Can be passed in as:
+   *   - Zod schema
+   *     ```ts
+   *     const agent = createAgent({
+   *       responseFormat: z.object({
+   *         capital: z.string(),
+   *       }),
+   *       // ...
+   *     });
+   *     ```
+   *   - JSON schema
+   *     ```ts
+   *     const agent = createAgent({
+   *       responseFormat: {
+   *         type: "json_schema",
+   *         schema: {
+   *           type: "object",
+   *           properties: {
+   *             capital: { type: "string" },
+   *           },
+   *           required: ["capital"],
+   *         },
+   *       },
+   *       // ...
+   *     });
+   *     ```
+   *   - Create React Agent ResponseFormat
+   *     ```ts
+   *     import { providerStrategy, toolStrategy } from "langchain";
+   *     const agent = createAgent({
+   *       responseFormat: providerStrategy(
+   *         z.object({
+   *           capital: z.string(),
+   *         })
+   *       ),
+   *       // or
+   *       responseFormat: [
+   *         toolStrategy({ ... }),
+   *         toolStrategy({ ... }),
+   *       ]
+   *       // ...
+   *     });
+   *     ```
+   *
+   * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.
+   * 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.
+   */
+  middleware?: readonly AgentMiddleware<any, any, any>[];
+  /**
+   * An optional name for the agent.
+   */
+  name?: string;
+  /**
+   * An optional description for the agent.
+   * This can be used to describe the agent to the underlying supervisor LLM.
+   */
+  description?: string;
+  /**
+   * Use to specify how to expose the agent name to the underlying supervisor LLM.
+   *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.
+   *   - `"inline"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.
+   *       Example: `"How can I help you"` -> `"<name>agent_name</name><content>How can I help you?</content>"`
+   */
+  includeAgentName?: "inline" | undefined;
+  /**
+   * An optional abort signal that indicates that the overall operation should be aborted.
+   */
+  signal?: AbortSignal;
+  /**
+   * Determines the version of the graph to create.
+   *
+   * Can be one of
+   * - `"v1"`: The tool node processes a single message. All tool calls in the message are
+   *           executed in parallel within the tool node.
+   * - `"v2"`: The tool node processes a single tool call. Tool calls are distributed across
+   *           multiple instances of the tool node using the Send API.
+   *
+   * @default `"v2"`
+   */
+  version?: "v1" | "v2";
+};
+/**
+ * Helper type to check if all properties of a type are optional
+ */
+type IsAllOptional<T> = T extends Record<string, any> ? {} extends T ? true : false : true;
+/**
+ * Helper type to extract input type from context schema (with optional defaults)
+ */
+type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>["State"] : {};
+/**
+ * Helper type to get the required config type based on context schema
+ */
+//#endregion
+export { AgentBuiltInState, AgentMiddleware, BuiltInState, Controls, CreateAgentParams, InferContextInput, InferMiddlewareContextInputs, InferMiddlewareInputStates, InferMiddlewareStates, IsAllOptional, MiddlewareResult, ModelRequest, Runtime };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["z","InteropZodObject","InteropZodType","InferInteropZodInput","LangGraphRunnableConfig","START","LanguageModelLike","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","Runnable","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormatUndefined","JsonSchemaFormat","ToolNode","ClientTool","ServerTool","AgentRuntime","N","BuiltInState","ToolCall","Record","ToolResult","ModelRequest","Runtime","TContext","Controls","TState","Partial","ControlAction","Error","TStateSchema","MiddlewareResult","AgentBuiltInState","FilterPrivateProps","T","K","InferMiddlewareState","AgentMiddleware","S","ZodObject","infer","InferMiddlewareInputState","input","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","InferMiddlewareContexts","InferMiddlewareContextInputs","ZodRawShape","TSchema","TContextSchema","TFullContext","Promise","ExecutedToolCall","LLMCall","Prompt","ContextSchema","DynamicLLMFunction","CreateAgentParams","StructuredResponseType","ResponseFormatType","AbortSignal","IsAllOptional","InferContextInput","InferAgentConfig","TMiddleware","InternalAgentState"],"sources":["../../../src/agents/middlewareAgent/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport type { InteropZodObject, InteropZodType, InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START } 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 { Runnable } from \"@langchain/core/runnables\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, ResponseFormatUndefined, JsonSchemaFormat } from \"../responses.js\";\nimport type { ToolNode } from \"../nodes/ToolNode.js\";\nimport type { ClientTool, ServerTool, AgentRuntime } from \"../types.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\nexport interface BuiltInState {\n    messages: BaseMessage[];\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/**\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 * Configuration for modifying a model call at runtime.\n * All fields are optional and only provided fields will override defaults.\n */\nexport interface ModelRequest {\n    /**\n     * The model to use for this step.\n     */\n    model: LanguageModelLike;\n    /**\n     * The messages to send to the model.\n     */\n    messages: BaseMessage[];\n    /**\n     * The system message for this step.\n     */\n    systemMessage?: BaseMessage;\n    /**\n     * Tool choice configuration (model-specific format).\n     * Can be one of:\n     * - `\"auto\"`: means the model can pick between generating a message or calling one or more tools.\n     * - `\"none\"`: means the model will not call any tool and instead generates a message.\n     * - `\"required\"`: means the model must call one or more tools.\n     * - `{ type: \"function\", function: { name: string } }`: The model will use the specified function.\n     */\n    toolChoice?: \"auto\" | \"none\" | \"required\" | {\n        type: \"function\";\n        function: {\n            name: string;\n        };\n    };\n    /**\n     * The tools to make available for this step.\n     * Can be tool names (strings) or tool instances.\n     */\n    tools: (ClientTool | ServerTool)[];\n}\n/**\n * Runtime information available to middleware (readonly).\n */\nexport interface Runtime<TContext = unknown> {\n    readonly toolCalls: ToolCall[];\n    readonly toolResults: ToolResult[];\n    // readonly tokenUsage: {\n    //   readonly inputTokens: number;\n    //   readonly outputTokens: number;\n    //   readonly totalTokens: number;\n    // };\n    readonly context: TContext;\n}\n/**\n * Control flow interface for middleware.\n */\nexport interface Controls<TState = unknown> {\n    jumpTo(target: \"model\" | \"tools\", stateUpdate?: Partial<TState>): ControlAction<TState>;\n    terminate(result?: Partial<TState> | Error): ControlAction<TState>;\n}\n/**\n * Control action type returned by control methods.\n */\nexport type ControlAction<TStateSchema> = {\n    type: \"jump\" | \"terminate\" | \"retry\";\n    target?: string;\n    stateUpdate?: Partial<TStateSchema>;\n    result?: any;\n    error?: Error;\n};\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = TState | void;\n/**\n * Type for the agent's built-in state properties.\n */\nexport type AgentBuiltInState = {\n    messages: BaseMessage[];\n};\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends z.ZodObject<any> ? FilterPrivateProps<z.infer<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends z.ZodObject<any> ? FilterPrivateProps<z.input<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware<any, any, any>[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware<any, any, any>[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends z.ZodObject<any> ? z.infer<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends z.ZodObject<any> ? z.input<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareContextInput<First> & InferMiddlewareContextInputs<Rest> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends z.ZodObject<z.ZodRawShape> | undefined = undefined, TContextSchema extends z.ZodObject<z.ZodRawShape> | undefined = undefined, TFullContext = any> {\n    stateSchema?: TSchema;\n    contextSchema?: TContextSchema;\n    name: string;\n    /**\n     * Runs before each LLM call, can modify call parameters, changes are not persistent\n     * e.g. if you change `model`, it will only be changed for the next model call\n     *\n     * @param options - Current call options (can be modified by previous middleware)\n     * @param state - Current state (read-only in this phase)\n     * @param runtime - Runtime context and metadata\n     * @returns Modified options or undefined to pass through\n     */\n    prepareModelRequest?(request: ModelRequest, state: (TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<Partial<ModelRequest> | void> | Partial<ModelRequest> | void;\n    beforeModel?(state: (TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>, controls: Controls<(TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState>): Promise<MiddlewareResult<Partial<TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}>>>;\n    afterModel?(state: (TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>, controls: Controls<(TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}) & AgentBuiltInState>): Promise<MiddlewareResult<Partial<TSchema extends z.ZodObject<any> ? z.infer<TSchema> : {}>>>;\n}\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 * Duplicate of the Prompt type from ../types.ts\n */\nexport type Prompt<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: AgentBuiltInState, config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type DynamicLLMFunction<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: AgentBuiltInState & PreHookAnnotation[\"State\"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\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    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<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 `prepareModelRequest`.\n     */\n    prompt?: Prompt<ContextSchema>;\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    /** 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     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\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 * Helper type to check if all properties of a type are optional\n */\nexport type IsAllOptional<T> = T extends Record<string, any> ? {} extends T ? true : false : true;\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\n/**\n * Helper type to get the required config type based on context schema\n */\nexport type InferAgentConfig<ContextSchema extends AnyAnnotationRoot | InteropZodObject, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = IsAllOptional<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> extends true ? LangGraphRunnableConfig<{\n    context?: InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>;\n}> | undefined : LangGraphRunnableConfig<{\n    context: InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>;\n}>;\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n    __preparedModelOptions?: ModelRequest;\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport {};\n"],"mappings":";;;;;;;;;;;;;KAYY2B,CAAAA,UAAWtB;AAAXsB,UACKC,YAAAA,CADW;EACXA,QAAAA,EACHnB,WADe,EAAA;AAM7B;AAiBA;AAkBA;;AAIWH,UAvCMuB,QAAAA,CAuCNvB;EAAiB;;;EA2BN,EAAA,EAAGmB,MAAAA;EAAU;AAKnC;;EAAwB,IACAI,EAAAA,MAAAA;EAAQ;;AAOF;EAKbM,IAAAA,EAxEPL,MAwEe,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;AAC6CQ,UApErDP,UAAAA,CAoEqDO;EAAa;;;EACrC,EAAA,EAAiBF,MAAAA;EAAM;AAAP;AAK9D;EAAyB,MAAA,EAAA,GAAA;EAAA;;;EAKR,KAAA,CAAA,EAAA,MAAA;AAKjB;AAIA;AAEE;;;AAKmBS,UA7EJb,YAAAA,CA6EIa;EAAC;;;EAAuC,KAAA,EAzElDvC,iBAyEkD;EAMjDwC;;;EAA8C,QAAmBF,EA3E/DnC,WA2E+DmC,EAAAA;EAAC;;;EAAmE,aAAmCI,CAAAA,EAvEhKvC,WAuEgKuC;EAAC;;AAAV;AAK3K;;;;;EAA2G,UAAsBA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,UAAAA,GAAAA;IAAUhD,IAAEiD,EAAAA,UAAAA;IAA4CD,QAAAA,EAAAA;MAANI,IAAAA,EAAAA,MAAAA;IAArBT,CAAAA;EAAkB,CAAA;EAIpKU;;;;EAA8E,KAA4BT,EAAAA,CA7D1GpB,UA6D0GoB,GA7D7FnB,UA6D6FmB,CAAAA,EAAAA;;;;;AAA+KU,UAxDpRrB,OAwDoRqB,CAAAA,WAAAA,OAAAA,CAAAA,CAAAA;EAAK,SAA1BR,SAAAA,EAvDxPjB,QAuDwPiB,EAAAA;EAAoB,SAAgCS,WAAAA,EAtD1SxB,UAsD0SwB,EAAAA;EAAI;EAAL;EAAmC;EAAN;EAIpVC;EAA0B,SAAA,OAAA,EApDhBtB,QAoDgB;;;;;AAAqJa,UA/C1KZ,QA+C0KY,CAAAA,SAAAA,OAAAA,CAAAA,CAAAA;EAAe,MAAkBQ,CAAAA,MAAAA,EAAAA,OAAAA,GAAAA,OAAAA,EAAAA,WAAAA,CAAAA,EA9CxKlB,OA8CwKkB,CA9ChKnB,MA8CgKmB,CAAAA,CAAAA,EA9CtJjB,aA8CsJiB,CA9CxInB,MA8CwImB,CAAAA;EAAI,SAAkBR,CAAAA,MAAAA,CAAAA,EA7C3NV,OA6C2NU,CA7CnNX,MA6CmNW,CAAAA,GA7CzMR,KA6CyMQ,CAAAA,EA7CjMT,aA6CiMS,CA7CnLX,MA6CmLW,CAAAA;;;;;AAAmIO,KAxCzWhB,aAwCyWgB,CAAAA,YAAAA,CAAAA,GAAAA;EAAK,IAA/BH,EAAAA,MAAAA,GAAAA,WAAAA,GAAAA,OAAAA;EAAyB,MAAA,CAAA,EAAA,MAAA;EAgBxWU,WAAAA,CAAAA,EArDMxB,OAqDNwB,CArDcrB,YAqDa,CAAA;EAAA,MAAA,CAAA,EAAA,GAAA;EAAA,KAAWO,CAAAA,EAnDtCR,KAmDsCQ;CAAe;;;;AAAuGa,KA9C5JnB,gBA8C4JmB,CAAAA,MAAAA,CAAAA,GA9CjIxB,MA8CiIwB,GAAAA,IAAAA;;AAAD;AAQvK;AAAwC,KAlD5BlB,iBAAAA,GAkD4B;EAAA,QAAoBK,EAjD9CtC,WAiD8CsC,EAAAA;CAAe;;;;KA5CtEJ,kBA4CyNY,CAAAA,CAAAA,CAAAA,GAAAA,QAAsBR,MA3CpOH,CA2CoOG,IA3C/NF,CA2C+NE,SAAAA,IAAAA,MAAAA,EAAAA,GAAAA,KAAAA,GA3C9LF,CA2C8LE,GA3C1LH,CA2C0LG,CA3CxLF,CA2CwLE,CAAAA,EAAe;;;;;AAA8Fc,KArCrVf,oBAqCqVe,CAAAA,UArCtTd,eAqCsTc,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GArCpRjB,CAqCoRiB,SArC1Qd,eAqC0Qc,CAAAA,KAAAA,EAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,GArCrOb,CAqCqOa,SArC3N7D,CAAAA,CAAEiD,SAqCyNY,CAAAA,GAAAA,CAAAA,GArCxMlB,kBAqCwMkB,CArCrL7D,CAAAA,CAAEkD,KAqCmLW,CArC7Kb,CAqC6Ka,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;AAA2B;AAI5X;;;AAAiD7D,KApCrCmD,yBAoCuCF,CAAAA,UApCHF,eAoCGE,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GApC+BL,CAoC/BK,SApCyCF,eAoCzCE,CAAAA,KAAAA,EAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,GApC8ED,CAoC9EC,SApCwFjD,CAAAA,CAAEiD,SAoC1FA,CAAAA,GAAAA,CAAAA,GApC2GN,kBAoC3GM,CApC8HjD,CAAAA,CAAEoD,KAoChIH,CApCsID,CAoCtIC,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;AAE/BiB,KAlCRb,qBAkCQa,CAAAA,UAAAA,SAlCiCnB,eAkCjCmB,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,GAlCqEtB,CAkCrEsB,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAlCkGtB,CAkClGsB,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GAlCoJZ,KAkCpJY,SAlCkKnB,eAkClKmB,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,GAlCmMX,IAkCnMW,SAAAA,SAlCyNnB,eAkCzNmB,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,EAAAA,GAlC4PpB,oBAkC5PoB,CAlCiRZ,KAkCjRY,CAAAA,GAlC0Rb,qBAkC1Ra,CAlCgTX,IAkChTW,CAAAA,GAlCwTpB,oBAkCxToB,CAlC6UZ,KAkC7UY,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;AAW+ED,KAzCvFT,0BAyCuFS,CAAAA,UAAAA,SAzCzClB,eAyCyCkB,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,GAzCLrB,CAyCKqB,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAzCwBrB,CAyCxBqB,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GAzC0EX,KAyC1EW,SAzCwFlB,eAyCxFkB,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,GAzCyHV,IAyCzHU,SAAAA,SAzC+IlB,eAyC/IkB,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,EAAAA,GAzCkLd,yBAyClLc,CAzC4MX,KAyC5MW,CAAAA,GAzCqNT,0BAyCrNS,CAzCgPV,IAyChPU,CAAAA,GAzCwPd,yBAyCxPc,CAzCkRX,KAyClRW,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;;;;;AACchC,KA1BrG4B,2BA0BqG5B,CAAAA,UA1B/Dc,eA0B+Dd,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GA1B7BW,CA0B6BX,SA1BnBc,eA0BmBd,CAAAA,GAAAA,EAAAA,KAAAA,EAAAA,EAAAA,GAAAA,CAAAA,GA1BkB2B,CA0BlB3B,SA1B4BjC,CAAAA,CAAEiD,SA0B9BhB,CAAAA,GAAAA,CAAAA,GA1B+CjC,CAAAA,CAAEoD,KA0BjDnB,CA1BuD2B,CA0BvD3B,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;;;;;AAA6KjC,KAlBlR+D,4BAkBoRd,CAAAA,UAAAA,SAlBpOF,eAkBoOE,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,GAlBhML,CAkBgMK,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAlBnKL,CAkBmKK,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GAlBjHK,KAkBiHL,SAlBnGF,eAkBmGE,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,GAlBlEM,IAkBkEN,SAAAA,SAlB5CF,eAkB4CE,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,EAAAA,GAlBTY,2BAkBSZ,CAlBmBK,KAkBnBL,CAAAA,GAlB4Bc,4BAkB5Bd,CAlByDM,IAkBzDN,CAAAA,GAlBiEY,2BAkBjEZ,CAlB6FK,KAkB7FL,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;AAA3CR,UAdpOM,eAcoON,CAAAA,gBAdpMzC,CAAAA,CAAEiD,SAckMR,CAdxLzC,CAAAA,CAAEgE,WAcsLvB,CAAAA,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,uBAdzHzC,CAAAA,CAAEiD,SAcuHR,CAd7GzC,CAAAA,CAAEgE,WAc2GvB,CAAAA,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,eAAAA,GAAAA,CAAAA,CAAAA;EAAgB,WAAxB2B,CAAAA,EAb3NH,OAa2NG;EAAO,aAC5NH,CAAAA,EAbJC,cAaID;EAAO,IAASjE,EAAEiD,MAAAA;EAAS;;;;;;;;;EAAkJ,mBAAkBP,EAAAA,OAAAA,EAFrLV,YAEqLU,EAAAA,KAAAA,EAAAA,CAF/JuB,OAE+JvB,SAF/I1C,CAAAA,CAAEiD,SAE6IP,CAAAA,GAAAA,CAAAA,GAF5H1C,CAAAA,CAAEkD,KAE0HR,CAFpHuB,OAEoHvB,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,GAFnGA,iBAEmGA,EAAAA,OAAAA,EAFvET,OAEuES,CAF/DyB,YAE+DzB,CAAAA,CAAAA,EAF/C0B,OAE+C1B,CAFvCL,OAEuCK,CAF/BV,YAE+BU,CAAAA,GAAAA,IAAAA,CAAAA,GAFPL,OAEOK,CAFCV,YAEDU,CAAAA,GAAAA,IAAAA;EAAiB,WAAvFP,EAAAA,KAAAA,EAAAA,CADxH8B,OACwH9B,SADxGnC,CAAAA,CAAEiD,SACsGd,CAAAA,GAAAA,CAAAA,GADrFnC,CAAAA,CAAEkD,KACmFf,CAD7E8B,OAC6E9B,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,GAD5DO,iBAC4DP,EAAAA,OAAAA,EADhCF,OACgCE,CADxBgC,YACwBhC,CAAAA,EAAAA,QAAAA,EADCA,QACDA,CAAAA,CADW8B,OACX9B,SAD2BnC,CAAAA,CAAEiD,SAC7Bd,CAAAA,GAAAA,CAAAA,GAD8CnC,CAAAA,CAAEkD,KAChDf,CADsD8B,OACtD9B,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,GADuEO,iBACvEP,CAAAA,CAAAA,EAD4FiC,OAC5FjC,CADoGM,gBACpGN,CADqHE,OACrHF,CAD6H8B,OAC7H9B,SAD6InC,CAAAA,CAAEiD,SAC/Id,CAAAA,GAAAA,CAAAA,GADgKnC,CAAAA,CAAEkD,KAClKf,CADwK8B,OACxK9B,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA;EAAQ,UAAoH8B,EAAAA,KAAAA,EAAAA,CAArPA,OAAqPA,SAArOjE,CAAAA,CAAEiD,SAAmOgB,CAAAA,GAAAA,CAAAA,GAAlNjE,CAAAA,CAAEkD,KAAgNe,CAA1MA,OAA0MA,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,GAAzLvB,iBAAyLuB,EAAAA,OAAAA,EAA7JhC,OAA6JgC,CAArJE,YAAqJF,CAAAA,EAAAA,QAAAA,EAA5H9B,QAA4H8B,CAAAA,CAAlHA,OAAkHA,SAAlGjE,CAAAA,CAAEiD,SAAgGgB,CAAAA,GAAAA,CAAAA,GAA/EjE,CAAAA,CAAEkD,KAA6Ee,CAAvEA,OAAuEA,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,GAAtDvB,iBAAsDuB,CAAAA,CAAAA,EAAjCG,OAAiCH,CAAzBxB,gBAAyBwB,CAAR5B,OAAQ4B,CAAAA,OAAAA,SAAgBjE,CAAAA,CAAEiD,SAAlBgB,CAAAA,GAAAA,CAAAA,GAAmCjE,CAAAA,CAAEkD,KAArCe,CAA2CA,OAA3CA,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA;;;;;;AAwCc;AAC3R;;AAA6DnC,KAFjDyC,MAEiDzC,CAAAA,sBAFpBf,iBAEoBe,GAFA7B,gBAEA6B,GAFmBf,iBAEnBe,CAAAA,GAFwCvB,aAExCuB,GAAAA,MAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAF0EY,iBAE1EZ,EAAAA,MAAAA,EAFqG1B,uBAErG0B,CAF6Hd,gBAE7Hc,CAF8I0C,aAE9I1C,CAAAA,CAAAA,OAAAA,CAAAA,CAAAA,EAAAA,GAF2KtB,eAE3KsB,EAAAA,GAF+LsC,OAE/LtC,CAFuMtB,eAEvMsB,EAAAA,CAAAA,CAAAA,GAF6NjB,QAE7NiB;AAAsBA,KADvE2C,kBACuE3C,CAAAA,sBAD9Bf,iBAC8Be,GADV7B,gBACU6B,GADSf,iBACTe,CAAAA,GAAAA,CAAAA,KAAAA,EADsCY,iBACtCZ,GAD0DhB,iBAC1DgB,CAAAA,OAAAA,CAAAA,EAAAA,OAAAA,EAD+FJ,YAC/FI,CAD4Gd,gBAC5Gc,CAD6H0C,aAC7H1C,CAAAA,CAAAA,OAAAA,CAAAA,CAAAA,EAAAA,GAD0JsC,OAC1JtC,CADkKxB,iBAClKwB,CAAAA,GADuLxB,iBACvLwB;AAA2Cf,KAAlH2D,iBAAkH3D,CAAAA,+BAAjEe,MAAiEf,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAA3Ce,MAA2Cf,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,sBAAAA,iBAAAA,GAAoBd,gBAApBc,GAAuCA,iBAAvCA,EAAAA,qBAA+Eb,cAA/Ea,CAA8F4D,sBAA9F5D,CAAAA,GAAwHb,cAAxHa,CAAAA,OAAAA,CAAAA,EAAAA,GAAoJO,gBAApJP,GAAuKO,gBAAvKP,EAAAA,GAA4LE,cAA5LF,GAA6MI,iBAA7MJ,CAA+N4D,sBAA/N5D,CAAAA,GAAyPG,YAAzPH,CAAsQ4D,sBAAtQ5D,CAAAA,GAAgSK,gBAAhSL,CAAiT4D,sBAAjT5D,CAAAA,GAA2UM,uBAA3UN,CAAAA,GAAAA;EAAiB;EAAmB,GAAGA,CAAAA,EAE3JT,iBAF2JS,GAEvI0D,kBAFuI1D,CAEpHyD,aAFoHzD,CAAAA;EAAiB;;;;;;;;;;;;;EAA0S,KAEtdT,CAAAA,EAAAA,MAAAA;EAAiB;EAAmC,KAAhCmE,CAAAA,EAgBlBlD,QAhBkBkD,GAAAA,CAgBNhD,UAhBMgD,GAgBOjD,UAhBPiD,CAAAA,EAAAA;EAAkB;;;;;;;;;;;;;;;;EA2JxB,MAAA,CAAA,EA1HXF,MA0HW,CA1HJC,aA0HI,CAAA;EAiBZM;;;;;AAA+D;AAI3E;;;;;;;;;;;;AAAqO;;;;;;;;;;;;;;;kBA7GjNN;;oBAEE7D;;iBAEHA;;oBAEGgB,MAAMjB;;mBAEPiB,MAAMjB;UACfE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDSgE;;;;;wBAKK7B;;;;;;;;;;;;;;;;;;;;WAoBb8B;;;;;;;;;;;;;;;;;KAiBDC,mBAAmBlC,UAAUd,iCAAiCc;;;;KAI9DmC,wCAAwChE,oBAAoBd,oBAAoBuE,sBAAsBvE,mBAAmBE,qBAAqBqE,iBAAiBA,sBAAsBzD,oBAAoBC,iBAAiBwD"}

package/dist/agents/nodes/AgentNode.cjs

@@ -34,7 +34,7 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		* If so, we should generate structured response (if needed) and stop
 		*/
 		const lastMessage = state.messages[state.messages.length - 1];
-		if (lastMessage instanceof __langchain_core_messages.ToolMessage && lastMessage.name && this.#options.shouldReturnDirect.has(lastMessage.name))
+		if (__langchain_core_messages.ToolMessage.isInstance(lastMessage) && lastMessage.name && this.#options.shouldReturnDirect.has(lastMessage.name))
  /**
 		* return directly without invoking the model again
 		*/
@@ -53,9 +53,9 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		if (response instanceof __langchain_langgraph.Command) return response;
 		response.name = this.name;
 		response.lc_kwargs.name = this.name;
-		if (this.#areMoreStepsNeeded(state, response)) return { messages: [new __langchain_core_messages.AIMessage("Sorry, need more steps to process this request.", {
+		if (this.#areMoreStepsNeeded(state, response)) return { messages: [new __langchain_core_messages.AIMessage({
+			content: "Sorry, need more steps to process this request.",
 			name: this.name,
-			lc_kwargs: { name: this.name },
 			id: response.id
 		})] };
 		return { messages: [response] };
@@ -201,7 +201,7 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		throw error;
 	}
 	#areMoreStepsNeeded(state, response) {
-		const allToolsReturnDirect = response instanceof __langchain_core_messages.AIMessage && response.tool_calls?.every((call) => this.#options.shouldReturnDirect.has(call.name));
+		const allToolsReturnDirect = __langchain_core_messages.AIMessage.isInstance(response) && response.tool_calls?.every((call) => this.#options.shouldReturnDirect.has(call.name));
 		const remainingSteps = "remainingSteps" in state ? state.remainingSteps : void 0;
 		return Boolean(remainingSteps && (remainingSteps < 1 && allToolsReturnDirect || remainingSteps < 2 && require_utils.hasToolCalls(state.messages)));
 	}

package/dist/agents/nodes/AgentNode.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AgentNode.cjs","names":["RunnableCallable","options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >","#run","#options","#structuredToolInfo","transformResponseFormat","ToolStrategy","state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]","config: RunnableConfig","ToolMessage","#invokeModel","Command","#areMoreStepsNeeded","AIMessage","initChatModel","options: {\n      lastMessage?: string;\n    }","#deriveModel","validateLLMHasNoBoundTools","#bindTools","#getModelInputState","mergeAbortSignals","ProviderStrategy","#handleMultipleStructuredOutputs","#handleSingleStructuredOutput","response: AIMessage","toolCalls: ToolCall[]","MultipleStructuredOutputsError","#handleToolStrategyError","toolCall: ToolCall","lastMessage?: string","error: ToolStrategyError","response: BaseMessage","hasToolCalls","model: LanguageModelLike","options: Partial<BaseChatModelCallOptions>","hasSupportForJsonSchemaOutput","bindTools","getPromptRunnable","withAgentName"],"sources":["../../../src/agents/nodes/AgentNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { BaseMessage, AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { Command } from \"@langchain/langgraph\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport {\n  InteropZodObject,\n  getSchemaDescription,\n} from \"@langchain/core/utils/types\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\n\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport { MultipleStructuredOutputsError } from \"../errors.js\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot } from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport {\n  bindTools,\n  getPromptRunnable,\n  validateLLMHasNoBoundTools,\n  hasToolCalls,\n  hasSupportForJsonSchemaOutput,\n} from \"../utils.js\";\nimport {\n  InternalAgentState,\n  ClientTool,\n  ServerTool,\n  CreateAgentParams,\n} from \"../types.js\";\nimport { withAgentName } from \"../withAgentName.js\";\nimport {\n  ToolStrategy,\n  ProviderStrategy,\n  transformResponseFormat,\n  ToolStrategyError,\n} from \"../responses.js\";\n\ntype ResponseHandlerResult<StructuredResponseFormat> =\n  | {\n      structuredResponse: StructuredResponseFormat;\n      messages: BaseMessage[];\n    }\n  | Promise<Command>;\n\nexport interface AgentNodeOptions<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends Pick<\n    CreateAgentParams<StateSchema, StructuredResponseFormat, ContextSchema>,\n    \"llm\" | \"model\" | \"prompt\" | \"includeAgentName\" | \"name\" | \"responseFormat\"\n  > {\n  toolClasses: (ClientTool | ServerTool)[];\n  shouldReturnDirect: Set<string>;\n  signal?: AbortSignal;\n}\n\nexport class AgentNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends RunnableCallable<\n  InternalAgentState<StructuredResponseFormat> & PreHookAnnotation[\"State\"],\n  { messages: BaseMessage[] } | { structuredResponse: StructuredResponseFormat }\n> {\n  #options: AgentNodeOptions<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema\n  >;\n\n  #structuredToolInfo: Record<string, ToolStrategy> = {};\n\n  constructor(\n    options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >\n  ) {\n    super({\n      name: options.name ?? \"model\",\n      func: (input, config) =>\n        this.#run(input, config as RunnableConfig) as any,\n    });\n\n    this.#options = options;\n\n    /**\n     * Populate a list of structured tool info.\n     */\n    this.#structuredToolInfo = (\n      transformResponseFormat(this.#options.responseFormat).filter(\n        (format) => format instanceof ToolStrategy\n      ) as ToolStrategy[]\n    ).reduce((acc, format) => {\n      acc[format.name] = format;\n      return acc;\n    }, {} as Record<string, ToolStrategy>);\n  }\n\n  async #run(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    /**\n     * Check if we just executed a returnDirect tool\n     * If so, we should generate structured response (if needed) and stop\n     */\n    const lastMessage = state.messages[state.messages.length - 1];\n    if (\n      lastMessage instanceof ToolMessage &&\n      lastMessage.name &&\n      this.#options.shouldReturnDirect.has(lastMessage.name)\n    ) {\n      /**\n       * return directly without invoking the model again\n       */\n      return { messages: [] };\n    }\n\n    const response = await this.#invokeModel(state, config);\n\n    /**\n     * if we were able to generate a structured response, return it\n     */\n    if (\"structuredResponse\" in response) {\n      return {\n        messages: [...state.messages, ...(response.messages || [])],\n        structuredResponse: response.structuredResponse,\n      };\n    }\n\n    /**\n     * if we need to direct the agent to the model, return the update\n     */\n    if (response instanceof Command) {\n      return response;\n    }\n\n    response.name = this.name;\n    response.lc_kwargs.name = this.name;\n\n    if (this.#areMoreStepsNeeded(state, response)) {\n      return {\n        messages: [\n          new AIMessage(\"Sorry, need more steps to process this request.\", {\n            name: this.name,\n            lc_kwargs: { name: this.name },\n            id: response.id,\n          }),\n        ],\n      };\n    }\n\n    return { messages: [response] };\n  }\n\n  /**\n   * Derive the model from the options.\n   * @param state - The state of the agent.\n   * @param config - The config of the agent.\n   * @returns The model.\n   */\n  #deriveModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    if (this.#options.model) {\n      if (typeof this.#options.model === \"string\") {\n        return initChatModel(this.#options.model);\n      }\n\n      throw new Error(\"`model` option must be a string.\");\n    }\n\n    const model = this.#options.llm;\n\n    /**\n     * If the model is a function, call it to get the model.\n     */\n    if (typeof model === \"function\") {\n      return model(state, config);\n    }\n\n    if (model) {\n      return model;\n    }\n\n    throw new Error(\n      \"No model option was provided, either via `model` or via `llm` option.\"\n    );\n  }\n\n  async #invokeModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig,\n    options: {\n      lastMessage?: string;\n    } = {}\n  ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> {\n    const model = await this.#deriveModel(state, config);\n\n    /**\n     * Check if the LLM already has bound tools and throw if it does.\n     */\n    validateLLMHasNoBoundTools(model);\n\n    const modelWithTools = await this.#bindTools(model);\n    const modelInput = this.#getModelInputState(state);\n    const signal = mergeAbortSignals(this.#options.signal, config.signal);\n    const invokeConfig = {\n      ...config,\n      signal,\n    };\n\n    const response = (await modelWithTools.invoke(\n      modelInput,\n      invokeConfig\n    )) as AIMessage;\n\n    /**\n     * if the user requests a native schema output, try to parse the response\n     * and return the structured response if it is valid\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      const structuredResponse = this.#options.responseFormat.parse(response);\n      if (structuredResponse) {\n        return { structuredResponse, messages: [response] };\n      }\n    }\n\n    if (!response.tool_calls) {\n      return response;\n    }\n\n    const toolCalls = response.tool_calls.filter(\n      (call) => call.name in this.#structuredToolInfo\n    );\n\n    /**\n     * if there were not structured tool calls, we can return the response\n     */\n    if (toolCalls.length === 0) {\n      return response;\n    }\n\n    /**\n     * if there were multiple structured tool calls, we should throw an error as this\n     * scenario is not defined/supported.\n     */\n    if (toolCalls.length > 1) {\n      return this.#handleMultipleStructuredOutputs(response, toolCalls);\n    }\n\n    const toolStrategy = this.#structuredToolInfo[toolCalls[0].name];\n    const toolMessageContent = toolStrategy?.options?.toolMessageContent;\n    return this.#handleSingleStructuredOutput(\n      response,\n      toolCalls[0],\n      toolMessageContent ?? options.lastMessage\n    );\n  }\n\n  /**\n   * If the model returns multiple structured outputs, we need to handle it.\n   * @param response - The response from the model\n   * @param toolCalls - The tool calls that were made\n   * @returns The response from the model\n   */\n  #handleMultipleStructuredOutputs(\n    response: AIMessage,\n    toolCalls: ToolCall[]\n  ): Promise<Command> {\n    /**\n     * the following should never happen, let's throw an error if it does\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      throw new Error(\n        \"Multiple structured outputs should not apply to native structured output responses\"\n      );\n    }\n\n    const multipleStructuredOutputsError = new MultipleStructuredOutputsError(\n      toolCalls.map((call) => call.name)\n    );\n\n    return this.#handleToolStrategyError(\n      multipleStructuredOutputsError,\n      response,\n      toolCalls[0]\n    );\n  }\n\n  /**\n   * If the model returns a single structured output, we need to handle it.\n   * @param toolCall - The tool call that was made\n   * @returns The structured response and a message to the LLM if needed\n   */\n  #handleSingleStructuredOutput(\n    response: AIMessage,\n    toolCall: ToolCall,\n    lastMessage?: string\n  ): ResponseHandlerResult<StructuredResponseFormat> {\n    const tool = this.#structuredToolInfo[toolCall.name];\n\n    try {\n      const structuredResponse = tool.parse(\n        toolCall.args\n      ) as StructuredResponseFormat;\n\n      return {\n        structuredResponse,\n        messages: [\n          response,\n          new AIMessage(\n            lastMessage ??\n              `Returning structured response: ${JSON.stringify(\n                structuredResponse\n              )}`\n          ),\n        ],\n      };\n    } catch (error) {\n      return this.#handleToolStrategyError(\n        error as ToolStrategyError,\n        response,\n        toolCall\n      );\n    }\n  }\n\n  async #handleToolStrategyError(\n    error: ToolStrategyError,\n    response: AIMessage,\n    toolCall: ToolCall\n  ): Promise<Command> {\n    /**\n     * Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.\n     * There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user\n     * uses `toolStrategy` to define the response format. If the user applies a list of json\n     * schema objects, these will be transformed into multiple `ToolStrategy` entries but all\n     * with the same `handleError` option.\n     */\n    const errorHandler = Object.values(this.#structuredToolInfo).at(0)?.options\n      ?.handleError;\n\n    const toolCallId = toolCall.id;\n    if (!toolCallId) {\n      throw new Error(\n        \"Tool call ID is required to handle tool output errors. Please provide a tool call ID.\"\n      );\n    }\n\n    /**\n     * retry if:\n     */\n    if (\n      /**\n       * if the user has provided `true` as the `errorHandler` option, return a new AIMessage\n       * with the error message and retry the tool call.\n       */\n      (typeof errorHandler === \"boolean\" && errorHandler) ||\n      /**\n       * if `errorHandler` is an array and contains MultipleStructuredOutputsError\n       */\n      (Array.isArray(errorHandler) &&\n        errorHandler.some((h) => h instanceof MultipleStructuredOutputsError))\n    ) {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: error.message,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a string, retry the tool call with given string\n     */\n    if (typeof errorHandler === \"string\") {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: errorHandler,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a function, retry the tool call with the function\n     */\n    if (typeof errorHandler === \"function\") {\n      const content = await errorHandler(error);\n      if (typeof content !== \"string\") {\n        throw new Error(\"Error handler must return a string.\");\n      }\n\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * throw otherwise, e.g. if `errorHandler` is not defined or set to `false`\n     */\n    throw error;\n  }\n\n  #areMoreStepsNeeded(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    response: BaseMessage\n  ): boolean {\n    const allToolsReturnDirect =\n      response instanceof AIMessage &&\n      response.tool_calls?.every((call) =>\n        this.#options.shouldReturnDirect.has(call.name)\n      );\n    const remainingSteps =\n      \"remainingSteps\" in state ? (state.remainingSteps as number) : undefined;\n    return Boolean(\n      remainingSteps &&\n        ((remainingSteps < 1 && allToolsReturnDirect) ||\n          (remainingSteps < 2 && hasToolCalls(state.messages)))\n    );\n  }\n\n  #getModelInputState(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]\n  ): Omit<InternalAgentState<StructuredResponseFormat>, \"llmInputMessages\"> {\n    const { messages, llmInputMessages, ...rest } = state;\n    if (llmInputMessages && llmInputMessages.length > 0) {\n      return { messages: llmInputMessages, ...rest } as Omit<\n        InternalAgentState<StructuredResponseFormat>,\n        \"llmInputMessages\"\n      >;\n    }\n    return { messages, ...rest } as Omit<\n      InternalAgentState<StructuredResponseFormat>,\n      \"llmInputMessages\"\n    >;\n  }\n\n  async #bindTools(model: LanguageModelLike): Promise<Runnable> {\n    const options: Partial<BaseChatModelCallOptions> = {};\n    const structuredTools = Object.values(this.#structuredToolInfo);\n    const allTools = this.#options.toolClasses.concat(\n      ...structuredTools.map((toolStrategy) => toolStrategy.tool)\n    );\n\n    /**\n     * If there are structured tools, we need to set the tool choice to \"any\"\n     * so that the model can choose to use a structured tool or not.\n     */\n    const toolChoice = structuredTools.length > 0 ? \"any\" : undefined;\n\n    /**\n     * check if the user requests a native schema output\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      /**\n       * if the model does not support JSON schema output, throw an error\n       */\n      if (!hasSupportForJsonSchemaOutput(model)) {\n        throw new Error(\n          \"Model does not support native structured output responses. Please use a model that supports native structured output responses or use a tool output.\"\n        );\n      }\n\n      const jsonSchemaParams = {\n        name: this.#options.responseFormat.schema?.name ?? \"extract\",\n        description: getSchemaDescription(this.#options.responseFormat.schema),\n        schema: this.#options.responseFormat.schema,\n        strict: true,\n      };\n\n      Object.assign(options, {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: jsonSchemaParams,\n        },\n        ls_structured_output_format: {\n          kwargs: { method: \"json_schema\" },\n          schema: this.#options.responseFormat.schema,\n        },\n        strict: true,\n      });\n    }\n\n    /**\n     * Bind tools to the model if they are not already bound.\n     */\n    const modelWithTools = await bindTools(model, allTools, {\n      ...options,\n      tool_choice: toolChoice,\n    });\n\n    /**\n     * Create a model runnable with the prompt and agent name\n     */\n    const modelRunnable = getPromptRunnable(this.#options.prompt).pipe(\n      this.#options.includeAgentName === \"inline\"\n        ? withAgentName(modelWithTools, this.#options.includeAgentName)\n        : modelWithTools\n    );\n\n    return modelRunnable;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA6DA,IAAa,YAAb,cAOUA,0CAGR;CACA;CAMA,sBAAoD,CAAE;CAEtD,YACEC,SAKA;EACA,MAAM;GACJ,MAAM,QAAQ,QAAQ;GACtB,MAAM,CAAC,OAAO,WACZ,KAAKC,KAAK,OAAO,OAAyB;EAC7C,EAAC;EAEF,KAAKC,WAAW;;;;EAKhB,KAAKC,sBACHC,0CAAwB,KAAKF,SAAS,eAAe,CAAC,OACpD,CAAC,WAAW,kBAAkBG,+BAC/B,CACD,OAAO,CAAC,KAAK,WAAW;GACxB,IAAI,OAAO,QAAQ;AACnB,UAAO;EACR,GAAE,CAAE,EAAiC;CACvC;CAED,MAAMJ,KACJK,OAEAC,QACA;;;;;EAKA,MAAM,cAAc,MAAM,SAAS,MAAM,SAAS,SAAS;AAC3D,MACE,uBAAuBC,yCACvB,YAAY,QACZ,KAAKN,SAAS,mBAAmB,IAAI,YAAY,KAAK;;;;AAKtD,SAAO,EAAE,UAAU,CAAE,EAAE;EAGzB,MAAM,WAAW,MAAM,KAAKO,aAAa,OAAO,OAAO;;;;AAKvD,MAAI,wBAAwB,SAC1B,QAAO;GACL,UAAU,CAAC,GAAG,MAAM,UAAU,GAAI,SAAS,YAAY,CAAE,CAAE;GAC3D,oBAAoB,SAAS;EAC9B;;;;AAMH,MAAI,oBAAoBC,8BACtB,QAAO;EAGT,SAAS,OAAO,KAAK;EACrB,SAAS,UAAU,OAAO,KAAK;AAE/B,MAAI,KAAKC,oBAAoB,OAAO,SAAS,CAC3C,QAAO,EACL,UAAU,CACR,IAAIC,oCAAU,mDAAmD;GAC/D,MAAM,KAAK;GACX,WAAW,EAAE,MAAM,KAAK,KAAM;GAC9B,IAAI,SAAS;EACd,EACF,EACF;AAGH,SAAO,EAAE,UAAU,CAAC,QAAS,EAAE;CAChC;;;;;;;CAQD,aACEN,OAEAC,QACA;AACA,MAAI,KAAKL,SAAS,OAAO;AACvB,OAAI,OAAO,KAAKA,SAAS,UAAU,SACjC,QAAOW,4CAAc,KAAKX,SAAS,MAAM;AAG3C,SAAM,IAAI,MAAM;EACjB;EAED,MAAM,QAAQ,KAAKA,SAAS;;;;AAK5B,MAAI,OAAO,UAAU,WACnB,QAAO,MAAM,OAAO,OAAO;AAG7B,MAAI,MACF,QAAO;AAGT,QAAM,IAAI,MACR;CAEH;CAED,MAAMO,aACJH,OAEAC,QACAO,UAEI,CAAE,GACgE;EACtE,MAAM,QAAQ,MAAM,KAAKC,aAAa,OAAO,OAAO;;;;EAKpDC,yCAA2B,MAAM;EAEjC,MAAM,iBAAiB,MAAM,KAAKC,WAAW,MAAM;EACnD,MAAM,aAAa,KAAKC,oBAAoB,MAAM;EAClD,MAAM,SAASC,kCAAkB,KAAKjB,SAAS,QAAQ,OAAO,OAAO;EACrE,MAAM,eAAe;GACnB,GAAG;GACH;EACD;EAED,MAAM,WAAY,MAAM,eAAe,OACrC,YACA,aACD;;;;;AAMD,MAAI,KAAKA,SAAS,0BAA0BkB,oCAAkB;GAC5D,MAAM,qBAAqB,KAAKlB,SAAS,eAAe,MAAM,SAAS;AACvE,OAAI,mBACF,QAAO;IAAE;IAAoB,UAAU,CAAC,QAAS;GAAE;EAEtD;AAED,MAAI,CAAC,SAAS,WACZ,QAAO;EAGT,MAAM,YAAY,SAAS,WAAW,OACpC,CAAC,SAAS,KAAK,QAAQ,KAAKC,oBAC7B;;;;AAKD,MAAI,UAAU,WAAW,EACvB,QAAO;;;;;AAOT,MAAI,UAAU,SAAS,EACrB,QAAO,KAAKkB,iCAAiC,UAAU,UAAU;EAGnE,MAAM,eAAe,KAAKlB,oBAAoB,UAAU,GAAG;EAC3D,MAAM,qBAAqB,cAAc,SAAS;AAClD,SAAO,KAAKmB,8BACV,UACA,UAAU,IACV,sBAAsB,QAAQ,YAC/B;CACF;;;;;;;CAQD,iCACEC,UACAC,WACkB;;;;AAIlB,MAAI,KAAKtB,SAAS,0BAA0BkB,mCAC1C,OAAM,IAAI,MACR;EAIJ,MAAM,iCAAiC,IAAIK,8CACzC,UAAU,IAAI,CAAC,SAAS,KAAK,KAAK;AAGpC,SAAO,KAAKC,yBACV,gCACA,UACA,UAAU,GACX;CACF;;;;;;CAOD,8BACEH,UACAI,UACAC,aACiD;EACjD,MAAM,OAAO,KAAKzB,oBAAoB,SAAS;AAE/C,MAAI;GACF,MAAM,qBAAqB,KAAK,MAC9B,SAAS,KACV;AAED,UAAO;IACL;IACA,UAAU,CACR,UACA,IAAIS,oCACF,eACE,CAAC,+BAA+B,EAAE,KAAK,UACrC,mBACD,EAAE,CAER;GACF;EACF,SAAQ,OAAO;AACd,UAAO,KAAKc,yBACV,OACA,UACA,SACD;EACF;CACF;CAED,MAAMA,yBACJG,OACAN,UACAI,UACkB;;;;;;;;EAQlB,MAAM,eAAe,OAAO,OAAO,KAAKxB,oBAAoB,CAAC,GAAG,EAAE,EAAE,SAChE;EAEJ,MAAM,aAAa,SAAS;AAC5B,MAAI,CAAC,WACH,OAAM,IAAI,MACR;;;;AAOJ,MAKG,OAAO,iBAAiB,aAAa,gBAIrC,MAAM,QAAQ,aAAa,IAC1B,aAAa,KAAK,CAAC,MAAM,aAAasB,8CAA+B,CAEvE,QAAO,IAAIf,8BAAQ;GACjB,QAAQ,EACN,UAAU,CACR,UACA,IAAIF,sCAAY;IACd,SAAS,MAAM;IACf,cAAc;GACf,EACF,EACF;GACD,MAAM;EACP;;;;AAMH,MAAI,OAAO,iBAAiB,SAC1B,QAAO,IAAIE,8BAAQ;GACjB,QAAQ,EACN,UAAU,CACR,UACA,IAAIF,sCAAY;IACd,SAAS;IACT,cAAc;GACf,EACF,EACF;GACD,MAAM;EACP;;;;AAMH,MAAI,OAAO,iBAAiB,YAAY;GACtC,MAAM,UAAU,MAAM,aAAa,MAAM;AACzC,OAAI,OAAO,YAAY,SACrB,OAAM,IAAI,MAAM;AAGlB,UAAO,IAAIE,8BAAQ;IACjB,QAAQ,EACN,UAAU,CACR,UACA,IAAIF,sCAAY;KACd;KACA,cAAc;IACf,EACF,EACF;IACD,MAAM;GACP;EACF;;;;AAKD,QAAM;CACP;CAED,oBACEF,OAEAwB,UACS;EACT,MAAM,uBACJ,oBAAoBlB,uCACpB,SAAS,YAAY,MAAM,CAAC,SAC1B,KAAKV,SAAS,mBAAmB,IAAI,KAAK,KAAK,CAChD;EACH,MAAM,iBACJ,oBAAoB,QAAS,MAAM,iBAA4B;AACjE,SAAO,QACL,mBACI,iBAAiB,KAAK,wBACrB,iBAAiB,KAAK6B,2BAAa,MAAM,SAAS,EACxD;CACF;CAED,oBACEzB,OAEwE;EACxE,MAAM,EAAE,UAAU,iBAAkB,GAAG,MAAM,GAAG;AAChD,MAAI,oBAAoB,iBAAiB,SAAS,EAChD,QAAO;GAAE,UAAU;GAAkB,GAAG;EAAM;AAKhD,SAAO;GAAE;GAAU,GAAG;EAAM;CAI7B;CAED,MAAMW,WAAWe,OAA6C;EAC5D,MAAMC,UAA6C,CAAE;EACrD,MAAM,kBAAkB,OAAO,OAAO,KAAK9B,oBAAoB;EAC/D,MAAM,WAAW,KAAKD,SAAS,YAAY,OACzC,GAAG,gBAAgB,IAAI,CAAC,iBAAiB,aAAa,KAAK,CAC5D;;;;;EAMD,MAAM,aAAa,gBAAgB,SAAS,IAAI,QAAQ;;;;AAKxD,MAAI,KAAKA,SAAS,0BAA0BkB,oCAAkB;;;;AAI5D,OAAI,CAACc,4CAA8B,MAAM,CACvC,OAAM,IAAI,MACR;GAIJ,MAAM,mBAAmB;IACvB,MAAM,KAAKhC,SAAS,eAAe,QAAQ,QAAQ;IACnD,oEAAkC,KAAKA,SAAS,eAAe,OAAO;IACtE,QAAQ,KAAKA,SAAS,eAAe;IACrC,QAAQ;GACT;GAED,OAAO,OAAO,SAAS;IACrB,iBAAiB;KACf,MAAM;KACN,aAAa;IACd;IACD,6BAA6B;KAC3B,QAAQ,EAAE,QAAQ,cAAe;KACjC,QAAQ,KAAKA,SAAS,eAAe;IACtC;IACD,QAAQ;GACT,EAAC;EACH;;;;EAKD,MAAM,iBAAiB,MAAMiC,wBAAU,OAAO,UAAU;GACtD,GAAG;GACH,aAAa;EACd,EAAC;;;;EAKF,MAAM,gBAAgBC,gCAAkB,KAAKlC,SAAS,OAAO,CAAC,KAC5D,KAAKA,SAAS,qBAAqB,WAC/BmC,oCAAc,gBAAgB,KAAKnC,SAAS,iBAAiB,GAC7D,eACL;AAED,SAAO;CACR;AACF"}
+{"version":3,"file":"AgentNode.cjs","names":["RunnableCallable","options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >","#run","#options","#structuredToolInfo","transformResponseFormat","ToolStrategy","state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]","config: RunnableConfig","ToolMessage","#invokeModel","Command","#areMoreStepsNeeded","AIMessage","initChatModel","options: {\n      lastMessage?: string;\n    }","#deriveModel","validateLLMHasNoBoundTools","#bindTools","#getModelInputState","mergeAbortSignals","ProviderStrategy","#handleMultipleStructuredOutputs","#handleSingleStructuredOutput","response: AIMessage","toolCalls: ToolCall[]","MultipleStructuredOutputsError","#handleToolStrategyError","toolCall: ToolCall","lastMessage?: string","error: ToolStrategyError","response: BaseMessage","hasToolCalls","model: LanguageModelLike","options: Partial<BaseChatModelCallOptions>","hasSupportForJsonSchemaOutput","bindTools","getPromptRunnable","withAgentName"],"sources":["../../../src/agents/nodes/AgentNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { BaseMessage, AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { Command } from \"@langchain/langgraph\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport {\n  InteropZodObject,\n  getSchemaDescription,\n} from \"@langchain/core/utils/types\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\n\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport { MultipleStructuredOutputsError } from \"../errors.js\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot } from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport {\n  bindTools,\n  getPromptRunnable,\n  validateLLMHasNoBoundTools,\n  hasToolCalls,\n  hasSupportForJsonSchemaOutput,\n} from \"../utils.js\";\nimport {\n  InternalAgentState,\n  ClientTool,\n  ServerTool,\n  CreateAgentParams,\n} from \"../types.js\";\nimport { withAgentName } from \"../withAgentName.js\";\nimport {\n  ToolStrategy,\n  ProviderStrategy,\n  transformResponseFormat,\n  ToolStrategyError,\n} from \"../responses.js\";\n\ntype ResponseHandlerResult<StructuredResponseFormat> =\n  | {\n      structuredResponse: StructuredResponseFormat;\n      messages: BaseMessage[];\n    }\n  | Promise<Command>;\n\nexport interface AgentNodeOptions<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends Pick<\n    CreateAgentParams<StateSchema, StructuredResponseFormat, ContextSchema>,\n    \"llm\" | \"model\" | \"prompt\" | \"includeAgentName\" | \"name\" | \"responseFormat\"\n  > {\n  toolClasses: (ClientTool | ServerTool)[];\n  shouldReturnDirect: Set<string>;\n  signal?: AbortSignal;\n}\n\nexport class AgentNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends RunnableCallable<\n  InternalAgentState<StructuredResponseFormat> & PreHookAnnotation[\"State\"],\n  { messages: BaseMessage[] } | { structuredResponse: StructuredResponseFormat }\n> {\n  #options: AgentNodeOptions<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema\n  >;\n\n  #structuredToolInfo: Record<string, ToolStrategy> = {};\n\n  constructor(\n    options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >\n  ) {\n    super({\n      name: options.name ?? \"model\",\n      func: (input, config) =>\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this.#run(input, config as RunnableConfig) as any,\n    });\n\n    this.#options = options;\n\n    /**\n     * Populate a list of structured tool info.\n     */\n    this.#structuredToolInfo = (\n      transformResponseFormat(this.#options.responseFormat).filter(\n        (format) => format instanceof ToolStrategy\n      ) as ToolStrategy[]\n    ).reduce((acc, format) => {\n      acc[format.name] = format;\n      return acc;\n    }, {} as Record<string, ToolStrategy>);\n  }\n\n  async #run(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    /**\n     * Check if we just executed a returnDirect tool\n     * If so, we should generate structured response (if needed) and stop\n     */\n    const lastMessage = state.messages[state.messages.length - 1];\n    if (\n      ToolMessage.isInstance(lastMessage) &&\n      lastMessage.name &&\n      this.#options.shouldReturnDirect.has(lastMessage.name)\n    ) {\n      /**\n       * return directly without invoking the model again\n       */\n      return { messages: [] };\n    }\n\n    const response = await this.#invokeModel(state, config);\n\n    /**\n     * if we were able to generate a structured response, return it\n     */\n    if (\"structuredResponse\" in response) {\n      return {\n        messages: [...state.messages, ...(response.messages || [])],\n        structuredResponse: response.structuredResponse,\n      };\n    }\n\n    /**\n     * if we need to direct the agent to the model, return the update\n     */\n    if (response instanceof Command) {\n      return response;\n    }\n\n    response.name = this.name;\n    response.lc_kwargs.name = this.name;\n\n    if (this.#areMoreStepsNeeded(state, response)) {\n      return {\n        messages: [\n          new AIMessage({\n            content: \"Sorry, need more steps to process this request.\",\n            name: this.name,\n            id: response.id,\n          }),\n        ],\n      };\n    }\n\n    return { messages: [response] };\n  }\n\n  /**\n   * Derive the model from the options.\n   * @param state - The state of the agent.\n   * @param config - The config of the agent.\n   * @returns The model.\n   */\n  #deriveModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    if (this.#options.model) {\n      if (typeof this.#options.model === \"string\") {\n        return initChatModel(this.#options.model);\n      }\n\n      throw new Error(\"`model` option must be a string.\");\n    }\n\n    const model = this.#options.llm;\n\n    /**\n     * If the model is a function, call it to get the model.\n     */\n    if (typeof model === \"function\") {\n      return model(state, config);\n    }\n\n    if (model) {\n      return model;\n    }\n\n    throw new Error(\n      \"No model option was provided, either via `model` or via `llm` option.\"\n    );\n  }\n\n  async #invokeModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig,\n    options: {\n      lastMessage?: string;\n    } = {}\n  ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> {\n    const model = await this.#deriveModel(state, config);\n\n    /**\n     * Check if the LLM already has bound tools and throw if it does.\n     */\n    validateLLMHasNoBoundTools(model);\n\n    const modelWithTools = await this.#bindTools(model);\n    const modelInput = this.#getModelInputState(state);\n    const signal = mergeAbortSignals(this.#options.signal, config.signal);\n    const invokeConfig = {\n      ...config,\n      signal,\n    };\n\n    const response = (await modelWithTools.invoke(\n      modelInput,\n      invokeConfig\n    )) as AIMessage;\n\n    /**\n     * if the user requests a native schema output, try to parse the response\n     * and return the structured response if it is valid\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      const structuredResponse = this.#options.responseFormat.parse(response);\n      if (structuredResponse) {\n        return { structuredResponse, messages: [response] };\n      }\n    }\n\n    if (!response.tool_calls) {\n      return response;\n    }\n\n    const toolCalls = response.tool_calls.filter(\n      (call) => call.name in this.#structuredToolInfo\n    );\n\n    /**\n     * if there were not structured tool calls, we can return the response\n     */\n    if (toolCalls.length === 0) {\n      return response;\n    }\n\n    /**\n     * if there were multiple structured tool calls, we should throw an error as this\n     * scenario is not defined/supported.\n     */\n    if (toolCalls.length > 1) {\n      return this.#handleMultipleStructuredOutputs(response, toolCalls);\n    }\n\n    const toolStrategy = this.#structuredToolInfo[toolCalls[0].name];\n    const toolMessageContent = toolStrategy?.options?.toolMessageContent;\n    return this.#handleSingleStructuredOutput(\n      response,\n      toolCalls[0],\n      toolMessageContent ?? options.lastMessage\n    );\n  }\n\n  /**\n   * If the model returns multiple structured outputs, we need to handle it.\n   * @param response - The response from the model\n   * @param toolCalls - The tool calls that were made\n   * @returns The response from the model\n   */\n  #handleMultipleStructuredOutputs(\n    response: AIMessage,\n    toolCalls: ToolCall[]\n  ): Promise<Command> {\n    /**\n     * the following should never happen, let's throw an error if it does\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      throw new Error(\n        \"Multiple structured outputs should not apply to native structured output responses\"\n      );\n    }\n\n    const multipleStructuredOutputsError = new MultipleStructuredOutputsError(\n      toolCalls.map((call) => call.name)\n    );\n\n    return this.#handleToolStrategyError(\n      multipleStructuredOutputsError,\n      response,\n      toolCalls[0]\n    );\n  }\n\n  /**\n   * If the model returns a single structured output, we need to handle it.\n   * @param toolCall - The tool call that was made\n   * @returns The structured response and a message to the LLM if needed\n   */\n  #handleSingleStructuredOutput(\n    response: AIMessage,\n    toolCall: ToolCall,\n    lastMessage?: string\n  ): ResponseHandlerResult<StructuredResponseFormat> {\n    const tool = this.#structuredToolInfo[toolCall.name];\n\n    try {\n      const structuredResponse = tool.parse(\n        toolCall.args\n      ) as StructuredResponseFormat;\n\n      return {\n        structuredResponse,\n        messages: [\n          response,\n          new AIMessage(\n            lastMessage ??\n              `Returning structured response: ${JSON.stringify(\n                structuredResponse\n              )}`\n          ),\n        ],\n      };\n    } catch (error) {\n      return this.#handleToolStrategyError(\n        error as ToolStrategyError,\n        response,\n        toolCall\n      );\n    }\n  }\n\n  async #handleToolStrategyError(\n    error: ToolStrategyError,\n    response: AIMessage,\n    toolCall: ToolCall\n  ): Promise<Command> {\n    /**\n     * Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.\n     * There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user\n     * uses `toolStrategy` to define the response format. If the user applies a list of json\n     * schema objects, these will be transformed into multiple `ToolStrategy` entries but all\n     * with the same `handleError` option.\n     */\n    const errorHandler = Object.values(this.#structuredToolInfo).at(0)?.options\n      ?.handleError;\n\n    const toolCallId = toolCall.id;\n    if (!toolCallId) {\n      throw new Error(\n        \"Tool call ID is required to handle tool output errors. Please provide a tool call ID.\"\n      );\n    }\n\n    /**\n     * retry if:\n     */\n    if (\n      /**\n       * if the user has provided `true` as the `errorHandler` option, return a new AIMessage\n       * with the error message and retry the tool call.\n       */\n      (typeof errorHandler === \"boolean\" && errorHandler) ||\n      /**\n       * if `errorHandler` is an array and contains MultipleStructuredOutputsError\n       */\n      (Array.isArray(errorHandler) &&\n        errorHandler.some((h) => h instanceof MultipleStructuredOutputsError))\n    ) {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: error.message,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a string, retry the tool call with given string\n     */\n    if (typeof errorHandler === \"string\") {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: errorHandler,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a function, retry the tool call with the function\n     */\n    if (typeof errorHandler === \"function\") {\n      const content = await errorHandler(error);\n      if (typeof content !== \"string\") {\n        throw new Error(\"Error handler must return a string.\");\n      }\n\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * throw otherwise, e.g. if `errorHandler` is not defined or set to `false`\n     */\n    throw error;\n  }\n\n  #areMoreStepsNeeded(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    response: BaseMessage\n  ): boolean {\n    const allToolsReturnDirect =\n      AIMessage.isInstance(response) &&\n      response.tool_calls?.every((call) =>\n        this.#options.shouldReturnDirect.has(call.name)\n      );\n    const remainingSteps =\n      \"remainingSteps\" in state ? (state.remainingSteps as number) : undefined;\n    return Boolean(\n      remainingSteps &&\n        ((remainingSteps < 1 && allToolsReturnDirect) ||\n          (remainingSteps < 2 && hasToolCalls(state.messages)))\n    );\n  }\n\n  #getModelInputState(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]\n  ): Omit<InternalAgentState<StructuredResponseFormat>, \"llmInputMessages\"> {\n    const { messages, llmInputMessages, ...rest } = state;\n    if (llmInputMessages && llmInputMessages.length > 0) {\n      return { messages: llmInputMessages, ...rest } as Omit<\n        InternalAgentState<StructuredResponseFormat>,\n        \"llmInputMessages\"\n      >;\n    }\n    return { messages, ...rest } as Omit<\n      InternalAgentState<StructuredResponseFormat>,\n      \"llmInputMessages\"\n    >;\n  }\n\n  async #bindTools(model: LanguageModelLike): Promise<Runnable> {\n    const options: Partial<BaseChatModelCallOptions> = {};\n    const structuredTools = Object.values(this.#structuredToolInfo);\n    const allTools = this.#options.toolClasses.concat(\n      ...structuredTools.map((toolStrategy) => toolStrategy.tool)\n    );\n\n    /**\n     * If there are structured tools, we need to set the tool choice to \"any\"\n     * so that the model can choose to use a structured tool or not.\n     */\n    const toolChoice = structuredTools.length > 0 ? \"any\" : undefined;\n\n    /**\n     * check if the user requests a native schema output\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      /**\n       * if the model does not support JSON schema output, throw an error\n       */\n      if (!hasSupportForJsonSchemaOutput(model)) {\n        throw new Error(\n          \"Model does not support native structured output responses. Please use a model that supports native structured output responses or use a tool output.\"\n        );\n      }\n\n      const jsonSchemaParams = {\n        name: this.#options.responseFormat.schema?.name ?? \"extract\",\n        description: getSchemaDescription(this.#options.responseFormat.schema),\n        schema: this.#options.responseFormat.schema,\n        strict: true,\n      };\n\n      Object.assign(options, {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: jsonSchemaParams,\n        },\n        ls_structured_output_format: {\n          kwargs: { method: \"json_schema\" },\n          schema: this.#options.responseFormat.schema,\n        },\n        strict: true,\n      });\n    }\n\n    /**\n     * Bind tools to the model if they are not already bound.\n     */\n    const modelWithTools = await bindTools(model, allTools, {\n      ...options,\n      tool_choice: toolChoice,\n    });\n\n    /**\n     * Create a model runnable with the prompt and agent name\n     */\n    const modelRunnable = getPromptRunnable(this.#options.prompt).pipe(\n      this.#options.includeAgentName === \"inline\"\n        ? withAgentName(modelWithTools, this.#options.includeAgentName)\n        : modelWithTools\n    );\n\n    return modelRunnable;\n  }\n}\n"],"mappings":"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"}

package/dist/agents/nodes/AgentNode.js

@@ -33,7 +33,7 @@ var AgentNode = class extends RunnableCallable {
 		* If so, we should generate structured response (if needed) and stop
 		*/
 		const lastMessage = state.messages[state.messages.length - 1];
-		if (lastMessage instanceof ToolMessage && lastMessage.name && this.#options.shouldReturnDirect.has(lastMessage.name))
+		if (ToolMessage.isInstance(lastMessage) && lastMessage.name && this.#options.shouldReturnDirect.has(lastMessage.name))
  /**
 		* return directly without invoking the model again
 		*/
@@ -52,9 +52,9 @@ var AgentNode = class extends RunnableCallable {
 		if (response instanceof Command) return response;
 		response.name = this.name;
 		response.lc_kwargs.name = this.name;
-		if (this.#areMoreStepsNeeded(state, response)) return { messages: [new AIMessage("Sorry, need more steps to process this request.", {
+		if (this.#areMoreStepsNeeded(state, response)) return { messages: [new AIMessage({
+			content: "Sorry, need more steps to process this request.",
 			name: this.name,
-			lc_kwargs: { name: this.name },
 			id: response.id
 		})] };
 		return { messages: [response] };
@@ -200,7 +200,7 @@ var AgentNode = class extends RunnableCallable {
 		throw error;
 	}
 	#areMoreStepsNeeded(state, response) {
-		const allToolsReturnDirect = response instanceof AIMessage && response.tool_calls?.every((call) => this.#options.shouldReturnDirect.has(call.name));
+		const allToolsReturnDirect = AIMessage.isInstance(response) && response.tool_calls?.every((call) => this.#options.shouldReturnDirect.has(call.name));
 		const remainingSteps = "remainingSteps" in state ? state.remainingSteps : void 0;
 		return Boolean(remainingSteps && (remainingSteps < 1 && allToolsReturnDirect || remainingSteps < 2 && hasToolCalls(state.messages)));
 	}