@langchain/langgraph 0.0.1

package/dist/graph/state.js

@@ -0,0 +1,104 @@
+import { RunnableLambda } from "@langchain/core/runnables";
+import { BinaryOperatorAggregate } from "../channels/binop.js";
+import { END, Graph } from "./graph.js";
+import { LastValue } from "../channels/last_value.js";
+import { ChannelWrite } from "../pregel/write.js";
+import { Pregel, Channel } from "../pregel/index.js";
+import { ChannelRead } from "../pregel/read.js";
+export const START = "__start__";
+export class StateGraph extends Graph {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "channels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channels = _getChannels(fields.channels);
+    }
+    compile(checkpointer) {
+        this.validate();
+        if (Object.keys(this.nodes).some((key) => key in this.channels)) {
+            throw new Error("Cannot use channel names as node names");
+        }
+        const stateKeys = Object.keys(this.channels);
+        const outgoingEdges = {};
+        for (const [start, end] of this.edges) {
+            if (!outgoingEdges[start]) {
+                outgoingEdges[start] = [];
+            }
+            outgoingEdges[start].push(end !== END ? `${end}:inbox` : END);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const nodes = {};
+        for (const [key, node] of Object.entries(this.nodes)) {
+            nodes[key] = Channel.subscribeTo(`${key}:inbox`)
+                .pipe(node)
+                .pipe(_updateState)
+                .pipe(Channel.writeTo(key));
+        }
+        for (const key of Object.keys(this.nodes)) {
+            const outgoing = outgoingEdges[key];
+            const edgesKey = `${key}:edges`;
+            if (outgoing || this.branches[key]) {
+                nodes[edgesKey] = Channel.subscribeTo(key, {
+                    tags: ["langsmith:hidden"],
+                }).pipe(new ChannelRead(stateKeys));
+            }
+            if (outgoing) {
+                nodes[edgesKey] = nodes[edgesKey].pipe(Channel.writeTo(...outgoing));
+            }
+            if (this.branches[key]) {
+                for (const branch of this.branches[key]) {
+                    nodes[edgesKey] = nodes[edgesKey].pipe(new RunnableLambda({
+                        func: (i, c) => branch.runnable(i, c),
+                    }));
+                }
+            }
+        }
+        nodes[START] = Channel.subscribeTo(`${START}:inbox`, {
+            tags: ["langsmith:hidden"],
+        })
+            .pipe(_updateState)
+            .pipe(Channel.writeTo(START));
+        nodes[`${START}:edges`] = Channel.subscribeTo(START, {
+            tags: ["langsmith:hidden"],
+        })
+            .pipe(new ChannelRead(stateKeys))
+            .pipe(Channel.writeTo(`${this.entryPoint}:inbox`));
+        return new Pregel({
+            nodes,
+            channels: this.channels,
+            input: `${START}:inbox`,
+            output: END,
+            hidden: Object.keys(this.nodes)
+                .map((node) => `${node}:inbox`)
+                .concat(START, stateKeys),
+            checkpointer,
+        });
+    }
+}
+function _updateState(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input, options
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!options?.config) {
+        throw new Error("Config not found when updating state.");
+    }
+    ChannelWrite.doWrite(options.config, input);
+    return input;
+}
+function _getChannels(schema) {
+    const channels = {};
+    for (const [name, values] of Object.entries(schema)) {
+        if (values.value) {
+            channels[name] = new BinaryOperatorAggregate(values.value, values.default);
+        }
+        else {
+            channels[name] = new LastValue();
+        }
+    }
+    return channels;
+}

package/dist/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+var index_js_1 = require("./graph/index.cjs");
+Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
+Object.defineProperty(exports, "START", { enumerable: true, get: function () { return index_js_1.START; } });
+Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function () { return index_js_1.StateGraph; } });

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { END, Graph, type StateGraphArgs, START, StateGraph, } from "./graph/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { END, Graph, START, StateGraph, } from "./graph/index.js";

package/dist/prebuilt/agent_executor.cjs

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentExecutor = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const tool_executor_js_1 = require("./tool_executor.cjs");
+const state_js_1 = require("../graph/state.cjs");
+const index_js_1 = require("../index.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _getAgentState(inputSchema) {
+    if (!inputSchema) {
+        return {
+            input: {
+                value: null,
+            },
+            agentOutcome: {
+                value: null,
+            },
+            steps: {
+                value: (x, y) => x.concat(y),
+                default: () => [],
+            },
+        };
+    }
+    else {
+        return inputSchema;
+    }
+}
+function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
+    let toolExecutor;
+    if (!Array.isArray(tools)) {
+        toolExecutor = tools;
+    }
+    else {
+        toolExecutor = new tool_executor_js_1.ToolExecutor({
+            tools,
+        });
+    }
+    const state = _getAgentState(inputSchema);
+    // Define logic that will be used to determine which conditional edge to go down
+    const shouldContinue = (data) => {
+        if (data.agentOutcome && "returnValues" in data.agentOutcome) {
+            return "end";
+        }
+        return "continue";
+    };
+    const runAgent = async (data) => {
+        const agentOutcome = await agentRunnable.invoke(data);
+        return {
+            agentOutcome,
+        };
+    };
+    const executeTools = async (data) => {
+        const agentAction = data.agentOutcome;
+        if (!agentAction || "returnValues" in agentAction) {
+            throw new Error("Agent has not been run yet");
+        }
+        const output = await toolExecutor.invoke(agentAction);
+        return {
+            steps: [[agentAction, output]],
+        };
+    };
+    // Define a new graph
+    const workflow = new state_js_1.StateGraph({
+        channels: state,
+    });
+    // Define the two nodes we will cycle between
+    workflow.addNode("agent", new runnables_1.RunnableLambda({ func: runAgent }));
+    workflow.addNode("action", new runnables_1.RunnableLambda({ func: executeTools }));
+    // Set the entrypoint as `agent`
+    // This means that this node is the first one called
+    workflow.setEntryPoint("agent");
+    // We now add a conditional edge
+    workflow.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: index_js_1.END,
+    });
+    // We now add a normal edge from `tools` to `agent`.
+    // This means that after `tools` is called, `agent` node is called next.
+    workflow.addEdge("action", "agent");
+    return workflow.compile();
+}
+exports.createAgentExecutor = createAgentExecutor;

package/dist/prebuilt/agent_executor.d.ts

@@ -0,0 +1,12 @@
+import { Runnable } from "@langchain/core/runnables";
+import { Tool } from "@langchain/core/tools";
+import { ToolExecutor } from "./tool_executor.js";
+import { StateGraphArgs } from "../graph/state.js";
+import { Pregel } from "../pregel/index.js";
+type AgentChannels<T> = StateGraphArgs<Array<any> | T>["channels"];
+export declare function createAgentExecutor<T extends Array<any> = Array<any>>({ agentRunnable, tools, inputSchema, }: {
+    agentRunnable: Runnable;
+    tools: Array<Tool> | ToolExecutor;
+    inputSchema?: AgentChannels<T>;
+}): Pregel;
+export {};

package/dist/prebuilt/agent_executor.js

@@ -0,0 +1,92 @@
+import { RunnableLambda } from "@langchain/core/runnables";
+import { ToolExecutor } from "./tool_executor.js";
+import { StateGraph } from "../graph/state.js";
+import { END } from "../index.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _getAgentState(inputSchema) {
+    if (!inputSchema) {
+        return {
+            input: {
+                value: null,
+            },
+            agentOutcome: {
+                value: null,
+            },
+            steps: {
+                value: (x, y) => x.concat(y),
+                default: () => [],
+            },
+        };
+    }
+    else {
+        return inputSchema;
+    }
+}
+export function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
+    let toolExecutor;
+    if (!Array.isArray(tools)) {
+        toolExecutor = tools;
+    }
+    else {
+        toolExecutor = new ToolExecutor({
+            tools,
+        });
+    }
+    const state = _getAgentState(inputSchema);
+    // Define logic that will be used to determine which conditional edge to go down
+    const shouldContinue = (data) => {
+        if (data.agentOutcome && "returnValues" in data.agentOutcome) {
+            return "end";
+        }
+        return "continue";
+    };
+    const runAgent = async (data) => {
+        const agentOutcome = await agentRunnable.invoke(data);
+        return {
+            agentOutcome,
+        };
+    };
+    const executeTools = async (data) => {
+        const agentAction = data.agentOutcome;
+        if (!agentAction || "returnValues" in agentAction) {
+            throw new Error("Agent has not been run yet");
+        }
+        const output = await toolExecutor.invoke(agentAction);
+        return {
+            steps: [[agentAction, output]],
+        };
+    };
+    // Define a new graph
+    const workflow = new StateGraph({
+        channels: state,
+    });
+    // Define the two nodes we will cycle between
+    workflow.addNode("agent", new RunnableLambda({ func: runAgent }));
+    workflow.addNode("action", new RunnableLambda({ func: executeTools }));
+    // Set the entrypoint as `agent`
+    // This means that this node is the first one called
+    workflow.setEntryPoint("agent");
+    // We now add a conditional edge
+    workflow.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.
+    workflow.addEdge("action", "agent");
+    return workflow.compile();
+}

package/dist/prebuilt/chat_agent_executor.cjs

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionCallingExecutor = void 0;
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const messages_1 = require("@langchain/core/messages");
+const runnables_1 = require("@langchain/core/runnables");
+const tool_executor_js_1 = require("./tool_executor.cjs");
+const state_js_1 = require("../graph/state.cjs");
+const index_js_1 = require("../index.cjs");
+function createFunctionCallingExecutor({ model, tools, }) {
+    let toolExecutor;
+    let toolClasses;
+    if (!Array.isArray(tools)) {
+        toolExecutor = tools;
+        toolClasses = tools.tools;
+    }
+    else {
+        toolExecutor = new tool_executor_js_1.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, function_calling_1.convertToOpenAIFunction)(tool));
+    const newModel = model.bind({
+        functions: toolsAsOpenAIFunctions,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    // 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) => {
+        const { messages } = state;
+        const response = await newModel.invoke(messages);
+        // 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) => {
+        const action = _getAction(state);
+        // We call the tool_executor and get back a response
+        const response = await toolExecutor.invoke(action);
+        // We use the response to create a FunctionMessage
+        const functionMessage = new messages_1.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 state_js_1.StateGraph({
+        channels: schema,
+    });
+    // Define the two nodes we will cycle between
+    workflow.addNode("agent", new runnables_1.RunnableLambda({ func: callModel }));
+    workflow.addNode("action", new runnables_1.RunnableLambda({ func: callTool }));
+    // Set the entrypoint as `agent`
+    // This means that this node is the first one called
+    workflow.setEntryPoint("agent");
+    // We now add a conditional edge
+    workflow.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: index_js_1.END,
+    });
+    // We now add a normal edge from `tools` to `agent`.
+    // This means that after `tools` is called, `agent` node is called next.
+    workflow.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();
+}
+exports.createFunctionCallingExecutor = createFunctionCallingExecutor;

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -0,0 +1,6 @@
+import { Tool } from "@langchain/core/tools";
+import { ToolExecutor } from "./tool_executor.js";
+export declare function createFunctionCallingExecutor<Model extends object>({ model, tools, }: {
+    model: Model;
+    tools: Array<Tool> | ToolExecutor;
+}): import("../pregel/index.js").Pregel;

package/dist/prebuilt/chat_agent_executor.js

@@ -0,0 +1,126 @@
+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 } from "../index.js";
+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,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    // 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) => {
+        const { messages } = state;
+        const response = await newModel.invoke(messages);
+        // 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) => {
+        const action = _getAction(state);
+        // We call the tool_executor and get back a response
+        const response = await toolExecutor.invoke(action);
+        // 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
+    workflow.addNode("agent", new RunnableLambda({ func: callModel }));
+    workflow.addNode("action", new RunnableLambda({ func: callTool }));
+    // Set the entrypoint as `agent`
+    // This means that this node is the first one called
+    workflow.setEntryPoint("agent");
+    // We now add a conditional edge
+    workflow.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.
+    workflow.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();
+}

package/dist/prebuilt/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = 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 tool_executor_js_1 = require("./tool_executor.cjs");
+Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return tool_executor_js_1.ToolExecutor; } });

package/dist/prebuilt/index.d.ts

@@ -0,0 +1,3 @@
+export { createAgentExecutor } from "./agent_executor.js";
+export { createFunctionCallingExecutor } from "./chat_agent_executor.js";
+export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";

package/dist/prebuilt/index.js

@@ -0,0 +1,3 @@
+export { createAgentExecutor } from "./agent_executor.js";
+export { createFunctionCallingExecutor } from "./chat_agent_executor.js";
+export { ToolExecutor, } from "./tool_executor.js";

package/dist/prebuilt/tool_executor.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of [availableToolNamesString].`;
+class ToolExecutor extends runnables_1.RunnableBinding {
+    constructor(fields) {
+        const fieldsWithDefaults = {
+            invalidToolMsgTemplate: INVALID_TOOL_MSG_TEMPLATE,
+            ...fields,
+        };
+        const bound = new runnables_1.RunnableLambda({
+            func: async (input, options) => this._execute(input, options?.config),
+        });
+        super({
+            bound,
+            config: {},
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ToolExecutor"
+        });
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toolMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "invalidToolMsgTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tools = fieldsWithDefaults.tools;
+        this.invalidToolMsgTemplate = fieldsWithDefaults.invalidToolMsgTemplate;
+        this.toolMap = this.tools.reduce((acc, tool) => {
+            acc[tool.name] = tool;
+            return acc;
+        }, {});
+    }
+    async _execute(toolInvocation, _config) {
+        if (!(toolInvocation.tool in this.toolMap)) {
+            return this.invalidToolMsgTemplate
+                .replace("{requestedToolName}", toolInvocation.tool)
+                .replace("{availableToolNamesString}", Object.keys(this.toolMap).join(", "));
+        }
+        else {
+            const tool = this.toolMap[toolInvocation.tool];
+            const output = await tool.invoke(toolInvocation.toolInput);
+            return output;
+        }
+    }
+}
+exports.ToolExecutor = ToolExecutor;