@langchain/langgraph 0.4.8 → 1.0.0-alpha.0

package/dist/prebuilt/chat_agent_executor.js

@@ -1,127 +1,67 @@
-import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
-import { FunctionMessage } from "@langchain/core/messages";
-import { RunnableLambda, } from "@langchain/core/runnables";
-import { ToolExecutor } from "./tool_executor.js";
-import { StateGraph, } from "../graph/state.js";
 import { END, START } from "../constants.js";
+import { StateGraph } from "../graph/state.js";
+import { ToolExecutor } from "./tool_executor.js";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { FunctionMessage } from "@langchain/core/messages";
+import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
+
+//#region src/prebuilt/chat_agent_executor.ts
 /** @deprecated Use {@link createReactAgent} instead with tool calling. */
-export function createFunctionCallingExecutor({ model, tools, }) {
-    let toolExecutor;
-    let toolClasses;
-    if (!Array.isArray(tools)) {
-        toolExecutor = tools;
-        toolClasses = tools.tools;
-    }
-    else {
-        toolExecutor = new ToolExecutor({
-            tools,
-        });
-        toolClasses = tools;
-    }
-    if (!("bind" in model) || typeof model.bind !== "function") {
-        throw new Error("Model must be bindable");
-    }
-    const toolsAsOpenAIFunctions = toolClasses.map((tool) => convertToOpenAIFunction(tool));
-    const newModel = model.bind({
-        functions: toolsAsOpenAIFunctions,
-    });
-    // Define the function that determines whether to continue or not
-    const shouldContinue = (state) => {
-        const { messages } = state;
-        const lastMessage = messages[messages.length - 1];
-        // If there is no function call, then we finish
-        if (!("function_call" in lastMessage.additional_kwargs) ||
-            !lastMessage.additional_kwargs.function_call) {
-            return "end";
-        }
-        // Otherwise if there is, we continue
-        return "continue";
-    };
-    // Define the function that calls the model
-    const callModel = async (state, config) => {
-        const { messages } = state;
-        const response = await newModel.invoke(messages, config);
-        // We return a list, because this will get added to the existing list
-        return {
-            messages: [response],
-        };
-    };
-    // Define the function to execute tools
-    const _getAction = (state) => {
-        const { messages } = state;
-        // Based on the continue condition
-        // we know the last message involves a function call
-        const lastMessage = messages[messages.length - 1];
-        if (!lastMessage) {
-            throw new Error("No messages found.");
-        }
-        if (!lastMessage.additional_kwargs.function_call) {
-            throw new Error("No function call found in message.");
-        }
-        // We construct an AgentAction from the function_call
-        return {
-            tool: lastMessage.additional_kwargs.function_call.name,
-            toolInput: JSON.stringify(lastMessage.additional_kwargs.function_call.arguments),
-            log: "",
-        };
-    };
-    const callTool = async (state, config) => {
-        const action = _getAction(state);
-        // We call the tool_executor and get back a response
-        const response = await toolExecutor.invoke(action, config);
-        // We use the response to create a FunctionMessage
-        const functionMessage = new FunctionMessage({
-            content: response,
-            name: action.tool,
-        });
-        // We return a list, because this will get added to the existing list
-        return { messages: [functionMessage] };
-    };
-    // We create the AgentState that we will pass around
-    // This simply involves a list of messages
-    // We want steps to return messages to append to the list
-    // So we annotate the messages attribute with operator.add
-    const schema = {
-        messages: {
-            value: (x, y) => x.concat(y),
-            default: () => [],
-        },
-    };
-    // Define a new graph
-    const workflow = new StateGraph({
-        channels: schema,
-    })
-        // Define the two nodes we will cycle between
-        .addNode("agent", new RunnableLambda({ func: callModel }))
-        .addNode("action", new RunnableLambda({ func: callTool }))
-        // Set the entrypoint as `agent`
-        // This means that this node is the first one called
-        .addEdge(START, "agent")
-        // We now add a conditional edge
-        .addConditionalEdges(
-    // First, we define the start node. We use `agent`.
-    // This means these are the edges taken after the `agent` node is called.
-    "agent", 
-    // Next, we pass in the function that will determine which node is called next.
-    shouldContinue, 
-    // Finally we pass in a mapping.
-    // The keys are strings, and the values are other nodes.
-    // END is a special node marking that the graph should finish.
-    // What will happen is we will call `should_continue`, and then the output of that
-    // will be matched against the keys in this mapping.
-    // Based on which one it matches, that node will then be called.
-    {
-        // If `tools`, then we call the tool node.
-        continue: "action",
-        // Otherwise we finish.
-        end: END,
-    })
-        // We now add a normal edge from `tools` to `agent`.
-        // This means that after `tools` is called, `agent` node is called next.
-        .addEdge("action", "agent");
-    // Finally, we compile it!
-    // This compiles it into a LangChain Runnable,
-    // meaning you can use it as you would any other runnable
-    return workflow.compile();
+function createFunctionCallingExecutor({ model, tools }) {
+	let toolExecutor;
+	let toolClasses;
+	if (!Array.isArray(tools)) {
+		toolExecutor = tools;
+		toolClasses = tools.tools;
+	} else {
+		toolExecutor = new ToolExecutor({ tools });
+		toolClasses = tools;
+	}
+	if (!("bind" in model) || typeof model.bind !== "function") throw new Error("Model must be bindable");
+	const toolsAsOpenAIFunctions = toolClasses.map((tool) => convertToOpenAIFunction(tool));
+	const newModel = model.bind({ functions: toolsAsOpenAIFunctions });
+	const shouldContinue = (state) => {
+		const { messages } = state;
+		const lastMessage = messages[messages.length - 1];
+		if (!("function_call" in lastMessage.additional_kwargs) || !lastMessage.additional_kwargs.function_call) return "end";
+		return "continue";
+	};
+	const callModel = async (state, config) => {
+		const { messages } = state;
+		const response = await newModel.invoke(messages, config);
+		return { messages: [response] };
+	};
+	const _getAction = (state) => {
+		const { messages } = state;
+		const lastMessage = messages[messages.length - 1];
+		if (!lastMessage) throw new Error("No messages found.");
+		if (!lastMessage.additional_kwargs.function_call) throw new Error("No function call found in message.");
+		return {
+			tool: lastMessage.additional_kwargs.function_call.name,
+			toolInput: JSON.stringify(lastMessage.additional_kwargs.function_call.arguments),
+			log: ""
+		};
+	};
+	const callTool = async (state, config) => {
+		const action = _getAction(state);
+		const response = await toolExecutor.invoke(action, config);
+		const functionMessage = new FunctionMessage({
+			content: response,
+			name: action.tool
+		});
+		return { messages: [functionMessage] };
+	};
+	const schema = { messages: {
+		value: (x, y) => x.concat(y),
+		default: () => []
+	} };
+	const workflow = new StateGraph({ channels: schema }).addNode("agent", new RunnableLambda({ func: callModel })).addNode("action", new RunnableLambda({ func: callTool })).addEdge(START, "agent").addConditionalEdges("agent", shouldContinue, {
+		continue: "action",
+		end: END
+	}).addEdge("action", "agent");
+	return workflow.compile();
 }
+
+//#endregion
+export { createFunctionCallingExecutor };
 //# sourceMappingURL=chat_agent_executor.js.map

package/dist/prebuilt/chat_agent_executor.js.map

@@ -1 +1 @@
-{"version":3,"file":"chat_agent_executor.js","sourceRoot":"","sources":["../../src/prebuilt/chat_agent_executor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chat_agent_executor.js","names":["toolExecutor: ToolExecutor","toolClasses: Array<StructuredToolInterface | RunnableToolLike>","schema: StateGraphArgs<FunctionCallingExecutorState>[\"channels\"]"],"sources":["../../src/prebuilt/chat_agent_executor.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { convertToOpenAIFunction } from \"@langchain/core/utils/function_calling\";\nimport { AgentAction } from \"@langchain/core/agents\";\nimport { FunctionMessage, BaseMessage } from \"@langchain/core/messages\";\nimport {\n  type RunnableConfig,\n  RunnableLambda,\n  RunnableToolLike,\n} from \"@langchain/core/runnables\";\nimport { ToolExecutor } from \"./tool_executor.js\";\nimport {\n  CompiledStateGraph,\n  StateGraph,\n  StateGraphArgs,\n} from \"../graph/state.js\";\nimport { END, START } from \"../constants.js\";\n\n/** @deprecated Use {@link createReactAgent} instead with tool calling. */\nexport type FunctionCallingExecutorState = { messages: Array<BaseMessage> };\n\n/** @deprecated Use {@link createReactAgent} instead with tool calling. */\nexport function createFunctionCallingExecutor<Model extends object>({\n  model,\n  tools,\n}: {\n  model: Model;\n  tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;\n}): CompiledStateGraph<\n  FunctionCallingExecutorState,\n  Partial<FunctionCallingExecutorState>,\n  typeof START | \"agent\" | \"action\"\n> {\n  let toolExecutor: ToolExecutor;\n  let toolClasses: Array<StructuredToolInterface | RunnableToolLike>;\n  if (!Array.isArray(tools)) {\n    toolExecutor = tools;\n    toolClasses = tools.tools;\n  } else {\n    toolExecutor = new ToolExecutor({\n      tools,\n    });\n    toolClasses = tools;\n  }\n\n  if (!(\"bind\" in model) || typeof model.bind !== \"function\") {\n    throw new Error(\"Model must be bindable\");\n  }\n  const toolsAsOpenAIFunctions = toolClasses.map((tool) =>\n    convertToOpenAIFunction(tool)\n  );\n  const newModel = model.bind({\n    functions: toolsAsOpenAIFunctions,\n  });\n\n  // Define the function that determines whether to continue or not\n  const shouldContinue = (state: FunctionCallingExecutorState) => {\n    const { messages } = state;\n    const lastMessage = messages[messages.length - 1];\n    // If there is no function call, then we finish\n    if (\n      !(\"function_call\" in lastMessage.additional_kwargs) ||\n      !lastMessage.additional_kwargs.function_call\n    ) {\n      return \"end\";\n    }\n    // Otherwise if there is, we continue\n    return \"continue\";\n  };\n\n  // Define the function that calls the model\n  const callModel = async (\n    state: FunctionCallingExecutorState,\n    config?: RunnableConfig\n  ) => {\n    const { messages } = state;\n    const response = await newModel.invoke(messages, config);\n    // We return a list, because this will get added to the existing list\n    return {\n      messages: [response],\n    };\n  };\n\n  // Define the function to execute tools\n  const _getAction = (state: FunctionCallingExecutorState): AgentAction => {\n    const { messages } = state;\n    // Based on the continue condition\n    // we know the last message involves a function call\n    const lastMessage = messages[messages.length - 1];\n    if (!lastMessage) {\n      throw new Error(\"No messages found.\");\n    }\n    if (!lastMessage.additional_kwargs.function_call) {\n      throw new Error(\"No function call found in message.\");\n    }\n    // We construct an AgentAction from the function_call\n    return {\n      tool: lastMessage.additional_kwargs.function_call.name,\n      toolInput: JSON.stringify(\n        lastMessage.additional_kwargs.function_call.arguments\n      ),\n      log: \"\",\n    };\n  };\n\n  const callTool = async (\n    state: FunctionCallingExecutorState,\n    config?: RunnableConfig\n  ) => {\n    const action = _getAction(state);\n    // We call the tool_executor and get back a response\n    const response = await toolExecutor.invoke(action, config);\n    // We use the response to create a FunctionMessage\n    const functionMessage = new FunctionMessage({\n      content: response,\n      name: action.tool,\n    });\n    // We return a list, because this will get added to the existing list\n    return { messages: [functionMessage] };\n  };\n\n  // We create the AgentState that we will pass around\n  // This simply involves a list of messages\n  // We want steps to return messages to append to the list\n  // So we annotate the messages attribute with operator.add\n  const schema: StateGraphArgs<FunctionCallingExecutorState>[\"channels\"] = {\n    messages: {\n      value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),\n      default: () => [],\n    },\n  };\n\n  // Define a new graph\n  const workflow = new StateGraph<FunctionCallingExecutorState>({\n    channels: schema,\n  })\n    // Define the two nodes we will cycle between\n    .addNode(\"agent\", new RunnableLambda({ func: callModel }))\n    .addNode(\"action\", new RunnableLambda({ func: callTool }))\n    // Set the entrypoint as `agent`\n    // This means that this node is the first one called\n    .addEdge(START, \"agent\")\n    // We now add a conditional edge\n    .addConditionalEdges(\n      // First, we define the start node. We use `agent`.\n      // This means these are the edges taken after the `agent` node is called.\n      \"agent\",\n      // Next, we pass in the function that will determine which node is called next.\n      shouldContinue,\n      // Finally we pass in a mapping.\n      // The keys are strings, and the values are other nodes.\n      // END is a special node marking that the graph should finish.\n      // What will happen is we will call `should_continue`, and then the output of that\n      // will be matched against the keys in this mapping.\n      // Based on which one it matches, that node will then be called.\n      {\n        // If `tools`, then we call the tool node.\n        continue: \"action\",\n        // Otherwise we finish.\n        end: END,\n      }\n    )\n    // We now add a normal edge from `tools` to `agent`.\n    // This means that after `tools` is called, `agent` node is called next.\n    .addEdge(\"action\", \"agent\");\n\n  // Finally, we compile it!\n  // This compiles it into a LangChain Runnable,\n  // meaning you can use it as you would any other runnable\n  return workflow.compile();\n}\n"],"mappings":";;;;;;;;;AAqBA,SAAgB,8BAAoD,EAClE,OACA,SAQA;CACA,IAAIA;CACJ,IAAIC;AACJ,KAAI,CAAC,MAAM,QAAQ,QAAQ;AACzB,iBAAe;AACf,gBAAc,MAAM;QACf;AACL,iBAAe,IAAI,aAAa,EAC9B;AAEF,gBAAc;;AAGhB,KAAI,EAAE,UAAU,UAAU,OAAO,MAAM,SAAS,WAC9C,OAAM,IAAI,MAAM;CAElB,MAAM,yBAAyB,YAAY,KAAK,SAC9C,wBAAwB;CAE1B,MAAM,WAAW,MAAM,KAAK,EAC1B,WAAW;CAIb,MAAM,kBAAkB,UAAwC;EAC9D,MAAM,EAAE,aAAa;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;AAE/C,MACE,EAAE,mBAAmB,YAAY,sBACjC,CAAC,YAAY,kBAAkB,cAE/B,QAAO;AAGT,SAAO;;CAIT,MAAM,YAAY,OAChB,OACA,WACG;EACH,MAAM,EAAE,aAAa;EACrB,MAAM,WAAW,MAAM,SAAS,OAAO,UAAU;AAEjD,SAAO,EACL,UAAU,CAAC;;CAKf,MAAM,cAAc,UAAqD;EACvE,MAAM,EAAE,aAAa;EAGrB,MAAM,cAAc,SAAS,SAAS,SAAS;AAC/C,MAAI,CAAC,YACH,OAAM,IAAI,MAAM;AAElB,MAAI,CAAC,YAAY,kBAAkB,cACjC,OAAM,IAAI,MAAM;AAGlB,SAAO;GACL,MAAM,YAAY,kBAAkB,cAAc;GAClD,WAAW,KAAK,UACd,YAAY,kBAAkB,cAAc;GAE9C,KAAK;;;CAIT,MAAM,WAAW,OACf,OACA,WACG;EACH,MAAM,SAAS,WAAW;EAE1B,MAAM,WAAW,MAAM,aAAa,OAAO,QAAQ;EAEnD,MAAM,kBAAkB,IAAI,gBAAgB;GAC1C,SAAS;GACT,MAAM,OAAO;;AAGf,SAAO,EAAE,UAAU,CAAC;;CAOtB,MAAMC,SAAmE,EACvE,UAAU;EACR,QAAQ,GAAkB,MAAqB,EAAE,OAAO;EACxD,eAAe;;CAKnB,MAAM,WAAW,IAAI,WAAyC,EAC5D,UAAU,UAGT,QAAQ,SAAS,IAAI,eAAe,EAAE,MAAM,cAC5C,QAAQ,UAAU,IAAI,eAAe,EAAE,MAAM,aAG7C,QAAQ,OAAO,SAEf,oBAGC,SAEA,gBAOA;EAEE,UAAU;EAEV,KAAK;IAKR,QAAQ,UAAU;AAKrB,QAAO,SAAS"}

package/dist/prebuilt/index.cjs

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withAgentName = exports.toolsCondition = exports.ToolNode = exports.ToolExecutor = exports.createReactAgentAnnotation = exports.createReactAgent = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
-var agent_executor_js_1 = require("./agent_executor.cjs");
-Object.defineProperty(exports, "createAgentExecutor", { enumerable: true, get: function () { return agent_executor_js_1.createAgentExecutor; } });
-var chat_agent_executor_js_1 = require("./chat_agent_executor.cjs");
-Object.defineProperty(exports, "createFunctionCallingExecutor", { enumerable: true, get: function () { return chat_agent_executor_js_1.createFunctionCallingExecutor; } });
-var react_agent_executor_js_1 = require("./react_agent_executor.cjs");
-Object.defineProperty(exports, "createReactAgent", { enumerable: true, get: function () { return react_agent_executor_js_1.createReactAgent; } });
-Object.defineProperty(exports, "createReactAgentAnnotation", { enumerable: true, get: function () { return react_agent_executor_js_1.createReactAgentAnnotation; } });
-var tool_executor_js_1 = require("./tool_executor.cjs");
-Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return tool_executor_js_1.ToolExecutor; } });
-var tool_node_js_1 = require("./tool_node.cjs");
-Object.defineProperty(exports, "ToolNode", { enumerable: true, get: function () { return tool_node_js_1.ToolNode; } });
-Object.defineProperty(exports, "toolsCondition", { enumerable: true, get: function () { return tool_node_js_1.toolsCondition; } });
-var agentName_js_1 = require("./agentName.cjs");
-Object.defineProperty(exports, "withAgentName", { enumerable: true, get: function () { return agentName_js_1.withAgentName; } });
-//# sourceMappingURL=index.js.map
+const require_tool_executor = require('./tool_executor.cjs');
+const require_agent_executor = require('./agent_executor.cjs');
+const require_chat_agent_executor = require('./chat_agent_executor.cjs');
+const require_tool_node = require('./tool_node.cjs');
+const require_agentName = require('./agentName.cjs');
+const require_react_agent_executor = require('./react_agent_executor.cjs');
+
+exports.ToolExecutor = require_tool_executor.ToolExecutor;
+exports.ToolNode = require_tool_node.ToolNode;
+exports.createAgentExecutor = require_agent_executor.createAgentExecutor;
+exports.createFunctionCallingExecutor = require_chat_agent_executor.createFunctionCallingExecutor;
+exports.createReactAgent = require_react_agent_executor.createReactAgent;
+exports.createReactAgentAnnotation = require_react_agent_executor.createReactAgentAnnotation;
+exports.toolsCondition = require_tool_node.toolsCondition;
+exports.withAgentName = require_agentName.withAgentName;

package/dist/prebuilt/index.d.cts

@@ -0,0 +1,8 @@
+import { ToolExecutor, ToolExecutorArgs, ToolInvocationInterface } from "./tool_executor.cjs";
+import { AgentExecutorState, createAgentExecutor } from "./agent_executor.cjs";
+import { FunctionCallingExecutorState, createFunctionCallingExecutor } from "./chat_agent_executor.cjs";
+import { ToolNode, ToolNodeOptions, toolsCondition } from "./tool_node.cjs";
+import { AgentState, CreateReactAgentParams, createReactAgent, createReactAgentAnnotation } from "./react_agent_executor.cjs";
+import { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse } from "./interrupt.cjs";
+import { AgentNameMode, withAgentName } from "./agentName.cjs";
+export { type ActionRequest, type AgentExecutorState, type AgentNameMode, type AgentState, type CreateReactAgentParams, type FunctionCallingExecutorState, type HumanInterrupt, type HumanInterruptConfig, type HumanResponse, ToolExecutor, type ToolExecutorArgs, type ToolInvocationInterface, ToolNode, type ToolNodeOptions, createAgentExecutor, createFunctionCallingExecutor, createReactAgent, createReactAgentAnnotation, toolsCondition, withAgentName };

package/dist/prebuilt/index.d.ts

@@ -1,8 +1,8 @@
-export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.js";
-export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { type AgentState, type CreateReactAgentParams, createReactAgent, createReactAgentAnnotation, } from "./react_agent_executor.js";
-export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
-export { ToolNode, toolsCondition, type ToolNodeOptions } from "./tool_node.js";
-export type { HumanInterruptConfig, ActionRequest, HumanInterrupt, HumanResponse, } from "./interrupt.js";
-export { withAgentName } from "./agentName.js";
-export type { AgentNameMode } from "./agentName.js";
+import { ToolExecutor, ToolExecutorArgs, ToolInvocationInterface } from "./tool_executor.js";
+import { AgentExecutorState, createAgentExecutor } from "./agent_executor.js";
+import { FunctionCallingExecutorState, createFunctionCallingExecutor } from "./chat_agent_executor.js";
+import { ToolNode, ToolNodeOptions, toolsCondition } from "./tool_node.js";
+import { AgentState, CreateReactAgentParams, createReactAgent, createReactAgentAnnotation } from "./react_agent_executor.js";
+import { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse } from "./interrupt.js";
+import { AgentNameMode, withAgentName } from "./agentName.js";
+export { type ActionRequest, type AgentExecutorState, type AgentNameMode, type AgentState, type CreateReactAgentParams, type FunctionCallingExecutorState, type HumanInterrupt, type HumanInterruptConfig, type HumanResponse, ToolExecutor, type ToolExecutorArgs, type ToolInvocationInterface, ToolNode, type ToolNodeOptions, createAgentExecutor, createFunctionCallingExecutor, createReactAgent, createReactAgentAnnotation, toolsCondition, withAgentName };

package/dist/prebuilt/index.js

@@ -1,7 +1,8 @@
-export { createAgentExecutor, } from "./agent_executor.js";
-export { createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { createReactAgent, createReactAgentAnnotation, } from "./react_agent_executor.js";
-export { ToolExecutor, } from "./tool_executor.js";
-export { ToolNode, toolsCondition } from "./tool_node.js";
-export { withAgentName } from "./agentName.js";
-//# sourceMappingURL=index.js.map
+import { ToolExecutor } from "./tool_executor.js";
+import { createAgentExecutor } from "./agent_executor.js";
+import { createFunctionCallingExecutor } from "./chat_agent_executor.js";
+import { ToolNode, toolsCondition } from "./tool_node.js";
+import { withAgentName } from "./agentName.js";
+import { createReactAgent, createReactAgentAnnotation } from "./react_agent_executor.js";
+
+export { ToolExecutor, ToolNode, createAgentExecutor, createFunctionCallingExecutor, createReactAgent, createReactAgentAnnotation, toolsCondition, withAgentName };

package/dist/prebuilt/interrupt.d.cts

@@ -0,0 +1,73 @@
+//#region src/prebuilt/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.
+ *
+ * @deprecated Use `HumanInterruptConfig` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { HumanInterruptConfig } from "langchain";`
+ *
+ * @property {boolean} allow_ignore - Whether the human can choose to ignore/skip the current step
+ * @property {boolean} allow_respond - Whether the human can provide a text response/feedback
+ * @property {boolean} allow_edit - Whether the human can edit the provided content/state
+ * @property {boolean} allow_accept - Whether the human can accept/approve the current state
+ */
+interface HumanInterruptConfig {
+  allow_ignore: boolean;
+  allow_respond: boolean;
+  allow_edit: boolean;
+  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.
+ *
+ * @deprecated Use `ActionRequest` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { ActionRequest } from "langchain/prebuilt/interrupt";`
+ *
+ * @property {string} action - The type or name of action being requested (e.g., "Approve XYZ action")
+ * @property {Record<string, any>} args - Key-value pairs of arguments needed for the action
+ */
+interface ActionRequest {
+  action: string;
+  // 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.
+ *
+ * @deprecated Use `HumanInterrupt` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { HumanInterrupt } from "langchain/prebuilt/interrupt";`
+ *
+ * @property {ActionRequest} action_request - The specific action being requested from the human
+ * @property {HumanInterruptConfig} config - Configuration defining what actions are allowed
+ * @property {string} [description] - Optional detailed description of what input is needed
+ */
+interface HumanInterrupt {
+  action_request: ActionRequest;
+  config: HumanInterruptConfig;
+  description?: string;
+}
+/**
+ * The response provided by a human to an interrupt, which is returned when graph execution resumes.
+ *
+ * @deprecated Use `HumanResponse` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { HumanResponse } from "langchain/prebuilt/interrupt";`
+ *
+ * @property {("accept"|"ignore"|"response"|"edit")} type - 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
+ * @property {null|string|ActionRequest} args - The response payload:
+ *   - null: For ignore/accept actions
+ *   - string: For text responses
+ *   - ActionRequest: For edit actions with updated content
+ */
+type HumanResponse = {
+  type: "accept" | "ignore" | "response" | "edit";
+  args: null | string | ActionRequest;
+};
+//#endregion
+export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse };
+//# sourceMappingURL=interrupt.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.cts","names":["HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/prebuilt/interrupt.d.ts"],"sourcesContent":["/**\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 *\n * @deprecated Use `HumanInterruptConfig` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { HumanInterruptConfig } from \"langchain\";`\n *\n * @property {boolean} allow_ignore - Whether the human can choose to ignore/skip the current step\n * @property {boolean} allow_respond - Whether the human can provide a text response/feedback\n * @property {boolean} allow_edit - Whether the human can edit the provided content/state\n * @property {boolean} allow_accept - Whether the human can accept/approve the current state\n */\nexport interface HumanInterruptConfig {\n    allow_ignore: boolean;\n    allow_respond: boolean;\n    allow_edit: boolean;\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 *\n * @deprecated Use `ActionRequest` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { ActionRequest } from \"langchain/prebuilt/interrupt\";`\n *\n * @property {string} action - The type or name of action being requested (e.g., \"Approve XYZ action\")\n * @property {Record<string, any>} args - Key-value pairs of arguments needed for the action\n */\nexport interface ActionRequest {\n    action: string;\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 *\n * @deprecated Use `HumanInterrupt` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { HumanInterrupt } from \"langchain/prebuilt/interrupt\";`\n *\n * @property {ActionRequest} action_request - The specific action being requested from the human\n * @property {HumanInterruptConfig} config - Configuration defining what actions are allowed\n * @property {string} [description] - Optional detailed description of what input is needed\n */\nexport interface HumanInterrupt {\n    action_request: ActionRequest;\n    config: HumanInterruptConfig;\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n *\n * @deprecated Use `HumanResponse` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { HumanResponse } from \"langchain/prebuilt/interrupt\";`\n *\n * @property {(\"accept\"|\"ignore\"|\"response\"|\"edit\")} type - 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 * @property {null|string|ActionRequest} args - The response payload:\n *   - null: For ignore/accept actions\n *   - string: For text responses\n *   - ActionRequest: For edit actions with updated content\n */\nexport type HumanResponse = {\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    args: null | string | ActionRequest;\n};\n"],"mappings":";;AAYA;AAgBA;AAgBA;;;;;AAqBA;;;;UArDiBA,oBAAAA;;;;;;;;;;;;;;;;UAgBAC,aAAAA;;;QAGPC;;;;;;;;;;;;;UAaOC,cAAAA;kBACGF;UACRD;;;;;;;;;;;;;;;;;;;KAmBAI,aAAAA;;wBAEcH"}

package/dist/prebuilt/interrupt.d.ts

@@ -1,45 +1,59 @@
+//#region src/prebuilt/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.
  *
+ * @deprecated Use `HumanInterruptConfig` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { HumanInterruptConfig } from "langchain";`
+ *
  * @property {boolean} allow_ignore - Whether the human can choose to ignore/skip the current step
  * @property {boolean} allow_respond - Whether the human can provide a text response/feedback
  * @property {boolean} allow_edit - Whether the human can edit the provided content/state
  * @property {boolean} allow_accept - Whether the human can accept/approve the current state
  */
-export interface HumanInterruptConfig {
-    allow_ignore: boolean;
-    allow_respond: boolean;
-    allow_edit: boolean;
-    allow_accept: boolean;
+interface HumanInterruptConfig {
+  allow_ignore: boolean;
+  allow_respond: boolean;
+  allow_edit: boolean;
+  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.
  *
+ * @deprecated Use `ActionRequest` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { ActionRequest } from "langchain/prebuilt/interrupt";`
+ *
  * @property {string} action - The type or name of action being requested (e.g., "Approve XYZ action")
  * @property {Record<string, any>} args - Key-value pairs of arguments needed for the action
  */
-export interface ActionRequest {
-    action: string;
-    args: Record<string, any>;
+interface ActionRequest {
+  action: string;
+  // 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.
  *
+ * @deprecated Use `HumanInterrupt` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { HumanInterrupt } from "langchain/prebuilt/interrupt";`
+ *
  * @property {ActionRequest} action_request - The specific action being requested from the human
  * @property {HumanInterruptConfig} config - Configuration defining what actions are allowed
  * @property {string} [description] - Optional detailed description of what input is needed
  */
-export interface HumanInterrupt {
-    action_request: ActionRequest;
-    config: HumanInterruptConfig;
-    description?: string;
+interface HumanInterrupt {
+  action_request: ActionRequest;
+  config: HumanInterruptConfig;
+  description?: string;
 }
 /**
  * The response provided by a human to an interrupt, which is returned when graph execution resumes.
  *
+ * @deprecated Use `HumanResponse` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { HumanResponse } from "langchain/prebuilt/interrupt";`
+ *
  * @property {("accept"|"ignore"|"response"|"edit")} type - The type of response:
  *   - "accept": Approves the current state without changes
  *   - "ignore": Skips/ignores the current step
@@ -50,7 +64,10 @@ export interface HumanInterrupt {
  *   - string: For text responses
  *   - ActionRequest: For edit actions with updated content
  */
-export type HumanResponse = {
-    type: "accept" | "ignore" | "response" | "edit";
-    args: null | string | ActionRequest;
+type HumanResponse = {
+  type: "accept" | "ignore" | "response" | "edit";
+  args: null | string | ActionRequest;
 };
+//#endregion
+export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse };
+//# sourceMappingURL=interrupt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.ts","names":["HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/prebuilt/interrupt.d.ts"],"sourcesContent":["/**\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 *\n * @deprecated Use `HumanInterruptConfig` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { HumanInterruptConfig } from \"langchain\";`\n *\n * @property {boolean} allow_ignore - Whether the human can choose to ignore/skip the current step\n * @property {boolean} allow_respond - Whether the human can provide a text response/feedback\n * @property {boolean} allow_edit - Whether the human can edit the provided content/state\n * @property {boolean} allow_accept - Whether the human can accept/approve the current state\n */\nexport interface HumanInterruptConfig {\n    allow_ignore: boolean;\n    allow_respond: boolean;\n    allow_edit: boolean;\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 *\n * @deprecated Use `ActionRequest` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { ActionRequest } from \"langchain/prebuilt/interrupt\";`\n *\n * @property {string} action - The type or name of action being requested (e.g., \"Approve XYZ action\")\n * @property {Record<string, any>} args - Key-value pairs of arguments needed for the action\n */\nexport interface ActionRequest {\n    action: string;\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 *\n * @deprecated Use `HumanInterrupt` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { HumanInterrupt } from \"langchain/prebuilt/interrupt\";`\n *\n * @property {ActionRequest} action_request - The specific action being requested from the human\n * @property {HumanInterruptConfig} config - Configuration defining what actions are allowed\n * @property {string} [description] - Optional detailed description of what input is needed\n */\nexport interface HumanInterrupt {\n    action_request: ActionRequest;\n    config: HumanInterruptConfig;\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n *\n * @deprecated Use `HumanResponse` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { HumanResponse } from \"langchain/prebuilt/interrupt\";`\n *\n * @property {(\"accept\"|\"ignore\"|\"response\"|\"edit\")} type - 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 * @property {null|string|ActionRequest} args - The response payload:\n *   - null: For ignore/accept actions\n *   - string: For text responses\n *   - ActionRequest: For edit actions with updated content\n */\nexport type HumanResponse = {\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    args: null | string | ActionRequest;\n};\n"],"mappings":";;AAYA;AAgBA;AAgBA;;;;;AAqBA;;;;UArDiBA,oBAAAA;;;;;;;;;;;;;;;;UAgBAC,aAAAA;;;QAGPC;;;;;;;;;;;;;UAaOC,cAAAA;kBACGF;UACRD;;;;;;;;;;;;;;;;;;;KAmBAI,aAAAA;;wBAEcH"}