@langchain/core 0.2.19 → 0.2.21

package/dist/language_models/base.d.ts

@@ -66,16 +66,6 @@ export interface BaseLanguageModelCallOptions extends RunnableConfig {
      * If not provided, the default stop tokens for the model will be used.
      */
     stop?: string[];
-    /**
-     * 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;
 }
 export interface FunctionDefinition {
     /**
@@ -99,6 +89,14 @@ export interface FunctionDefinition {
      * how to call the function.
      */
     description?: string;
+    /**
+     * Whether to enable strict schema adherence when generating the function call. If
+     * set to true, the model will follow the exact schema defined in the `parameters`
+     * field. Only a subset of JSON Schema is supported when `strict` is `true`. Learn
+     * more about Structured Outputs in the
+     * [function calling guide](https://platform.openai.com/docs/guides/function-calling).
+     */
+    strict?: boolean;
 }
 export interface ToolDefinition {
     type: "function";

package/dist/language_models/chat_models.cjs

@@ -43,11 +43,10 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             value: ["langchain", "chat_models", this._llmType()]
         });
     }
-    _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];
     }
     /**
@@ -76,7 +75,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         else {
             const prompt = BaseChatModel._convertInputToPromptValue(input);
             const messages = prompt.toChatMessages();
-            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
+            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
             const inheritableMetadata = {
                 ...runnableConfig.metadata,
                 ...this.getLsParams(callOptions),
@@ -303,7 +302,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             parsedOptions = options;
         }
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(parsedOptions);
         runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
         if (!this.cache) {
             return this._generateUncached(baseMessages, callOptions, runnableConfig);

package/dist/language_models/chat_models.d.ts

@@ -6,7 +6,7 @@ import { BaseLanguageModel, StructuredOutputMethodOptions, ToolDefinition, type
 import { type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/manager.js";
 import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches/base.js";
-import { StructuredToolInterface } from "../tools/index.js";
+import { StructuredToolInterface, StructuredToolParams } from "../tools/index.js";
 import { Runnable, RunnableToolLike } from "../runnables/base.js";
 type ToolChoice = string | Record<string, any> | "auto" | "any";
 /**
@@ -61,23 +61,17 @@ export type LangSmithParams = {
     ls_max_tokens?: number;
     ls_stop?: Array<string>;
 };
-interface ChatModelGenerateCachedParameters<T extends BaseChatModel<CallOptions>, CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> {
-    messages: BaseMessageLike[][];
-    cache: BaseCache<Generation[]>;
-    llmStringKey: string;
-    parsedOptions: T["ParsedCallOptions"];
-    handledOptions: RunnableConfig;
-}
+export type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
 /**
  * Base class for chat models. It extends the BaseLanguageModel class and
  * provides methods for generating chat based on input messages.
  */
 export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = BaseMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {
-    ParsedCallOptions: Omit<CallOptions, keyof RunnableConfig & "timeout">;
+    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, "signal" | "timeout" | "maxConcurrency">>;
     lc_namespace: string[];
     constructor(fields: BaseChatModelParams);
     _combineLLMOutput?(...llmOutputs: LLMResult["llmOutput"][]): LLMResult["llmOutput"];
-    protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
+    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
     /**
      * Bind tool-like objects to this chat model.
      *
@@ -86,7 +80,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
      * matching the provider's specific tool schema.
      * @param kwargs Any additional parameters to bind.
      */
-    bindTools?(tools: (StructuredToolInterface | Record<string, unknown> | ToolDefinition | RunnableToolLike)[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;
+    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;
     /**
      * Invokes the chat model with a single input.
      * @param input The input for the language model.
@@ -99,7 +93,13 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     /** @ignore */
     _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
-    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: ChatModelGenerateCachedParameters<typeof this>): Promise<LLMResult & {
+    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: {
+        messages: BaseMessageLike[][];
+        cache: BaseCache<Generation[]>;
+        llmStringKey: string;
+        parsedOptions: any;
+        handledOptions: RunnableConfig;
+    }): Promise<LLMResult & {
         missingPromptIndices: number[];
     }>;
     /**

package/dist/language_models/chat_models.js

@@ -39,11 +39,10 @@ export class BaseChatModel extends BaseLanguageModel {
             value: ["langchain", "chat_models", this._llmType()]
         });
     }
-    _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];
     }
     /**
@@ -72,7 +71,7 @@ export class BaseChatModel extends BaseLanguageModel {
         else {
             const prompt = BaseChatModel._convertInputToPromptValue(input);
             const messages = prompt.toChatMessages();
-            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
+            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
             const inheritableMetadata = {
                 ...runnableConfig.metadata,
                 ...this.getLsParams(callOptions),
@@ -299,7 +298,7 @@ export class BaseChatModel extends BaseLanguageModel {
             parsedOptions = options;
         }
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(parsedOptions);
         runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
         if (!this.cache) {
             return this._generateUncached(baseMessages, callOptions, runnableConfig);

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/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);
@@ -1141,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}`),
             }));
@@ -1170,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) {
@@ -1204,6 +1216,7 @@ class RunnableSequence extends Runnable {
                 }));
             }
             for await (const chunk of finalGenerator) {
+                options?.signal?.throwIfAborted();
                 yield chunk;
                 if (concatSupported) {
                     if (finalOutput === undefined) {
@@ -1350,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);
@@ -1379,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 };
@@ -1436,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;
@@ -1524,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;
                             }
@@ -1543,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;
                             }
@@ -1616,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;
             }
         }
@@ -1697,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"));
@@ -1728,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(),

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);
@@ -1130,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}`),
             }));
@@ -1159,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) {
@@ -1193,6 +1205,7 @@ export class RunnableSequence extends Runnable {
                 }));
             }
             for await (const chunk of finalGenerator) {
+                options?.signal?.throwIfAborted();
                 yield chunk;
                 if (concatSupported) {
                     if (finalOutput === undefined) {
@@ -1338,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);
@@ -1367,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 };
@@ -1423,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;
@@ -1510,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;
                             }
@@ -1529,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;
                             }
@@ -1602,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;
             }
         }
@@ -1681,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"));
@@ -1712,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(),