@langchain/core 0.1.33-rc.1 → 0.1.33-rc.3

package/dist/runnables/base.cjs

@@ -159,7 +159,7 @@ class Runnable extends serializable_js_1.Serializable {
     async stream(input, options) {
         // Buffer the first streamed chunk to allow for initial errors
         // to surface immediately.
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this._streamIterator(input, options));
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this._streamIterator(input, (0, config_js_1.ensureConfig)(options)));
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -341,7 +341,7 @@ class Runnable extends serializable_js_1.Serializable {
                 finalChunk = (0, stream_js_1.concat)(finalChunk, chunk);
             }
         }
-        yield* this._streamIterator(finalChunk, options);
+        yield* this._streamIterator(finalChunk, (0, config_js_1.ensureConfig)(options));
     }
     /**
      * Stream all output from a runnable, as reported to the callback system.
@@ -1015,20 +1015,21 @@ class RunnableSequence extends Runnable {
         return [this.first, ...this.middle, this.last];
     }
     async invoke(input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, config?.runName);
         let nextStepInput = input;
         let finalOutput;
         try {
             const initialSteps = [this.first, ...this.middle];
             for (let i = 0; i < initialSteps.length; i += 1) {
                 const step = initialSteps[i];
-                nextStepInput = await step.invoke(nextStepInput, (0, config_js_1.patchConfig)(options, {
+                nextStepInput = await step.invoke(nextStepInput, (0, config_js_1.patchConfig)(config, {
                     callbacks: runManager?.getChild(`seq:step:${i + 1}`),
                 }));
             }
             // TypeScript can't detect that the last output of the sequence returns RunOutput, so call it out of the loop here
-            finalOutput = await this.last.invoke(nextStepInput, (0, config_js_1.patchConfig)(options, {
+            finalOutput = await this.last.invoke(nextStepInput, (0, config_js_1.patchConfig)(config, {
                 callbacks: runManager?.getChild(`seq:step:${this.steps.length}`),
             }));
         }
@@ -1194,15 +1195,16 @@ class RunnableMap extends Runnable {
         return new RunnableMap({ steps });
     }
     async invoke(input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
-        }, undefined, undefined, undefined, undefined, options?.runName);
+        }, undefined, undefined, undefined, undefined, config?.runName);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
             await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => {
-                output[key] = await runnable.invoke(input, (0, config_js_1.patchConfig)(options, {
+                output[key] = await runnable.invoke(input, (0, config_js_1.patchConfig)(config, {
                     callbacks: runManager?.getChild(`map:key:${key}`),
                 }));
             }));
@@ -1302,7 +1304,7 @@ class RunnableLambda extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore());
+        return this._callWithConfig(this._invoke, input, options);
     }
     async *_transform(generator, runManager, config) {
         let finalChunk;
@@ -1321,36 +1323,38 @@ class RunnableLambda extends Runnable {
                 }
             }
         }
-        // eslint-disable-next-line prefer-destructuring
-        const func = this.func;
-        async function* generatorWrapper() {
-            const output = await func(finalChunk, { ...config, config });
-            if (output && Runnable.isRunnable(output)) {
-                if (config?.recursionLimit === 0) {
-                    throw new Error("Recursion limit reached.");
+        const output = await new Promise((resolve, reject) => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+                try {
+                    const res = await this.func(finalChunk, {
+                        ...config,
+                        config,
+                    });
+                    resolve(res);
                 }
-                const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
-                    callbacks: runManager?.getChild(),
-                    recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
-                }));
-                for await (const chunk of stream) {
-                    yield chunk;
+                catch (e) {
+                    reject(e);
                 }
+            });
+        });
+        if (output && Runnable.isRunnable(output)) {
+            if (config?.recursionLimit === 0) {
+                throw new Error("Recursion limit reached.");
             }
-            else {
-                yield output;
+            const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+            }));
+            for await (const chunk of stream) {
+                yield chunk;
             }
         }
-        const finalGenerator = await new Promise((resolve) => {
-            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
-                const wrappedGenerator = generatorWrapper();
-                resolve(wrappedGenerator);
-            });
-        });
-        yield* finalGenerator;
+        else {
+            yield output;
+        }
     }
     transform(generator, options) {
-        return this._transformStreamWithConfig(generator, this._transform.bind(this), options ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore());
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
     }
     async stream(input, options) {
         async function* generator() {

package/dist/runnables/base.js

@@ -152,7 +152,7 @@ export class Runnable extends Serializable {
     async stream(input, options) {
         // Buffer the first streamed chunk to allow for initial errors
         // to surface immediately.
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this._streamIterator(input, options));
+        const wrappedGenerator = new AsyncGeneratorWithSetup(this._streamIterator(input, ensureConfig(options)));
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -334,7 +334,7 @@ export class Runnable extends Serializable {
                 finalChunk = concat(finalChunk, chunk);
             }
         }
-        yield* this._streamIterator(finalChunk, options);
+        yield* this._streamIterator(finalChunk, ensureConfig(options));
     }
     /**
      * Stream all output from a runnable, as reported to the callback system.
@@ -1004,20 +1004,21 @@ export class RunnableSequence extends Runnable {
         return [this.first, ...this.middle, this.last];
     }
     async invoke(input, options) {
-        const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, config?.runName);
         let nextStepInput = input;
         let finalOutput;
         try {
             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(options, {
+                nextStepInput = await step.invoke(nextStepInput, patchConfig(config, {
                     callbacks: runManager?.getChild(`seq:step:${i + 1}`),
                 }));
             }
             // TypeScript can't detect that the last output of the sequence returns RunOutput, so call it out of the loop here
-            finalOutput = await this.last.invoke(nextStepInput, patchConfig(options, {
+            finalOutput = await this.last.invoke(nextStepInput, patchConfig(config, {
                 callbacks: runManager?.getChild(`seq:step:${this.steps.length}`),
             }));
         }
@@ -1182,15 +1183,16 @@ export class RunnableMap extends Runnable {
         return new RunnableMap({ steps });
     }
     async invoke(input, options) {
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
-        }, undefined, undefined, undefined, undefined, options?.runName);
+        }, undefined, undefined, undefined, undefined, config?.runName);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
             await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => {
-                output[key] = await runnable.invoke(input, patchConfig(options, {
+                output[key] = await runnable.invoke(input, patchConfig(config, {
                     callbacks: runManager?.getChild(`map:key:${key}`),
                 }));
             }));
@@ -1289,7 +1291,7 @@ export class RunnableLambda extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options ?? AsyncLocalStorageProviderSingleton.getInstance().getStore());
+        return this._callWithConfig(this._invoke, input, options);
     }
     async *_transform(generator, runManager, config) {
         let finalChunk;
@@ -1308,36 +1310,38 @@ export class RunnableLambda extends Runnable {
                 }
             }
         }
-        // eslint-disable-next-line prefer-destructuring
-        const func = this.func;
-        async function* generatorWrapper() {
-            const output = await func(finalChunk, { ...config, config });
-            if (output && Runnable.isRunnable(output)) {
-                if (config?.recursionLimit === 0) {
-                    throw new Error("Recursion limit reached.");
+        const output = await new Promise((resolve, reject) => {
+            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+                try {
+                    const res = await this.func(finalChunk, {
+                        ...config,
+                        config,
+                    });
+                    resolve(res);
                 }
-                const stream = await output.stream(finalChunk, patchConfig(config, {
-                    callbacks: runManager?.getChild(),
-                    recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
-                }));
-                for await (const chunk of stream) {
-                    yield chunk;
+                catch (e) {
+                    reject(e);
                 }
+            });
+        });
+        if (output && Runnable.isRunnable(output)) {
+            if (config?.recursionLimit === 0) {
+                throw new Error("Recursion limit reached.");
             }
-            else {
-                yield output;
+            const stream = await output.stream(finalChunk, patchConfig(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+            }));
+            for await (const chunk of stream) {
+                yield chunk;
             }
         }
-        const finalGenerator = await new Promise((resolve) => {
-            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
-                const wrappedGenerator = generatorWrapper();
-                resolve(wrappedGenerator);
-            });
-        });
-        yield* finalGenerator;
+        else {
+            yield output;
+        }
     }
     transform(generator, options) {
-        return this._transformStreamWithConfig(generator, this._transform.bind(this), options ?? AsyncLocalStorageProviderSingleton.getInstance().getStore());
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
     }
     async stream(input, options) {
         async function* generator() {

package/dist/runnables/config.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchConfig = exports.ensureConfig = exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
 const manager_js_1 = require("../callbacks/manager.cjs");
+const index_js_1 = require("../singletons/index.cjs");
 exports.DEFAULT_RECURSION_LIMIT = 25;
 async function getCallbackManagerForConfig(config) {
     return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
@@ -83,23 +84,24 @@ const PRIMITIVES = new Set(["string", "number", "boolean"]);
  * Ensure that a passed config is an object with all required keys present.
  */
 function ensureConfig(config) {
+    const loadedConfig = config ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
     let empty = {
         tags: [],
         metadata: {},
         callbacks: undefined,
         recursionLimit: 25,
     };
-    if (config) {
-        empty = { ...empty, ...config };
+    if (loadedConfig) {
+        empty = { ...empty, ...loadedConfig };
     }
-    if (config?.configurable) {
-        for (const key of Object.keys(config.configurable)) {
-            if (PRIMITIVES.has(typeof config.configurable[key]) &&
+    if (loadedConfig?.configurable) {
+        for (const key of Object.keys(loadedConfig.configurable)) {
+            if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) &&
                 !empty.metadata?.[key]) {
                 if (!empty.metadata) {
                     empty.metadata = {};
                 }
-                empty.metadata[key] = config.configurable[key];
+                empty.metadata[key] = loadedConfig.configurable[key];
             }
         }
     }

package/dist/runnables/config.js

@@ -1,4 +1,5 @@
 import { CallbackManager, ensureHandler, } from "../callbacks/manager.js";
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 export const DEFAULT_RECURSION_LIMIT = 25;
 export async function getCallbackManagerForConfig(config) {
     return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
@@ -78,23 +79,24 @@ const PRIMITIVES = new Set(["string", "number", "boolean"]);
  * Ensure that a passed config is an object with all required keys present.
  */
 export function ensureConfig(config) {
+    const loadedConfig = config ?? AsyncLocalStorageProviderSingleton.getInstance().getStore();
     let empty = {
         tags: [],
         metadata: {},
         callbacks: undefined,
         recursionLimit: 25,
     };
-    if (config) {
-        empty = { ...empty, ...config };
+    if (loadedConfig) {
+        empty = { ...empty, ...loadedConfig };
     }
-    if (config?.configurable) {
-        for (const key of Object.keys(config.configurable)) {
-            if (PRIMITIVES.has(typeof config.configurable[key]) &&
+    if (loadedConfig?.configurable) {
+        for (const key of Object.keys(loadedConfig.configurable)) {
+            if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) &&
                 !empty.metadata?.[key]) {
                 if (!empty.metadata) {
                     empty.metadata = {};
                 }
-                empty.metadata[key] = config.configurable[key];
+                empty.metadata[key] = loadedConfig.configurable[key];
             }
         }
     }

package/dist/runnables/index.cjs

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

package/dist/runnables/index.d.ts

@@ -1,5 +1,5 @@
 export { type RunnableFunc, type RunnableLike, type RunnableBatchOptions, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableInterface, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
-export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, } from "./config.js";
+export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, ensureConfig, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { type RouterInput, RouterRunnable } from "./router.js";
 export { RunnableBranch, type Branch, type BranchLike } from "./branch.js";

package/dist/runnables/index.js

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

package/dist/runnables/passthrough.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnablePassthrough = void 0;
 const stream_js_1 = require("../utils/stream.cjs");
 const base_js_1 = require("./base.cjs");
+const config_js_1 = require("./config.cjs");
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.
  *
@@ -58,15 +59,17 @@ class RunnablePassthrough extends base_js_1.Runnable {
         }
     }
     async invoke(input, options) {
+        const config = (0, config_js_1.ensureConfig)(options);
         if (this.func) {
-            await this.func(input, options);
+            await this.func(input, config);
         }
-        return this._callWithConfig((input) => Promise.resolve(input), input, options);
+        return this._callWithConfig((input) => Promise.resolve(input), input, config);
     }
     async *transform(generator, options) {
+        const config = (0, config_js_1.ensureConfig)(options);
         let finalOutput;
         let finalOutputSupported = true;
-        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, options)) {
+        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, config)) {
             yield chunk;
             if (finalOutputSupported) {
                 if (finalOutput === undefined) {
@@ -85,7 +88,7 @@ class RunnablePassthrough extends base_js_1.Runnable {
             }
         }
         if (this.func && finalOutput !== undefined) {
-            await this.func(finalOutput, options);
+            await this.func(finalOutput, config);
         }
     }
     /**

package/dist/runnables/passthrough.d.ts

@@ -1,5 +1,5 @@
 import { Runnable, RunnableAssign, RunnableMapLike } from "./base.js";
-import type { RunnableConfig } from "./config.js";
+import { type RunnableConfig } from "./config.js";
 type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((input: RunInput, config?: RunnableConfig) => void) | ((input: RunInput) => Promise<void>) | ((input: RunInput, config?: RunnableConfig) => Promise<void>);
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.

package/dist/runnables/passthrough.js

@@ -1,5 +1,6 @@
 import { concat } from "../utils/stream.js";
 import { Runnable, RunnableAssign, RunnableMap, } from "./base.js";
+import { ensureConfig } from "./config.js";
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.
  *
@@ -55,15 +56,17 @@ export class RunnablePassthrough extends Runnable {
         }
     }
     async invoke(input, options) {
+        const config = ensureConfig(options);
         if (this.func) {
-            await this.func(input, options);
+            await this.func(input, config);
         }
-        return this._callWithConfig((input) => Promise.resolve(input), input, options);
+        return this._callWithConfig((input) => Promise.resolve(input), input, config);
     }
     async *transform(generator, options) {
+        const config = ensureConfig(options);
         let finalOutput;
         let finalOutputSupported = true;
-        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, options)) {
+        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, config)) {
             yield chunk;
             if (finalOutputSupported) {
                 if (finalOutput === undefined) {
@@ -82,7 +85,7 @@ export class RunnablePassthrough extends Runnable {
             }
         }
         if (this.func && finalOutput !== undefined) {
-            await this.func(finalOutput, options);
+            await this.func(finalOutput, config);
         }
     }
     /**

package/dist/tools.cjs

@@ -4,6 +4,7 @@ exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.Str
 const zod_1 = require("zod");
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./language_models/base.cjs");
+const config_js_1 = require("./runnables/config.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`
@@ -45,7 +46,7 @@ class StructuredTool extends base_js_1.BaseLangChain {
      * @returns A Promise that resolves with a string.
      */
     async invoke(input, config) {
-        return this.call(input, config);
+        return this.call(input, (0, config_js_1.ensureConfig)(config));
     }
     /**
      * Calls the tool with the provided argument, configuration, and tags. It

package/dist/tools.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { CallbackManagerForToolRun, Callbacks } from "./callbacks/manager.js";
 import { BaseLangChain, type BaseLangChainParams } from "./language_models/base.js";
-import type { RunnableConfig } from "./runnables/config.js";
+import { type RunnableConfig } from "./runnables/config.js";
 import type { RunnableInterface } from "./runnables/base.js";
 /**
  * Parameters for the Tool classes.

package/dist/tools.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { CallbackManager, parseCallbackConfigArg, } from "./callbacks/manager.js";
 import { BaseLangChain, } from "./language_models/base.js";
+import { ensureConfig } from "./runnables/config.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`
@@ -41,7 +42,7 @@ export class StructuredTool extends BaseLangChain {
      * @returns A Promise that resolves with a string.
      */
     async invoke(input, config) {
-        return this.call(input, config);
+        return this.call(input, ensureConfig(config));
     }
     /**
      * Calls the tool with the provided argument, configuration, and tags. It

package/package.json

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