@langchain/core 0.2.15 → 0.2.17

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,10 +17,19 @@ 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;
     static isInstance(message: BaseMessage): message is ToolMessage;
+    get _printableFields(): Record<string, unknown>;
 }
 /**
  * Represents a chunk of a tool message, which can be concatenated
@@ -20,10 +37,19 @@ 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;
     concat(chunk: ToolMessageChunk): ToolMessageChunk;
+    get _printableFields(): Record<string, unknown>;
 }
 /**
  * A call to a tool.
@@ -35,6 +61,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 +118,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";
@@ -30,6 +45,13 @@ export class ToolMessage extends BaseMessage {
     static isInstance(message) {
         return message._getType() === "tool";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_call_id: this.tool_call_id,
+            artifact: this.artifact,
+        };
+    }
 }
 /**
  * Represents a chunk of a tool message, which can be concatenated
@@ -44,7 +66,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,10 +94,18 @@ 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,
         });
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_call_id: this.tool_call_id,
+            artifact: this.artifact,
+        };
+    }
 }
 export function defaultToolCallParser(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/messages/transformers.cjs

@@ -6,6 +6,7 @@ const ai_js_1 = require("./ai.cjs");
 const chat_js_1 = require("./chat.cjs");
 const function_js_1 = require("./function.cjs");
 const human_js_1 = require("./human.cjs");
+const modifier_js_1 = require("./modifier.cjs");
 const system_js_1 = require("./system.cjs");
 const tool_js_1 = require("./tool.cjs");
 const utils_js_1 = require("./utils.cjs");
@@ -303,6 +304,10 @@ const _MSG_CHUNK_MAP = {
         message: chat_js_1.ChatMessage,
         messageChunk: chat_js_1.ChatMessageChunk,
     },
+    remove: {
+        message: modifier_js_1.RemoveMessage,
+        messageChunk: modifier_js_1.RemoveMessage, // RemoveMessage does not have a chunk class.
+    },
 };
 function _switchTypeToMessage(messageType, fields, returnChunk) {
     let chunk;
@@ -326,6 +331,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.d.ts

@@ -6,10 +6,11 @@ import { BaseMessage, MessageType } from "./base.js";
 import { ChatMessage, ChatMessageChunk } from "./chat.js";
 import { FunctionMessage, FunctionMessageChunk } from "./function.js";
 import { HumanMessage, HumanMessageChunk } from "./human.js";
+import { RemoveMessage } from "./modifier.js";
 import { SystemMessage, SystemMessageChunk } from "./system.js";
 import { ToolMessage, ToolMessageChunk } from "./tool.js";
-export type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage;
-export type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk;
+export type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
+export type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
 export type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
 export interface FilterMessagesFields {
     /**

package/dist/messages/transformers.js

@@ -3,6 +3,7 @@ import { AIMessage, AIMessageChunk } from "./ai.js";
 import { ChatMessage, ChatMessageChunk, } from "./chat.js";
 import { FunctionMessage, FunctionMessageChunk, } from "./function.js";
 import { HumanMessage, HumanMessageChunk } from "./human.js";
+import { RemoveMessage } from "./modifier.js";
 import { SystemMessage, SystemMessageChunk } from "./system.js";
 import { ToolMessage, ToolMessageChunk, } from "./tool.js";
 import { convertToChunk } from "./utils.js";
@@ -297,6 +298,10 @@ const _MSG_CHUNK_MAP = {
         message: ChatMessage,
         messageChunk: ChatMessageChunk,
     },
+    remove: {
+        message: RemoveMessage,
+        messageChunk: RemoveMessage, // RemoveMessage does not have a chunk class.
+    },
 };
 function _switchTypeToMessage(messageType, fields, returnChunk) {
     let chunk;
@@ -320,6 +325,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,7 +3,7 @@ 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");
@@ -20,6 +20,7 @@ const index_js_1 = require("../singletons/index.cjs");
 const graph_js_1 = require("./graph.cjs");
 const wrappers_js_1 = require("./wrappers.cjs");
 const iter_js_1 = require("./iter.cjs");
+const utils_js_2 = require("../tools/utils.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value &&
@@ -718,6 +719,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;
 /**
@@ -1912,3 +1928,90 @@ class RunnablePick extends Runnable {
     }
 }
 exports.RunnablePick = RunnablePick;
+class RunnableToolLike extends RunnableBinding {
+    constructor(fields) {
+        const sequence = RunnableSequence.from([
+            RunnableLambda.from(async (input) => {
+                let toolInput;
+                if ((0, utils_js_2._isToolCall)(input)) {
+                    try {
+                        toolInput = await this.schema.parseAsync(input.args);
+                    }
+                    catch (e) {
+                        throw new utils_js_2.ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
+                    }
+                }
+                else {
+                    toolInput = input;
+                }
+                return toolInput;
+            }).withConfig({ runName: `${fields.name}:parse_input` }),
+            fields.bound,
+        ]).withConfig({ runName: fields.name });
+        super({
+            bound: sequence,
+            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;
+    if (fields.schema.constructor === zod_1.z.ZodString) {
+        return new RunnableToolLike({
+            name,
+            description,
+            schema: zod_1.z
+                .object({
+                input: zod_1.z.string(),
+            })
+                .transform((input) => input.input),
+            bound: runnable,
+        });
+    }
+    return new RunnableToolLike({
+        name,
+        description,
+        schema: fields.schema,
+        bound: runnable,
+    });
+}
+exports.convertRunnableToTool = convertRunnableToTool;

package/dist/runnables/base.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { type TraceableFunction } from "langsmith/singletons/traceable";
 import type { RunnableInterface, RunnableBatchOptions } from "./types.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
@@ -8,6 +9,7 @@ import { IterableReadableStream } from "../utils/stream.js";
 import { RunnableConfig } from "./config.js";
 import { Run } from "../tracers/base.js";
 import { Graph } from "./graph.js";
+import { ToolCall } from "../messages/tool.js";
 export { type RunnableInterface, RunnableBatchOptions };
 export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: ({
     /** @deprecated Use top-level config fields instead. */
@@ -245,6 +247,23 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
         onEnd?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
         onError?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
     }): Runnable<RunInput, RunOutput, CallOptions>;
+    /**
+     * 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<T extends RunInput = RunInput>(fields: {
+        name?: string;
+        description?: string;
+        schema: z.ZodType<T>;
+    }): RunnableToolLike<z.ZodType<T | ToolCall>, RunOutput>;
 }
 export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = {
     bound: Runnable<RunInput, RunOutput, CallOptions>;
@@ -560,3 +579,34 @@ export declare class RunnablePick<RunInput extends Record<string, any> = Record<
     transform(generator: AsyncGenerator<RunInput>, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
     stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;
 }
+export interface RunnableToolLikeArgs<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends Omit<RunnableBindingArgs<z.infer<RunInput>, RunOutput>, "config"> {
+    name: string;
+    description?: string;
+    schema: RunInput;
+    config?: RunnableConfig;
+}
+export declare class RunnableToolLike<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends RunnableBinding<z.infer<RunInput>, RunOutput> {
+    name: string;
+    description?: string;
+    schema: RunInput;
+    constructor(fields: RunnableToolLikeArgs<RunInput, RunOutput>);
+    static lc_name(): string;
+}
+/**
+ * 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.
+ */
+export declare function convertRunnableToTool<RunInput, RunOutput>(runnable: Runnable<RunInput, RunOutput>, fields: {
+    name?: string;
+    description?: string;
+    schema: z.ZodType<RunInput>;
+}): RunnableToolLike<z.ZodType<RunInput | ToolCall>, RunOutput>;

package/dist/runnables/base.js

@@ -14,6 +14,7 @@ import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
 import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterableIterator, isIterator, } from "./iter.js";
+import { _isToolCall, ToolInputParsingException } from "../tools/utils.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -711,6 +712,21 @@ export class Runnable extends 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);
+    }
 }
 /**
  * A runnable that delegates calls to another runnable with a set of kwargs.
@@ -1892,3 +1908,88 @@ export class RunnablePick extends Runnable {
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
+export class RunnableToolLike extends RunnableBinding {
+    constructor(fields) {
+        const sequence = RunnableSequence.from([
+            RunnableLambda.from(async (input) => {
+                let toolInput;
+                if (_isToolCall(input)) {
+                    try {
+                        toolInput = await this.schema.parseAsync(input.args);
+                    }
+                    catch (e) {
+                        throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
+                    }
+                }
+                else {
+                    toolInput = input;
+                }
+                return toolInput;
+            }).withConfig({ runName: `${fields.name}:parse_input` }),
+            fields.bound,
+        ]).withConfig({ runName: fields.name });
+        super({
+            bound: sequence,
+            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";
+    }
+}
+/**
+ * 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.
+ */
+export function convertRunnableToTool(runnable, fields) {
+    const name = fields.name ?? runnable.getName();
+    const description = fields.description ?? fields.schema?.description;
+    if (fields.schema.constructor === z.ZodString) {
+        return new RunnableToolLike({
+            name,
+            description,
+            schema: z
+                .object({
+                input: z.string(),
+            })
+                .transform((input) => input.input),
+            bound: runnable,
+        });
+    }
+    return new RunnableToolLike({
+        name,
+        description,
+        schema: fields.schema,
+        bound: runnable,
+    });
+}

package/dist/runnables/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports.RunnableToolLike = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
 Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
@@ -14,6 +14,7 @@ Object.defineProperty(exports, "RunnableWithFallbacks", { enumerable: true, get:
 Object.defineProperty(exports, "RunnableAssign", { enumerable: true, get: function () { return base_js_1.RunnableAssign; } });
 Object.defineProperty(exports, "RunnablePick", { enumerable: true, get: function () { return base_js_1.RunnablePick; } });
 Object.defineProperty(exports, "_coerceToRunnable", { enumerable: true, get: function () { return base_js_1._coerceToRunnable; } });
+Object.defineProperty(exports, "RunnableToolLike", { enumerable: true, get: function () { return base_js_1.RunnableToolLike; } });
 var config_js_1 = require("./config.cjs");
 Object.defineProperty(exports, "getCallbackManagerForConfig", { enumerable: true, get: function () { return config_js_1.getCallbackManagerForConfig; } });
 Object.defineProperty(exports, "patchConfig", { enumerable: true, get: function () { return config_js_1.patchConfig; } });

package/dist/runnables/index.d.ts

@@ -1,4 +1,4 @@
-export { type RunnableFunc, type RunnableLike, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
+export { type RunnableFunc, type RunnableLike, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, RunnableToolLike, type RunnableToolLikeArgs, } from "./base.js";
 export { type RunnableBatchOptions, type RunnableInterface, type RunnableIOSchema, } from "./types.js";
 export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";

package/dist/runnables/index.js

@@ -1,4 +1,4 @@
-export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
+export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, RunnableToolLike, } from "./base.js";
 export { getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";

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

@@ -8,7 +8,7 @@ import { ChatPromptTemplate } from "../../prompts/chat.js";
 import { FakeListChatModel, FakeRetriever, FakeStreamingLLM, } from "../../utils/testing/index.js";
 import { AIMessageChunk, HumanMessage, SystemMessage, } from "../../messages/index.js";
 import { ChatGenerationChunk, GenerationChunk } from "../../outputs.js";
-import { DynamicStructuredTool, DynamicTool } from "../../tools.js";
+import { DynamicStructuredTool, DynamicTool } from "../../tools/index.js";
 import { Document } from "../../documents/document.js";
 function reverse(s) {
     // Reverse a string.