@langchain/core 0.2.14 → 0.2.16

package/dist/runnables/tests/runnable_stream_events_v2.test.js

@@ -7,10 +7,12 @@ import { RunnableLambda, RunnableMap, RunnablePassthrough, RunnablePick, } from
 import { ChatPromptTemplate } from "../../prompts/chat.js";
 import { FakeChatModel, FakeLLM, FakeListChatModel, FakeRetriever, FakeStreamingLLM, } from "../../utils/testing/index.js";
 import { AIMessage, AIMessageChunk, HumanMessage, SystemMessage, } from "../../messages/index.js";
-import { DynamicStructuredTool, DynamicTool, tool } from "../../tools.js";
+import { DynamicStructuredTool, DynamicTool, tool } from "../../tools/index.js";
 import { Document } from "../../documents/document.js";
 import { PromptTemplate } from "../../prompts/prompt.js";
 import { GenerationChunk } from "../../outputs.js";
+// Import from web to avoid side-effects from AsyncLocalStorage
+import { dispatchCustomEvent } from "../../callbacks/dispatch/web.js";
 function reverse(s) {
     // Reverse a string.
     return s.split("").reverse().join("");
@@ -958,7 +960,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
             event: "on_chat_model_start",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -976,7 +978,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -989,7 +991,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1002,7 +1004,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1015,7 +1017,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1029,7 +1031,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
             event: "on_chat_model_end",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1172,7 +1174,7 @@ test("Chat model that doesn't support streaming, but is invoked, should emit one
             event: "on_chat_model_start",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1190,7 +1192,7 @@ test("Chat model that doesn't support streaming, but is invoked, should emit one
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1204,7 +1206,7 @@ test("Chat model that doesn't support streaming, but is invoked, should emit one
             event: "on_chat_model_end",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1356,7 +1358,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
                 },
             },
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             run_id: expect.any(String),
             metadata: {
                 foo: "bar",
@@ -1372,7 +1374,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1387,7 +1389,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1402,7 +1404,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1417,7 +1419,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1443,7 +1445,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1587,7 +1589,7 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
                 },
             },
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             run_id: expect.any(String),
             metadata: {
                 foo: "bar",
@@ -1603,7 +1605,7 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1629,7 +1631,7 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1748,6 +1750,109 @@ test("Runnable streamEvents method with simple tools", async () => {
         },
     ]);
 });
+test("Runnable streamEvents method with a custom event", async () => {
+    const lambda = RunnableLambda.from(async (params, config) => {
+        await dispatchCustomEvent("testEvent", { someval: "test" }, config);
+        await dispatchCustomEvent("testEvent", { someval: "test2" }, config);
+        return JSON.stringify({ x: params.x, y: params.y });
+    });
+    const events = [];
+    const eventStream = await lambda.streamEvents({ x: 1, y: "2" }, { version: "v2" });
+    for await (const event of eventStream) {
+        events.push(event);
+    }
+    expect(events).toEqual([
+        {
+            event: "on_chain_start",
+            data: { input: { x: 1, y: "2" } },
+            name: "RunnableLambda",
+            tags: [],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_custom_event",
+            run_id: expect.any(String),
+            name: "testEvent",
+            tags: [],
+            metadata: {},
+            data: { someval: "test" },
+        },
+        {
+            event: "on_custom_event",
+            run_id: expect.any(String),
+            name: "testEvent",
+            tags: [],
+            metadata: {},
+            data: { someval: "test2" },
+        },
+        {
+            event: "on_chain_stream",
+            run_id: expect.any(String),
+            name: "RunnableLambda",
+            tags: [],
+            metadata: {},
+            data: { chunk: '{"x":1,"y":"2"}' },
+        },
+        {
+            event: "on_chain_end",
+            data: { output: '{"x":1,"y":"2"}' },
+            run_id: expect.any(String),
+            name: "RunnableLambda",
+            tags: [],
+            metadata: {},
+        },
+    ]);
+});
+test("Custom event inside a custom tool", async () => {
+    const customTool = tool(async (params, config) => {
+        await dispatchCustomEvent("testEvent", { someval: "test" }, config);
+        await dispatchCustomEvent("testEvent", { someval: "test2" }, config);
+        return JSON.stringify({ x: params.x, y: params.y });
+    }, {
+        schema: z.object({ x: z.number(), y: z.string() }),
+        name: "testtool",
+    });
+    const events = [];
+    const eventStream = await customTool.streamEvents({ x: 1, y: "2" }, { version: "v2" });
+    for await (const event of eventStream) {
+        events.push(event);
+    }
+    expect(events).toEqual([
+        {
+            event: "on_tool_start",
+            data: { input: { x: 1, y: "2" } },
+            name: "testtool",
+            tags: [],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_custom_event",
+            run_id: expect.any(String),
+            name: "testEvent",
+            tags: [],
+            metadata: {},
+            data: { someval: "test" },
+        },
+        {
+            event: "on_custom_event",
+            run_id: expect.any(String),
+            name: "testEvent",
+            tags: [],
+            metadata: {},
+            data: { someval: "test2" },
+        },
+        {
+            event: "on_tool_end",
+            data: { output: '{"x":1,"y":"2"}' },
+            run_id: expect.any(String),
+            name: "testtool",
+            tags: [],
+            metadata: {},
+        },
+    ]);
+});
 test("Runnable streamEvents method with tools that return objects", async () => {
     const adderFunc = (_params) => {
         return JSON.stringify({ sum: 3 });

package/dist/runnables/tests/runnable_tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runnables/tests/runnable_tools.test.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { RunnableLambda, RunnableToolLike } from "../base.js";
+test("Runnable asTool works", async () => {
+    const schema = z.object({
+        foo: z.string(),
+    });
+    const runnable = RunnableLambda.from((input, config) => {
+        return `${input.foo}${config?.configurable.foo}`;
+    });
+    const tool = runnable.asTool({
+        schema,
+    });
+    expect(tool).toBeInstanceOf(RunnableToolLike);
+    expect(tool.schema).toBe(schema);
+    expect(tool.name).toBe(runnable.getName());
+});
+test("Runnable asTool works with all populated fields", async () => {
+    const schema = z.object({
+        foo: z.string(),
+    });
+    const runnable = RunnableLambda.from((input, config) => {
+        return `${input.foo}${config?.configurable.foo}`;
+    });
+    const tool = runnable.asTool({
+        schema,
+        name: "test",
+        description: "test",
+    });
+    expect(tool).toBeInstanceOf(RunnableToolLike);
+    expect(tool.schema).toBe(schema);
+    expect(tool.description).toBe("test");
+    expect(tool.name).toBe("test");
+});
+test("Runnable asTool can invoke", async () => {
+    const schema = z.object({
+        foo: z.string(),
+    });
+    const runnable = RunnableLambda.from((input, config) => {
+        return `${input.foo}${config?.configurable.foo}`;
+    });
+    const tool = runnable.asTool({
+        schema,
+    });
+    const toolResponse = await tool.invoke({
+        foo: "bar",
+    }, {
+        configurable: {
+            foo: "bar",
+        },
+    });
+    expect(toolResponse).toBe("barbar");
+});
+test("asTool should type error with mismatched schema", async () => {
+    // asTool infers the type of the Zod schema from the existing runnable's RunInput generic.
+    // If the Zod schema does not match the RunInput, it should throw a type error.
+    const schema = z.object({
+        foo: z.string(),
+    });
+    const runnable = RunnableLambda.from((input, config) => {
+        return `${input.bar}${config?.configurable.foo}`;
+    });
+    runnable.asTool({
+        // @ts-expect-error - Should error. If this does not give a type error, the generics/typing of `asTool` is broken.
+        schema,
+    });
+});
+test("Create a runnable tool directly from RunnableToolLike", async () => {
+    const schema = z.object({
+        foo: z.string(),
+    });
+    const adderFunc = (_) => {
+        return Promise.resolve(true);
+    };
+    const tool = new RunnableToolLike({
+        schema,
+        name: "test",
+        description: "test",
+        bound: RunnableLambda.from(adderFunc),
+    });
+    const result = await tool.invoke({ foo: "bar" });
+    expect(result).toBe(true);
+});
+test("asTool can take a single string input", async () => {
+    const firstRunnable = RunnableLambda.from((input) => {
+        return `${input}a`;
+    });
+    const secondRunnable = RunnableLambda.from((input) => {
+        return `${input}z`;
+    });
+    const runnable = firstRunnable.pipe(secondRunnable);
+    const asTool = runnable.asTool({
+        schema: z.string(),
+    });
+    const result = await asTool.invoke("b");
+    expect(result).toBe("baz");
+});
+test("Runnable asTool uses Zod schema description if not provided", async () => {
+    const description = "Test schema";
+    const schema = z
+        .object({
+        foo: z.string(),
+    })
+        .describe(description);
+    const runnable = RunnableLambda.from((input, config) => {
+        return `${input.foo}${config?.configurable.foo}`;
+    });
+    const tool = runnable.asTool({
+        schema,
+    });
+    expect(tool.description).toBe(description);
+});

package/dist/singletons/tests/async_local_storage.test.js

@@ -1,8 +1,22 @@
 import { test, expect } from "@jest/globals";
+import { v4 } from "uuid";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { AsyncLocalStorageProviderSingleton } from "../index.js";
 import { RunnableLambda } from "../../runnables/base.js";
 import { FakeListChatModel } from "../../utils/testing/index.js";
+import { getCallbackManagerForConfig } from "../../runnables/config.js";
+import { BaseCallbackHandler } from "../../callbacks/base.js";
+class FakeCallbackHandler extends BaseCallbackHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: `fake-${v4()}`
+        });
+    }
+}
 test("Config should be automatically populated after setting global async local storage", async () => {
     const inner = RunnableLambda.from((_, config) => config);
     const outer = RunnableLambda.from(async (input) => {
@@ -32,7 +46,6 @@ test("Config should be automatically populated after setting global async local
     });
     const chunks = [];
     for await (const chunk of stream) {
-        console.log(chunk);
         chunks.push(chunk);
     }
     expect(chunks.length).toEqual(1);
@@ -58,7 +71,6 @@ test("Config should be automatically populated after setting global async local
     });
     const chunks2 = [];
     for await (const chunk of stream2) {
-        console.log(chunk);
         chunks2.push(chunk);
     }
     expect(chunks2.length).toEqual(1);
@@ -90,17 +102,38 @@ test("Config should be automatically populated after setting global async local
     const eventStream = await outer4.streamEvents({ hi: true }, { version: "v1" });
     const events = [];
     for await (const event of eventStream) {
-        console.log(event);
         events.push(event);
     }
     expect(events.filter((event) => event.event === "on_llm_start").length).toEqual(1);
 });
 test("Runnable streamEvents method with streaming nested in a RunnableLambda", async () => {
     AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
+    const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
     const chat = new FakeListChatModel({
         responses: ["Hello"],
     });
+    const outerRunId = v4();
+    const innerRunId = v4();
+    const innerRunId2 = v4();
+    const dummyHandler = new FakeCallbackHandler();
     const myFunc = async (input) => {
+        const outerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+        expect(outerCallbackManager?.getParentRunId()).toEqual(outerRunId);
+        const nestedLambdaWithOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
+            expect(config?.callbacks?.handlers).toEqual([]);
+        });
+        await nestedLambdaWithOverriddenCallbacks.invoke(input, {
+            runId: innerRunId,
+            callbacks: [],
+        });
+        const nestedLambdaWithoutOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
+            const innerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+            expect(innerCallbackManager?.getParentRunId()).toEqual(innerRunId2);
+            expect(config?.callbacks?.handlers).toContain(dummyHandler);
+        });
+        await nestedLambdaWithoutOverriddenCallbacks.invoke(input, {
+            runId: innerRunId2,
+        });
         for await (const _ of await chat.stream(input)) {
             // no-op
         }
@@ -109,8 +142,9 @@ test("Runnable streamEvents method with streaming nested in a RunnableLambda", a
     const events = [];
     for await (const event of myNestedLambda.streamEvents("hello", {
         version: "v1",
+        runId: outerRunId,
+        callbacks: [dummyHandler],
     })) {
-        console.log(event);
         events.push(event);
     }
     const chatModelStreamEvent = events.find((event) => {

package/dist/{tools.cjs → tools/index.cjs}

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tool = exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
 const zod_1 = require("zod");
-const manager_js_1 = require("./callbacks/manager.cjs");
-const base_js_1 = require("./language_models/base.cjs");
-const config_js_1 = require("./runnables/config.cjs");
+const manager_js_1 = require("../callbacks/manager.cjs");
+const base_js_1 = require("../language_models/base.cjs");
+const config_js_1 = require("../runnables/config.cjs");
+const tool_js_1 = require("../messages/tool.cjs");
+const index_js_1 = require("../singletons/index.cjs");
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`
@@ -38,6 +40,22 @@ class StructuredTool extends base_js_1.BaseLangChain {
             writable: true,
             value: false
         });
+        /**
+         * The tool response format.
+         *
+         * If "content" then the output of the tool is interpreted as the contents of a
+         * ToolMessage. If "content_and_artifact" then the output is expected to be a
+         * two-tuple corresponding to the (content, artifact) of a ToolMessage.
+         *
+         * @default "content"
+         */
+        Object.defineProperty(this, "responseFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "content"
+        });
+        this.responseFormat = fields?.responseFormat ?? this.responseFormat;
     }
     /**
      * Invokes the tool with the provided input and configuration.
@@ -46,7 +64,23 @@ class StructuredTool extends base_js_1.BaseLangChain {
      * @returns A Promise that resolves with a string.
      */
     async invoke(input, config) {
-        return this.call(input, (0, config_js_1.ensureConfig)(config));
+        let tool_call_id;
+        let toolInput;
+        if (_isToolCall(input)) {
+            tool_call_id = input.id;
+            toolInput = input.args;
+        }
+        else {
+            toolInput = input;
+        }
+        const ensuredConfig = (0, config_js_1.ensureConfig)(config);
+        return this.call(toolInput, {
+            ...ensuredConfig,
+            configurable: {
+                ...ensuredConfig.configurable,
+                tool_call_id,
+            },
+        });
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -81,8 +115,32 @@ class StructuredTool extends base_js_1.BaseLangChain {
             await runManager?.handleToolError(e);
             throw e;
         }
-        await runManager?.handleToolEnd(result);
-        return result;
+        let content;
+        let artifact;
+        if (this.responseFormat === "content_and_artifact") {
+            if (Array.isArray(result) && result.length === 2) {
+                [content, artifact] = result;
+            }
+            else {
+                throw new Error(`Tool response format is "content_and_artifact" but the output was not a two-tuple.\nResult: ${JSON.stringify(result)}`);
+            }
+        }
+        else {
+            content = result;
+        }
+        let toolCallId;
+        if (config && "configurable" in config) {
+            toolCallId = config.configurable
+                .tool_call_id;
+        }
+        const formattedOutput = _formatToolOutput({
+            content,
+            artifact,
+            toolCallId,
+            name: this.name,
+        });
+        await runManager?.handleToolEnd(formattedOutput);
+        return formattedOutput;
     }
 }
 exports.StructuredTool = StructuredTool;
@@ -158,8 +216,8 @@ class DynamicTool extends Tool {
         return super.call(arg, config);
     }
     /** @ignore */
-    async _call(input, runManager, config) {
-        return this.func(input, runManager, config);
+    async _call(input, runManager, parentConfig) {
+        return this.func(input, runManager, parentConfig);
     }
 }
 exports.DynamicTool = DynamicTool;
@@ -217,8 +275,8 @@ class DynamicStructuredTool extends StructuredTool {
         }
         return super.call(arg, config, tags);
     }
-    _call(arg, runManager, config) {
-        return this.func(arg, runManager, config);
+    _call(arg, runManager, parentConfig) {
+        return this.func(arg, runManager, parentConfig);
     }
 }
 exports.DynamicStructuredTool = DynamicStructuredTool;
@@ -236,15 +294,17 @@ exports.BaseToolkit = BaseToolkit;
 /**
  * Creates a new StructuredTool instance with the provided function, name, description, and schema.
  * @function
- * @template {ZodAny} RunInput The input schema for the tool.
+ * @template {RunInput extends ZodAny = ZodAny} RunInput The input schema for the tool. This corresponds to the input type when the tool is invoked.
+ * @template {RunOutput = any} RunOutput The output type for the tool. This corresponds to the output type when the tool is invoked.
+ * @template {FuncInput extends z.infer<RunInput> | ToolCall = z.infer<RunInput>} FuncInput The input type for the function.
  *
- * @param {RunnableFunc<RunInput, string>} func - The function to invoke when the tool is called.
+ * @param {RunnableFunc<z.infer<RunInput> | ToolCall, RunOutput>} func - The function to invoke when the tool is called.
  * @param fields - An object containing the following properties:
  * @param {string} fields.name The name of the tool.
  * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
  * @param {z.ZodObject<any, any, any, any>} fields.schema The Zod schema defining the input for the tool.
  *
- * @returns {StructuredTool<RunInput, string>} A new StructuredTool instance.
+ * @returns {DynamicStructuredTool<RunInput, RunOutput>} A new StructuredTool instance.
  */
 function tool(func, fields) {
     const schema = fields.schema ??
@@ -254,7 +314,63 @@ function tool(func, fields) {
         name: fields.name,
         description,
         schema: schema,
-        func: async (input, _runManager, config) => func(input, config),
+        // TODO: Consider moving into DynamicStructuredTool constructor
+        func: async (input, runManager, config) => {
+            return new Promise((resolve, reject) => {
+                const childConfig = (0, config_js_1.patchConfig)(config, {
+                    callbacks: runManager?.getChild(),
+                });
+                void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+                    try {
+                        resolve(func(input, childConfig));
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+        },
+        responseFormat: fields.responseFormat,
     });
 }
 exports.tool = tool;
+function _isToolCall(toolCall) {
+    return !!(toolCall &&
+        typeof toolCall === "object" &&
+        "type" in toolCall &&
+        toolCall.type === "tool_call");
+}
+function _formatToolOutput(params) {
+    const { content, artifact, toolCallId } = params;
+    if (toolCallId) {
+        if (typeof content === "string" ||
+            (Array.isArray(content) &&
+                content.every((item) => typeof item === "object"))) {
+            return new tool_js_1.ToolMessage({
+                content,
+                artifact,
+                tool_call_id: toolCallId,
+                name: params.name,
+            });
+        }
+        else {
+            return new tool_js_1.ToolMessage({
+                content: _stringify(content),
+                artifact,
+                tool_call_id: toolCallId,
+                name: params.name,
+            });
+        }
+    }
+    else {
+        return content;
+    }
+}
+function _stringify(content) {
+    try {
+        return JSON.stringify(content, null, 2);
+    }
+    catch (_noOp) {
+        return `${content}`;
+    }
+}