@langchain/core 0.2.0-rc.0 → 0.2.0

package/dist/runnables/base.cjs

@@ -17,6 +17,7 @@ const utils_js_1 = require("./utils.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 const graph_js_1 = require("./graph.cjs");
 const wrappers_js_1 = require("./wrappers.cjs");
+const iter_js_1 = require("./iter.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value &&
@@ -167,7 +168,11 @@ class Runnable extends serializable_js_1.Serializable {
     async stream(input, options) {
         // Buffer the first streamed chunk to allow for initial errors
         // to surface immediately.
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this._streamIterator(input, (0, config_js_1.ensureConfig)(options)));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this._streamIterator(input, config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -449,13 +454,13 @@ class Runnable extends serializable_js_1.Serializable {
             await runnableStreamConsumePromise;
         }
     }
-    async *streamEvents(input, options, streamOptions) {
+    streamEvents(input, options, streamOptions) {
+        const stream = this._streamEvents(input, options, streamOptions);
         if (options.encoding === "text/event-stream") {
-            const stream = await this._streamEvents(input, options, streamOptions);
-            yield* (0, wrappers_js_1.convertToHttpEventStream)(stream);
+            return (0, wrappers_js_1.convertToHttpEventStream)(stream);
         }
         else {
-            yield* this._streamEvents(input, options, streamOptions);
+            return stream_js_1.IterableReadableStream.fromAsyncGenerator(stream);
         }
     }
     async *_streamEvents(input, options, streamOptions) {
@@ -739,11 +744,16 @@ class RunnableBinding extends Runnable {
     generator, options) {
         yield* this.bound.transform(generator, await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs));
     }
-    async *streamEvents(input, options, streamOptions) {
-        yield* this.bound.streamEvents(input, {
-            ...(await this._mergeConfig((0, config_js_1.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((0, config_js_1.ensureConfig)(options), outerThis.kwargs)),
+                version: options.version,
+            }, streamOptions);
+        };
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(generator());
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1291,7 +1301,11 @@ class RunnableMap extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1346,6 +1360,44 @@ class RunnableLambda extends Runnable {
                             recursionLimit: (childConfig.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
                         });
                     }
+                    else if ((0, iter_js_1.isAsyncIterable)(output)) {
+                        let finalOutput;
+                        for await (const chunk of (0, iter_js_1.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 = (0, stream_js_1.concat)(finalOutput, chunk);
+                                }
+                                catch (e) {
+                                    finalOutput = chunk;
+                                }
+                            }
+                        }
+                        output = finalOutput;
+                    }
+                    else if ((0, iter_js_1.isIterator)(output)) {
+                        let finalOutput;
+                        for (const chunk of (0, iter_js_1.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 = (0, stream_js_1.concat)(finalOutput, chunk);
+                                }
+                                catch (e) {
+                                    finalOutput = chunk;
+                                }
+                            }
+                        }
+                        output = finalOutput;
+                    }
                     resolve(output);
                 }
                 catch (e) {
@@ -1400,6 +1452,16 @@ class RunnableLambda extends Runnable {
                 yield chunk;
             }
         }
+        else if ((0, iter_js_1.isAsyncIterable)(output)) {
+            for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(config, output)) {
+                yield chunk;
+            }
+        }
+        else if ((0, iter_js_1.isIterator)(output)) {
+            for (const chunk of (0, iter_js_1.consumeIteratorInContext)(config, output)) {
+                yield chunk;
+            }
+        }
         else {
             yield output;
         }
@@ -1411,7 +1473,11 @@ class RunnableLambda extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1615,7 +1681,11 @@ class RunnableAssign extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1683,7 +1753,11 @@ class RunnablePick extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }

package/dist/runnables/base.d.ts

@@ -198,11 +198,11 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      */
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
     _streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
@@ -263,11 +263,11 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
     static isRunnableBinding(thing: any): thing is RunnableBinding<any, any, any>;
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.

package/dist/runnables/base.js

@@ -11,6 +11,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 +161,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);
     }
@@ -442,13 +447,13 @@ export class Runnable extends Serializable {
             await runnableStreamConsumePromise;
         }
     }
-    async *streamEvents(input, options, streamOptions) {
+    streamEvents(input, options, streamOptions) {
+        const stream = this._streamEvents(input, options, streamOptions);
         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) {
@@ -731,11 +736,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 +1289,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 +1347,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 +1439,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 +1460,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 +1664,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 +1735,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/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>;

package/dist/runnables/iter.js

@@ -0,0 +1,39 @@
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
+export function isIterator(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        typeof thing[Symbol.iterator] === "function" &&
+        // avoid detecting array/set as iterator
+        typeof thing.next === "function");
+}
+export function isAsyncIterable(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        typeof thing[Symbol.asyncIterator] ===
+            "function");
+}
+export function* consumeIteratorInContext(context, iter) {
+    const storage = AsyncLocalStorageProviderSingleton.getInstance();
+    while (true) {
+        const { value, done } = storage.run(context, iter.next.bind(iter));
+        if (done) {
+            break;
+        }
+        else {
+            yield value;
+        }
+    }
+}
+export async function* consumeAsyncIterableInContext(context, iter) {
+    const storage = 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;
+        }
+    }
+}

package/dist/runnables/passthrough.cjs

@@ -30,6 +30,7 @@ const config_js_1 = require("./config.cjs");
  * );
  * ```
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 class RunnablePassthrough extends base_js_1.Runnable {
     static lc_name() {
         return "RunnablePassthrough";

package/dist/runnables/passthrough.d.ts

@@ -27,7 +27,7 @@ type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((i
  * );
  * ```
  */
-export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, RunInput> {
+export declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;

package/dist/runnables/passthrough.js

@@ -27,6 +27,7 @@ import { ensureConfig } from "./config.js";
  * );
  * ```
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class RunnablePassthrough extends Runnable {
     static lc_name() {
         return "RunnablePassthrough";

package/dist/runnables/remote.cjs

@@ -405,58 +405,70 @@ class RemoteRunnable extends base_js_1.Runnable {
         }
         await runManager?.handleChainEnd(runLog?.state.final_output);
     }
-    async *streamEvents(input, options, streamOptions) {
-        if (options?.version !== "v1") {
-            throw new Error(`Only version "v1" of the events schema is currently supported.`);
-        }
-        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
-        // The type is in camelCase but the API only accepts snake_case.
-        const camelCaseStreamOptions = {
-            include_names: streamOptions?.includeNames,
-            include_types: streamOptions?.includeTypes,
-            include_tags: streamOptions?.includeTags,
-            exclude_names: streamOptions?.excludeNames,
-            exclude_types: streamOptions?.excludeTypes,
-            exclude_tags: streamOptions?.excludeTags,
-        };
-        const events = [];
-        try {
-            const response = await this.post("/stream_events", {
-                input,
-                config: removeCallbacks(config),
-                kwargs,
-                ...camelCaseStreamOptions,
-                diff: false,
-            });
-            const { body, ok } = response;
-            if (!ok) {
-                throw new Error(`${response.status} Error: ${await response.text()}`);
+    _streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        const generator = async function* () {
+            const [config, kwargs] = outerThis._separateRunnableConfigFromCallOptions(options);
+            const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+            // The type is in camelCase but the API only accepts snake_case.
+            const camelCaseStreamOptions = {
+                include_names: streamOptions?.includeNames,
+                include_types: streamOptions?.includeTypes,
+                include_tags: streamOptions?.includeTags,
+                exclude_names: streamOptions?.excludeNames,
+                exclude_types: streamOptions?.excludeTypes,
+                exclude_tags: streamOptions?.excludeTags,
+            };
+            const events = [];
+            try {
+                const response = await outerThis.post("/stream_events", {
+                    input,
+                    config: removeCallbacks(config),
+                    kwargs,
+                    ...camelCaseStreamOptions,
+                    diff: false,
+                });
+                const { body, ok } = response;
+                if (!ok) {
+                    throw new Error(`${response.status} Error: ${await response.text()}`);
+                }
+                if (!body) {
+                    throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+                }
+                const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
+                for await (const log of runnableStream) {
+                    const chunk = revive(JSON.parse(log));
+                    const event = {
+                        event: chunk.event,
+                        name: chunk.name,
+                        run_id: chunk.run_id,
+                        tags: chunk.tags,
+                        metadata: chunk.metadata,
+                        data: chunk.data,
+                    };
+                    yield event;
+                    events.push(event);
+                }
             }
-            if (!body) {
-                throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
-            }
-            const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
-            for await (const log of runnableStream) {
-                const chunk = revive(JSON.parse(log));
-                const event = {
-                    event: chunk.event,
-                    name: chunk.name,
-                    run_id: chunk.run_id,
-                    tags: chunk.tags,
-                    metadata: chunk.metadata,
-                    data: chunk.data,
-                };
-                yield event;
-                events.push(event);
+            catch (err) {
+                await runManager?.handleChainError(err);
+                throw err;
             }
+            await runManager?.handleChainEnd(events);
+        };
+        return generator();
+    }
+    streamEvents(input, options, streamOptions) {
+        if (options?.version !== "v1") {
+            throw new Error(`Only version "v1" of the events schema is currently supported.`);
         }
-        catch (err) {
-            await runManager?.handleChainError(err);
-            throw err;
+        if (options.encoding !== undefined) {
+            throw new Error("Special encodings are not supported for this runnable.");
         }
-        await runManager?.handleChainEnd(events);
+        const eventStream = this._streamEvents(input, options, streamOptions);
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(eventStream);
     }
 }
 exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -2,6 +2,7 @@ import { Runnable, RunnableBatchOptions } from "./base.js";
 import { type RunnableConfig } from "./config.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { RunLogPatch, type LogStreamCallbackHandlerInput, type StreamEvent } from "../tracers/log_stream.js";
+import { IterableReadableStream } from "../utils/stream.js";
 type RemoteRunnableOptions = {
     timeout?: number;
     headers?: Record<string, unknown>;
@@ -27,12 +28,15 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     _streamIterator(input: RunInput, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
+    _streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose"> | undefined): AsyncGenerator<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
 }
 export {};