@langchain/langgraph 1.0.12 → 1.0.14

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent_executor.d.ts","names":["___web_js0","AgentAction","AgentFinish","BaseMessage","Runnable","Tool","ToolExecutor","BaseChannel","Step","AgentExecutorState","Array","createAgentExecutor","agentRunnable","tools","_langchain_core_messages0","MessageToolSet","MessageStructure","MessageType","StateDefinition","Partial","CompiledStateGraph"],"sources":["../../src/prebuilt/agent_executor.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { ToolExecutor } from \"./tool_executor.js\";\nimport type { BaseChannel } from \"../channels/base.js\";\ninterface Step {\n    action: AgentAction | AgentFinish;\n    observation: unknown;\n}\n/** @ignore */\nexport interface AgentExecutorState {\n    agentOutcome?: AgentAction | AgentFinish;\n    steps: Array<Step>;\n    input: string;\n    chatHistory?: BaseMessage[];\n}\n/** @ignore */\nexport declare function createAgentExecutor({ agentRunnable, tools }: {\n    agentRunnable: Runnable;\n    tools: Array<Tool> | ToolExecutor;\n}): import(\"../web.js\").CompiledStateGraph<{\n    agentOutcome?: AgentAction | AgentFinish | undefined;\n    steps: Step[];\n    input: string;\n    chatHistory?: BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[] | undefined;\n}, {\n    agentOutcome?: AgentAction | AgentFinish | undefined;\n    steps?: Step[] | undefined;\n    input?: string | undefined;\n    chatHistory?: BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[] | undefined;\n}, \"__start__\" | \"action\" | \"agent\", {\n    agentOutcome?: BaseChannel<AgentAction | AgentFinish | undefined, AgentAction | AgentFinish | undefined, unknown> | undefined;\n    steps: BaseChannel<Step[], Step[], unknown>;\n    input: BaseChannel<string, string, unknown>;\n    chatHistory?: BaseChannel<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[] | undefined, BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[] | undefined, unknown> | undefined;\n}, {\n    agentOutcome?: BaseChannel<AgentAction | AgentFinish | undefined, AgentAction | AgentFinish | undefined, unknown> | undefined;\n    steps: BaseChannel<Step[], Step[], unknown>;\n    input: BaseChannel<string, string, unknown>;\n    chatHistory?: BaseChannel<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[] | undefined, BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[] | undefined, unknown> | undefined;\n}, import(\"../web.js\").StateDefinition, {\n    action: Partial<AgentExecutorState>;\n    agent: {\n        agentOutcome: any;\n    };\n}, unknown, unknown>;\nexport {};\n"],"mappings":";;;;;;;;;;;UAMUQ,IAAAA;UACEP,cAAcC;;;;AADhBM,UAKOC,kBAAAA,CALH;EAAA,YAAA,CAAA,EAMKR,WANL,GAMmBC,WANnB;OACFD,EAMDS,KANCT,CAMKO,IANLP,CAAAA;OAAcC,EAAAA,MAAAA;EAAW,WAAA,CAAA,EAQnBC,WARmB,EAAA;AAIrC;;AACmBF,iBAMKU,mBAAAA,CANLV;EAAAA,aAAAA;EAAAA;CAAAA,EAAAA;eAAcC,EAOdE,QAPcF;OAChBM,EAONE,KAPMF,CAOAH,IAPAG,CAAAA,GAOQF,YAPRE;IA6BER,kBA7BRU,CAAAA;cAEOP,CAAAA,EAOCF,WAPDE,GAOeD,WAPfC,GAAAA,SAAAA;EAAW,KAAA,EAQlBK,IARkB,EAAA;EAGLG,KAAAA,EAAAA,MAAAA;EAAmB,WAAA,CAAA,EAOzBR,WAPyB,CAOwFW,yBAAAA,CAAlEE,gBAPtB,CAK5BF,yBAAAA,CAEsGC,cAAAA,CAP1E,EAOsCD,yBAAAA,CAAwFG,WAAAA,CAP9H,EAAA,GAAA,SAAA;;cAAkBJ,CAAAA,EAS1CZ,WAT0CY,GAS5BX,WAT4BW,GAAAA,SAAAA;OAC1CT,CAAAA,EASPI,IATOJ,EAAAA,GAAAA,SAAAA;OACFC,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;aAANK,CAAAA,EAUOP,WAVPO,CAUwHI,yBAAAA,CAAlEE,gBAVtDN,CAQKI,yBAAAA,CAEqGC,cAAAA,CAV1GL,EAUsEI,yBAAAA,CAAwFG,WAAAA,CAV9JP,EAAAA,GAAAA,SAAAA;cAAcJ,GAAAA,QAAAA,GAAAA,OAAAA,EAAAA;cAENL,CAAAA,EAUAM,WAVAN,CAUYA,WAVZA,GAU0BC,WAV1BD,GAAAA,SAAAA,EAUmDA,WAVnDA,GAUiEC,WAVjED,GAAAA,SAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;OAAcC,EAWtBK,WAXsBL,CAWVM,IAXUN,EAAAA,EAWFM,IAXEN,EAAAA,EAAAA,OAAAA,CAAAA;OACtBM,EAWAD,WAXAC,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,OAAAA,CAAAA;aAAIM,CAAAA,EAYGP,WAZHO,CAYeX,WAVuFY,CAU0BD,yBAAAA,CAAlEE,gBAVwCD,CAS/FD,yBAAAA,CAC2GC,cAAAA,CAVZA,EAUxBD,yBAAAA,CAAwFG,WAAAA,CAVhEF,EAAAA,GAAAA,SAAAA,EAU4FZ,WAV5FY,CAU6MD,yBAAAA,CAAlEE,gBAV3ID,CAU5ED,yBAAAA,CAA2QC,cAAAA,CAV/LA,EAU2JD,yBAAAA,CAAwFG,WAAAA,CAVnPF,EAAAA,GAAAA,SAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;;cAApCD,CAAAA,EAY9DP,WAZ8DO,CAYlDb,WAZ0IgB,GAY5Hf,WAZ4He,GAAAA,SAAAA,EAYnGhB,WAZmGgB,GAYrFf,WAZqFe,GAAAA,SAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;OAAvJd,EAaPI,WAbOJ,CAaKK,IAbLL,EAAAA,EAaaK,IAbbL,EAAAA,EAAAA,OAAAA,CAAAA;OAECF,EAYRM,WAZQN,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,OAAAA,CAAAA;aAAcC,CAAAA,EAafK,WAbeL,CAaHC,WAbGD,CAa8GY,yBAAAA,CAAlEE,gBAb5Cd,CAYXY,yBAAAA,CAC2GC,cAAAA,CAbhGb,EAa4DY,yBAAAA,CAAwFG,WAAAA,CAbpJf,EAAAA,GAAAA,SAAAA,EAagLC,WAbhLD,CAaiSY,yBAAAA,CAAlEE,gBAb/Nd,CAaQY,yBAAAA,CAA2QC,cAAAA,CAbnRb,EAa+OY,yBAAAA,CAAwFG,WAAAA,CAbvUf,EAAAA,GAAAA,SAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;GAaJF,eAAAA,EAZjBQ;QAAIM,EAcJK,OAdIL,CAcIL,kBAZiGM,CAAAA;OAAcD,EAAAA;IAAlDA,YAAAA,EAAAA,GAAAA;;UAElDb,EAAAA,OAAAA,CAAAA"}

package/dist/prebuilt/agent_executor.js

@@ -0,0 +1,41 @@
+import { END, START } from "../constants.js";
+import { StateGraph } from "../graph/state.js";
+import { ToolExecutor } from "./tool_executor.js";
+
+//#region src/prebuilt/agent_executor.ts
+/** @ignore */
+function createAgentExecutor({ agentRunnable, tools }) {
+	let toolExecutor;
+	if (!Array.isArray(tools)) toolExecutor = tools;
+	else toolExecutor = new ToolExecutor({ tools });
+	const shouldContinue = (data) => {
+		if (data.agentOutcome && "returnValues" in data.agentOutcome) return "end";
+		return "continue";
+	};
+	const runAgent = async (data, config) => {
+		return { agentOutcome: await agentRunnable.invoke(data, config) };
+	};
+	const executeTools = async (data, config) => {
+		const agentAction = data.agentOutcome;
+		if (!agentAction || "returnValues" in agentAction) throw new Error("Agent has not been run yet");
+		return { steps: [{
+			action: agentAction,
+			observation: await toolExecutor.invoke(agentAction, config)
+		}] };
+	};
+	return new StateGraph({ channels: {
+		input: null,
+		agentOutcome: null,
+		steps: {
+			reducer: (x, y) => x.concat(y),
+			default: () => []
+		}
+	} }).addNode("agent", runAgent).addNode("action", executeTools).addEdge(START, "agent").addConditionalEdges("agent", shouldContinue, {
+		continue: "action",
+		end: END
+	}).addEdge("action", "agent").compile();
+}
+
+//#endregion
+export { createAgentExecutor };
+//# sourceMappingURL=agent_executor.js.map

package/dist/prebuilt/agent_executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent_executor.js","names":[],"sources":["../../src/prebuilt/agent_executor.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { Runnable, type RunnableConfig } from \"@langchain/core/runnables\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { ToolExecutor } from \"./tool_executor.js\";\nimport { StateGraph } from \"../graph/state.js\";\nimport { END, START } from \"../constants.js\";\nimport type { BaseChannel } from \"../channels/base.js\";\n\ninterface Step {\n  action: AgentAction | AgentFinish;\n  observation: unknown;\n}\n\n/** @ignore */\nexport interface AgentExecutorState {\n  agentOutcome?: AgentAction | AgentFinish;\n  steps: Array<Step>;\n  input: string;\n  chatHistory?: BaseMessage[];\n}\n\n/** @ignore */\nexport function createAgentExecutor({\n  agentRunnable,\n  tools,\n}: {\n  agentRunnable: Runnable;\n  tools: Array<Tool> | ToolExecutor;\n}) {\n  let toolExecutor: ToolExecutor;\n  if (!Array.isArray(tools)) {\n    toolExecutor = tools;\n  } else {\n    toolExecutor = new ToolExecutor({\n      tools,\n    });\n  }\n\n  // Define logic that will be used to determine which conditional edge to go down\n  const shouldContinue = (data: AgentExecutorState) => {\n    if (data.agentOutcome && \"returnValues\" in data.agentOutcome) {\n      return \"end\";\n    }\n    return \"continue\";\n  };\n\n  const runAgent = async (\n    data: AgentExecutorState,\n    config?: RunnableConfig\n  ) => {\n    const agentOutcome = await agentRunnable.invoke(data, config);\n    return {\n      agentOutcome,\n    };\n  };\n\n  const executeTools = async (\n    data: AgentExecutorState,\n    config?: RunnableConfig\n  ): Promise<Partial<AgentExecutorState>> => {\n    const agentAction = data.agentOutcome;\n    if (!agentAction || \"returnValues\" in agentAction) {\n      throw new Error(\"Agent has not been run yet\");\n    }\n    const output = await toolExecutor.invoke(agentAction, config);\n    return {\n      steps: [{ action: agentAction, observation: output }],\n    };\n  };\n\n  // Define a new graph\n  const workflow = new StateGraph<{\n    [K in keyof AgentExecutorState]: BaseChannel<\n      AgentExecutorState[K],\n      AgentExecutorState[K]\n    >;\n  }>({\n    channels: {\n      input: null,\n      agentOutcome: null,\n      steps: {\n        reducer: (x: Step[], y: Step[]) => x.concat(y),\n        default: () => [] as Step[],\n      },\n    },\n  })\n    // Define the two nodes we will cycle between\n    .addNode(\"agent\", runAgent)\n    .addNode(\"action\", executeTools)\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  return workflow.compile();\n}\n"],"mappings":";;;;;;AAuBA,SAAgB,oBAAoB,EAClC,eACA,SAIC;CACD,IAAI;AACJ,KAAI,CAAC,MAAM,QAAQ,MAAM,CACvB,gBAAe;KAEf,gBAAe,IAAI,aAAa,EAC9B,OACD,CAAC;CAIJ,MAAM,kBAAkB,SAA6B;AACnD,MAAI,KAAK,gBAAgB,kBAAkB,KAAK,aAC9C,QAAO;AAET,SAAO;;CAGT,MAAM,WAAW,OACf,MACA,WACG;AAEH,SAAO,EACL,cAFmB,MAAM,cAAc,OAAO,MAAM,OAAO,EAG5D;;CAGH,MAAM,eAAe,OACnB,MACA,WACyC;EACzC,MAAM,cAAc,KAAK;AACzB,MAAI,CAAC,eAAe,kBAAkB,YACpC,OAAM,IAAI,MAAM,6BAA6B;AAG/C,SAAO,EACL,OAAO,CAAC;GAAE,QAAQ;GAAa,aAFlB,MAAM,aAAa,OAAO,aAAa,OAAO;GAEP,CAAC,EACtD;;AAiDH,QA7CiB,IAAI,WAKlB,EACD,UAAU;EACR,OAAO;EACP,cAAc;EACd,OAAO;GACL,UAAU,GAAW,MAAc,EAAE,OAAO,EAAE;GAC9C,eAAe,EAAE;GAClB;EACF,EACF,CAAC,CAEC,QAAQ,SAAS,SAAS,CAC1B,QAAQ,UAAU,aAAa,CAG/B,QAAQ,OAAO,QAAQ,CAEvB,oBAGC,SAEA,gBAOA;EAEE,UAAU;EAEV,KAAK;EACN,CACF,CAGA,QAAQ,UAAU,QAAQ,CAEb,SAAS"}

package/dist/prebuilt/chat_agent_executor.cjs

@@ -0,0 +1,62 @@
+const require_constants = require('../constants.cjs');
+const require_state = require('../graph/state.cjs');
+const require_tool_executor = require('./tool_executor.cjs');
+let _langchain_core_runnables = require("@langchain/core/runnables");
+let _langchain_core_messages = require("@langchain/core/messages");
+let _langchain_core_utils_function_calling = require("@langchain/core/utils/function_calling");
+
+//#region src/prebuilt/chat_agent_executor.ts
+/** @deprecated Use {@link createReactAgent} instead with tool calling. */
+function createFunctionCallingExecutor({ model, tools }) {
+	let toolExecutor;
+	let toolClasses;
+	if (!Array.isArray(tools)) {
+		toolExecutor = tools;
+		toolClasses = tools.tools;
+	} else {
+		toolExecutor = new require_tool_executor.ToolExecutor({ tools });
+		toolClasses = tools;
+	}
+	if (!("bind" in model) || typeof model.bind !== "function") throw new Error("Model must be bindable");
+	const toolsAsOpenAIFunctions = toolClasses.map((tool) => (0, _langchain_core_utils_function_calling.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;
+		return { messages: [await newModel.invoke(messages, config)] };
+	};
+	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);
+		return { messages: [new _langchain_core_messages.FunctionMessage({
+			content: await toolExecutor.invoke(action, config),
+			name: action.tool
+		})] };
+	};
+	return new require_state.StateGraph({ channels: { messages: {
+		value: (x, y) => x.concat(y),
+		default: () => []
+	} } }).addNode("agent", new _langchain_core_runnables.RunnableLambda({ func: callModel })).addNode("action", new _langchain_core_runnables.RunnableLambda({ func: callTool })).addEdge(require_constants.START, "agent").addConditionalEdges("agent", shouldContinue, {
+		continue: "action",
+		end: require_constants.END
+	}).addEdge("action", "agent").compile();
+}
+
+//#endregion
+exports.createFunctionCallingExecutor = createFunctionCallingExecutor;
+//# sourceMappingURL=chat_agent_executor.cjs.map

package/dist/prebuilt/chat_agent_executor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_agent_executor.cjs","names":["ToolExecutor","FunctionMessage","StateGraph","RunnableLambda","START","END"],"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,IAAI;CACJ,IAAI;AACJ,KAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,iBAAe;AACf,gBAAc,MAAM;QACf;AACL,iBAAe,IAAIA,mCAAa,EAC9B,OACD,CAAC;AACF,gBAAc;;AAGhB,KAAI,EAAE,UAAU,UAAU,OAAO,MAAM,SAAS,WAC9C,OAAM,IAAI,MAAM,yBAAyB;CAE3C,MAAM,yBAAyB,YAAY,KAAK,6EACtB,KAAK,CAC9B;CACD,MAAM,WAAW,MAAM,KAAK,EAC1B,WAAW,wBACZ,CAAC;CAGF,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;AAGrB,SAAO,EACL,UAAU,CAHK,MAAM,SAAS,OAAO,UAAU,OAAO,CAGlC,EACrB;;CAIH,MAAM,cAAc,UAAqD;EACvE,MAAM,EAAE,aAAa;EAGrB,MAAM,cAAc,SAAS,SAAS,SAAS;AAC/C,MAAI,CAAC,YACH,OAAM,IAAI,MAAM,qBAAqB;AAEvC,MAAI,CAAC,YAAY,kBAAkB,cACjC,OAAM,IAAI,MAAM,qCAAqC;AAGvD,SAAO;GACL,MAAM,YAAY,kBAAkB,cAAc;GAClD,WAAW,KAAK,UACd,YAAY,kBAAkB,cAAc,UAC7C;GACD,KAAK;GACN;;CAGH,MAAM,WAAW,OACf,OACA,WACG;EACH,MAAM,SAAS,WAAW,MAAM;AAShC,SAAO,EAAE,UAAU,CALK,IAAIC,yCAAgB;GAC1C,SAHe,MAAM,aAAa,OAAO,QAAQ,OAAO;GAIxD,MAAM,OAAO;GACd,CAAC,CAEkC,EAAE;;AAmDxC,QApCiB,IAAIC,yBAAyC,EAC5D,UATuE,EACvE,UAAU;EACR,QAAQ,GAAkB,MAAqB,EAAE,OAAO,EAAE;EAC1D,eAAe,EAAE;EAClB,EACF,EAKA,CAAC,CAEC,QAAQ,SAAS,IAAIC,yCAAe,EAAE,MAAM,WAAW,CAAC,CAAC,CACzD,QAAQ,UAAU,IAAIA,yCAAe,EAAE,MAAM,UAAU,CAAC,CAAC,CAGzD,QAAQC,yBAAO,QAAQ,CAEvB,oBAGC,SAEA,gBAOA;EAEE,UAAU;EAEV,KAAKC;EACN,CACF,CAGA,QAAQ,UAAU,QAAQ,CAKb,SAAS"}

package/dist/prebuilt/chat_agent_executor.d.cts

@@ -0,0 +1,23 @@
+import { START } from "../constants.cjs";
+import { CompiledStateGraph } from "../graph/state.cjs";
+import { ToolExecutor } from "./tool_executor.cjs";
+import { RunnableToolLike } from "@langchain/core/runnables";
+import { BaseMessage } from "@langchain/core/messages";
+import { StructuredToolInterface } from "@langchain/core/tools";
+
+//#region src/prebuilt/chat_agent_executor.d.ts
+/** @deprecated Use {@link createReactAgent} instead with tool calling. */
+type FunctionCallingExecutorState = {
+  messages: Array<BaseMessage>;
+};
+/** @deprecated Use {@link createReactAgent} instead with tool calling. */
+declare function createFunctionCallingExecutor<Model extends object>({
+  model,
+  tools
+}: {
+  model: Model;
+  tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;
+}): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | "agent" | "action">;
+//#endregion
+export { FunctionCallingExecutorState, createFunctionCallingExecutor };
+//# sourceMappingURL=chat_agent_executor.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chat_agent_executor.d.cts","names":["StructuredToolInterface","BaseMessage","RunnableToolLike","ToolExecutor","CompiledStateGraph","START","FunctionCallingExecutorState","Array","createFunctionCallingExecutor","model","tools","Model","Partial"],"sources":["../../src/prebuilt/chat_agent_executor.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { RunnableToolLike } from \"@langchain/core/runnables\";\nimport { ToolExecutor } from \"./tool_executor.js\";\nimport { CompiledStateGraph } from \"../graph/state.js\";\nimport { START } from \"../constants.js\";\n/** @deprecated Use {@link createReactAgent} instead with tool calling. */\nexport type FunctionCallingExecutorState = {\n    messages: Array<BaseMessage>;\n};\n/** @deprecated Use {@link createReactAgent} instead with tool calling. */\nexport declare function createFunctionCallingExecutor<Model extends object>({ model, tools }: {\n    model: Model;\n    tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;\n}): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | \"agent\" | \"action\">;\n"],"mappings":";;;;;;;;;KAOYM,4BAAAA;EAAAA,QAAAA,EACEC,KADFD,CACQL,WADRK,CAAAA;CAA4B;;AAC1BC,iBAGUC,6BAHVD,CAAAA,cAAAA,MAAAA,CAAAA,CAAAA;EAAAA,KAAAA;EAAAA;CAAAA,EAAAA;EAAK,KAAA,EAIRI,KAJQ;EAGKH,KAAAA,EAEbD,KAFaC,CAEPR,uBAFoC,GAEVE,gBAFU,CAAA,GAEUC,YAFV;CAAA,CAAA,EAGjDC,kBAHiD,CAG9BE,4BAH8B,EAGAM,OAHA,CAGQN,4BAHR,CAAA,EAAA,OAG8CD,KAH9C,GAAA,OAAA,GAAA,QAAA,CAAA"}

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -0,0 +1,23 @@
+import { START } from "../constants.js";
+import { CompiledStateGraph } from "../graph/state.js";
+import { ToolExecutor } from "./tool_executor.js";
+import { RunnableToolLike } from "@langchain/core/runnables";
+import { BaseMessage } from "@langchain/core/messages";
+import { StructuredToolInterface } from "@langchain/core/tools";
+
+//#region src/prebuilt/chat_agent_executor.d.ts
+/** @deprecated Use {@link createReactAgent} instead with tool calling. */
+type FunctionCallingExecutorState = {
+  messages: Array<BaseMessage>;
+};
+/** @deprecated Use {@link createReactAgent} instead with tool calling. */
+declare function createFunctionCallingExecutor<Model extends object>({
+  model,
+  tools
+}: {
+  model: Model;
+  tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;
+}): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | "agent" | "action">;
+//#endregion
+export { FunctionCallingExecutorState, createFunctionCallingExecutor };
+//# sourceMappingURL=chat_agent_executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chat_agent_executor.d.ts","names":["StructuredToolInterface","BaseMessage","RunnableToolLike","ToolExecutor","CompiledStateGraph","START","FunctionCallingExecutorState","Array","createFunctionCallingExecutor","model","tools","Model","Partial"],"sources":["../../src/prebuilt/chat_agent_executor.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { RunnableToolLike } from \"@langchain/core/runnables\";\nimport { ToolExecutor } from \"./tool_executor.js\";\nimport { CompiledStateGraph } from \"../graph/state.js\";\nimport { START } from \"../constants.js\";\n/** @deprecated Use {@link createReactAgent} instead with tool calling. */\nexport type FunctionCallingExecutorState = {\n    messages: Array<BaseMessage>;\n};\n/** @deprecated Use {@link createReactAgent} instead with tool calling. */\nexport declare function createFunctionCallingExecutor<Model extends object>({ model, tools }: {\n    model: Model;\n    tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;\n}): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | \"agent\" | \"action\">;\n"],"mappings":";;;;;;;;;KAOYM,4BAAAA;EAAAA,QAAAA,EACEC,KADFD,CACQL,WADRK,CAAAA;CAA4B;;AAC1BC,iBAGUC,6BAHVD,CAAAA,cAAAA,MAAAA,CAAAA,CAAAA;EAAAA,KAAAA;EAAAA;CAAAA,EAAAA;EAAK,KAAA,EAIRI,KAJQ;EAGKH,KAAAA,EAEbD,KAFaC,CAEPR,uBAFoC,GAEVE,gBAFU,CAAA,GAEUC,YAFV;CAAA,CAAA,EAGjDC,kBAHiD,CAG9BE,4BAH8B,EAGAM,OAHA,CAGQN,4BAHR,CAAA,EAAA,OAG8CD,KAH9C,GAAA,OAAA,GAAA,QAAA,CAAA"}

package/dist/prebuilt/chat_agent_executor.js

@@ -0,0 +1,62 @@
+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. */
+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;
+		return { messages: [await newModel.invoke(messages, config)] };
+	};
+	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);
+		return { messages: [new FunctionMessage({
+			content: await toolExecutor.invoke(action, config),
+			name: action.tool
+		})] };
+	};
+	return new StateGraph({ channels: { messages: {
+		value: (x, y) => x.concat(y),
+		default: () => []
+	} } }).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").compile();
+}
+
+//#endregion
+export { createFunctionCallingExecutor };
+//# sourceMappingURL=chat_agent_executor.js.map

package/dist/prebuilt/chat_agent_executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_agent_executor.js","names":[],"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,IAAI;CACJ,IAAI;AACJ,KAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,iBAAe;AACf,gBAAc,MAAM;QACf;AACL,iBAAe,IAAI,aAAa,EAC9B,OACD,CAAC;AACF,gBAAc;;AAGhB,KAAI,EAAE,UAAU,UAAU,OAAO,MAAM,SAAS,WAC9C,OAAM,IAAI,MAAM,yBAAyB;CAE3C,MAAM,yBAAyB,YAAY,KAAK,SAC9C,wBAAwB,KAAK,CAC9B;CACD,MAAM,WAAW,MAAM,KAAK,EAC1B,WAAW,wBACZ,CAAC;CAGF,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;AAGrB,SAAO,EACL,UAAU,CAHK,MAAM,SAAS,OAAO,UAAU,OAAO,CAGlC,EACrB;;CAIH,MAAM,cAAc,UAAqD;EACvE,MAAM,EAAE,aAAa;EAGrB,MAAM,cAAc,SAAS,SAAS,SAAS;AAC/C,MAAI,CAAC,YACH,OAAM,IAAI,MAAM,qBAAqB;AAEvC,MAAI,CAAC,YAAY,kBAAkB,cACjC,OAAM,IAAI,MAAM,qCAAqC;AAGvD,SAAO;GACL,MAAM,YAAY,kBAAkB,cAAc;GAClD,WAAW,KAAK,UACd,YAAY,kBAAkB,cAAc,UAC7C;GACD,KAAK;GACN;;CAGH,MAAM,WAAW,OACf,OACA,WACG;EACH,MAAM,SAAS,WAAW,MAAM;AAShC,SAAO,EAAE,UAAU,CALK,IAAI,gBAAgB;GAC1C,SAHe,MAAM,aAAa,OAAO,QAAQ,OAAO;GAIxD,MAAM,OAAO;GACd,CAAC,CAEkC,EAAE;;AAmDxC,QApCiB,IAAI,WAAyC,EAC5D,UATuE,EACvE,UAAU;EACR,QAAQ,GAAkB,MAAqB,EAAE,OAAO,EAAE;EAC1D,eAAe,EAAE;EAClB,EACF,EAKA,CAAC,CAEC,QAAQ,SAAS,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC,CAAC,CACzD,QAAQ,UAAU,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC,CAAC,CAGzD,QAAQ,OAAO,QAAQ,CAEvB,oBAGC,SAEA,gBAOA;EAEE,UAAU;EAEV,KAAK;EACN,CACF,CAGA,QAAQ,UAAU,QAAQ,CAKb,SAAS"}

package/dist/prebuilt/index.cjs

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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,60 @@
+//#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.
+ *
+ * @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.
+ *
+ * @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;
+  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.
+ *
+ * @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.
+ *
+ * @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 * @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 * @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    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 * @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 * @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":";;AASA;AAaA;AAYA;;;;;AAkBA;UA3CiBA,oBAAAA;;;;;;;;;;;;;UAaAC,aAAAA;;QAEPC;;;;;;;;;;UAUOC,cAAAA;kBACGF;UACRD;;;;;;;;;;;;;;;;KAgBAI,aAAAA;;wBAEcH"}

package/dist/prebuilt/interrupt.d.ts

@@ -0,0 +1,60 @@
+//#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.
+ *
+ * @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.
+ *
+ * @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;
+  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.
+ *
+ * @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.
+ *
+ * @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.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 * @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 * @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    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 * @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 * @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":";;AASA;AAaA;AAYA;;;;;AAkBA;UA3CiBA,oBAAAA;;;;;;;;;;;;;UAaAC,aAAAA;;QAEPC;;;;;;;;;;UAUOC,cAAAA;kBACGF;UACRD;;;;;;;;;;;;;;;;KAgBAI,aAAAA;;wBAEcH"}