@langchain/core 0.2.18 → 0.2.20

package/dist/runnables/base.js

@@ -6,6 +6,7 @@ import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler, } fr
 import { EventStreamCallbackHandler, isStreamEventsHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGeneratorWithSetup, } from "../utils/stream.js";
+import { raceWithSignal } from "../utils/signal.js";
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
@@ -187,6 +188,8 @@ export class Runnable extends Serializable {
                 recursionLimit: options.recursionLimit,
                 maxConcurrency: options.maxConcurrency,
                 runId: options.runId,
+                timeout: options.timeout,
+                signal: options.signal,
             });
         }
         const callOptions = { ...options };
@@ -198,6 +201,8 @@ export class Runnable extends Serializable {
         delete callOptions.recursionLimit;
         delete callOptions.maxConcurrency;
         delete callOptions.runId;
+        delete callOptions.timeout;
+        delete callOptions.signal;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
@@ -207,7 +212,8 @@ export class Runnable extends Serializable {
         delete config.runId;
         let output;
         try {
-            output = await func.call(this, input, config, runManager);
+            const promise = func.call(this, input, config, runManager);
+            output = await raceWithSignal(promise, options?.signal);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -235,7 +241,8 @@ export class Runnable extends Serializable {
         }));
         let outputs;
         try {
-            outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
+            const promise = func.call(this, inputs, optionsList, runManagers, batchOptions);
+            outputs = await raceWithSignal(promise, optionsList?.[0]?.signal);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
@@ -278,7 +285,7 @@ export class Runnable extends Serializable {
         }
         let runManager;
         try {
-            const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
+            const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), options?.signal, config);
             delete config.runId;
             runManager = pipe.setup;
             const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
@@ -826,9 +833,7 @@ export class RunnableBinding extends Runnable {
     async stream(input, options) {
         return this.bound.stream(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
-    async *transform(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    generator, options) {
+    async *transform(generator, options) {
         yield* this.bound.transform(generator, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
     streamEvents(input, options, streamOptions) {
@@ -1132,11 +1137,15 @@ export class RunnableSequence extends Runnable {
             const initialSteps = [this.first, ...this.middle];
             for (let i = 0; i < initialSteps.length; i += 1) {
                 const step = initialSteps[i];
-                nextStepInput = await step.invoke(nextStepInput, patchConfig(config, {
+                const promise = step.invoke(nextStepInput, patchConfig(config, {
                     callbacks: runManager?.getChild(`seq:step:${i + 1}`),
                 }));
+                nextStepInput = await raceWithSignal(promise, options?.signal);
             }
             // TypeScript can't detect that the last output of the sequence returns RunOutput, so call it out of the loop here
+            if (options?.signal?.aborted) {
+                throw new Error("Aborted");
+            }
             finalOutput = await this.last.invoke(nextStepInput, patchConfig(config, {
                 callbacks: runManager?.getChild(`seq:step:${this.steps.length}`),
             }));
@@ -1161,10 +1170,11 @@ export class RunnableSequence extends Runnable {
         try {
             for (let i = 0; i < this.steps.length; i += 1) {
                 const step = this.steps[i];
-                nextStepInputs = await step.batch(nextStepInputs, runManagers.map((runManager, j) => {
+                const promise = step.batch(nextStepInputs, runManagers.map((runManager, j) => {
                     const childRunManager = runManager?.getChild(`seq:step:${i + 1}`);
                     return patchConfig(configList[j], { callbacks: childRunManager });
                 }), batchOptions);
+                nextStepInputs = await raceWithSignal(promise, configList[0]?.signal);
             }
         }
         catch (e) {
@@ -1195,6 +1205,7 @@ export class RunnableSequence extends Runnable {
                 }));
             }
             for await (const chunk of finalGenerator) {
+                options?.signal?.throwIfAborted();
                 yield chunk;
                 if (concatSupported) {
                     if (finalOutput === undefined) {
@@ -1340,11 +1351,12 @@ export class RunnableMap extends Runnable {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
-            await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => {
+            const promises = Object.entries(this.steps).map(async ([key, runnable]) => {
                 output[key] = await runnable.invoke(input, patchConfig(config, {
                     callbacks: runManager?.getChild(`map:key:${key}`),
                 }));
-            }));
+            });
+            await raceWithSignal(Promise.all(promises), options?.signal);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -1369,7 +1381,8 @@ export class RunnableMap extends Runnable {
         // starting new iterations as needed,
         // until all iterators are done
         while (tasks.size) {
-            const { key, result, gen } = await Promise.race(tasks.values());
+            const promise = Promise.race(tasks.values());
+            const { key, result, gen } = await raceWithSignal(promise, options?.signal);
             tasks.delete(key);
             if (!result.done) {
                 yield { [key]: result.value };
@@ -1425,18 +1438,22 @@ export class RunnableTraceable extends Runnable {
     async invoke(input, options) {
         const [config] = this._getOptionsList(options ?? {}, 1);
         const callbacks = await getCallbackManagerForConfig(config);
-        return (await this.func(patchConfig(config, { callbacks }), input));
+        const promise = this.func(patchConfig(config, { callbacks }), input);
+        return raceWithSignal(promise, config?.signal);
     }
     async *_streamIterator(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
         const result = await this.invoke(input, options);
         if (isAsyncIterable(result)) {
             for await (const item of result) {
+                config?.signal?.throwIfAborted();
                 yield item;
             }
             return;
         }
         if (isIterator(result)) {
             while (true) {
+                config?.signal?.throwIfAborted();
                 const state = result.next();
                 if (state.done)
                     break;
@@ -1512,6 +1529,7 @@ export class RunnableLambda extends Runnable {
                     else if (isAsyncIterable(output)) {
                         let finalOutput;
                         for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
+                            config?.signal?.throwIfAborted();
                             if (finalOutput === undefined) {
                                 finalOutput = chunk;
                             }
@@ -1531,6 +1549,7 @@ export class RunnableLambda extends Runnable {
                     else if (isIterableIterator(output)) {
                         let finalOutput;
                         for (const chunk of consumeIteratorInContext(childConfig, output)) {
+                            config?.signal?.throwIfAborted();
                             if (finalOutput === undefined) {
                                 finalOutput = chunk;
                             }
@@ -1604,11 +1623,13 @@ export class RunnableLambda extends Runnable {
         }
         else if (isAsyncIterable(output)) {
             for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
+                config?.signal?.throwIfAborted();
                 yield chunk;
             }
         }
         else if (isIterableIterator(output)) {
             for (const chunk of consumeIteratorInContext(childConfig, output)) {
+                config?.signal?.throwIfAborted();
                 yield chunk;
             }
         }
@@ -1683,6 +1704,7 @@ export class RunnableWithFallbacks extends Runnable {
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
+            config?.signal?.throwIfAborted();
             try {
                 const output = await runnable.invoke(input, patchConfig(otherConfigFields, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
@@ -1714,6 +1736,7 @@ export class RunnableWithFallbacks extends Runnable {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let firstError;
         for (const runnable of this.runnables()) {
+            configList[0].signal?.throwIfAborted();
             try {
                 const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => patchConfig(configList[j], {
                     callbacks: runManager?.getChild(),

package/dist/runnables/config.cjs

@@ -24,6 +24,31 @@ function mergeConfigs(...configs) {
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
+            else if (key === "timeout") {
+                if (copy.timeout === undefined) {
+                    copy.timeout = options.timeout;
+                }
+                else if (options.timeout !== undefined) {
+                    copy.timeout = Math.min(copy.timeout, options.timeout);
+                }
+            }
+            else if (key === "signal") {
+                if (copy.signal === undefined) {
+                    copy.signal = options.signal;
+                }
+                else if (options.signal !== undefined) {
+                    if ("any" in AbortSignal) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        copy.signal = AbortSignal.any([
+                            copy.signal,
+                            options.signal,
+                        ]);
+                    }
+                    else {
+                        copy.signal = options.signal;
+                    }
+                }
+            }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
                 const providedCallbacks = options.callbacks;
@@ -130,6 +155,22 @@ function ensureConfig(config) {
             }
         }
     }
+    if (empty.timeout !== undefined) {
+        if (empty.timeout <= 0) {
+            throw new Error("Timeout must be a positive number");
+        }
+        const timeoutSignal = AbortSignal.timeout(empty.timeout);
+        if (empty.signal !== undefined) {
+            if ("any" in AbortSignal) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                empty.signal = AbortSignal.any([empty.signal, timeoutSignal]);
+            }
+        }
+        else {
+            empty.signal = timeoutSignal;
+        }
+        delete empty.timeout;
+    }
     return empty;
 }
 exports.ensureConfig = ensureConfig;

package/dist/runnables/config.js

@@ -20,6 +20,31 @@ export function mergeConfigs(...configs) {
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
+            else if (key === "timeout") {
+                if (copy.timeout === undefined) {
+                    copy.timeout = options.timeout;
+                }
+                else if (options.timeout !== undefined) {
+                    copy.timeout = Math.min(copy.timeout, options.timeout);
+                }
+            }
+            else if (key === "signal") {
+                if (copy.signal === undefined) {
+                    copy.signal = options.signal;
+                }
+                else if (options.signal !== undefined) {
+                    if ("any" in AbortSignal) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        copy.signal = AbortSignal.any([
+                            copy.signal,
+                            options.signal,
+                        ]);
+                    }
+                    else {
+                        copy.signal = options.signal;
+                    }
+                }
+            }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
                 const providedCallbacks = options.callbacks;
@@ -125,6 +150,22 @@ export function ensureConfig(config) {
             }
         }
     }
+    if (empty.timeout !== undefined) {
+        if (empty.timeout <= 0) {
+            throw new Error("Timeout must be a positive number");
+        }
+        const timeoutSignal = AbortSignal.timeout(empty.timeout);
+        if (empty.signal !== undefined) {
+            if ("any" in AbortSignal) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                empty.signal = AbortSignal.any([empty.signal, timeoutSignal]);
+            }
+        }
+        else {
+            empty.signal = timeoutSignal;
+        }
+        delete empty.timeout;
+    }
     return empty;
 }
 /**

package/dist/runnables/remote.cjs

@@ -46,7 +46,7 @@ function revive(obj) {
                     content: obj.content,
                 });
             }
-            if (obj.type === "ChatMessage" || obj.type === "chat") {
+            if (obj.type === "ChatMessage" || obj.type === "generic") {
                 return new index_js_2.ChatMessage({
                     content: obj.content,
                     role: obj.role,
@@ -62,6 +62,7 @@ function revive(obj) {
                 return new index_js_2.ToolMessage({
                     content: obj.content,
                     tool_call_id: obj.tool_call_id,
+                    status: obj.status,
                 });
             }
             if (obj.type === "AIMessage" || obj.type === "ai") {
@@ -95,6 +96,7 @@ function revive(obj) {
                 return new index_js_2.ToolMessageChunk({
                     content: obj.content,
                     tool_call_id: obj.tool_call_id,
+                    status: obj.status,
                 });
             }
             if (obj.type === "AIMessageChunk") {
@@ -184,9 +186,10 @@ function deserialize(str) {
     const obj = JSON.parse(str);
     return revive(obj);
 }
-function removeCallbacks(options) {
+function removeCallbacksAndSignal(options) {
     const rest = { ...options };
     delete rest.callbacks;
+    delete rest.signal;
     return rest;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -251,7 +254,7 @@ class RemoteRunnable extends base_js_1.Runnable {
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
     }
-    async post(path, body) {
+    async post(path, body, signal) {
         return fetch(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
@@ -259,16 +262,16 @@ class RemoteRunnable extends base_js_1.Runnable {
                 "Content-Type": "application/json",
                 ...this.options?.headers,
             },
-            signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const response = await this.post("/invoke", {
             input,
-            config: removeCallbacks(config),
+            config: removeCallbacksAndSignal(config),
             kwargs: kwargs ?? {},
-        });
+        }, config.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -289,10 +292,10 @@ class RemoteRunnable extends base_js_1.Runnable {
         const response = await this.post("/batch", {
             inputs,
             config: (configs ?? [])
-                .map(removeCallbacks)
+                .map(removeCallbacksAndSignal)
                 .map((config) => ({ ...config, ...batchOptions })),
             kwargs,
-        });
+        }, options?.[0]?.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -317,9 +320,9 @@ class RemoteRunnable extends base_js_1.Runnable {
         try {
             const response = await this.post("/stream", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
-            });
+            }, config.signal);
             if (!response.ok) {
                 const json = await response.json();
                 const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
@@ -376,11 +379,11 @@ class RemoteRunnable extends base_js_1.Runnable {
         try {
             const response = await this.post("/stream_log", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
                 ...camelCaseStreamOptions,
                 diff: false,
-            });
+            }, config.signal);
             const { body, ok } = response;
             if (!ok) {
                 throw new Error(`${response.status} Error: ${await response.text()}`);
@@ -428,11 +431,11 @@ class RemoteRunnable extends base_js_1.Runnable {
             try {
                 const response = await outerThis.post("/stream_events", {
                     input,
-                    config: removeCallbacks(config),
+                    config: removeCallbacksAndSignal(config),
                     kwargs,
                     ...camelCaseStreamOptions,
                     diff: false,
-                });
+                }, config.signal);
                 const { body, ok } = response;
                 if (!ok) {
                     throw new Error(`${response.status} Error: ${await response.text()}`);

package/dist/runnables/remote.js

@@ -43,7 +43,7 @@ function revive(obj) {
                     content: obj.content,
                 });
             }
-            if (obj.type === "ChatMessage" || obj.type === "chat") {
+            if (obj.type === "ChatMessage" || obj.type === "generic") {
                 return new ChatMessage({
                     content: obj.content,
                     role: obj.role,
@@ -59,6 +59,7 @@ function revive(obj) {
                 return new ToolMessage({
                     content: obj.content,
                     tool_call_id: obj.tool_call_id,
+                    status: obj.status,
                 });
             }
             if (obj.type === "AIMessage" || obj.type === "ai") {
@@ -92,6 +93,7 @@ function revive(obj) {
                 return new ToolMessageChunk({
                     content: obj.content,
                     tool_call_id: obj.tool_call_id,
+                    status: obj.status,
                 });
             }
             if (obj.type === "AIMessageChunk") {
@@ -181,9 +183,10 @@ function deserialize(str) {
     const obj = JSON.parse(str);
     return revive(obj);
 }
-function removeCallbacks(options) {
+function removeCallbacksAndSignal(options) {
     const rest = { ...options };
     delete rest.callbacks;
+    delete rest.signal;
     return rest;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -248,7 +251,7 @@ export class RemoteRunnable extends Runnable {
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
     }
-    async post(path, body) {
+    async post(path, body, signal) {
         return fetch(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
@@ -256,16 +259,16 @@ export class RemoteRunnable extends Runnable {
                 "Content-Type": "application/json",
                 ...this.options?.headers,
             },
-            signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const response = await this.post("/invoke", {
             input,
-            config: removeCallbacks(config),
+            config: removeCallbacksAndSignal(config),
             kwargs: kwargs ?? {},
-        });
+        }, config.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -286,10 +289,10 @@ export class RemoteRunnable extends Runnable {
         const response = await this.post("/batch", {
             inputs,
             config: (configs ?? [])
-                .map(removeCallbacks)
+                .map(removeCallbacksAndSignal)
                 .map((config) => ({ ...config, ...batchOptions })),
             kwargs,
-        });
+        }, options?.[0]?.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -314,9 +317,9 @@ export class RemoteRunnable extends Runnable {
         try {
             const response = await this.post("/stream", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
-            });
+            }, config.signal);
             if (!response.ok) {
                 const json = await response.json();
                 const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
@@ -373,11 +376,11 @@ export class RemoteRunnable extends Runnable {
         try {
             const response = await this.post("/stream_log", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
                 ...camelCaseStreamOptions,
                 diff: false,
-            });
+            }, config.signal);
             const { body, ok } = response;
             if (!ok) {
                 throw new Error(`${response.status} Error: ${await response.text()}`);
@@ -425,11 +428,11 @@ export class RemoteRunnable extends Runnable {
             try {
                 const response = await outerThis.post("/stream_events", {
                     input,
-                    config: removeCallbacks(config),
+                    config: removeCallbacksAndSignal(config),
                     kwargs,
                     ...camelCaseStreamOptions,
                     diff: false,
-                });
+                }, config.signal);
                 const { body, ok } = response;
                 if (!ok) {
                     throw new Error(`${response.status} Error: ${await response.text()}`);

package/dist/runnables/types.d.ts

@@ -53,4 +53,14 @@ export interface RunnableConfig extends BaseCallbackConfig {
     recursionLimit?: number;
     /** Maximum number of parallel calls to make. */
     maxConcurrency?: number;
+    /**
+     * Timeout for this call in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Abort signal for this call.
+     * If provided, the call will be aborted when the signal is aborted.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+     */
+    signal?: AbortSignal;
 }

package/dist/tools/index.cjs

@@ -9,6 +9,7 @@ const tool_js_1 = require("../messages/tool.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 const utils_js_1 = require("./utils.cjs");
 Object.defineProperty(exports, "ToolInputParsingException", { enumerable: true, get: function () { return utils_js_1.ToolInputParsingException; } });
+const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
@@ -94,6 +95,7 @@ class StructuredTool extends base_js_1.BaseLangChain {
         let result;
         try {
             result = await this._call(parsed, runManager, config);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             await runManager?.handleToolError(e);
@@ -210,6 +212,9 @@ exports.DynamicTool = DynamicTool;
  * description, designed to work with structured data. It extends the
  * StructuredTool class and overrides the _call method to execute the
  * provided function when the tool is called.
+ *
+ * Schema can be passed as Zod or JSON schema. The tool will not validate
+ * input if JSON schema is passed.
  */
 class DynamicStructuredTool extends StructuredTool {
     static lc_name() {
@@ -245,7 +250,7 @@ class DynamicStructuredTool extends StructuredTool {
         this.description = fields.description;
         this.func = fields.func;
         this.returnDirect = fields.returnDirect ?? this.returnDirect;
-        this.schema = fields.schema;
+        this.schema = ((0, is_zod_schema_js_1.isZodSchema)(fields.schema) ? fields.schema : zod_1.z.object({}));
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -260,6 +265,7 @@ class DynamicStructuredTool extends StructuredTool {
         return super.call(arg, config, tags);
     }
     _call(arg, runManager, parentConfig) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.func(arg, runManager, parentConfig);
     }
 }
@@ -279,18 +285,20 @@ function tool(func, fields) {
     // 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,
+            ...fields,
             description: fields.description ??
                 fields.schema?.description ??
                 `${fields.name} tool`,
-            responseFormat: fields.responseFormat,
-            func,
+            // TS doesn't restrict the type here based on the guard above
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            func: func,
         });
     }
     const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
     return new DynamicStructuredTool({
-        name: fields.name,
+        ...fields,
         description,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         schema: fields.schema,
         // TODO: Consider moving into DynamicStructuredTool constructor
         func: async (input, runManager, config) => {
@@ -300,6 +308,8 @@ function tool(func, fields) {
                 });
                 void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                     try {
+                        // TS doesn't restrict the type here based on the guard above
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         resolve(func(input, childConfig));
                     }
                     catch (e) {
@@ -308,7 +318,6 @@ function tool(func, fields) {
                 });
             });
         },
-        responseFormat: fields.responseFormat,
     });
 }
 exports.tool = tool;