@langchain/core 0.2.18 → 0.2.20

package/dist/language_models/llms.cjs

@@ -39,11 +39,10 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
     async *_streamResponseChunks(_input, _options, _runManager) {
         throw new Error("Not implemented.");
     }
-    _separateRunnableConfigFromCallOptions(options) {
+    _separateRunnableConfigFromCallOptionsCompat(options) {
+        // For backwards compat, keep `signal` in both runnableConfig and callOptions
         const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
-        if (callOptions?.timeout && !callOptions.signal) {
-            callOptions.signal = AbortSignal.timeout(callOptions.timeout);
-        }
+        callOptions.signal = runnableConfig.signal;
         return [runnableConfig, callOptions];
     }
     async *_streamIterator(input, options) {
@@ -53,7 +52,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         }
         else {
             const prompt = BaseLLM._convertInputToPromptValue(input);
-            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
+            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
             const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
             const extra = {
                 options: callOptions,
@@ -261,7 +260,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         else {
             parsedOptions = options;
         }
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(parsedOptions);
         runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
         if (!this.cache) {
             return this._generateUncached(prompts, callOptions, runnableConfig);

package/dist/language_models/llms.d.ts

@@ -17,19 +17,11 @@ export interface BaseLLMParams extends BaseLanguageModelParams {
 }
 export interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {
 }
-interface LLMGenerateCachedParameters<T extends BaseLLM<CallOptions>, CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> {
-    prompts: string[];
-    cache: BaseCache<Generation[]>;
-    llmStringKey: string;
-    parsedOptions: T["ParsedCallOptions"];
-    handledOptions: RunnableConfig;
-    runId?: string;
-}
 /**
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
 export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {
-    ParsedCallOptions: Omit<CallOptions, keyof RunnableConfig & "timeout">;
+    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, "signal" | "timeout" | "maxConcurrency">>;
     lc_namespace: string[];
     constructor({ concurrency, ...rest }: BaseLLMParams);
     /**
@@ -42,7 +34,7 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
      */
     invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;
     _streamResponseChunks(_input: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
-    protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
+    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
     _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;
     /**
      * This method takes prompt values, options, and callbacks, and generates
@@ -64,7 +56,14 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
     _flattenLLMResult(llmResult: LLMResult): LLMResult[];
     /** @ignore */
     _generateUncached(prompts: string[], parsedOptions: this["ParsedCallOptions"], handledOptions: BaseCallbackConfig): Promise<LLMResult>;
-    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }: LLMGenerateCachedParameters<typeof this>): Promise<LLMResult & {
+    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }: {
+        prompts: string[];
+        cache: BaseCache<Generation[]>;
+        llmStringKey: string;
+        parsedOptions: any;
+        handledOptions: RunnableConfig;
+        runId?: string;
+    }): Promise<LLMResult & {
         missingPromptIndices: number[];
     }>;
     /**
@@ -127,4 +126,3 @@ export declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseL
     abstract _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
     _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
 }
-export {};

package/dist/language_models/llms.js

@@ -36,11 +36,10 @@ export class BaseLLM extends BaseLanguageModel {
     async *_streamResponseChunks(_input, _options, _runManager) {
         throw new Error("Not implemented.");
     }
-    _separateRunnableConfigFromCallOptions(options) {
+    _separateRunnableConfigFromCallOptionsCompat(options) {
+        // For backwards compat, keep `signal` in both runnableConfig and callOptions
         const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
-        if (callOptions?.timeout && !callOptions.signal) {
-            callOptions.signal = AbortSignal.timeout(callOptions.timeout);
-        }
+        callOptions.signal = runnableConfig.signal;
         return [runnableConfig, callOptions];
     }
     async *_streamIterator(input, options) {
@@ -50,7 +49,7 @@ export class BaseLLM extends BaseLanguageModel {
         }
         else {
             const prompt = BaseLLM._convertInputToPromptValue(input);
-            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
+            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
             const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
             const extra = {
                 options: callOptions,
@@ -258,7 +257,7 @@ export class BaseLLM extends BaseLanguageModel {
         else {
             parsedOptions = options;
         }
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(parsedOptions);
         runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
         if (!this.cache) {
             return this._generateUncached(prompts, callOptions, runnableConfig);

package/dist/messages/base.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBaseMessageChunk = exports.isBaseMessage = exports.BaseMessageChunk = exports._mergeObj = exports._mergeLists = exports._mergeDicts = exports.isOpenAIToolCallArray = exports.BaseMessage = exports.mergeContent = void 0;
+exports.isBaseMessageChunk = exports.isBaseMessage = exports.BaseMessageChunk = exports._mergeObj = exports._mergeLists = exports._mergeDicts = exports.isOpenAIToolCallArray = exports.BaseMessage = exports._mergeStatus = exports.mergeContent = void 0;
 const serializable_js_1 = require("../load/serializable.cjs");
 function mergeContent(firstContent, secondContent) {
     // If first content is a string
@@ -25,6 +25,21 @@ function mergeContent(firstContent, secondContent) {
     }
 }
 exports.mergeContent = mergeContent;
+/**
+ * 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else
+ * it will return 'success'.
+ *
+ * @param {"success" | "error" | undefined} left The existing value to 'merge' with the new value.
+ * @param {"success" | "error" | undefined} right The new value to 'merge' with the existing value
+ * @returns {"success" | "error"} The 'merged' value.
+ */
+function _mergeStatus(left, right) {
+    if (left === "error" || right === "error") {
+        return "error";
+    }
+    return "success";
+}
+exports._mergeStatus = _mergeStatus;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function stringifyWithDepthLimit(obj, depthLimit) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/messages/base.d.ts

@@ -90,6 +90,15 @@ export type BaseMessageFields = {
     id?: string;
 };
 export declare function mergeContent(firstContent: MessageContent, secondContent: MessageContent): MessageContent;
+/**
+ * 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else
+ * it will return 'success'.
+ *
+ * @param {"success" | "error" | undefined} left The existing value to 'merge' with the new value.
+ * @param {"success" | "error" | undefined} right The new value to 'merge' with the existing value
+ * @returns {"success" | "error"} The 'merged' value.
+ */
+export declare function _mergeStatus(left?: "success" | "error", right?: "success" | "error"): "success" | "error" | undefined;
 /**
  * Base class for all types of messages in a conversation. It includes
  * properties like `content`, `name`, and `additional_kwargs`. It also

package/dist/messages/base.js

@@ -21,6 +21,20 @@ export function mergeContent(firstContent, secondContent) {
         return [...firstContent, { type: "text", text: secondContent }];
     }
 }
+/**
+ * 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else
+ * it will return 'success'.
+ *
+ * @param {"success" | "error" | undefined} left The existing value to 'merge' with the new value.
+ * @param {"success" | "error" | undefined} right The new value to 'merge' with the existing value
+ * @returns {"success" | "error"} The 'merged' value.
+ */
+export function _mergeStatus(left, right) {
+    if (left === "error" || right === "error") {
+        return "error";
+    }
+    return "success";
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function stringifyWithDepthLimit(obj, depthLimit) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/messages/tool.cjs

@@ -19,6 +19,16 @@ class ToolMessage extends base_js_1.BaseMessage {
             fields = { content: fields, name, tool_call_id: tool_call_id };
         }
         super(fields);
+        /**
+         * Status of the tool invocation.
+         * @version 0.2.19
+         */
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "tool_call_id", {
             enumerable: true,
             configurable: true,
@@ -41,6 +51,7 @@ class ToolMessage extends base_js_1.BaseMessage {
         });
         this.tool_call_id = fields.tool_call_id;
         this.artifact = fields.artifact;
+        this.status = fields.status;
     }
     _getType() {
         return "tool";
@@ -70,6 +81,16 @@ class ToolMessageChunk extends base_js_1.BaseMessageChunk {
             writable: true,
             value: void 0
         });
+        /**
+         * Status of the tool invocation.
+         * @version 0.2.19
+         */
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /**
          * Artifact of the Tool execution which is not meant to be sent to the model.
          *
@@ -86,6 +107,7 @@ class ToolMessageChunk extends base_js_1.BaseMessageChunk {
         });
         this.tool_call_id = fields.tool_call_id;
         this.artifact = fields.artifact;
+        this.status = fields.status;
     }
     static lc_name() {
         return "ToolMessageChunk";
@@ -101,6 +123,7 @@ class ToolMessageChunk extends base_js_1.BaseMessageChunk {
             artifact: (0, base_js_1._mergeObj)(this.artifact, chunk.artifact),
             tool_call_id: this.tool_call_id,
             id: this.id ?? chunk.id,
+            status: (0, base_js_1._mergeStatus)(this.status, chunk.status),
         });
     }
     get _printableFields() {

package/dist/messages/tool.d.ts

@@ -9,6 +9,11 @@ export interface ToolMessageFieldsWithToolCallId extends BaseMessageFields {
      */
     artifact?: any;
     tool_call_id: string;
+    /**
+     * Status of the tool invocation.
+     * @version 0.2.19
+     */
+    status?: "success" | "error";
 }
 /**
  * Represents a tool message in a conversation.
@@ -16,6 +21,11 @@ export interface ToolMessageFieldsWithToolCallId extends BaseMessageFields {
 export declare class ToolMessage extends BaseMessage {
     static lc_name(): string;
     get lc_aliases(): Record<string, string>;
+    /**
+     * Status of the tool invocation.
+     * @version 0.2.19
+     */
+    status?: "success" | "error";
     tool_call_id: string;
     /**
      * Artifact of the Tool execution which is not meant to be sent to the model.
@@ -37,6 +47,11 @@ export declare class ToolMessage extends BaseMessage {
  */
 export declare class ToolMessageChunk extends BaseMessageChunk {
     tool_call_id: string;
+    /**
+     * Status of the tool invocation.
+     * @version 0.2.19
+     */
+    status?: "success" | "error";
     /**
      * Artifact of the Tool execution which is not meant to be sent to the model.
      *

package/dist/messages/tool.js

@@ -1,4 +1,4 @@
-import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, _mergeObj, } from "./base.js";
+import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, _mergeObj, _mergeStatus, } from "./base.js";
 /**
  * Represents a tool message in a conversation.
  */
@@ -16,6 +16,16 @@ export class ToolMessage extends BaseMessage {
             fields = { content: fields, name, tool_call_id: tool_call_id };
         }
         super(fields);
+        /**
+         * Status of the tool invocation.
+         * @version 0.2.19
+         */
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "tool_call_id", {
             enumerable: true,
             configurable: true,
@@ -38,6 +48,7 @@ export class ToolMessage extends BaseMessage {
         });
         this.tool_call_id = fields.tool_call_id;
         this.artifact = fields.artifact;
+        this.status = fields.status;
     }
     _getType() {
         return "tool";
@@ -66,6 +77,16 @@ export class ToolMessageChunk extends BaseMessageChunk {
             writable: true,
             value: void 0
         });
+        /**
+         * Status of the tool invocation.
+         * @version 0.2.19
+         */
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /**
          * Artifact of the Tool execution which is not meant to be sent to the model.
          *
@@ -82,6 +103,7 @@ export class ToolMessageChunk extends BaseMessageChunk {
         });
         this.tool_call_id = fields.tool_call_id;
         this.artifact = fields.artifact;
+        this.status = fields.status;
     }
     static lc_name() {
         return "ToolMessageChunk";
@@ -97,6 +119,7 @@ export class ToolMessageChunk extends BaseMessageChunk {
             artifact: _mergeObj(this.artifact, chunk.artifact),
             tool_call_id: this.tool_call_id,
             id: this.id ?? chunk.id,
+            status: _mergeStatus(this.status, chunk.status),
         });
     }
     get _printableFields() {

package/dist/messages/utils.cjs

@@ -121,7 +121,7 @@ function mapStoredMessageToChatMessage(message) {
                 throw new Error("Tool call ID must be defined for tool messages");
             }
             return new tool_js_1.ToolMessage(storedMessage.data);
-        case "chat": {
+        case "generic": {
             if (storedMessage.data.role === undefined) {
                 throw new Error("Role must be defined for chat messages");
             }

package/dist/messages/utils.js

@@ -116,7 +116,7 @@ export function mapStoredMessageToChatMessage(message) {
                 throw new Error("Tool call ID must be defined for tool messages");
             }
             return new ToolMessage(storedMessage.data);
-        case "chat": {
+        case "generic": {
             if (storedMessage.data.role === undefined) {
                 throw new Error("Role must be defined for chat messages");
             }

package/dist/output_parsers/string.cjs

@@ -62,6 +62,7 @@ class StringOutputParser extends transform_js_1.BaseTransformOutputParser {
     _messageContentComplexToString(content) {
         switch (content.type) {
             case "text":
+            case "text_delta":
                 if ("text" in content) {
                     // Type guard for MessageContentText
                     return this._textContentToString(content);

package/dist/output_parsers/string.js

@@ -59,6 +59,7 @@ export class StringOutputParser extends BaseTransformOutputParser {
     _messageContentComplexToString(content) {
         switch (content.type) {
             case "text":
+            case "text_delta":
                 if ("text" in content) {
                     // Type guard for MessageContentText
                     return this._textContentToString(content);

package/dist/runnables/base.cjs

@@ -12,6 +12,7 @@ const log_stream_js_1 = require("../tracers/log_stream.cjs");
 const event_stream_js_1 = require("../tracers/event_stream.cjs");
 const serializable_js_1 = require("../load/serializable.cjs");
 const stream_js_1 = require("../utils/stream.cjs");
+const signal_js_1 = require("../utils/signal.cjs");
 const config_js_1 = require("./config.cjs");
 const async_caller_js_1 = require("../utils/async_caller.cjs");
 const root_listener_js_1 = require("../tracers/root_listener.cjs");
@@ -194,6 +195,8 @@ class Runnable extends serializable_js_1.Serializable {
                 recursionLimit: options.recursionLimit,
                 maxConcurrency: options.maxConcurrency,
                 runId: options.runId,
+                timeout: options.timeout,
+                signal: options.signal,
             });
         }
         const callOptions = { ...options };
@@ -205,6 +208,8 @@ class Runnable extends serializable_js_1.Serializable {
         delete callOptions.recursionLimit;
         delete callOptions.maxConcurrency;
         delete callOptions.runId;
+        delete callOptions.timeout;
+        delete callOptions.signal;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
@@ -214,7 +219,8 @@ class Runnable extends serializable_js_1.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 (0, signal_js_1.raceWithSignal)(promise, options?.signal);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -242,7 +248,8 @@ class Runnable extends serializable_js_1.Serializable {
         }));
         let outputs;
         try {
-            outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
+            const promise = func.call(this, inputs, optionsList, runManagers, batchOptions);
+            outputs = await (0, signal_js_1.raceWithSignal)(promise, optionsList?.[0]?.signal);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
@@ -285,7 +292,7 @@ class Runnable extends serializable_js_1.Serializable {
         }
         let runManager;
         try {
-            const pipe = await (0, stream_js_1.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 (0, stream_js_1.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(event_stream_js_1.isStreamEventsHandler);
@@ -834,9 +841,7 @@ class RunnableBinding extends Runnable {
     async stream(input, options) {
         return this.bound.stream(input, await this._mergeConfig((0, config_js_1.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((0, config_js_1.ensureConfig)(options), this.kwargs));
     }
     streamEvents(input, options, streamOptions) {
@@ -1143,11 +1148,15 @@ 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, (0, config_js_1.patchConfig)(config, {
+                const promise = step.invoke(nextStepInput, (0, config_js_1.patchConfig)(config, {
                     callbacks: runManager?.getChild(`seq:step:${i + 1}`),
                 }));
+                nextStepInput = await (0, signal_js_1.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, (0, config_js_1.patchConfig)(config, {
                 callbacks: runManager?.getChild(`seq:step:${this.steps.length}`),
             }));
@@ -1172,10 +1181,11 @@ 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 (0, config_js_1.patchConfig)(configList[j], { callbacks: childRunManager });
                 }), batchOptions);
+                nextStepInputs = await (0, signal_js_1.raceWithSignal)(promise, configList[0]?.signal);
             }
         }
         catch (e) {
@@ -1206,6 +1216,7 @@ class RunnableSequence extends Runnable {
                 }));
             }
             for await (const chunk of finalGenerator) {
+                options?.signal?.throwIfAborted();
                 yield chunk;
                 if (concatSupported) {
                     if (finalOutput === undefined) {
@@ -1352,11 +1363,12 @@ 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, (0, config_js_1.patchConfig)(config, {
                     callbacks: runManager?.getChild(`map:key:${key}`),
                 }));
-            }));
+            });
+            await (0, signal_js_1.raceWithSignal)(Promise.all(promises), options?.signal);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -1381,7 +1393,8 @@ 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 (0, signal_js_1.raceWithSignal)(promise, options?.signal);
             tasks.delete(key);
             if (!result.done) {
                 yield { [key]: result.value };
@@ -1438,18 +1451,22 @@ class RunnableTraceable extends Runnable {
     async invoke(input, options) {
         const [config] = this._getOptionsList(options ?? {}, 1);
         const callbacks = await (0, config_js_1.getCallbackManagerForConfig)(config);
-        return (await this.func((0, config_js_1.patchConfig)(config, { callbacks }), input));
+        const promise = this.func((0, config_js_1.patchConfig)(config, { callbacks }), input);
+        return (0, signal_js_1.raceWithSignal)(promise, config?.signal);
     }
     async *_streamIterator(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
         const result = await this.invoke(input, options);
         if ((0, iter_js_1.isAsyncIterable)(result)) {
             for await (const item of result) {
+                config?.signal?.throwIfAborted();
                 yield item;
             }
             return;
         }
         if ((0, iter_js_1.isIterator)(result)) {
             while (true) {
+                config?.signal?.throwIfAborted();
                 const state = result.next();
                 if (state.done)
                     break;
@@ -1526,6 +1543,7 @@ class RunnableLambda extends Runnable {
                     else if ((0, iter_js_1.isAsyncIterable)(output)) {
                         let finalOutput;
                         for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(childConfig, output)) {
+                            config?.signal?.throwIfAborted();
                             if (finalOutput === undefined) {
                                 finalOutput = chunk;
                             }
@@ -1545,6 +1563,7 @@ class RunnableLambda extends Runnable {
                     else if ((0, iter_js_1.isIterableIterator)(output)) {
                         let finalOutput;
                         for (const chunk of (0, iter_js_1.consumeIteratorInContext)(childConfig, output)) {
+                            config?.signal?.throwIfAborted();
                             if (finalOutput === undefined) {
                                 finalOutput = chunk;
                             }
@@ -1618,11 +1637,13 @@ class RunnableLambda extends Runnable {
         }
         else if ((0, iter_js_1.isAsyncIterable)(output)) {
             for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(childConfig, output)) {
+                config?.signal?.throwIfAborted();
                 yield chunk;
             }
         }
         else if ((0, iter_js_1.isIterableIterator)(output)) {
             for (const chunk of (0, iter_js_1.consumeIteratorInContext)(childConfig, output)) {
+                config?.signal?.throwIfAborted();
                 yield chunk;
             }
         }
@@ -1699,6 +1720,7 @@ 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, (0, config_js_1.patchConfig)(otherConfigFields, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
@@ -1730,6 +1752,7 @@ 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) => (0, config_js_1.patchConfig)(configList[j], {
                     callbacks: runManager?.getChild(),