@langchain/core 0.2.0-rc.0 → 0.2.1

package/dist/runnables/base.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
 import pRetry from "p-retry";
+import { v4 as uuidv4 } from "uuid";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, } from "../tracers/log_stream.js";
+import { EventStreamCallbackHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGeneratorWithSetup, } from "../utils/stream.js";
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
@@ -11,6 +13,7 @@ import { _RootEventFilter, isRunnableInterface } from "./utils.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
+import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterator, } from "./iter.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -160,7 +163,11 @@ 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, ensureConfig(options)));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this._streamIterator(input, config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -273,11 +280,16 @@ export class Runnable extends Serializable {
             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);
             delete config.runId;
             runManager = pipe.setup;
+            const isStreamEventsHandler = (handler) => handler.name === "event_stream_tracer";
+            const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
+            let iterator = pipe.output;
+            if (streamEventsHandler !== undefined && runManager !== undefined) {
+                iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
+            }
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
-            let iterator = pipe.output;
             if (streamLogHandler !== undefined && runManager !== undefined) {
-                iterator = await streamLogHandler.tapOutputIterable(runManager.runId, pipe.output);
+                iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
             }
             for await (const chunk of iterator) {
                 yield chunk;
@@ -442,19 +454,93 @@ export class Runnable extends Serializable {
             await runnableStreamConsumePromise;
         }
     }
-    async *streamEvents(input, options, streamOptions) {
+    streamEvents(input, options, streamOptions) {
+        let stream;
+        if (options.version === "v1") {
+            stream = this._streamEventsV1(input, options, streamOptions);
+        }
+        else if (options.version === "v2") {
+            stream = this._streamEventsV2(input, options, streamOptions);
+        }
+        else {
+            throw new Error(`Only versions "v1" and "v2" of the schema are currently supported.`);
+        }
         if (options.encoding === "text/event-stream") {
-            const stream = await this._streamEvents(input, options, streamOptions);
-            yield* convertToHttpEventStream(stream);
+            return convertToHttpEventStream(stream);
         }
         else {
-            yield* this._streamEvents(input, options, streamOptions);
+            return IterableReadableStream.fromAsyncGenerator(stream);
         }
     }
-    async *_streamEvents(input, options, streamOptions) {
-        if (options.version !== "v1") {
-            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+    async *_streamEventsV2(input, options, streamOptions) {
+        const eventStreamer = new EventStreamCallbackHandler({
+            ...streamOptions,
+            autoClose: false,
+        });
+        const config = ensureConfig(options);
+        const runId = config.runId ?? uuidv4();
+        config.runId = runId;
+        const callbacks = config.callbacks;
+        if (callbacks === undefined) {
+            config.callbacks = [eventStreamer];
+        }
+        else if (Array.isArray(callbacks)) {
+            config.callbacks = callbacks.concat(eventStreamer);
         }
+        else {
+            const copiedCallbacks = callbacks.copy();
+            copiedCallbacks.inheritableHandlers.push(eventStreamer);
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = copiedCallbacks;
+        }
+        // Call the runnable in streaming mode,
+        // add each chunk to the output stream
+        const outerThis = this;
+        async function consumeRunnableStream() {
+            try {
+                const runnableStream = await outerThis.stream(input, config);
+                const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                for await (const _ of tappedStream) {
+                    // Just iterate so that the callback handler picks up events
+                }
+            }
+            finally {
+                await eventStreamer.writer.close();
+            }
+        }
+        const runnableStreamConsumePromise = consumeRunnableStream();
+        let firstEventSent = false;
+        let firstEventRunId;
+        try {
+            for await (const event of eventStreamer) {
+                // This is a work-around an issue where the inputs into the
+                // chain are not available until the entire input is consumed.
+                // As a temporary solution, we'll modify the input to be the input
+                // that was passed into the chain.
+                if (!firstEventSent) {
+                    event.data.input = input;
+                    firstEventSent = true;
+                    firstEventRunId = event.run_id;
+                    yield event;
+                    continue;
+                }
+                if (event.run_id === firstEventRunId && event.event.endsWith("_end")) {
+                    // If it's the end event corresponding to the root runnable
+                    // we dont include the input in the event since it's guaranteed
+                    // to be included in the first event.
+                    if (event.data?.input) {
+                        delete event.data.input;
+                    }
+                }
+                yield event;
+            }
+        }
+        finally {
+            await runnableStreamConsumePromise;
+        }
+    }
+    async *_streamEventsV1(input, options, streamOptions) {
         let runLog;
         let hasEncounteredStartEvent = false;
         const config = ensureConfig(options);
@@ -731,11 +817,16 @@ export class RunnableBinding extends Runnable {
     generator, options) {
         yield* this.bound.transform(generator, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
-    async *streamEvents(input, options, streamOptions) {
-        yield* this.bound.streamEvents(input, {
-            ...(await this._mergeConfig(ensureConfig(options), this.kwargs)),
-            version: options.version,
-        }, streamOptions);
+    streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        const generator = async function* () {
+            yield* outerThis.bound.streamEvents(input, {
+                ...(await outerThis._mergeConfig(ensureConfig(options), outerThis.kwargs)),
+                version: options.version,
+            }, streamOptions);
+        };
+        return IterableReadableStream.fromAsyncGenerator(generator());
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1279,7 +1370,11 @@ export class RunnableMap extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1333,6 +1428,44 @@ export class RunnableLambda extends Runnable {
                             recursionLimit: (childConfig.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
                         });
                     }
+                    else if (isAsyncIterable(output)) {
+                        let finalOutput;
+                        for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
+                            if (finalOutput === undefined) {
+                                finalOutput = chunk;
+                            }
+                            else {
+                                // Make a best effort to gather, for any type that supports concat.
+                                try {
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    finalOutput = concat(finalOutput, chunk);
+                                }
+                                catch (e) {
+                                    finalOutput = chunk;
+                                }
+                            }
+                        }
+                        output = finalOutput;
+                    }
+                    else if (isIterator(output)) {
+                        let finalOutput;
+                        for (const chunk of consumeIteratorInContext(childConfig, output)) {
+                            if (finalOutput === undefined) {
+                                finalOutput = chunk;
+                            }
+                            else {
+                                // Make a best effort to gather, for any type that supports concat.
+                                try {
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    finalOutput = concat(finalOutput, chunk);
+                                }
+                                catch (e) {
+                                    finalOutput = chunk;
+                                }
+                            }
+                        }
+                        output = finalOutput;
+                    }
                     resolve(output);
                 }
                 catch (e) {
@@ -1387,6 +1520,16 @@ export class RunnableLambda extends Runnable {
                 yield chunk;
             }
         }
+        else if (isAsyncIterable(output)) {
+            for await (const chunk of consumeAsyncIterableInContext(config, output)) {
+                yield chunk;
+            }
+        }
+        else if (isIterator(output)) {
+            for (const chunk of consumeIteratorInContext(config, output)) {
+                yield chunk;
+            }
+        }
         else {
             yield output;
         }
@@ -1398,7 +1541,11 @@ export class RunnableLambda extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1598,7 +1745,11 @@ export class RunnableAssign extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1665,7 +1816,11 @@ export class RunnablePick extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }

package/dist/runnables/history.cjs

@@ -126,68 +126,123 @@ class RunnableWithMessageHistory extends base_js_1.RunnableBinding {
         this.outputMessagesKey = fields.outputMessagesKey;
         this.historyMessagesKey = fields.historyMessagesKey;
     }
-    _getInputMessages(inputValue) {
-        if (typeof inputValue === "string") {
-            return [new index_js_1.HumanMessage(inputValue)];
+    _getInputMessages(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    inputValue) {
+        let parsedInputValue;
+        if (typeof inputValue === "object" &&
+            !Array.isArray(inputValue) &&
+            !(0, index_js_1.isBaseMessage)(inputValue)) {
+            let key;
+            if (this.inputMessagesKey) {
+                key = this.inputMessagesKey;
+            }
+            else if (Object.keys(inputValue).length === 1) {
+                key = Object.keys(inputValue)[0];
+            }
+            else {
+                key = "input";
+            }
+            if (Array.isArray(inputValue[key]) && Array.isArray(inputValue[key][0])) {
+                parsedInputValue = inputValue[key][0];
+            }
+            else {
+                parsedInputValue = inputValue[key];
+            }
+        }
+        else {
+            parsedInputValue = inputValue;
+        }
+        if (typeof parsedInputValue === "string") {
+            return [new index_js_1.HumanMessage(parsedInputValue)];
         }
-        else if (Array.isArray(inputValue)) {
-            return inputValue;
+        else if (Array.isArray(parsedInputValue)) {
+            return parsedInputValue;
+        }
+        else if ((0, index_js_1.isBaseMessage)(parsedInputValue)) {
+            return [parsedInputValue];
         }
         else {
-            return [inputValue];
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages.\nGot ${JSON.stringify(parsedInputValue, null, 2)}`);
         }
     }
     _getOutputMessages(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     outputValue) {
-        let newOutputValue = outputValue;
+        let parsedOutputValue;
         if (!Array.isArray(outputValue) &&
             !(0, index_js_1.isBaseMessage)(outputValue) &&
             typeof outputValue !== "string") {
-            newOutputValue = outputValue[this.outputMessagesKey ?? "output"];
+            let key;
+            if (this.outputMessagesKey !== undefined) {
+                key = this.outputMessagesKey;
+            }
+            else if (Object.keys(outputValue).length === 1) {
+                key = Object.keys(outputValue)[0];
+            }
+            else {
+                key = "output";
+            }
+            // If you are wrapping a chat model directly
+            // The output is actually this weird generations object
+            if (outputValue.generations !== undefined) {
+                parsedOutputValue = outputValue.generations[0][0].message;
+            }
+            else {
+                parsedOutputValue = outputValue[key];
+            }
+        }
+        else {
+            parsedOutputValue = outputValue;
         }
-        if (typeof newOutputValue === "string") {
-            return [new index_js_1.AIMessage(newOutputValue)];
+        if (typeof parsedOutputValue === "string") {
+            return [new index_js_1.AIMessage(parsedOutputValue)];
         }
-        else if (Array.isArray(newOutputValue)) {
-            return newOutputValue;
+        else if (Array.isArray(parsedOutputValue)) {
+            return parsedOutputValue;
         }
-        else if ((0, index_js_1.isBaseMessage)(newOutputValue)) {
-            return [newOutputValue];
+        else if ((0, index_js_1.isBaseMessage)(parsedOutputValue)) {
+            return [parsedOutputValue];
+        }
+        else {
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(parsedOutputValue, null, 2)}`);
         }
-        throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(newOutputValue, null, 2)}`);
     }
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
         const history = kwargs?.config?.configurable?.messageHistory;
-        if (this.historyMessagesKey) {
-            return history.getMessages();
-        }
-        const inputVal = input ||
-            (this.inputMessagesKey ? input[this.inputMessagesKey] : undefined);
-        const historyMessages = history ? await history.getMessages() : [];
-        const returnType = [
-            ...historyMessages,
-            ...this._getInputMessages(inputVal),
-        ];
-        return returnType;
+        const messages = await history.getMessages();
+        if (this.historyMessagesKey === undefined) {
+            return messages.concat(this._getInputMessages(input));
+        }
+        return messages;
     }
     async _exitHistory(run, config) {
         const history = config.configurable?.messageHistory;
         // Get input messages
-        const { inputs } = run;
-        const inputValue = inputs[this.inputMessagesKey ?? "input"];
-        const inputMessages = this._getInputMessages(inputValue);
+        let inputs;
+        // Chat model inputs are nested arrays
+        if (Array.isArray(run.inputs) && Array.isArray(run.inputs[0])) {
+            inputs = run.inputs[0];
+        }
+        else {
+            inputs = run.inputs;
+        }
+        let inputMessages = this._getInputMessages(inputs);
+        // If historic messages were prepended to the input messages, remove them to
+        // avoid adding duplicate messages to history.
+        if (this.historyMessagesKey === undefined) {
+            const existingMessages = await history.getMessages();
+            inputMessages = inputMessages.slice(existingMessages.length);
+        }
         // Get output messages
         const outputValue = run.outputs;
         if (!outputValue) {
             throw new Error(`Output values from 'Run' undefined. Run: ${JSON.stringify(run, null, 2)}`);
         }
         const outputMessages = this._getOutputMessages(outputValue);
-        for await (const message of [...inputMessages, ...outputMessages]) {
-            await history.addMessage(message);
-        }
+        await history.addMessages([...inputMessages, ...outputMessages]);
     }
     async _mergeConfig(...configs) {
         const config = await super._mergeConfig(...configs);

package/dist/runnables/history.d.ts

@@ -83,7 +83,7 @@ export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends Run
     historyMessagesKey?: string;
     getMessageHistory: GetSessionHistoryCallable;
     constructor(fields: RunnableWithMessageHistoryInputs<RunInput, RunOutput>);
-    _getInputMessages(inputValue: string | BaseMessage | Array<BaseMessage>): Array<BaseMessage>;
+    _getInputMessages(inputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
     _getOutputMessages(outputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
     _enterHistory(input: any, kwargs?: {
         config?: RunnableConfig;

package/dist/runnables/history.js

@@ -123,68 +123,123 @@ export class RunnableWithMessageHistory extends RunnableBinding {
         this.outputMessagesKey = fields.outputMessagesKey;
         this.historyMessagesKey = fields.historyMessagesKey;
     }
-    _getInputMessages(inputValue) {
-        if (typeof inputValue === "string") {
-            return [new HumanMessage(inputValue)];
+    _getInputMessages(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    inputValue) {
+        let parsedInputValue;
+        if (typeof inputValue === "object" &&
+            !Array.isArray(inputValue) &&
+            !isBaseMessage(inputValue)) {
+            let key;
+            if (this.inputMessagesKey) {
+                key = this.inputMessagesKey;
+            }
+            else if (Object.keys(inputValue).length === 1) {
+                key = Object.keys(inputValue)[0];
+            }
+            else {
+                key = "input";
+            }
+            if (Array.isArray(inputValue[key]) && Array.isArray(inputValue[key][0])) {
+                parsedInputValue = inputValue[key][0];
+            }
+            else {
+                parsedInputValue = inputValue[key];
+            }
+        }
+        else {
+            parsedInputValue = inputValue;
+        }
+        if (typeof parsedInputValue === "string") {
+            return [new HumanMessage(parsedInputValue)];
         }
-        else if (Array.isArray(inputValue)) {
-            return inputValue;
+        else if (Array.isArray(parsedInputValue)) {
+            return parsedInputValue;
+        }
+        else if (isBaseMessage(parsedInputValue)) {
+            return [parsedInputValue];
         }
         else {
-            return [inputValue];
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages.\nGot ${JSON.stringify(parsedInputValue, null, 2)}`);
         }
     }
     _getOutputMessages(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     outputValue) {
-        let newOutputValue = outputValue;
+        let parsedOutputValue;
         if (!Array.isArray(outputValue) &&
             !isBaseMessage(outputValue) &&
             typeof outputValue !== "string") {
-            newOutputValue = outputValue[this.outputMessagesKey ?? "output"];
+            let key;
+            if (this.outputMessagesKey !== undefined) {
+                key = this.outputMessagesKey;
+            }
+            else if (Object.keys(outputValue).length === 1) {
+                key = Object.keys(outputValue)[0];
+            }
+            else {
+                key = "output";
+            }
+            // If you are wrapping a chat model directly
+            // The output is actually this weird generations object
+            if (outputValue.generations !== undefined) {
+                parsedOutputValue = outputValue.generations[0][0].message;
+            }
+            else {
+                parsedOutputValue = outputValue[key];
+            }
+        }
+        else {
+            parsedOutputValue = outputValue;
         }
-        if (typeof newOutputValue === "string") {
-            return [new AIMessage(newOutputValue)];
+        if (typeof parsedOutputValue === "string") {
+            return [new AIMessage(parsedOutputValue)];
         }
-        else if (Array.isArray(newOutputValue)) {
-            return newOutputValue;
+        else if (Array.isArray(parsedOutputValue)) {
+            return parsedOutputValue;
         }
-        else if (isBaseMessage(newOutputValue)) {
-            return [newOutputValue];
+        else if (isBaseMessage(parsedOutputValue)) {
+            return [parsedOutputValue];
+        }
+        else {
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(parsedOutputValue, null, 2)}`);
         }
-        throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(newOutputValue, null, 2)}`);
     }
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
         const history = kwargs?.config?.configurable?.messageHistory;
-        if (this.historyMessagesKey) {
-            return history.getMessages();
-        }
-        const inputVal = input ||
-            (this.inputMessagesKey ? input[this.inputMessagesKey] : undefined);
-        const historyMessages = history ? await history.getMessages() : [];
-        const returnType = [
-            ...historyMessages,
-            ...this._getInputMessages(inputVal),
-        ];
-        return returnType;
+        const messages = await history.getMessages();
+        if (this.historyMessagesKey === undefined) {
+            return messages.concat(this._getInputMessages(input));
+        }
+        return messages;
     }
     async _exitHistory(run, config) {
         const history = config.configurable?.messageHistory;
         // Get input messages
-        const { inputs } = run;
-        const inputValue = inputs[this.inputMessagesKey ?? "input"];
-        const inputMessages = this._getInputMessages(inputValue);
+        let inputs;
+        // Chat model inputs are nested arrays
+        if (Array.isArray(run.inputs) && Array.isArray(run.inputs[0])) {
+            inputs = run.inputs[0];
+        }
+        else {
+            inputs = run.inputs;
+        }
+        let inputMessages = this._getInputMessages(inputs);
+        // If historic messages were prepended to the input messages, remove them to
+        // avoid adding duplicate messages to history.
+        if (this.historyMessagesKey === undefined) {
+            const existingMessages = await history.getMessages();
+            inputMessages = inputMessages.slice(existingMessages.length);
+        }
         // Get output messages
         const outputValue = run.outputs;
         if (!outputValue) {
             throw new Error(`Output values from 'Run' undefined. Run: ${JSON.stringify(run, null, 2)}`);
         }
         const outputMessages = this._getOutputMessages(outputValue);
-        for await (const message of [...inputMessages, ...outputMessages]) {
-            await history.addMessage(message);
-        }
+        await history.addMessages([...inputMessages, ...outputMessages]);
     }
     async _mergeConfig(...configs) {
         const config = await super._mergeConfig(...configs);

package/dist/runnables/iter.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = void 0;
+const index_js_1 = require("../singletons/index.cjs");
+function isIterator(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        typeof thing[Symbol.iterator] === "function" &&
+        // avoid detecting array/set as iterator
+        typeof thing.next === "function");
+}
+exports.isIterator = isIterator;
+function isAsyncIterable(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        typeof thing[Symbol.asyncIterator] ===
+            "function");
+}
+exports.isAsyncIterable = isAsyncIterable;
+function* consumeIteratorInContext(context, iter) {
+    const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
+    while (true) {
+        const { value, done } = storage.run(context, iter.next.bind(iter));
+        if (done) {
+            break;
+        }
+        else {
+            yield value;
+        }
+    }
+}
+exports.consumeIteratorInContext = consumeIteratorInContext;
+async function* consumeAsyncIterableInContext(context, iter) {
+    const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
+    const iterator = iter[Symbol.asyncIterator]();
+    while (true) {
+        const { value, done } = await storage.run(context, iterator.next.bind(iter));
+        if (done) {
+            break;
+        }
+        else {
+            yield value;
+        }
+    }
+}
+exports.consumeAsyncIterableInContext = consumeAsyncIterableInContext;

package/dist/runnables/iter.d.ts

@@ -0,0 +1,5 @@
+import { RunnableConfig } from "./config.js";
+export declare function isIterator(thing: unknown): thing is IterableIterator<unknown>;
+export declare function isAsyncIterable(thing: unknown): thing is AsyncIterable<unknown>;
+export declare function consumeIteratorInContext<T>(context: Partial<RunnableConfig> | undefined, iter: IterableIterator<T>): IterableIterator<T>;
+export declare function consumeAsyncIterableInContext<T>(context: Partial<RunnableConfig> | undefined, iter: AsyncIterable<T>): AsyncIterableIterator<T>;