@langchain/core 0.2.16 → 0.2.18-rc.0

package/dist/runnables/iter.js

@@ -17,9 +17,8 @@ export function isAsyncIterable(thing) {
             "function");
 }
 export function* consumeIteratorInContext(context, iter) {
-    const storage = AsyncLocalStorageProviderSingleton.getInstance();
     while (true) {
-        const { value, done } = storage.run(context, iter.next.bind(iter));
+        const { value, done } = AsyncLocalStorageProviderSingleton.runWithConfig(context, iter.next.bind(iter), true);
         if (done) {
             break;
         }
@@ -29,10 +28,9 @@ export function* consumeIteratorInContext(context, iter) {
     }
 }
 export async function* consumeAsyncIterableInContext(context, iter) {
-    const storage = AsyncLocalStorageProviderSingleton.getInstance();
     const iterator = iter[Symbol.asyncIterator]();
     while (true) {
-        const { value, done } = await storage.run(context, iterator.next.bind(iter));
+        const { value, done } = await AsyncLocalStorageProviderSingleton.runWithConfig(context, iterator.next.bind(iter), true);
         if (done) {
             break;
         }

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

@@ -57,6 +57,58 @@ test("Runnable streamEvents method", async () => {
         },
     ]);
 });
+test("Runnable streamEvents method on a chat model", async () => {
+    const model = new FakeListChatModel({
+        responses: ["abc"],
+    });
+    const events = [];
+    const eventStream = await model.streamEvents("hello", { version: "v2" });
+    for await (const event of eventStream) {
+        events.push(event);
+    }
+    expect(events).toMatchObject([
+        {
+            data: { input: "hello" },
+            event: "on_chat_model_start",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { chunk: new AIMessageChunk({ content: "a" }) },
+            event: "on_chat_model_stream",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { chunk: new AIMessageChunk({ content: "b" }) },
+            event: "on_chat_model_stream",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { chunk: new AIMessageChunk({ content: "c" }) },
+            event: "on_chat_model_stream",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { output: new AIMessageChunk({ content: "abc" }) },
+            event: "on_chat_model_end",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+    ]);
+});
 test("Runnable streamEvents method with three runnables", async () => {
     const r = RunnableLambda.from(reverse);
     const chain = r
@@ -556,18 +608,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "h",
-            },
-        },
         {
             event: "on_llm_stream",
             data: {
@@ -582,18 +622,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "e",
-            },
-        },
         {
             event: "on_llm_stream",
             data: {
@@ -608,18 +636,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "y",
-            },
-        },
         {
             event: "on_llm_stream",
             data: {
@@ -634,18 +650,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "!",
-            },
-        },
         {
             event: "on_llm_end",
             data: {

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/runnables/types.d.ts

@@ -1,7 +1,7 @@
 import type { z } from "zod";
-import type { RunnableConfig } from "./config.js";
 import type { IterableReadableStreamInterface } from "../utils/stream.js";
 import type { SerializableInterface } from "../load/serializable.js";
+import type { BaseCallbackConfig } from "../callbacks/manager.js";
 export type RunnableBatchOptions = {
     /** @deprecated Pass in via the standard runnable config object instead */
     maxConcurrency?: number;
@@ -41,3 +41,16 @@ export interface Node {
     id: string;
     data: RunnableIOSchema | RunnableInterface;
 }
+export interface RunnableConfig extends BaseCallbackConfig {
+    /**
+     * Runtime values for attributes previously made configurable on this Runnable,
+     * or sub-Runnables.
+     */
+    configurable?: Record<string, any>;
+    /**
+     * Maximum number of times a call can recurse. If not provided, defaults to 25.
+     */
+    recursionLimit?: number;
+    /** Maximum number of parallel calls to make. */
+    maxConcurrency?: number;
+}

package/dist/singletons/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncLocalStorageProviderSingleton = exports.MockAsyncLocalStorage = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const langsmith_1 = require("langsmith");
+const manager_js_1 = require("../callbacks/manager.cjs");
 class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -12,14 +14,42 @@ class MockAsyncLocalStorage {
 }
 exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
+const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const LC_CHILD_KEY = Symbol.for("lc:child_config");
 class AsyncLocalStorageProvider {
     getInstance() {
-        return (globalThis.__lc_tracing_async_local_storage ??
-            mockAsyncLocalStorage);
+        return globalThis[TRACING_ALS_KEY] ?? mockAsyncLocalStorage;
+    }
+    getRunnableConfig() {
+        const storage = this.getInstance();
+        // this has the runnable config
+        // which means that we should also have an instance of a LangChainTracer
+        // with the run map prepopulated
+        return storage.getStore()?.extra?.[LC_CHILD_KEY];
+    }
+    runWithConfig(config, callback, avoidCreatingRootRunTree) {
+        const callbackManager = manager_js_1.CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
+        const storage = this.getInstance();
+        const parentRunId = callbackManager?.getParentRunId();
+        const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
+        let runTree;
+        if (langChainTracer && parentRunId) {
+            runTree = langChainTracer.convertToRunTree(parentRunId);
+        }
+        else if (!avoidCreatingRootRunTree) {
+            runTree = new langsmith_1.RunTree({
+                name: "<runnable_lambda>",
+                tracingEnabled: false,
+            });
+        }
+        if (runTree) {
+            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
+        }
+        return storage.run(runTree, callback);
     }
     initializeGlobalInstance(instance) {
-        if (globalThis.__lc_tracing_async_local_storage === undefined) {
-            globalThis.__lc_tracing_async_local_storage = instance;
+        if (globalThis[TRACING_ALS_KEY] === undefined) {
+            globalThis[TRACING_ALS_KEY] = instance;
         }
     }
 }

package/dist/singletons/index.d.ts

@@ -8,6 +8,8 @@ export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface
 }
 declare class AsyncLocalStorageProvider {
     getInstance(): AsyncLocalStorageInterface;
+    getRunnableConfig(): any;
+    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;
     initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
 }
 declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;

package/dist/singletons/index.js

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { RunTree } from "langsmith";
+import { CallbackManager } from "../callbacks/manager.js";
 export class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -8,14 +10,42 @@ export class MockAsyncLocalStorage {
     }
 }
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
+const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const LC_CHILD_KEY = Symbol.for("lc:child_config");
 class AsyncLocalStorageProvider {
     getInstance() {
-        return (globalThis.__lc_tracing_async_local_storage ??
-            mockAsyncLocalStorage);
+        return globalThis[TRACING_ALS_KEY] ?? mockAsyncLocalStorage;
+    }
+    getRunnableConfig() {
+        const storage = this.getInstance();
+        // this has the runnable config
+        // which means that we should also have an instance of a LangChainTracer
+        // with the run map prepopulated
+        return storage.getStore()?.extra?.[LC_CHILD_KEY];
+    }
+    runWithConfig(config, callback, avoidCreatingRootRunTree) {
+        const callbackManager = CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
+        const storage = this.getInstance();
+        const parentRunId = callbackManager?.getParentRunId();
+        const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
+        let runTree;
+        if (langChainTracer && parentRunId) {
+            runTree = langChainTracer.convertToRunTree(parentRunId);
+        }
+        else if (!avoidCreatingRootRunTree) {
+            runTree = new RunTree({
+                name: "<runnable_lambda>",
+                tracingEnabled: false,
+            });
+        }
+        if (runTree) {
+            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
+        }
+        return storage.run(runTree, callback);
     }
     initializeGlobalInstance(instance) {
-        if (globalThis.__lc_tracing_async_local_storage === undefined) {
-            globalThis.__lc_tracing_async_local_storage = instance;
+        if (globalThis[TRACING_ALS_KEY] === undefined) {
+            globalThis[TRACING_ALS_KEY] = instance;
         }
     }
 }

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

@@ -108,7 +108,6 @@ test("Config should be automatically populated after setting global async local
 });
 test("Runnable streamEvents method with streaming nested in a RunnableLambda", async () => {
     AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
-    const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
     const chat = new FakeListChatModel({
         responses: ["Hello"],
     });
@@ -117,7 +116,7 @@ test("Runnable streamEvents method with streaming nested in a RunnableLambda", a
     const innerRunId2 = v4();
     const dummyHandler = new FakeCallbackHandler();
     const myFunc = async (input) => {
-        const outerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+        const outerCallbackManager = await getCallbackManagerForConfig(AsyncLocalStorageProviderSingleton.getRunnableConfig());
         expect(outerCallbackManager?.getParentRunId()).toEqual(outerRunId);
         const nestedLambdaWithOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
             expect(config?.callbacks?.handlers).toEqual([]);
@@ -127,7 +126,7 @@ test("Runnable streamEvents method with streaming nested in a RunnableLambda", a
             callbacks: [],
         });
         const nestedLambdaWithoutOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
-            const innerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+            const innerCallbackManager = await getCallbackManagerForConfig(AsyncLocalStorageProviderSingleton.getRunnableConfig());
             expect(innerCallbackManager?.getParentRunId()).toEqual(innerRunId2);
             expect(config?.callbacks?.handlers).toContain(dummyHandler);
         });

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>;