@langchain/core 0.2.16 → 0.2.17

package/dist/language_models/chat_models.d.ts

@@ -8,6 +8,7 @@ import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches/base.js";
 import { StructuredToolInterface } from "../tools/index.js";
 import { Runnable, RunnableToolLike } from "../runnables/base.js";
+type ToolChoice = string | Record<string, any> | "auto" | "any";
 /**
  * Represents a serialized chat model.
  */
@@ -29,7 +30,23 @@ export type BaseChatModelParams = BaseLanguageModelParams;
 /**
  * Represents the call options for a base chat model.
  */
-export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
+export type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {
+    /**
+     * Specifies how the chat model should use tools.
+     * @default undefined
+     *
+     * Possible values:
+     * - "auto": The model may choose to use any of the provided tools, or none.
+     * - "any": The model must use one of the provided tools.
+     * - "none": The model must not use any tools.
+     * - A string (not "auto", "any", or "none"): The name of a specific tool the model must use.
+     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.
+     *
+     * Note: Not all providers support tool_choice. An error will be thrown
+     * if used with an unsupported model.
+     */
+    tool_choice?: ToolChoice;
+};
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead

package/dist/messages/ai.cjs

@@ -98,6 +98,14 @@ class AIMessage extends base_js_1.BaseMessage {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
 }
 exports.AIMessage = AIMessage;
 function isAIMessage(x) {
@@ -215,6 +223,15 @@ class AIMessageChunk extends base_js_1.BaseMessageChunk {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            tool_call_chunks: this.tool_call_chunks,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
     concat(chunk) {
         const combinedFields = {
             content: (0, base_js_1.mergeContent)(this.content, chunk.content),

package/dist/messages/ai.d.ts

@@ -38,6 +38,7 @@ export declare class AIMessage extends BaseMessage {
     kwargs?: Record<string, unknown>);
     static lc_name(): string;
     _getType(): MessageType;
+    get _printableFields(): Record<string, unknown>;
 }
 export declare function isAIMessage(x: BaseMessage): x is AIMessage;
 export type AIMessageChunkFields = AIMessageFields & {
@@ -59,5 +60,6 @@ export declare class AIMessageChunk extends BaseMessageChunk {
     get lc_aliases(): Record<string, string>;
     static lc_name(): string;
     _getType(): MessageType;
+    get _printableFields(): Record<string, unknown>;
     concat(chunk: AIMessageChunk): AIMessageChunk;
 }

package/dist/messages/ai.js

@@ -95,6 +95,14 @@ export class AIMessage extends BaseMessage {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
 }
 export function isAIMessage(x) {
     return x._getType() === "ai";
@@ -210,6 +218,15 @@ export class AIMessageChunk extends BaseMessageChunk {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            tool_call_chunks: this.tool_call_chunks,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
     concat(chunk) {
         const combinedFields = {
             content: mergeContent(this.content, chunk.content),

package/dist/messages/base.cjs

@@ -25,6 +25,30 @@ function mergeContent(firstContent, secondContent) {
     }
 }
 exports.mergeContent = mergeContent;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function stringifyWithDepthLimit(obj, depthLimit) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function helper(obj, currentDepth) {
+        if (typeof obj !== "object" || obj === null || obj === undefined) {
+            return obj;
+        }
+        if (currentDepth >= depthLimit) {
+            if (Array.isArray(obj)) {
+                return "[Array]";
+            }
+            return "[Object]";
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => helper(item, currentDepth + 1));
+        }
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = helper(obj[key], currentDepth + 1);
+        }
+        return result;
+    }
+    return JSON.stringify(helper(obj, 0), null, 2);
+}
 /**
  * Base class for all types of messages in a conversation. It includes
  * properties like `content`, `name`, and `additional_kwargs`. It also
@@ -129,6 +153,32 @@ class BaseMessage extends serializable_js_1.Serializable {
                 .kwargs,
         };
     }
+    static lc_name() {
+        return "BaseMessage";
+    }
+    // Can't be protected for silly reasons
+    get _printableFields() {
+        return {
+            id: this.id,
+            content: this.content,
+            name: this.name,
+            additional_kwargs: this.additional_kwargs,
+            response_metadata: this.response_metadata,
+        };
+    }
+    get [Symbol.toStringTag]() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.constructor.lc_name();
+    }
+    // Override the default behavior of console.log
+    [Symbol.for("nodejs.util.inspect.custom")](depth) {
+        if (depth === null) {
+            return this;
+        }
+        const printable = stringifyWithDepthLimit(this._printableFields, Math.max(4, depth));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return `${this.constructor.lc_name()} ${printable}`;
+    }
 }
 exports.BaseMessage = BaseMessage;
 function isOpenAIToolCallArray(value) {

package/dist/messages/base.d.ts

@@ -23,7 +23,7 @@ export interface StoredMessageV1 {
     role: string | undefined;
     text: string;
 }
-export type MessageType = "human" | "ai" | "generic" | "system" | "function" | "tool";
+export type MessageType = "human" | "ai" | "generic" | "system" | "function" | "tool" | "remove";
 export type ImageDetail = "auto" | "low" | "high";
 export type MessageContentText = {
     type: "text";
@@ -123,6 +123,9 @@ export declare abstract class BaseMessage extends Serializable implements BaseMe
     /** @deprecated */
     kwargs?: Record<string, unknown>);
     toDict(): StoredMessage;
+    static lc_name(): string;
+    get _printableFields(): Record<string, unknown>;
+    get [Symbol.toStringTag](): any;
 }
 export type OpenAIToolCall = ToolCall & {
     index: number;

package/dist/messages/base.js

@@ -21,6 +21,30 @@ export function mergeContent(firstContent, secondContent) {
         return [...firstContent, { type: "text", text: secondContent }];
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function stringifyWithDepthLimit(obj, depthLimit) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function helper(obj, currentDepth) {
+        if (typeof obj !== "object" || obj === null || obj === undefined) {
+            return obj;
+        }
+        if (currentDepth >= depthLimit) {
+            if (Array.isArray(obj)) {
+                return "[Array]";
+            }
+            return "[Object]";
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => helper(item, currentDepth + 1));
+        }
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = helper(obj[key], currentDepth + 1);
+        }
+        return result;
+    }
+    return JSON.stringify(helper(obj, 0), null, 2);
+}
 /**
  * Base class for all types of messages in a conversation. It includes
  * properties like `content`, `name`, and `additional_kwargs`. It also
@@ -125,6 +149,32 @@ export class BaseMessage extends Serializable {
                 .kwargs,
         };
     }
+    static lc_name() {
+        return "BaseMessage";
+    }
+    // Can't be protected for silly reasons
+    get _printableFields() {
+        return {
+            id: this.id,
+            content: this.content,
+            name: this.name,
+            additional_kwargs: this.additional_kwargs,
+            response_metadata: this.response_metadata,
+        };
+    }
+    get [Symbol.toStringTag]() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.constructor.lc_name();
+    }
+    // Override the default behavior of console.log
+    [Symbol.for("nodejs.util.inspect.custom")](depth) {
+        if (depth === null) {
+            return this;
+        }
+        const printable = stringifyWithDepthLimit(this._printableFields, Math.max(4, depth));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return `${this.constructor.lc_name()} ${printable}`;
+    }
 }
 export function isOpenAIToolCallArray(value) {
     return (Array.isArray(value) &&

package/dist/messages/chat.cjs

@@ -32,6 +32,12 @@ class ChatMessage extends base_js_1.BaseMessage {
     static isInstance(message) {
         return message._getType() === "generic";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            role: this.role,
+        };
+    }
 }
 exports.ChatMessage = ChatMessage;
 /**
@@ -68,5 +74,11 @@ class ChatMessageChunk extends base_js_1.BaseMessageChunk {
             id: this.id ?? chunk.id,
         });
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            role: this.role,
+        };
+    }
 }
 exports.ChatMessageChunk = ChatMessageChunk;

package/dist/messages/chat.d.ts

@@ -13,6 +13,7 @@ export declare class ChatMessage extends BaseMessage implements ChatMessageField
     constructor(fields: ChatMessageFieldsWithRole);
     _getType(): MessageType;
     static isInstance(message: BaseMessage): message is ChatMessage;
+    get _printableFields(): Record<string, unknown>;
 }
 /**
  * Represents a chunk of a chat message, which can be concatenated with
@@ -25,4 +26,5 @@ export declare class ChatMessageChunk extends BaseMessageChunk {
     constructor(fields: ChatMessageFieldsWithRole);
     _getType(): MessageType;
     concat(chunk: ChatMessageChunk): ChatMessageChunk;
+    get _printableFields(): Record<string, unknown>;
 }

package/dist/messages/chat.js

@@ -29,6 +29,12 @@ export class ChatMessage extends BaseMessage {
     static isInstance(message) {
         return message._getType() === "generic";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            role: this.role,
+        };
+    }
 }
 /**
  * Represents a chunk of a chat message, which can be concatenated with
@@ -64,4 +70,10 @@ export class ChatMessageChunk extends BaseMessageChunk {
             id: this.id ?? chunk.id,
         });
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            role: this.role,
+        };
+    }
 }

package/dist/messages/index.cjs

@@ -23,6 +23,7 @@ __exportStar(require("./human.cjs"), exports);
 __exportStar(require("./system.cjs"), exports);
 __exportStar(require("./utils.cjs"), exports);
 __exportStar(require("./transformers.cjs"), exports);
+__exportStar(require("./modifier.cjs"), exports);
 // TODO: Use a star export when we deprecate the
 // existing "ToolCall" type in "base.js".
 var tool_js_1 = require("./tool.cjs");

package/dist/messages/index.d.ts

@@ -6,4 +6,5 @@ export * from "./human.js";
 export * from "./system.js";
 export * from "./utils.js";
 export * from "./transformers.js";
+export * from "./modifier.js";
 export { type ToolMessageFieldsWithToolCallId, ToolMessage, ToolMessageChunk, type InvalidToolCall, } from "./tool.js";

package/dist/messages/index.js

@@ -6,6 +6,7 @@ export * from "./human.js";
 export * from "./system.js";
 export * from "./utils.js";
 export * from "./transformers.js";
+export * from "./modifier.js";
 // TODO: Use a star export when we deprecate the
 // existing "ToolCall" type in "base.js".
 export { ToolMessage, ToolMessageChunk, } from "./tool.js";

package/dist/messages/modifier.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveMessage = void 0;
+const base_js_1 = require("./base.cjs");
+/**
+ * Message responsible for deleting other messages.
+ */
+class RemoveMessage extends base_js_1.BaseMessage {
+    constructor(fields) {
+        super({
+            ...fields,
+            content: "",
+        });
+        /**
+         * The ID of the message to remove.
+         */
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.id = fields.id;
+    }
+    _getType() {
+        return "remove";
+    }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            id: this.id,
+        };
+    }
+}
+exports.RemoveMessage = RemoveMessage;

package/dist/messages/modifier.d.ts

@@ -0,0 +1,19 @@
+import { BaseMessage, BaseMessageFields, MessageType } from "./base.js";
+export interface RemoveMessageFields extends Omit<BaseMessageFields, "content"> {
+    /**
+     * The ID of the message to remove.
+     */
+    id: string;
+}
+/**
+ * Message responsible for deleting other messages.
+ */
+export declare class RemoveMessage extends BaseMessage {
+    /**
+     * The ID of the message to remove.
+     */
+    id: string;
+    constructor(fields: RemoveMessageFields);
+    _getType(): MessageType;
+    get _printableFields(): Record<string, unknown>;
+}

package/dist/messages/modifier.js

@@ -0,0 +1,31 @@
+import { BaseMessage } from "./base.js";
+/**
+ * Message responsible for deleting other messages.
+ */
+export class RemoveMessage extends BaseMessage {
+    constructor(fields) {
+        super({
+            ...fields,
+            content: "",
+        });
+        /**
+         * The ID of the message to remove.
+         */
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.id = fields.id;
+    }
+    _getType() {
+        return "remove";
+    }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            id: this.id,
+        };
+    }
+}

package/dist/messages/tool.cjs

@@ -48,6 +48,13 @@ class ToolMessage extends base_js_1.BaseMessage {
     static isInstance(message) {
         return message._getType() === "tool";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_call_id: this.tool_call_id,
+            artifact: this.artifact,
+        };
+    }
 }
 exports.ToolMessage = ToolMessage;
 /**
@@ -96,6 +103,13 @@ class ToolMessageChunk extends base_js_1.BaseMessageChunk {
             id: this.id ?? chunk.id,
         });
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_call_id: this.tool_call_id,
+            artifact: this.artifact,
+        };
+    }
 }
 exports.ToolMessageChunk = ToolMessageChunk;
 function defaultToolCallParser(

package/dist/messages/tool.d.ts

@@ -29,6 +29,7 @@ export declare class ToolMessage extends BaseMessage {
     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
@@ -48,6 +49,7 @@ export declare class ToolMessageChunk extends BaseMessageChunk {
     static lc_name(): string;
     _getType(): MessageType;
     concat(chunk: ToolMessageChunk): ToolMessageChunk;
+    get _printableFields(): Record<string, unknown>;
 }
 /**
  * A call to a tool.

package/dist/messages/tool.js

@@ -45,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
@@ -92,6 +99,13 @@ export class ToolMessageChunk extends BaseMessageChunk {
             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;

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;

package/dist/runnables/base.cjs

@@ -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 &&
@@ -1929,8 +1930,26 @@ 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: fields.bound,
+            bound: sequence,
             config: fields.config ?? {},
         });
         Object.defineProperty(this, "name", {
@@ -1975,7 +1994,19 @@ exports.RunnableToolLike = RunnableToolLike;
  */
 function convertRunnableToTool(runnable, fields) {
     const name = fields.name ?? runnable.getName();
-    const description = fields.description ?? fields.schema.description;
+    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,

package/dist/runnables/base.d.ts

@@ -9,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. */
@@ -262,7 +263,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
         name?: string;
         description?: string;
         schema: z.ZodType<T>;
-    }): RunnableToolLike<z.ZodType<T>, RunOutput>;
+    }): RunnableToolLike<z.ZodType<T | ToolCall>, RunOutput>;
 }
 export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = {
     bound: Runnable<RunInput, RunOutput, CallOptions>;
@@ -608,4 +609,4 @@ export declare function convertRunnableToTool<RunInput, RunOutput>(runnable: Run
     name?: string;
     description?: string;
     schema: z.ZodType<RunInput>;
-}): RunnableToolLike<z.ZodType<RunInput>, RunOutput>;
+}): 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 &&
@@ -1909,8 +1910,26 @@ export class RunnablePick extends Runnable {
 }
 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: fields.bound,
+            bound: sequence,
             config: fields.config ?? {},
         });
         Object.defineProperty(this, "name", {
@@ -1954,7 +1973,19 @@ export class RunnableToolLike extends RunnableBinding {
  */
 export function convertRunnableToTool(runnable, fields) {
     const name = fields.name ?? runnable.getName();
-    const description = fields.description ?? fields.schema.description;
+    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,

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

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { RunnableLambda, RunnableToolLike } from "../base.js";
+import { FakeRetriever } from "../../utils/testing/index.js";
+import { Document } from "../../documents/document.js";
 test("Runnable asTool works", async () => {
     const schema = z.object({
         foo: z.string(),
@@ -109,3 +111,39 @@ test("Runnable asTool uses Zod schema description if not provided", async () =>
     });
     expect(tool.description).toBe(description);
 });
+test("Runnable asTool can accept a string zod schema", async () => {
+    const lambda = RunnableLambda.from((input) => {
+        return `${input}a`;
+    }).asTool({
+        name: "string_tool",
+        description: "A tool that appends 'a' to the input string",
+        schema: z.string(),
+    });
+    const result = await lambda.invoke("b");
+    expect(result).toBe("ba");
+});
+test("Runnables which dont accept ToolCalls as inputs can accept ToolCalls", async () => {
+    const pageContent = "Dogs are pretty cool, man!";
+    const retriever = new FakeRetriever({
+        output: [
+            new Document({
+                pageContent,
+            }),
+        ],
+    });
+    const tool = retriever.asTool({
+        name: "pet_info_retriever",
+        description: "Get information about pets.",
+        schema: z.string(),
+    });
+    const result = await tool.invoke({
+        type: "tool_call",
+        name: "pet_info_retriever",
+        args: {
+            input: "dogs",
+        },
+        id: "string",
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].pageContent).toBe(pageContent);
+});

package/dist/tools/index.cjs

@@ -7,24 +7,8 @@ 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`
- * property that can hold the output that caused the exception.
- */
-class ToolInputParsingException extends Error {
-    constructor(message, output) {
-        super(message);
-        Object.defineProperty(this, "output", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.output = output;
-    }
-}
-exports.ToolInputParsingException = ToolInputParsingException;
+const utils_js_1 = require("./utils.cjs");
+Object.defineProperty(exports, "ToolInputParsingException", { enumerable: true, get: function () { return utils_js_1.ToolInputParsingException; } });
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
@@ -66,7 +50,7 @@ class StructuredTool extends base_js_1.BaseLangChain {
     async invoke(input, config) {
         let tool_call_id;
         let toolInput;
-        if (_isToolCall(input)) {
+        if ((0, utils_js_1._isToolCall)(input)) {
             tool_call_id = input.id;
             toolInput = input.args;
         }
@@ -101,7 +85,7 @@ class StructuredTool extends base_js_1.BaseLangChain {
             parsed = await this.schema.parseAsync(arg);
         }
         catch (e) {
-            throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(arg));
+            throw new utils_js_1.ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(arg));
         }
         const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
         const callbackManager_ = await manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
@@ -291,29 +275,23 @@ class BaseToolkit {
     }
 }
 exports.BaseToolkit = BaseToolkit;
-/**
- * Creates a new StructuredTool instance with the provided function, name, description, and schema.
- * @function
- * @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<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 {DynamicStructuredTool<RunInput, RunOutput>} A new StructuredTool instance.
- */
 function tool(func, fields) {
-    const schema = fields.schema ??
-        zod_1.z.object({ input: zod_1.z.string().optional() }).transform((obj) => obj.input);
-    const description = fields.description ?? schema.description ?? `${fields.name} tool`;
+    // If the schema is not provided, or it's a string schema, create a DynamicTool
+    if (!fields.schema || !("shape" in fields.schema) || !fields.schema.shape) {
+        return new DynamicTool({
+            name: fields.name,
+            description: fields.description ??
+                fields.schema?.description ??
+                `${fields.name} tool`,
+            responseFormat: fields.responseFormat,
+            func,
+        });
+    }
+    const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
     return new DynamicStructuredTool({
         name: fields.name,
         description,
-        schema: schema,
+        schema: fields.schema,
         // TODO: Consider moving into DynamicStructuredTool constructor
         func: async (input, runManager, config) => {
             return new Promise((resolve, reject) => {
@@ -334,12 +312,6 @@ function tool(func, fields) {
     });
 }
 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) {

package/dist/tools/index.d.ts

@@ -4,8 +4,10 @@ import { BaseLangChain, type BaseLangChainParams } from "../language_models/base
 import { type RunnableConfig } from "../runnables/config.js";
 import type { RunnableFunc, RunnableInterface } from "../runnables/base.js";
 import { ToolCall } from "../messages/tool.js";
-import { ZodAny } from "../types/zod.js";
+import { ZodObjectAny } from "../types/zod.js";
 import { MessageContent } from "../messages/base.js";
+import { ToolInputParsingException } from "./utils.js";
+export { ToolInputParsingException };
 export type ResponseFormat = "content" | "content_and_artifact" | string;
 type ToolReturnType = any;
 export type ContentAndArtifact = [MessageContent, any];
@@ -24,16 +26,7 @@ export interface ToolParams extends BaseLangChainParams {
      */
     responseFormat?: ResponseFormat;
 }
-/**
- * Custom error class used to handle exceptions related to tool input parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
- */
-export declare class ToolInputParsingException extends Error {
-    output?: string;
-    constructor(message: string, output?: string);
-}
-export interface StructuredToolInterface<T extends ZodAny = ZodAny> extends RunnableInterface<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
+export interface StructuredToolInterface<T extends ZodObjectAny = ZodObjectAny> extends RunnableInterface<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
     lc_namespace: string[];
     schema: T | z.ZodEffects<T>;
     /**
@@ -57,7 +50,7 @@ export interface StructuredToolInterface<T extends ZodAny = ZodAny> extends Runn
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
-export declare abstract class StructuredTool<T extends ZodAny = ZodAny> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
+export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectAny> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
     abstract name: string;
     abstract description: string;
     abstract schema: T | z.ZodEffects<T>;
@@ -97,7 +90,7 @@ export declare abstract class StructuredTool<T extends ZodAny = ZodAny> extends
     /** @deprecated */
     tags?: string[]): Promise<ToolReturnType>;
 }
-export interface ToolInterface<T extends ZodAny = ZodAny> extends StructuredToolInterface<T> {
+export interface ToolInterface<T extends ZodObjectAny = ZodObjectAny> extends StructuredToolInterface<T> {
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      *
@@ -112,7 +105,7 @@ export interface ToolInterface<T extends ZodAny = ZodAny> extends StructuredTool
 /**
  * Base class for Tools that accept input as a string.
  */
-export declare abstract class Tool extends StructuredTool<ZodAny> {
+export declare abstract class Tool extends StructuredTool<ZodObjectAny> {
     schema: z.ZodEffects<z.ZodObject<{
         input: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -148,7 +141,7 @@ export interface DynamicToolInput extends BaseDynamicToolInput {
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
  */
-export interface DynamicStructuredToolInput<T extends ZodAny = ZodAny> extends BaseDynamicToolInput {
+export interface DynamicStructuredToolInput<T extends ZodObjectAny = ZodObjectAny> extends BaseDynamicToolInput {
     func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : z.infer<T>, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
     schema: T;
 }
@@ -174,7 +167,7 @@ export declare class DynamicTool extends Tool {
  * StructuredTool class and overrides the _call method to execute the
  * provided function when the tool is called.
  */
-export declare class DynamicStructuredTool<T extends ZodAny = ZodAny> extends StructuredTool<T> {
+export declare class DynamicStructuredTool<T extends ZodObjectAny = ZodObjectAny> extends StructuredTool<T> {
     static lc_name(): string;
     name: string;
     description: string;
@@ -200,10 +193,9 @@ export declare abstract class BaseToolkit {
 }
 /**
  * Parameters for the tool function.
- * @template {ZodAny} RunInput The input schema for the tool.
- * @template {any} RunOutput The output type for the tool.
+ * @template {ZodObjectAny | z.ZodString = ZodObjectAny} RunInput The input schema for the tool. Either any Zod object, or a Zod string.
  */
-interface ToolWrapperParams<RunInput extends ZodAny = ZodAny> extends ToolParams {
+interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString = ZodObjectAny> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -233,18 +225,17 @@ interface ToolWrapperParams<RunInput extends ZodAny = ZodAny> extends ToolParams
 }
 /**
  * Creates a new StructuredTool instance with the provided function, name, description, and schema.
+ *
  * @function
- * @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.
+ * @template {ZodObjectAny | z.ZodString = ZodObjectAny} T The input schema for the tool. Either any Zod object, or a Zod string.
  *
- * @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 {RunnableFunc<z.output<T>, ToolReturnType>} func - The function to invoke when the tool is called.
+ * @param {ToolWrapperParams<T>} 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.
+ * @param {ZodObjectAny | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.
  *
- * @returns {DynamicStructuredTool<RunInput, RunOutput>} A new StructuredTool instance.
+ * @returns {DynamicStructuredTool<T>} A new StructuredTool instance.
  */
-export declare function tool<T extends ZodAny = ZodAny>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
-export {};
+export declare function tool<T extends z.ZodString = z.ZodString>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicTool;
+export declare function tool<T extends ZodObjectAny = ZodObjectAny>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;

package/dist/tools/index.js

@@ -4,23 +4,8 @@ import { BaseLangChain, } from "../language_models/base.js";
 import { ensureConfig, patchConfig, } from "../runnables/config.js";
 import { ToolMessage } from "../messages/tool.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
-/**
- * Custom error class used to handle exceptions related to tool input parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
- */
-export class ToolInputParsingException extends Error {
-    constructor(message, output) {
-        super(message);
-        Object.defineProperty(this, "output", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.output = output;
-    }
-}
+import { _isToolCall, ToolInputParsingException } from "./utils.js";
+export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
@@ -282,29 +267,23 @@ export class BaseToolkit {
         return this.tools;
     }
 }
-/**
- * Creates a new StructuredTool instance with the provided function, name, description, and schema.
- * @function
- * @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<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 {DynamicStructuredTool<RunInput, RunOutput>} A new StructuredTool instance.
- */
 export function tool(func, fields) {
-    const schema = fields.schema ??
-        z.object({ input: z.string().optional() }).transform((obj) => obj.input);
-    const description = fields.description ?? schema.description ?? `${fields.name} tool`;
+    // If the schema is not provided, or it's a string schema, create a DynamicTool
+    if (!fields.schema || !("shape" in fields.schema) || !fields.schema.shape) {
+        return new DynamicTool({
+            name: fields.name,
+            description: fields.description ??
+                fields.schema?.description ??
+                `${fields.name} tool`,
+            responseFormat: fields.responseFormat,
+            func,
+        });
+    }
+    const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
     return new DynamicStructuredTool({
         name: fields.name,
         description,
-        schema: schema,
+        schema: fields.schema,
         // TODO: Consider moving into DynamicStructuredTool constructor
         func: async (input, runManager, config) => {
             return new Promise((resolve, reject) => {
@@ -324,12 +303,6 @@ export function tool(func, fields) {
         responseFormat: fields.responseFormat,
     });
 }
-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) {

package/dist/tools/tests/tools.test.js

@@ -72,3 +72,14 @@ test("Returns tool message if responseFormat is content_and_artifact and returns
     expect(toolResult.artifact).toEqual({ location: "San Francisco" });
     expect(toolResult.name).toBe("weather");
 });
+test("Tool can accept single string input", async () => {
+    const stringTool = tool((input) => {
+        return `${input}a`;
+    }, {
+        name: "string_tool",
+        description: "A tool that appends 'a' to the input string",
+        schema: z.string(),
+    });
+    const result = await stringTool.invoke("b");
+    expect(result).toBe("ba");
+});

package/dist/tools/utils.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolInputParsingException = exports._isToolCall = void 0;
+function _isToolCall(toolCall) {
+    return !!(toolCall &&
+        typeof toolCall === "object" &&
+        "type" in toolCall &&
+        toolCall.type === "tool_call");
+}
+exports._isToolCall = _isToolCall;
+/**
+ * Custom error class used to handle exceptions related to tool input parsing.
+ * It extends the built-in `Error` class and adds an optional `output`
+ * property that can hold the output that caused the exception.
+ */
+class ToolInputParsingException extends Error {
+    constructor(message, output) {
+        super(message);
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.output = output;
+    }
+}
+exports.ToolInputParsingException = ToolInputParsingException;

package/dist/tools/utils.d.ts

@@ -0,0 +1,11 @@
+import { ToolCall } from "../messages/tool.js";
+export declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;
+/**
+ * Custom error class used to handle exceptions related to tool input parsing.
+ * It extends the built-in `Error` class and adds an optional `output`
+ * property that can hold the output that caused the exception.
+ */
+export declare class ToolInputParsingException extends Error {
+    output?: string;
+    constructor(message: string, output?: string);
+}

package/dist/tools/utils.js

@@ -0,0 +1,23 @@
+export function _isToolCall(toolCall) {
+    return !!(toolCall &&
+        typeof toolCall === "object" &&
+        "type" in toolCall &&
+        toolCall.type === "tool_call");
+}
+/**
+ * Custom error class used to handle exceptions related to tool input parsing.
+ * It extends the built-in `Error` class and adds an optional `output`
+ * property that can hold the output that caused the exception.
+ */
+export class ToolInputParsingException extends Error {
+    constructor(message, output) {
+        super(message);
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.output = output;
+    }
+}

package/dist/types/zod.d.ts

@@ -1,2 +1,2 @@
 import type { z } from "zod";
-export type ZodAny = z.ZodObject<any, any, any, any>;
+export type ZodObjectAny = z.ZodObject<any, any, any, any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {