langchain 0.3.31 → 1.0.0-alpha.1

package/dist/agents/index.js

@@ -1,19 +1,14 @@
-export { Agent, BaseSingleActionAgent, BaseMultiActionAgent, RunnableAgent, LLMSingleActionAgent, } from "./agent.js";
-export { JsonToolkit, OpenApiToolkit, RequestsToolkit, VectorStoreRouterToolkit, VectorStoreToolkit, createJsonAgent, createOpenApiAgent, createVectorStoreAgent, createVectorStoreRouterAgent, } from "./toolkits/index.js";
-export { Toolkit } from "./toolkits/base.js";
-export { ChatAgent, } from "./chat/index.js";
-export { ChatAgentOutputParser } from "./chat/outputParser.js";
-export { ChatConversationalAgent, } from "./chat_convo/index.js";
-export { ChatConversationalAgentOutputParser, ChatConversationalAgentOutputParserWithRetries, } from "./chat_convo/outputParser.js";
-export { AgentExecutor } from "./executor.js";
-export { initializeAgentExecutor, initializeAgentExecutorWithOptions, } from "./initialize.js";
-export { ZeroShotAgent, } from "./mrkl/index.js";
-export { ZeroShotAgentOutputParser } from "./mrkl/outputParser.js";
-export { AgentActionOutputParser, } from "./types.js";
-export { StructuredChatAgent, createStructuredChatAgent, } from "./structured_chat/index.js";
-export { StructuredChatOutputParser, StructuredChatOutputParserWithRetries, } from "./structured_chat/outputParser.js";
-export { OpenAIAgent, createOpenAIFunctionsAgent, } from "./openai_functions/index.js";
-export { createOpenAIToolsAgent, } from "./openai_tools/index.js";
-export { createToolCallingAgent, } from "./tool_calling/index.js";
-export { XMLAgent, createXmlAgent, } from "./xml/index.js";
-export { createReactAgent, } from "./react/index.js";
+import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutputParsingError, ToolInvocationError } from "./errors.js";
+import { ProviderStrategy, ToolStrategy, providerStrategy, toolStrategy } from "./responses.js";
+import { ToolNode } from "./nodes/ToolNode.js";
+import { ReactAgent } from "./ReactAgent.js";
+import "./interrupt.js";
+
+//#region src/agents/index.ts
+function createReactAgent(params) {
+	return new ReactAgent(params);
+}
+
+//#endregion
+export { createReactAgent };
+//# sourceMappingURL=index.js.map

package/dist/agents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["params: CreateReactAgentParams<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema,\n    any\n  >"],"sources":["../../src/agents/index.ts"],"sourcesContent":["import type {\n  InteropZodObject,\n  InteropZodType,\n} from \"@langchain/core/utils/types\";\n\nimport { MessagesAnnotation } from \"@langchain/langgraph\";\n\nimport { type AnyAnnotationRoot } from \"./annotation.js\";\nimport type { CreateReactAgentParams, ExtractZodArrayTypes } from \"./types.js\";\nimport type {\n  ToolStrategy,\n  TypedToolStrategy,\n  ProviderStrategy,\n  ResponseFormat,\n  ResponseFormatUndefined,\n  JsonSchemaFormat,\n} from \"./responses.js\";\nimport { ReactAgent } from \"./ReactAgent.js\";\n\n/**\n * Creates a StateGraph agent that relies on a chat model utilizing tool calling.\n *\n * @example\n * ```ts\n * import { ChatOpenAI } from \"@langchain/openai\";\n * import { createReactAgent, tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const model = new ChatOpenAI({\n *   model: \"gpt-4o\",\n * });\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   })\n * })\n *\n * const agent = createReactAgent({ llm: model, tools: [getWeather] });\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await agent.stream(inputs, { streamMode: \"values\" });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\n// Overload 1: With responseFormat as single InteropZodType\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    InteropZodType<T>\n  > & {\n    responseFormat: InteropZodType<T>;\n  }\n): ReactAgent<StateSchema, T, ContextSchema>;\n\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport function createReactAgent<\n  T extends readonly InteropZodType<any>[],\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    ExtractZodArrayTypes<T> extends Record<string, any>\n      ? ExtractZodArrayTypes<T>\n      : Record<string, any>,\n    ContextSchema,\n    T\n  > & {\n    responseFormat: T;\n  }\n): ReactAgent<\n  StateSchema,\n  ExtractZodArrayTypes<T> extends Record<string, any>\n    ? ExtractZodArrayTypes<T>\n    : Record<string, any>,\n  ContextSchema\n>;\n\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat\n  > & {\n    responseFormat: JsonSchemaFormat;\n  }\n): ReactAgent<StateSchema, Record<string, unknown>, ContextSchema>;\n\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat[];\n  }\n): ReactAgent<StateSchema, Record<string, unknown>, ContextSchema>;\n\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat | JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n  }\n): ReactAgent<StateSchema, Record<string, unknown>, ContextSchema>;\n\n// Overload 5: With responseFormat as TypedToolStrategy (for union types from toolStrategy)\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    TypedToolStrategy<T>\n  > & {\n    responseFormat: TypedToolStrategy<T>;\n  }\n): ReactAgent<StateSchema, T, ContextSchema>;\n\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    ToolStrategy<T>\n  > & {\n    responseFormat: ToolStrategy<T>;\n  }\n): ReactAgent<StateSchema, T, ContextSchema>;\n\n// Overload 7: With responseFormat as ProviderStrategy\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    ProviderStrategy<T>\n  > & {\n    responseFormat: ProviderStrategy<T>;\n  }\n): ReactAgent<StateSchema, T, ContextSchema>;\n\n// Overload 8: Without responseFormat property at all\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: Omit<\n    CreateReactAgentParams<\n      StateSchema,\n      ResponseFormatUndefined,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  >\n): ReactAgent<StateSchema, ResponseFormatUndefined, ContextSchema>;\n\n// Overload 9: With responseFormat explicitly undefined\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: Omit<\n    CreateReactAgentParams<\n      StateSchema,\n      ResponseFormatUndefined,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  > & {\n    responseFormat?: undefined;\n  }\n): ReactAgent<StateSchema, ResponseFormatUndefined, ContextSchema>;\n\n// Overload 10: For other ResponseFormat values (failsafe)\nexport function createReactAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema,\n    ResponseFormat\n  > & {\n    responseFormat: ResponseFormat;\n  }\n): ReactAgent<StateSchema, StructuredResponseFormat, ContextSchema>;\n\n// Implementation\nexport function createReactAgent<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject,\n  StructuredResponseFormat extends Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject\n>(\n  params: CreateReactAgentParams<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema,\n    any\n  >\n): ReactAgent<StateSchema, StructuredResponseFormat, ContextSchema> {\n  return new ReactAgent(params);\n}\n\nexport * from \"./types.js\";\nexport * from \"./errors.js\";\nexport * from \"./interrupt.js\";\nexport { ToolNode } from \"./nodes/ToolNode.js\";\nexport {\n  toolStrategy,\n  providerStrategy,\n  ToolStrategy,\n  ProviderStrategy,\n  type ResponseFormat,\n} from \"./responses.js\";\n"],"mappings":";;;;;;;AA0QA,SAAgB,iBAKdA,QAMkE;AAClE,QAAO,IAAI,WAAW;AACvB"}

package/dist/agents/interrupt.cjs

@@ -0,0 +1,2 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));

package/dist/agents/interrupt.d.cts

@@ -0,0 +1,79 @@
+//#region src/agents/interrupt.d.ts
+/**
+ * Configuration interface that defines what actions are allowed for a human interrupt.
+ * This controls the available interaction options when the graph is paused for human input.
+ */
+interface HumanInterruptConfig {
+  /**
+   * Whether the human can choose to ignore/skip the current step
+   */
+  allow_ignore: boolean;
+  /**
+   * Whether the human can provide a text response/feedback
+   */
+  allow_respond: boolean;
+  /**
+   * Whether the human can edit the provided content/state
+   */
+  allow_edit: boolean;
+  /**
+   * Whether the human can accept/approve the current state
+   */
+  allow_accept: boolean;
+}
+/**
+ * Represents a request for human action within the graph execution.
+ * Contains the action type and any associated arguments needed for the action.
+ */
+interface ActionRequest {
+  /**
+   * The type or name of action being requested (e.g., "Approve XYZ action")
+   */
+  action: string;
+  /**
+   * Key-value pairs of arguments needed for the action
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  args: Record<string, any>;
+}
+/**
+ * Represents an interrupt triggered by the graph that requires human intervention.
+ * This is passed to the `interrupt` function when execution is paused for human input.
+ */
+interface HumanInterrupt {
+  /**
+   * The specific action being requested from the human
+   */
+  action_request: ActionRequest;
+  /**
+   * Configuration defining what actions are allowed
+   */
+  config: HumanInterruptConfig;
+  /**
+   * Optional detailed description of what input is needed
+   */
+  description?: string;
+}
+/**
+ * The response provided by a human to an interrupt, which is returned when graph execution resumes.
+ */
+type HumanResponse = {
+  /**
+   * The type of response:
+   * - "accept": Approves the current state without changes
+   * - "ignore": Skips/ignores the current step
+   * - "response": Provides text feedback or instructions
+   * - "edit": Modifies the current state/content
+   */
+  type: "accept" | "ignore" | "response" | "edit";
+  /**
+   * The response payload:
+   * - null: For ignore/accept actions
+   * - string: For text responses
+   * - ActionRequest: For edit actions with updated content
+   */
+  args: null | string | ActionRequest;
+};
+//#endregion
+export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse };
+//# sourceMappingURL=interrupt.d.cts.map

package/dist/agents/interrupt.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.cts","names":["interrupt","HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/agents/interrupt.d.ts"],"sourcesContent":["export { interrupt } from \"@langchain/langgraph\";\n/**\n * Configuration interface that defines what actions are allowed for a human interrupt.\n * This controls the available interaction options when the graph is paused for human input.\n */\nexport interface HumanInterruptConfig {\n    /**\n     * Whether the human can choose to ignore/skip the current step\n     */\n    allow_ignore: boolean;\n    /**\n     * Whether the human can provide a text response/feedback\n     */\n    allow_respond: boolean;\n    /**\n     * Whether the human can edit the provided content/state\n     */\n    allow_edit: boolean;\n    /**\n     * Whether the human can accept/approve the current state\n     */\n    allow_accept: boolean;\n}\n/**\n * Represents a request for human action within the graph execution.\n * Contains the action type and any associated arguments needed for the action.\n */\nexport interface ActionRequest {\n    /**\n     * The type or name of action being requested (e.g., \"Approve XYZ action\")\n     */\n    action: string;\n    /**\n     * Key-value pairs of arguments needed for the action\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention.\n * This is passed to the `interrupt` function when execution is paused for human input.\n */\nexport interface HumanInterrupt {\n    /**\n     * The specific action being requested from the human\n     */\n    action_request: ActionRequest;\n    /**\n     * Configuration defining what actions are allowed\n     */\n    config: HumanInterruptConfig;\n    /**\n     * Optional detailed description of what input is needed\n     */\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n */\nexport type HumanResponse = {\n    /**\n     * The type of response:\n     * - \"accept\": Approves the current state without changes\n     * - \"ignore\": Skips/ignores the current step\n     * - \"response\": Provides text feedback or instructions\n     * - \"edit\": Modifies the current state/content\n     */\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    /**\n     * The response payload:\n     * - null: For ignore/accept actions\n     * - string: For text responses\n     * - ActionRequest: For edit actions with updated content\n     */\n    args: null | string | ActionRequest;\n};\n"],"mappings":";AAKA;AAsBA;AAeA;;AAIoBE,UAzCHD,oBAAAA,CAyCGC;EAAa;AAID;AAShC;;;;;;;;;;;;;;;;;;;UAhCiBA,aAAAA;;;;;;;;;QASPC;;;;;;UAMOC,cAAAA;;;;kBAIGF;;;;UAIRD;;;;;;;;;KASAI,aAAAA;;;;;;;;;;;;;;;wBAecH"}

package/dist/agents/interrupt.d.ts

@@ -0,0 +1,82 @@
+import "@langchain/langgraph";
+
+//#region src/agents/interrupt.d.ts
+
+/**
+ * Configuration interface that defines what actions are allowed for a human interrupt.
+ * This controls the available interaction options when the graph is paused for human input.
+ */
+interface HumanInterruptConfig {
+  /**
+   * Whether the human can choose to ignore/skip the current step
+   */
+  allow_ignore: boolean;
+  /**
+   * Whether the human can provide a text response/feedback
+   */
+  allow_respond: boolean;
+  /**
+   * Whether the human can edit the provided content/state
+   */
+  allow_edit: boolean;
+  /**
+   * Whether the human can accept/approve the current state
+   */
+  allow_accept: boolean;
+}
+/**
+ * Represents a request for human action within the graph execution.
+ * Contains the action type and any associated arguments needed for the action.
+ */
+interface ActionRequest {
+  /**
+   * The type or name of action being requested (e.g., "Approve XYZ action")
+   */
+  action: string;
+  /**
+   * Key-value pairs of arguments needed for the action
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  args: Record<string, any>;
+}
+/**
+ * Represents an interrupt triggered by the graph that requires human intervention.
+ * This is passed to the `interrupt` function when execution is paused for human input.
+ */
+interface HumanInterrupt {
+  /**
+   * The specific action being requested from the human
+   */
+  action_request: ActionRequest;
+  /**
+   * Configuration defining what actions are allowed
+   */
+  config: HumanInterruptConfig;
+  /**
+   * Optional detailed description of what input is needed
+   */
+  description?: string;
+}
+/**
+ * The response provided by a human to an interrupt, which is returned when graph execution resumes.
+ */
+type HumanResponse = {
+  /**
+   * The type of response:
+   * - "accept": Approves the current state without changes
+   * - "ignore": Skips/ignores the current step
+   * - "response": Provides text feedback or instructions
+   * - "edit": Modifies the current state/content
+   */
+  type: "accept" | "ignore" | "response" | "edit";
+  /**
+   * The response payload:
+   * - null: For ignore/accept actions
+   * - string: For text responses
+   * - ActionRequest: For edit actions with updated content
+   */
+  args: null | string | ActionRequest;
+};
+//#endregion
+export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse };
+//# sourceMappingURL=interrupt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.ts","names":["interrupt","HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/agents/interrupt.d.ts"],"sourcesContent":["export { interrupt } from \"@langchain/langgraph\";\n/**\n * Configuration interface that defines what actions are allowed for a human interrupt.\n * This controls the available interaction options when the graph is paused for human input.\n */\nexport interface HumanInterruptConfig {\n    /**\n     * Whether the human can choose to ignore/skip the current step\n     */\n    allow_ignore: boolean;\n    /**\n     * Whether the human can provide a text response/feedback\n     */\n    allow_respond: boolean;\n    /**\n     * Whether the human can edit the provided content/state\n     */\n    allow_edit: boolean;\n    /**\n     * Whether the human can accept/approve the current state\n     */\n    allow_accept: boolean;\n}\n/**\n * Represents a request for human action within the graph execution.\n * Contains the action type and any associated arguments needed for the action.\n */\nexport interface ActionRequest {\n    /**\n     * The type or name of action being requested (e.g., \"Approve XYZ action\")\n     */\n    action: string;\n    /**\n     * Key-value pairs of arguments needed for the action\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention.\n * This is passed to the `interrupt` function when execution is paused for human input.\n */\nexport interface HumanInterrupt {\n    /**\n     * The specific action being requested from the human\n     */\n    action_request: ActionRequest;\n    /**\n     * Configuration defining what actions are allowed\n     */\n    config: HumanInterruptConfig;\n    /**\n     * Optional detailed description of what input is needed\n     */\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n */\nexport type HumanResponse = {\n    /**\n     * The type of response:\n     * - \"accept\": Approves the current state without changes\n     * - \"ignore\": Skips/ignores the current step\n     * - \"response\": Provides text feedback or instructions\n     * - \"edit\": Modifies the current state/content\n     */\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    /**\n     * The response payload:\n     * - null: For ignore/accept actions\n     * - string: For text responses\n     * - ActionRequest: For edit actions with updated content\n     */\n    args: null | string | ActionRequest;\n};\n"],"mappings":";;;;;;AAKA;AAsBA;AAeiBI,UArCAH,oBAAAA,CAqCc;EAAA;;;EAQC,YAAA,EAAA,OAAA;EASpBI;;;;;;;;;;;;;;;;;UAhCKH,aAAAA;;;;;;;;;QASPC;;;;;;UAMOC,cAAAA;;;;kBAIGF;;;;UAIRD;;;;;;;;;KASAI,aAAAA;;;;;;;;;;;;;;;wBAecH"}

package/dist/agents/interrupt.js

@@ -0,0 +1 @@
+import "@langchain/langgraph";

package/dist/agents/nodes/AgentNode.cjs

@@ -0,0 +1,266 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_chat_models_universal = require('../../chat_models/universal.cjs');
+const require_errors = require('../errors.cjs');
+const require_utils = require('../utils.cjs');
+const require_RunnableCallable = require('../RunnableCallable.cjs');
+const require_utils$1 = require('./utils.cjs');
+const require_withAgentName = require('../withAgentName.cjs');
+const require_responses = require('../responses.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));
+const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
+
+//#region src/agents/nodes/AgentNode.ts
+var AgentNode = class extends require_RunnableCallable.RunnableCallable {
+	#options;
+	#structuredToolInfo = {};
+	constructor(options) {
+		super({
+			name: options.name ?? "model",
+			func: (input, config) => this.#run(input, config)
+		});
+		this.#options = options;
+		/**
+		* Populate a list of structured tool info.
+		*/
+		this.#structuredToolInfo = require_responses.transformResponseFormat(this.#options.responseFormat).filter((format) => format instanceof require_responses.ToolStrategy).reduce((acc, format) => {
+			acc[format.name] = format;
+			return acc;
+		}, {});
+	}
+	async #run(state, config) {
+		/**
+		* Check if we just executed a returnDirect tool
+		* 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))
+ /**
+		* return directly without invoking the model again
+		*/
+		return { messages: [] };
+		const response = await this.#invokeModel(state, config);
+		/**
+		* if we were able to generate a structured response, return it
+		*/
+		if ("structuredResponse" in response) return response;
+		/**
+		* if we need to direct the agent to the model, return the update
+		*/
+		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.", {
+			name: this.name,
+			lc_kwargs: { name: this.name },
+			id: response.id
+		})] };
+		return { messages: [response] };
+	}
+	/**
+	* Derive the model from the options.
+	* @param state - The state of the agent.
+	* @param config - The config of the agent.
+	* @returns The model.
+	*/
+	#deriveModel(state, config) {
+		if (this.#options.model) {
+			if (typeof this.#options.model === "string") return require_chat_models_universal.initChatModel(this.#options.model);
+			throw new Error("`model` option must be a string.");
+		}
+		const model = this.#options.llm;
+		/**
+		* If the model is a function, call it to get the model.
+		*/
+		if (typeof model === "function") return model(state, config);
+		if (model) return model;
+		throw new Error("No model option was provided, either via `model` or via `llm` option.");
+	}
+	async #invokeModel(state, config, options = {}) {
+		const model = await this.#deriveModel(state, config);
+		/**
+		* Check if the LLM already has bound tools and throw if it does.
+		*/
+		require_utils.validateLLMHasNoBoundTools(model);
+		const modelWithTools = await this.#bindTools(model);
+		const modelInput = this.#getModelInputState(state);
+		const signal = require_utils$1.mergeAbortSignals(this.#options.signal, config.signal);
+		const invokeConfig = {
+			...config,
+			signal
+		};
+		const response = await modelWithTools.invoke(modelInput, invokeConfig);
+		/**
+		* if the user requests a native schema output, try to parse the response
+		* and return the structured response if it is valid
+		*/
+		if (this.#options.responseFormat instanceof require_responses.ProviderStrategy) {
+			const structuredResponse = this.#options.responseFormat.parse(response);
+			if (structuredResponse) return {
+				structuredResponse,
+				messages: [response]
+			};
+		}
+		if (!response.tool_calls) return response;
+		const toolCalls = response.tool_calls.filter((call) => call.name in this.#structuredToolInfo);
+		/**
+		* if there were not structured tool calls, we can return the response
+		*/
+		if (toolCalls.length === 0) return response;
+		/**
+		* if there were multiple structured tool calls, we should throw an error as this
+		* scenario is not defined/supported.
+		*/
+		if (toolCalls.length > 1) return this.#handleMultipleStructuredOutputs(response, toolCalls);
+		return this.#handleSingleStructuredOutput(response, toolCalls[0], options.lastMessage);
+	}
+	/**
+	* If the model returns multiple structured outputs, we need to handle it.
+	* @param response - The response from the model
+	* @param toolCalls - The tool calls that were made
+	* @returns The response from the model
+	*/
+	#handleMultipleStructuredOutputs(response, toolCalls) {
+		/**
+		* the following should never happen, let's throw an error if it does
+		*/
+		if (this.#options.responseFormat instanceof require_responses.ProviderStrategy) throw new Error("Multiple structured outputs should not apply to native structured output responses");
+		const multipleStructuredOutputsError = new require_errors.MultipleStructuredOutputsError(toolCalls.map((call) => call.name));
+		return this.#handleToolStrategyError(multipleStructuredOutputsError, response, toolCalls[0]);
+	}
+	/**
+	* If the model returns a single structured output, we need to handle it.
+	* @param toolCall - The tool call that was made
+	* @returns The structured response and a message to the LLM if needed
+	*/
+	#handleSingleStructuredOutput(response, toolCall, lastMessage) {
+		const tool = this.#structuredToolInfo[toolCall.name];
+		try {
+			const structuredResponse = tool.parse(toolCall.args);
+			return {
+				structuredResponse,
+				message: new __langchain_core_messages.AIMessage(lastMessage ?? `Returning structured response: ${JSON.stringify(structuredResponse)}`)
+			};
+		} catch (error) {
+			return this.#handleToolStrategyError(error, response, toolCall);
+		}
+	}
+	async #handleToolStrategyError(error, response, toolCall) {
+		/**
+		* Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.
+		* There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user
+		* uses `toolStrategy` to define the response format. If the user applies a list of json
+		* schema objects, these will be transformed into multiple `ToolStrategy` entries but all
+		* with the same `handleError` option.
+		*/
+		const errorHandler = Object.values(this.#structuredToolInfo).at(0)?.options?.handleError;
+		const toolCallId = toolCall.id;
+		if (!toolCallId) throw new Error("Tool call ID is required to handle tool output errors. Please provide a tool call ID.");
+		/**
+		* retry if:
+		*/
+		if (typeof errorHandler === "boolean" && errorHandler || Array.isArray(errorHandler) && errorHandler.some((h) => h instanceof require_errors.MultipleStructuredOutputsError)) return new __langchain_langgraph.Command({
+			update: { messages: [response, new __langchain_core_messages.ToolMessage({
+				content: error.message,
+				tool_call_id: toolCallId
+			})] },
+			goto: "model"
+		});
+		/**
+		* if `errorHandler` is a string, retry the tool call with given string
+		*/
+		if (typeof errorHandler === "string") return new __langchain_langgraph.Command({
+			update: { messages: [response, new __langchain_core_messages.ToolMessage({
+				content: errorHandler,
+				tool_call_id: toolCallId
+			})] },
+			goto: "model"
+		});
+		/**
+		* if `errorHandler` is a function, retry the tool call with the function
+		*/
+		if (typeof errorHandler === "function") {
+			const content = await errorHandler(error);
+			if (typeof content !== "string") throw new Error("Error handler must return a string.");
+			return new __langchain_langgraph.Command({
+				update: { messages: [response, new __langchain_core_messages.ToolMessage({
+					content,
+					tool_call_id: toolCallId
+				})] },
+				goto: "model"
+			});
+		}
+		/**
+		* throw otherwise, e.g. if `errorHandler` is not defined or set to `false`
+		*/
+		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 remainingSteps = "remainingSteps" in state ? state.remainingSteps : void 0;
+		return Boolean(remainingSteps && (remainingSteps < 1 && allToolsReturnDirect || remainingSteps < 2 && require_utils.hasToolCalls(state.messages)));
+	}
+	#getModelInputState(state) {
+		const { messages, llmInputMessages,...rest } = state;
+		if (llmInputMessages && llmInputMessages.length > 0) return {
+			messages: llmInputMessages,
+			...rest
+		};
+		return {
+			messages,
+			...rest
+		};
+	}
+	async #bindTools(model) {
+		const options = {};
+		const structuredTools = Object.values(this.#structuredToolInfo);
+		const allTools = this.#options.toolClasses.concat(...structuredTools.map((toolStrategy) => toolStrategy.tool));
+		/**
+		* If there are structured tools, we need to set the tool choice to "any"
+		* so that the model can choose to use a structured tool or not.
+		*/
+		const toolChoice = structuredTools.length > 0 ? "any" : void 0;
+		/**
+		* check if the user requests a native schema output
+		*/
+		if (this.#options.responseFormat instanceof require_responses.ProviderStrategy) {
+			/**
+			* if the model does not support JSON schema output, throw an error
+			*/
+			if (!require_utils.hasSupportForJsonSchemaOutput(model)) throw new Error("Model does not support native structured output responses. Please use a model that supports native structured output responses or use a tool output.");
+			const jsonSchemaParams = {
+				name: this.#options.responseFormat.schema?.name ?? "extract",
+				description: (0, __langchain_core_utils_types.getSchemaDescription)(this.#options.responseFormat.schema),
+				schema: this.#options.responseFormat.schema,
+				strict: true
+			};
+			Object.assign(options, {
+				response_format: {
+					type: "json_schema",
+					json_schema: jsonSchemaParams
+				},
+				ls_structured_output_format: {
+					kwargs: { method: "json_schema" },
+					schema: this.#options.responseFormat.schema
+				},
+				strict: true
+			});
+		}
+		/**
+		* Bind tools to the model if they are not already bound.
+		*/
+		const modelWithTools = await require_utils.bindTools(model, allTools, {
+			...options,
+			tool_choice: toolChoice
+		});
+		/**
+		* Create a model runnable with the prompt and agent name
+		*/
+		const modelRunnable = require_utils.getPromptRunnable(this.#options.prompt).pipe(this.#options.includeAgentName === "inline" ? require_withAgentName.withAgentName(modelWithTools, this.#options.includeAgentName) : modelWithTools);
+		return modelRunnable;
+	}
+};
+
+//#endregion
+exports.AgentNode = AgentNode;
+//# sourceMappingURL=AgentNode.cjs.map

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

@@ -0,0 +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","response:\n      | AIMessage\n      | Command\n      | { structuredResponse: StructuredResponseFormat }","#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  CreateReactAgentParams,\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      message: AIMessage;\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    CreateReactAgentParams<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >,\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:\n      | AIMessage\n      | Command\n      | { structuredResponse: StructuredResponseFormat } =\n      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 response;\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<\n    | AIMessage\n    | Command\n    | { structuredResponse: StructuredResponseFormat; messages?: BaseMessage[] }\n  > {\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    return this.#handleSingleStructuredOutput(\n      response,\n      toolCalls[0],\n      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        message: new AIMessage(\n          lastMessage ??\n            `Returning structured response: ${JSON.stringify(\n              structuredResponse\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":";;;;;;;;;;;;;AAiEA,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,MAAMO,WAIJ,MAAM,KAAKC,aAAa,OAAO,OAAO;;;;AAKxC,MAAI,wBAAwB,SAC1B,QAAO;;;;AAMT,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,aACEP,OAEAC,QACA;AACA,MAAI,KAAKL,SAAS,OAAO;AACvB,OAAI,OAAO,KAAKA,SAAS,UAAU,SACjC,QAAOY,4CAAc,KAAKZ,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,MAAMQ,aACJJ,OAEAC,QACAQ,UAEI,CAAE,GAKN;EACA,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,KAAKlB,SAAS,QAAQ,OAAO,OAAO;EACrE,MAAM,eAAe;GACnB,GAAG;GACH;EACD;EAED,MAAM,WAAY,MAAM,eAAe,OACrC,YACA,aACD;;;;;AAMD,MAAI,KAAKA,SAAS,0BAA0BmB,oCAAkB;GAC5D,MAAM,qBAAqB,KAAKnB,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,KAAKmB,iCAAiC,UAAU,UAAU;AAGnE,SAAO,KAAKC,8BACV,UACA,UAAU,IACV,QAAQ,YACT;CACF;;;;;;;CAQD,iCACEC,UACAC,WACkB;;;;AAIlB,MAAI,KAAKvB,SAAS,0BAA0BmB,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,KAAK1B,oBAAoB,SAAS;AAE/C,MAAI;GACF,MAAM,qBAAqB,KAAK,MAC9B,SAAS,KACV;AAED,UAAO;IACL;IACA,SAAS,IAAIU,oCACX,eACE,CAAC,+BAA+B,EAAE,KAAK,UACrC,mBACD,EAAE;GAER;EACF,SAAQ,OAAO;AACd,UAAO,KAAKc,yBACV,OACA,UACA,SACD;EACF;CACF;CAED,MAAMA,yBACJG,OACAN,UACAI,UACkB;;;;;;;;EAQlB,MAAM,eAAe,OAAO,OAAO,KAAKzB,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,aAAauB,8CAA+B,CAEvE,QAAO,IAAIf,8BAAQ;GACjB,QAAQ,EACN,UAAU,CACR,UACA,IAAIH,sCAAY;IACd,SAAS,MAAM;IACf,cAAc;GACf,EACF,EACF;GACD,MAAM;EACP;;;;AAMH,MAAI,OAAO,iBAAiB,SAC1B,QAAO,IAAIG,8BAAQ;GACjB,QAAQ,EACN,UAAU,CACR,UACA,IAAIH,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,IAAIG,8BAAQ;IACjB,QAAQ,EACN,UAAU,CACR,UACA,IAAIH,sCAAY;KACd;KACA,cAAc;IACf,EACF,EACF;IACD,MAAM;GACP;EACF;;;;AAKD,QAAM;CACP;CAED,oBACEF,OAEAyB,UACS;EACT,MAAM,uBACJ,oBAAoBlB,uCACpB,SAAS,YAAY,MAAM,CAAC,SAC1B,KAAKX,SAAS,mBAAmB,IAAI,KAAK,KAAK,CAChD;EACH,MAAM,iBACJ,oBAAoB,QAAS,MAAM,iBAA4B;AACjE,SAAO,QACL,mBACI,iBAAiB,KAAK,wBACrB,iBAAiB,KAAK8B,2BAAa,MAAM,SAAS,EACxD;CACF;CAED,oBACE1B,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,MAAMY,WAAWe,OAA6C;EAC5D,MAAMC,UAA6C,CAAE;EACrD,MAAM,kBAAkB,OAAO,OAAO,KAAK/B,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,0BAA0BmB,oCAAkB;;;;AAI5D,OAAI,CAACc,4CAA8B,MAAM,CACvC,OAAM,IAAI,MACR;GAIJ,MAAM,mBAAmB;IACvB,MAAM,KAAKjC,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,MAAMkC,wBAAU,OAAO,UAAU;GACtD,GAAG;GACH,aAAa;EACd,EAAC;;;;EAKF,MAAM,gBAAgBC,gCAAkB,KAAKnC,SAAS,OAAO,CAAC,KAC5D,KAAKA,SAAS,qBAAqB,WAC/BoC,oCAAc,gBAAgB,KAAKpC,SAAS,iBAAiB,GAC7D,eACL;AAED,SAAO;CACR;AACF"}