@langchain/core 0.2.14 → 0.2.16

package/dist/messages/tests/base_message.test.js

@@ -1,6 +1,6 @@
-import { test } from "@jest/globals";
+import { test, describe, it, expect } from "@jest/globals";
 import { ChatPromptTemplate } from "../../prompts/chat.js";
-import { HumanMessage, AIMessage, ToolMessage } from "../index.js";
+import { HumanMessage, AIMessage, ToolMessage, ToolMessageChunk, AIMessageChunk, } from "../index.js";
 import { load } from "../../load/index.js";
 test("Test ChatPromptTemplate can format OpenAI content image messages", async () => {
     const message = new HumanMessage({
@@ -111,3 +111,135 @@ test("Deserialisation and serialisation of messages with ID", async () => {
     expect(deserialized).toEqual(message);
     expect(deserialized.id).toBe(messageId);
 });
+test("Can concat artifact (string) of ToolMessageChunk", () => {
+    const rawOutputOne = "Hello";
+    const rawOutputTwo = " world";
+    const chunk1 = new ToolMessageChunk({
+        content: "Hello",
+        tool_call_id: "1",
+        artifact: rawOutputOne,
+    });
+    const chunk2 = new ToolMessageChunk({
+        content: " world",
+        tool_call_id: "1",
+        artifact: rawOutputTwo,
+    });
+    const concated = chunk1.concat(chunk2);
+    expect(concated.artifact).toBe(`${rawOutputOne}${rawOutputTwo}`);
+});
+test("Can concat artifact (array) of ToolMessageChunk", () => {
+    const rawOutputOne = ["Hello", " world"];
+    const rawOutputTwo = ["!!"];
+    const chunk1 = new ToolMessageChunk({
+        content: "Hello",
+        tool_call_id: "1",
+        artifact: rawOutputOne,
+    });
+    const chunk2 = new ToolMessageChunk({
+        content: " world",
+        tool_call_id: "1",
+        artifact: rawOutputTwo,
+    });
+    const concated = chunk1.concat(chunk2);
+    expect(concated.artifact).toEqual(["Hello", " world", "!!"]);
+});
+test("Can concat artifact (object) of ToolMessageChunk", () => {
+    const rawOutputOne = {
+        foo: "bar",
+    };
+    const rawOutputTwo = {
+        bar: "baz",
+    };
+    const chunk1 = new ToolMessageChunk({
+        content: "Hello",
+        tool_call_id: "1",
+        artifact: rawOutputOne,
+    });
+    const chunk2 = new ToolMessageChunk({
+        content: " world",
+        tool_call_id: "1",
+        artifact: rawOutputTwo,
+    });
+    const concated = chunk1.concat(chunk2);
+    expect(concated.artifact).toEqual({
+        foo: "bar",
+        bar: "baz",
+    });
+});
+describe("Complex AIMessageChunk concat", () => {
+    it("concatenates content arrays of strings", () => {
+        expect(new AIMessageChunk({
+            content: [{ type: "text", text: "I am" }],
+            id: "ai4",
+        }).concat(new AIMessageChunk({ content: [{ type: "text", text: " indeed." }] }))).toEqual(new AIMessageChunk({
+            id: "ai4",
+            content: [
+                { type: "text", text: "I am" },
+                { type: "text", text: " indeed." },
+            ],
+        }));
+    });
+    it("concatenates mixed content arrays", () => {
+        expect(new AIMessageChunk({
+            content: [{ index: 0, type: "text", text: "I am" }],
+        }).concat(new AIMessageChunk({ content: [{ type: "text", text: " indeed." }] }))).toEqual(new AIMessageChunk({
+            content: [
+                { index: 0, type: "text", text: "I am" },
+                { type: "text", text: " indeed." },
+            ],
+        }));
+    });
+    it("merges content arrays with same index", () => {
+        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ index: 0, text: " indeed." }] }))).toEqual(new AIMessageChunk({ content: [{ index: 0, text: "I am indeed." }] }));
+    });
+    it("does not merge when one chunk is missing an index", () => {
+        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ text: " indeed." }] }))).toEqual(new AIMessageChunk({
+            content: [{ index: 0, text: "I am" }, { text: " indeed." }],
+        }));
+    });
+    it("does not create a holey array when there's a gap between indexes", () => {
+        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ index: 2, text: " indeed." }] }))).toEqual(new AIMessageChunk({
+            content: [
+                { index: 0, text: "I am" },
+                { index: 2, text: " indeed." },
+            ],
+        }));
+    });
+    it("does not merge content arrays with separate indexes", () => {
+        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ index: 1, text: " indeed." }] }))).toEqual(new AIMessageChunk({
+            content: [
+                { index: 0, text: "I am" },
+                { index: 1, text: " indeed." },
+            ],
+        }));
+    });
+    it("merges content arrays with same index and type", () => {
+        expect(new AIMessageChunk({
+            content: [{ index: 0, text: "I am", type: "text_block" }],
+        }).concat(new AIMessageChunk({
+            content: [{ index: 0, text: " indeed.", type: "text_block" }],
+        }))).toEqual(new AIMessageChunk({
+            content: [{ index: 0, text: "I am indeed.", type: "text_block" }],
+        }));
+    });
+    it("merges content arrays with same index and different types without updating type", () => {
+        expect(new AIMessageChunk({
+            content: [{ index: 0, text: "I am", type: "text_block" }],
+        }).concat(new AIMessageChunk({
+            content: [{ index: 0, text: " indeed.", type: "text_block_delta" }],
+        }))).toEqual(new AIMessageChunk({
+            content: [{ index: 0, text: "I am indeed.", type: "text_block" }],
+        }));
+    });
+    it("concatenates empty string content and merges other fields", () => {
+        expect(new AIMessageChunk({
+            content: [{ index: 0, type: "text", text: "I am" }],
+        }).concat(new AIMessageChunk({
+            content: [{ type: "text", text: "" }],
+            response_metadata: { extra: "value" },
+        }))).toEqual(new AIMessageChunk({
+            content: [{ index: 0, type: "text", text: "I am" }],
+            response_metadata: { extra: "value" },
+        }));
+    });
+});

package/dist/messages/tests/message_utils.test.js

@@ -3,6 +3,7 @@ import { filterMessages, mergeMessageRuns, trimMessages, } from "../transformers
 import { AIMessage } from "../ai.js";
 import { HumanMessage } from "../human.js";
 import { SystemMessage } from "../system.js";
+import { getBufferString } from "../utils.js";
 describe("filterMessage", () => {
     const getMessages = () => [
         new SystemMessage("you're a good assistant."),
@@ -97,8 +98,8 @@ describe("mergeMessageRuns", () => {
                     { type: "text", text: "my favorite dish is lasagna" },
                 ],
                 tool_calls: [
-                    { name: "blah_tool", args: { x: 2 }, id: "123" },
-                    { name: "blah_tool", args: { x: -10 }, id: "456" },
+                    { name: "blah_tool", args: { x: 2 }, id: "123", type: "tool_call" },
+                    { name: "blah_tool", args: { x: -10 }, id: "456", type: "tool_call" },
                 ],
                 id: "baz",
             }),
@@ -380,3 +381,54 @@ describe("trimMessages can trim", () => {
         expect(typeof trimmedMessages.func).toBe("function");
     });
 });
+test("getBufferString can handle complex messages", () => {
+    const messageArr1 = [new HumanMessage("Hello there!")];
+    const messageArr2 = [
+        new AIMessage({
+            content: [
+                {
+                    type: "text",
+                    text: "Hello there!",
+                },
+            ],
+        }),
+    ];
+    const messageArr3 = [
+        new HumanMessage({
+            content: [
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: "https://example.com/image.jpg",
+                    },
+                },
+                {
+                    type: "image_url",
+                    image_url: "https://example.com/image.jpg",
+                },
+            ],
+        }),
+    ];
+    const bufferString1 = getBufferString(messageArr1);
+    expect(bufferString1).toBe("Human: Hello there!");
+    const bufferString2 = getBufferString(messageArr2);
+    expect(bufferString2).toBe(`AI: ${JSON.stringify([
+        {
+            type: "text",
+            text: "Hello there!",
+        },
+    ], null, 2)}`);
+    const bufferString3 = getBufferString(messageArr3);
+    expect(bufferString3).toBe(`Human: ${JSON.stringify([
+        {
+            type: "image_url",
+            image_url: {
+                url: "https://example.com/image.jpg",
+            },
+        },
+        {
+            type: "image_url",
+            image_url: "https://example.com/image.jpg",
+        },
+    ], null, 2)}`);
+});

package/dist/messages/tool.cjs

@@ -25,7 +25,22 @@ class ToolMessage extends base_js_1.BaseMessage {
             writable: true,
             value: void 0
         });
+        /**
+         * Artifact of the Tool execution which is not meant to be sent to the model.
+         *
+         * Should only be specified if it is different from the message content, e.g. if only
+         * a subset of the full tool output is being passed as message content but the full
+         * output is needed in other parts of the code.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "artifact", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.tool_call_id = fields.tool_call_id;
+        this.artifact = fields.artifact;
     }
     _getType() {
         return "tool";
@@ -48,7 +63,22 @@ class ToolMessageChunk extends base_js_1.BaseMessageChunk {
             writable: true,
             value: void 0
         });
+        /**
+         * Artifact of the Tool execution which is not meant to be sent to the model.
+         *
+         * Should only be specified if it is different from the message content, e.g. if only
+         * a subset of the full tool output is being passed as message content but the full
+         * output is needed in other parts of the code.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "artifact", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.tool_call_id = fields.tool_call_id;
+        this.artifact = fields.artifact;
     }
     static lc_name() {
         return "ToolMessageChunk";
@@ -61,6 +91,7 @@ class ToolMessageChunk extends base_js_1.BaseMessageChunk {
             content: (0, base_js_1.mergeContent)(this.content, chunk.content),
             additional_kwargs: (0, base_js_1._mergeDicts)(this.additional_kwargs, chunk.additional_kwargs),
             response_metadata: (0, base_js_1._mergeDicts)(this.response_metadata, chunk.response_metadata),
+            artifact: (0, base_js_1._mergeObj)(this.artifact, chunk.artifact),
             tool_call_id: this.tool_call_id,
             id: this.id ?? chunk.id,
         });

package/dist/messages/tool.d.ts

@@ -1,5 +1,13 @@
 import { BaseMessage, BaseMessageChunk, type BaseMessageFields, type MessageType } from "./base.js";
 export interface ToolMessageFieldsWithToolCallId extends BaseMessageFields {
+    /**
+     * Artifact of the Tool execution which is not meant to be sent to the model.
+     *
+     * Should only be specified if it is different from the message content, e.g. if only
+     * a subset of the full tool output is being passed as message content but the full
+     * output is needed in other parts of the code.
+     */
+    artifact?: any;
     tool_call_id: string;
 }
 /**
@@ -9,6 +17,14 @@ export declare class ToolMessage extends BaseMessage {
     static lc_name(): string;
     get lc_aliases(): Record<string, string>;
     tool_call_id: string;
+    /**
+     * Artifact of the Tool execution which is not meant to be sent to the model.
+     *
+     * Should only be specified if it is different from the message content, e.g. if only
+     * a subset of the full tool output is being passed as message content but the full
+     * output is needed in other parts of the code.
+     */
+    artifact?: any;
     constructor(fields: ToolMessageFieldsWithToolCallId);
     constructor(fields: string | BaseMessageFields, tool_call_id: string, name?: string);
     _getType(): MessageType;
@@ -20,6 +36,14 @@ export declare class ToolMessage extends BaseMessage {
  */
 export declare class ToolMessageChunk extends BaseMessageChunk {
     tool_call_id: string;
+    /**
+     * Artifact of the Tool execution which is not meant to be sent to the model.
+     *
+     * Should only be specified if it is different from the message content, e.g. if only
+     * a subset of the full tool output is being passed as message content but the full
+     * output is needed in other parts of the code.
+     */
+    artifact?: any;
     constructor(fields: ToolMessageFieldsWithToolCallId);
     static lc_name(): string;
     _getType(): MessageType;
@@ -35,6 +59,7 @@ export type ToolCall = {
     name: string;
     args: Record<string, any>;
     id?: string;
+    type?: "tool_call";
 };
 /**
  * A chunk of a tool call (e.g., as part of a stream).
@@ -91,11 +116,13 @@ export type ToolCallChunk = {
     args?: string;
     id?: string;
     index?: number;
+    type?: "tool_call_chunk";
 };
 export type InvalidToolCall = {
     name?: string;
     args?: string;
     id?: string;
     error?: string;
+    type?: "invalid_tool_call";
 };
 export declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];

package/dist/messages/tool.js

@@ -1,4 +1,4 @@
-import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, } from "./base.js";
+import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, _mergeObj, } from "./base.js";
 /**
  * Represents a tool message in a conversation.
  */
@@ -22,7 +22,22 @@ export class ToolMessage extends BaseMessage {
             writable: true,
             value: void 0
         });
+        /**
+         * Artifact of the Tool execution which is not meant to be sent to the model.
+         *
+         * Should only be specified if it is different from the message content, e.g. if only
+         * a subset of the full tool output is being passed as message content but the full
+         * output is needed in other parts of the code.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "artifact", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.tool_call_id = fields.tool_call_id;
+        this.artifact = fields.artifact;
     }
     _getType() {
         return "tool";
@@ -44,7 +59,22 @@ export class ToolMessageChunk extends BaseMessageChunk {
             writable: true,
             value: void 0
         });
+        /**
+         * Artifact of the Tool execution which is not meant to be sent to the model.
+         *
+         * Should only be specified if it is different from the message content, e.g. if only
+         * a subset of the full tool output is being passed as message content but the full
+         * output is needed in other parts of the code.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "artifact", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.tool_call_id = fields.tool_call_id;
+        this.artifact = fields.artifact;
     }
     static lc_name() {
         return "ToolMessageChunk";
@@ -57,6 +87,7 @@ export class ToolMessageChunk extends BaseMessageChunk {
             content: mergeContent(this.content, chunk.content),
             additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
             response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
+            artifact: _mergeObj(this.artifact, chunk.artifact),
             tool_call_id: this.tool_call_id,
             id: this.id ?? chunk.id,
         });

package/dist/messages/transformers.cjs

@@ -326,6 +326,7 @@ function _switchTypeToMessage(messageType, fields, returnChunk) {
                         ...aiChunkFields,
                         tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
                             ...tc,
+                            type: "tool_call_chunk",
                             index: undefined,
                             args: JSON.stringify(tc.args),
                         })),

package/dist/messages/transformers.js

@@ -320,6 +320,7 @@ function _switchTypeToMessage(messageType, fields, returnChunk) {
                         ...aiChunkFields,
                         tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
                             ...tc,
+                            type: "tool_call_chunk",
                             index: undefined,
                             args: JSON.stringify(tc.args),
                         })),

package/dist/messages/utils.cjs

@@ -69,7 +69,10 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
             throw new Error(`Got unsupported message type: ${m._getType()}`);
         }
         const nameStr = m.name ? `${m.name}, ` : "";
-        string_messages.push(`${role}: ${nameStr}${m.content}`);
+        const readableContent = typeof m.content === "string"
+            ? m.content
+            : JSON.stringify(m.content, null, 2);
+        string_messages.push(`${role}: ${nameStr}${readableContent}`);
     }
     return string_messages.join("\n");
 }
@@ -166,6 +169,7 @@ function convertToChunk(message) {
                 ...aiChunkFields,
                 tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
                     ...tc,
+                    type: "tool_call_chunk",
                     index: undefined,
                     args: JSON.stringify(tc.args),
                 })),

package/dist/messages/utils.js

@@ -65,7 +65,10 @@ export function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI"
             throw new Error(`Got unsupported message type: ${m._getType()}`);
         }
         const nameStr = m.name ? `${m.name}, ` : "";
-        string_messages.push(`${role}: ${nameStr}${m.content}`);
+        const readableContent = typeof m.content === "string"
+            ? m.content
+            : JSON.stringify(m.content, null, 2);
+        string_messages.push(`${role}: ${nameStr}${readableContent}`);
     }
     return string_messages.join("\n");
 }
@@ -158,6 +161,7 @@ export function convertToChunk(message) {
                 ...aiChunkFields,
                 tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
                     ...tc,
+                    type: "tool_call_chunk",
                     index: undefined,
                     args: JSON.stringify(tc.args),
                 })),

package/dist/output_parsers/openai_tools/json_output_tools_parsers.cjs

@@ -37,6 +37,7 @@ rawToolCall, options) {
     const parsedToolCall = {
         name: rawToolCall.function.name,
         args: functionArgs,
+        type: "tool_call",
     };
     if (options?.returnId) {
         parsedToolCall.id = rawToolCall.id;
@@ -66,6 +67,7 @@ rawToolCall, errorMsg) {
         args: rawToolCall.function?.arguments,
         id: rawToolCall.id,
         error: errorMsg,
+        type: "invalid_tool_call",
     };
 }
 exports.makeInvalidToolCall = makeInvalidToolCall;

package/dist/output_parsers/openai_tools/json_output_tools_parsers.js

@@ -34,6 +34,7 @@ rawToolCall, options) {
     const parsedToolCall = {
         name: rawToolCall.function.name,
         args: functionArgs,
+        type: "tool_call",
     };
     if (options?.returnId) {
         parsedToolCall.id = rawToolCall.id;
@@ -61,6 +62,7 @@ rawToolCall, errorMsg) {
         args: rawToolCall.function?.arguments,
         id: rawToolCall.id,
         error: errorMsg,
+        type: "invalid_tool_call",
     };
 }
 /**

package/dist/runnables/base.cjs

@@ -3,12 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableTraceable = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = exports._coerceToDict = void 0;
+exports.convertRunnableToTool = exports.RunnableToolLike = exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableTraceable = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = exports._coerceToDict = void 0;
 const zod_1 = require("zod");
 const p_retry_1 = __importDefault(require("p-retry"));
 const uuid_1 = require("uuid");
 const traceable_1 = require("langsmith/singletons/traceable");
-const manager_js_1 = require("../callbacks/manager.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
 const event_stream_js_1 = require("../tracers/event_stream.cjs");
 const serializable_js_1 = require("../load/serializable.cjs");
@@ -719,6 +718,21 @@ class Runnable extends serializable_js_1.Serializable {
             ],
         });
     }
+    /**
+     * Convert a runnable to a tool. Return a new instance of `RunnableToolLike`
+     * which contains the runnable, name, description and schema.
+     *
+     * @template {T extends RunInput = RunInput} RunInput - The input type of the runnable. Should be the same as the `RunInput` type of the runnable.
+     *
+     * @param fields
+     * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
+     * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
+     * @param {z.ZodType<T>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+     * @returns {RunnableToolLike<z.ZodType<T>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+     */
+    asTool(fields) {
+        return convertRunnableToTool(this, fields);
+    }
 }
 exports.Runnable = Runnable;
 /**
@@ -1574,12 +1588,16 @@ class RunnableLambda extends Runnable {
                 }
             }
         }
+        const childConfig = (0, config_js_1.patchConfig)(config, {
+            callbacks: runManager?.getChild(),
+            recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+        });
         const output = await new Promise((resolve, reject) => {
-            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                 try {
                     const res = await this.func(finalChunk, {
-                        ...config,
-                        config,
+                        ...childConfig,
+                        config: childConfig,
                     });
                     resolve(res);
                 }
@@ -1592,21 +1610,18 @@ class RunnableLambda extends Runnable {
             if (config?.recursionLimit === 0) {
                 throw new Error("Recursion limit reached.");
             }
-            const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
-            }));
+            const stream = await output.stream(finalChunk, childConfig);
             for await (const chunk of stream) {
                 yield chunk;
             }
         }
         else if ((0, iter_js_1.isAsyncIterable)(output)) {
-            for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(config, output)) {
+            for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(childConfig, output)) {
                 yield chunk;
             }
         }
         else if ((0, iter_js_1.isIterableIterator)(output)) {
-            for (const chunk of (0, iter_js_1.consumeIteratorInContext)(config, output)) {
+            for (const chunk of (0, iter_js_1.consumeIteratorInContext)(childConfig, output)) {
                 yield chunk;
             }
         }
@@ -1677,13 +1692,14 @@ class RunnableWithFallbacks extends Runnable {
         }
     }
     async invoke(input, options) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const { runId, ...otherOptions } = options ?? {};
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const { runId, ...otherConfigFields } = config;
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherOptions, { callbacks: runManager?.getChild() }));
+                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherConfigFields, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1704,7 +1720,7 @@ class RunnableWithFallbacks extends Runnable {
             throw new Error("Not implemented.");
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map((config) => manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
+        const callbackManagers = await Promise.all(configList.map((config) => (0, config_js_1.getCallbackManagerForConfig)(config)));
         const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
             const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
             delete configList[i].runId;
@@ -1911,3 +1927,60 @@ class RunnablePick extends Runnable {
     }
 }
 exports.RunnablePick = RunnablePick;
+class RunnableToolLike extends RunnableBinding {
+    constructor(fields) {
+        super({
+            bound: fields.bound,
+            config: fields.config ?? {},
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.schema = fields.schema;
+    }
+    static lc_name() {
+        return "RunnableToolLike";
+    }
+}
+exports.RunnableToolLike = RunnableToolLike;
+/**
+ * Given a runnable and a Zod schema, convert the runnable to a tool.
+ *
+ * @template RunInput The input type for the runnable.
+ * @template RunOutput The output type for the runnable.
+ *
+ * @param {Runnable<RunInput, RunOutput>} runnable The runnable to convert to a tool.
+ * @param fields
+ * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
+ * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
+ * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ */
+function convertRunnableToTool(runnable, fields) {
+    const name = fields.name ?? runnable.getName();
+    const description = fields.description ?? fields.schema.description;
+    return new RunnableToolLike({
+        name,
+        description,
+        schema: fields.schema,
+        bound: runnable,
+    });
+}
+exports.convertRunnableToTool = convertRunnableToTool;