@langchain/core 0.1.27-rc.1 → 0.1.27-rc.2

package/dist/runnables/base.cjs

@@ -12,6 +12,7 @@ const stream_js_1 = require("../utils/stream.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");
+const utils_js_1 = require("./utils.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value &&
@@ -353,21 +354,28 @@ class Runnable extends serializable_js_1.Serializable {
      * @param streamOptions
      */
     async *streamLog(input, options, streamOptions) {
-        const stream = new log_stream_js_1.LogStreamCallbackHandler({
+        const logStreamCallbackHandler = new log_stream_js_1.LogStreamCallbackHandler({
             ...streamOptions,
             autoClose: false,
+            _schemaFormat: "original",
         });
         const config = (0, config_js_1.ensureConfig)(options);
+        yield* this._streamLog(input, logStreamCallbackHandler, config);
+    }
+    async *_streamLog(input, logStreamCallbackHandler, config) {
         const { callbacks } = config;
         if (callbacks === undefined) {
-            config.callbacks = [stream];
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = [logStreamCallbackHandler];
         }
         else if (Array.isArray(callbacks)) {
-            config.callbacks = callbacks.concat([stream]);
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = callbacks.concat([logStreamCallbackHandler]);
         }
         else {
             const copiedCallbacks = callbacks.copy();
-            copiedCallbacks.inheritableHandlers.push(stream);
+            copiedCallbacks.inheritableHandlers.push(logStreamCallbackHandler);
+            // eslint-disable-next-line no-param-reassign
             config.callbacks = copiedCallbacks;
         }
         const runnableStreamPromise = this.stream(input, config);
@@ -384,16 +392,16 @@ class Runnable extends serializable_js_1.Serializable {
                             },
                         ],
                     });
-                    await stream.writer.write(patch);
+                    await logStreamCallbackHandler.writer.write(patch);
                 }
             }
             finally {
-                await stream.writer.close();
+                await logStreamCallbackHandler.writer.close();
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();
         try {
-            for await (const log of stream) {
+            for await (const log of logStreamCallbackHandler) {
                 yield log;
             }
         }
@@ -401,6 +409,187 @@ class Runnable extends serializable_js_1.Serializable {
             await runnableStreamConsumePromise;
         }
     }
+    /**
+     * Generate a stream of events emitted by the internal steps of the runnable.
+     *
+     * Use to create an iterator over StreamEvents that provide real-time information
+     * about the progress of the runnable, including StreamEvents from intermediate
+     * results.
+     *
+     * A StreamEvent is a dictionary with the following schema:
+     *
+     * - `event`: string - Event names are of the format: on_[runnable_type]_(start|stream|end).
+     * - `name`: string - The name of the runnable that generated the event.
+     * - `run_id`: string - Randomly generated ID associated with the given execution of
+     *   the runnable that emitted the event. A child runnable that gets invoked as part of the execution of a
+     *   parent runnable is assigned its own unique ID.
+     * - `tags`: string[] - The tags of the runnable that generated the event.
+     * - `metadata`: Record<string, any> - The metadata of the runnable that generated the event.
+     * - `data`: Record<string, any>
+     *
+     * Below is a table that illustrates some events that might be emitted by various
+     * chains. Metadata fields have been omitted from the table for brevity.
+     * Chain definitions have been included after the table.
+     *
+     * | event                | name             | chunk                              | input                                         | output                                          |
+     * |----------------------|------------------|------------------------------------|-----------------------------------------------|-------------------------------------------------|
+     * | on_llm_start         | [model name]     |                                    | {'input': 'hello'}                            |                                                 |
+     * | on_llm_stream        | [model name]     | 'Hello' OR AIMessageChunk("hello") |                                               |                                                 |
+     * | on_llm_end           | [model name]     |                                    | 'Hello human!'                                |
+     * | on_chain_start       | format_docs      |                                    |                                               |                                                 |
+     * | on_chain_stream      | format_docs      | "hello world!, goodbye world!"     |                                               |                                                 |
+     * | on_chain_end         | format_docs      |                                    | [Document(...)]                               | "hello world!, goodbye world!"                  |
+     * | on_tool_start        | some_tool        |                                    | {"x": 1, "y": "2"}                            |                                                 |
+     * | on_tool_stream       | some_tool        |   {"x": 1, "y": "2"}               |                                               |                                                 |
+     * | on_tool_end          | some_tool        |                                    |                                               | {"x": 1, "y": "2"}                              |
+     * | on_retriever_start   | [retriever name] |                                    | {"query": "hello"}                            |                                                 |
+     * | on_retriever_chunk   | [retriever name] |  {documents: [...]}                |                                               |                                                 |
+     * | on_retriever_end     | [retriever name] |                                    | {"query": "hello"}                            | {documents: [...]}                              |
+     * | on_prompt_start      | [template_name]  |                                    | {"question": "hello"}                         |                                                 |
+     * | on_prompt_end        | [template_name]  |                                    | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
+     */
+    async *streamEvents(input, options, streamOptions) {
+        if (options.version !== "v1") {
+            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+        }
+        let runLog;
+        let hasEncounteredStartEvent = false;
+        const config = (0, config_js_1.ensureConfig)(options);
+        const rootTags = config.tags ?? [];
+        const rootMetadata = config.metadata ?? {};
+        const rootName = config.runName ?? this.getName();
+        const logStreamCallbackHandler = new log_stream_js_1.LogStreamCallbackHandler({
+            ...streamOptions,
+            autoClose: false,
+            _schemaFormat: "streaming_events",
+        });
+        const rootEventFilter = new utils_js_1._RootEventFilter({
+            ...streamOptions,
+        });
+        const logStream = this._streamLog(input, logStreamCallbackHandler, config);
+        for await (const log of logStream) {
+            if (!runLog) {
+                runLog = log_stream_js_1.RunLog.fromRunLogPatch(log);
+            }
+            else {
+                runLog = runLog.concat(log);
+            }
+            if (runLog.state === undefined) {
+                throw new Error(`Internal error: "streamEvents" state is missing. Please open a bug report.`);
+            }
+            // Yield the start event for the root runnable if it hasn't been seen.
+            // The root run is never filtered out
+            if (!hasEncounteredStartEvent) {
+                hasEncounteredStartEvent = true;
+                const state = { ...runLog.state };
+                const event = {
+                    run_id: state.id,
+                    event: `on_${state.type}_start`,
+                    name: rootName,
+                    tags: rootTags,
+                    metadata: rootMetadata,
+                    data: {
+                        input,
+                    },
+                };
+                if (rootEventFilter.includeEvent(event, state.type)) {
+                    yield event;
+                }
+            }
+            const paths = log.ops
+                .filter((op) => op.path.startsWith("/logs/"))
+                .map((op) => op.path.split("/")[2]);
+            const dedupedPaths = [...new Set(paths)];
+            for (const path of dedupedPaths) {
+                let eventType;
+                let data = {};
+                const logEntry = runLog.state.logs[path];
+                if (logEntry.end_time === undefined) {
+                    if (logEntry.streamed_output.length > 0) {
+                        eventType = "stream";
+                    }
+                    else {
+                        eventType = "start";
+                    }
+                }
+                else {
+                    eventType = "end";
+                }
+                if (eventType === "start") {
+                    // Include the inputs with the start event if they are available.
+                    // Usually they will NOT be available for components that operate
+                    // on streams, since those components stream the input and
+                    // don't know its final value until the end of the stream.
+                    if (logEntry.inputs !== undefined) {
+                        data.input = logEntry.inputs;
+                    }
+                }
+                else if (eventType === "end") {
+                    if (logEntry.inputs !== undefined) {
+                        data.input = logEntry.inputs;
+                    }
+                    data.output = logEntry.final_output;
+                }
+                else if (eventType === "stream") {
+                    const chunkCount = logEntry.streamed_output.length;
+                    if (chunkCount !== 1) {
+                        throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${logEntry.name}"`);
+                    }
+                    data = { chunk: logEntry.streamed_output[0] };
+                    // Clean up the stream, we don't need it anymore.
+                    // And this avoids duplicates as well!
+                    logEntry.streamed_output = [];
+                }
+                yield {
+                    event: `on_${logEntry.type}_${eventType}`,
+                    name: logEntry.name,
+                    run_id: logEntry.id,
+                    tags: logEntry.tags,
+                    metadata: logEntry.metadata,
+                    data,
+                };
+            }
+            // Finally, we take care of the streaming output from the root chain
+            // if there is any.
+            const { state } = runLog;
+            if (state.streamed_output.length > 0) {
+                const chunkCount = state.streamed_output.length;
+                if (chunkCount !== 1) {
+                    throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state.name}"`);
+                }
+                const data = { chunk: state.streamed_output[0] };
+                // Clean up the stream, we don't need it anymore.
+                state.streamed_output = [];
+                const event = {
+                    event: `on_${state.type}_stream`,
+                    run_id: state.id,
+                    tags: rootTags,
+                    metadata: rootMetadata,
+                    name: rootName,
+                    data,
+                };
+                if (rootEventFilter.includeEvent(event, state.type)) {
+                    yield event;
+                }
+            }
+        }
+        const state = runLog?.state;
+        if (state !== undefined) {
+            // Finally, yield the end event for the root runnable.
+            const event = {
+                event: `on_${state.type}_end`,
+                name: rootName,
+                run_id: state.id,
+                tags: rootTags,
+                metadata: rootMetadata,
+                data: {
+                    output: state.final_output,
+                },
+            };
+            if (rootEventFilter.includeEvent(event, state.type))
+                yield event;
+        }
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
         return thing ? thing.lc_runnable : false;
@@ -540,6 +729,12 @@ class RunnableBinding extends Runnable {
     generator, options) {
         yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
     }
+    async *streamEvents(input, options, streamOptions) {
+        yield* this.bound.streamEvents(input, {
+            ...(await this._mergeConfig(options, this.kwargs)),
+            version: options.version,
+        }, streamOptions);
+    }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     thing

package/dist/runnables/base.d.ts

@@ -1,5 +1,5 @@
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
-import { LogStreamCallbackHandlerInput, RunLogPatch } from "../tracers/log_stream.js";
+import { LogStreamCallbackHandler, LogStreamCallbackHandlerInput, RunLogPatch, StreamEvent } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, type IterableReadableStreamInterface } from "../utils/stream.js";
 import { RunnableConfig } from "./config.js";
@@ -176,6 +176,49 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @param streamOptions
      */
     streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
+    protected _streamLog(input: RunInput, logStreamCallbackHandler: LogStreamCallbackHandler, config: Partial<CallOptions>): AsyncGenerator<RunLogPatch>;
+    /**
+     * Generate a stream of events emitted by the internal steps of the runnable.
+     *
+     * Use to create an iterator over StreamEvents that provide real-time information
+     * about the progress of the runnable, including StreamEvents from intermediate
+     * results.
+     *
+     * A StreamEvent is a dictionary with the following schema:
+     *
+     * - `event`: string - Event names are of the format: on_[runnable_type]_(start|stream|end).
+     * - `name`: string - The name of the runnable that generated the event.
+     * - `run_id`: string - Randomly generated ID associated with the given execution of
+     *   the runnable that emitted the event. A child runnable that gets invoked as part of the execution of a
+     *   parent runnable is assigned its own unique ID.
+     * - `tags`: string[] - The tags of the runnable that generated the event.
+     * - `metadata`: Record<string, any> - The metadata of the runnable that generated the event.
+     * - `data`: Record<string, any>
+     *
+     * Below is a table that illustrates some events that might be emitted by various
+     * chains. Metadata fields have been omitted from the table for brevity.
+     * Chain definitions have been included after the table.
+     *
+     * | event                | name             | chunk                              | input                                         | output                                          |
+     * |----------------------|------------------|------------------------------------|-----------------------------------------------|-------------------------------------------------|
+     * | on_llm_start         | [model name]     |                                    | {'input': 'hello'}                            |                                                 |
+     * | on_llm_stream        | [model name]     | 'Hello' OR AIMessageChunk("hello") |                                               |                                                 |
+     * | on_llm_end           | [model name]     |                                    | 'Hello human!'                                |
+     * | on_chain_start       | format_docs      |                                    |                                               |                                                 |
+     * | on_chain_stream      | format_docs      | "hello world!, goodbye world!"     |                                               |                                                 |
+     * | on_chain_end         | format_docs      |                                    | [Document(...)]                               | "hello world!, goodbye world!"                  |
+     * | on_tool_start        | some_tool        |                                    | {"x": 1, "y": "2"}                            |                                                 |
+     * | on_tool_stream       | some_tool        |   {"x": 1, "y": "2"}               |                                               |                                                 |
+     * | on_tool_end          | some_tool        |                                    |                                               | {"x": 1, "y": "2"}                              |
+     * | on_retriever_start   | [retriever name] |                                    | {"query": "hello"}                            |                                                 |
+     * | on_retriever_chunk   | [retriever name] |  {documents: [...]}                |                                               |                                                 |
+     * | on_retriever_end     | [retriever name] |                                    | {"query": "hello"}                            | {documents: [...]}                              |
+     * | on_prompt_start      | [template_name]  |                                    | {"question": "hello"}                         |                                                 |
+     * | on_prompt_end        | [template_name]  |                                    | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
+     */
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
     static isRunnable(thing: any): thing is Runnable;
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -231,6 +274,9 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     _streamIterator(input: RunInput, options?: Partial<CallOptions> | undefined): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
     stream(input: RunInput, options?: Partial<CallOptions> | undefined): Promise<IterableReadableStream<RunOutput>>;
     transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
     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

@@ -1,11 +1,12 @@
 import pRetry from "p-retry";
 import { CallbackManager, } from "../callbacks/manager.js";
-import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
+import { LogStreamCallbackHandler, RunLog, RunLogPatch, } from "../tracers/log_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";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
+import { _RootEventFilter } from "./utils.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -346,21 +347,28 @@ export class Runnable extends Serializable {
      * @param streamOptions
      */
     async *streamLog(input, options, streamOptions) {
-        const stream = new LogStreamCallbackHandler({
+        const logStreamCallbackHandler = new LogStreamCallbackHandler({
             ...streamOptions,
             autoClose: false,
+            _schemaFormat: "original",
         });
         const config = ensureConfig(options);
+        yield* this._streamLog(input, logStreamCallbackHandler, config);
+    }
+    async *_streamLog(input, logStreamCallbackHandler, config) {
         const { callbacks } = config;
         if (callbacks === undefined) {
-            config.callbacks = [stream];
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = [logStreamCallbackHandler];
         }
         else if (Array.isArray(callbacks)) {
-            config.callbacks = callbacks.concat([stream]);
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = callbacks.concat([logStreamCallbackHandler]);
         }
         else {
             const copiedCallbacks = callbacks.copy();
-            copiedCallbacks.inheritableHandlers.push(stream);
+            copiedCallbacks.inheritableHandlers.push(logStreamCallbackHandler);
+            // eslint-disable-next-line no-param-reassign
             config.callbacks = copiedCallbacks;
         }
         const runnableStreamPromise = this.stream(input, config);
@@ -377,16 +385,16 @@ export class Runnable extends Serializable {
                             },
                         ],
                     });
-                    await stream.writer.write(patch);
+                    await logStreamCallbackHandler.writer.write(patch);
                 }
             }
             finally {
-                await stream.writer.close();
+                await logStreamCallbackHandler.writer.close();
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();
         try {
-            for await (const log of stream) {
+            for await (const log of logStreamCallbackHandler) {
                 yield log;
             }
         }
@@ -394,6 +402,187 @@ export class Runnable extends Serializable {
             await runnableStreamConsumePromise;
         }
     }
+    /**
+     * Generate a stream of events emitted by the internal steps of the runnable.
+     *
+     * Use to create an iterator over StreamEvents that provide real-time information
+     * about the progress of the runnable, including StreamEvents from intermediate
+     * results.
+     *
+     * A StreamEvent is a dictionary with the following schema:
+     *
+     * - `event`: string - Event names are of the format: on_[runnable_type]_(start|stream|end).
+     * - `name`: string - The name of the runnable that generated the event.
+     * - `run_id`: string - Randomly generated ID associated with the given execution of
+     *   the runnable that emitted the event. A child runnable that gets invoked as part of the execution of a
+     *   parent runnable is assigned its own unique ID.
+     * - `tags`: string[] - The tags of the runnable that generated the event.
+     * - `metadata`: Record<string, any> - The metadata of the runnable that generated the event.
+     * - `data`: Record<string, any>
+     *
+     * Below is a table that illustrates some events that might be emitted by various
+     * chains. Metadata fields have been omitted from the table for brevity.
+     * Chain definitions have been included after the table.
+     *
+     * | event                | name             | chunk                              | input                                         | output                                          |
+     * |----------------------|------------------|------------------------------------|-----------------------------------------------|-------------------------------------------------|
+     * | on_llm_start         | [model name]     |                                    | {'input': 'hello'}                            |                                                 |
+     * | on_llm_stream        | [model name]     | 'Hello' OR AIMessageChunk("hello") |                                               |                                                 |
+     * | on_llm_end           | [model name]     |                                    | 'Hello human!'                                |
+     * | on_chain_start       | format_docs      |                                    |                                               |                                                 |
+     * | on_chain_stream      | format_docs      | "hello world!, goodbye world!"     |                                               |                                                 |
+     * | on_chain_end         | format_docs      |                                    | [Document(...)]                               | "hello world!, goodbye world!"                  |
+     * | on_tool_start        | some_tool        |                                    | {"x": 1, "y": "2"}                            |                                                 |
+     * | on_tool_stream       | some_tool        |   {"x": 1, "y": "2"}               |                                               |                                                 |
+     * | on_tool_end          | some_tool        |                                    |                                               | {"x": 1, "y": "2"}                              |
+     * | on_retriever_start   | [retriever name] |                                    | {"query": "hello"}                            |                                                 |
+     * | on_retriever_chunk   | [retriever name] |  {documents: [...]}                |                                               |                                                 |
+     * | on_retriever_end     | [retriever name] |                                    | {"query": "hello"}                            | {documents: [...]}                              |
+     * | on_prompt_start      | [template_name]  |                                    | {"question": "hello"}                         |                                                 |
+     * | on_prompt_end        | [template_name]  |                                    | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
+     */
+    async *streamEvents(input, options, streamOptions) {
+        if (options.version !== "v1") {
+            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+        }
+        let runLog;
+        let hasEncounteredStartEvent = false;
+        const config = ensureConfig(options);
+        const rootTags = config.tags ?? [];
+        const rootMetadata = config.metadata ?? {};
+        const rootName = config.runName ?? this.getName();
+        const logStreamCallbackHandler = new LogStreamCallbackHandler({
+            ...streamOptions,
+            autoClose: false,
+            _schemaFormat: "streaming_events",
+        });
+        const rootEventFilter = new _RootEventFilter({
+            ...streamOptions,
+        });
+        const logStream = this._streamLog(input, logStreamCallbackHandler, config);
+        for await (const log of logStream) {
+            if (!runLog) {
+                runLog = RunLog.fromRunLogPatch(log);
+            }
+            else {
+                runLog = runLog.concat(log);
+            }
+            if (runLog.state === undefined) {
+                throw new Error(`Internal error: "streamEvents" state is missing. Please open a bug report.`);
+            }
+            // Yield the start event for the root runnable if it hasn't been seen.
+            // The root run is never filtered out
+            if (!hasEncounteredStartEvent) {
+                hasEncounteredStartEvent = true;
+                const state = { ...runLog.state };
+                const event = {
+                    run_id: state.id,
+                    event: `on_${state.type}_start`,
+                    name: rootName,
+                    tags: rootTags,
+                    metadata: rootMetadata,
+                    data: {
+                        input,
+                    },
+                };
+                if (rootEventFilter.includeEvent(event, state.type)) {
+                    yield event;
+                }
+            }
+            const paths = log.ops
+                .filter((op) => op.path.startsWith("/logs/"))
+                .map((op) => op.path.split("/")[2]);
+            const dedupedPaths = [...new Set(paths)];
+            for (const path of dedupedPaths) {
+                let eventType;
+                let data = {};
+                const logEntry = runLog.state.logs[path];
+                if (logEntry.end_time === undefined) {
+                    if (logEntry.streamed_output.length > 0) {
+                        eventType = "stream";
+                    }
+                    else {
+                        eventType = "start";
+                    }
+                }
+                else {
+                    eventType = "end";
+                }
+                if (eventType === "start") {
+                    // Include the inputs with the start event if they are available.
+                    // Usually they will NOT be available for components that operate
+                    // on streams, since those components stream the input and
+                    // don't know its final value until the end of the stream.
+                    if (logEntry.inputs !== undefined) {
+                        data.input = logEntry.inputs;
+                    }
+                }
+                else if (eventType === "end") {
+                    if (logEntry.inputs !== undefined) {
+                        data.input = logEntry.inputs;
+                    }
+                    data.output = logEntry.final_output;
+                }
+                else if (eventType === "stream") {
+                    const chunkCount = logEntry.streamed_output.length;
+                    if (chunkCount !== 1) {
+                        throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${logEntry.name}"`);
+                    }
+                    data = { chunk: logEntry.streamed_output[0] };
+                    // Clean up the stream, we don't need it anymore.
+                    // And this avoids duplicates as well!
+                    logEntry.streamed_output = [];
+                }
+                yield {
+                    event: `on_${logEntry.type}_${eventType}`,
+                    name: logEntry.name,
+                    run_id: logEntry.id,
+                    tags: logEntry.tags,
+                    metadata: logEntry.metadata,
+                    data,
+                };
+            }
+            // Finally, we take care of the streaming output from the root chain
+            // if there is any.
+            const { state } = runLog;
+            if (state.streamed_output.length > 0) {
+                const chunkCount = state.streamed_output.length;
+                if (chunkCount !== 1) {
+                    throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state.name}"`);
+                }
+                const data = { chunk: state.streamed_output[0] };
+                // Clean up the stream, we don't need it anymore.
+                state.streamed_output = [];
+                const event = {
+                    event: `on_${state.type}_stream`,
+                    run_id: state.id,
+                    tags: rootTags,
+                    metadata: rootMetadata,
+                    name: rootName,
+                    data,
+                };
+                if (rootEventFilter.includeEvent(event, state.type)) {
+                    yield event;
+                }
+            }
+        }
+        const state = runLog?.state;
+        if (state !== undefined) {
+            // Finally, yield the end event for the root runnable.
+            const event = {
+                event: `on_${state.type}_end`,
+                name: rootName,
+                run_id: state.id,
+                tags: rootTags,
+                metadata: rootMetadata,
+                data: {
+                    output: state.final_output,
+                },
+            };
+            if (rootEventFilter.includeEvent(event, state.type))
+                yield event;
+        }
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
         return thing ? thing.lc_runnable : false;
@@ -532,6 +721,12 @@ export class RunnableBinding extends Runnable {
     generator, options) {
         yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
     }
+    async *streamEvents(input, options, streamOptions) {
+        yield* this.bound.streamEvents(input, {
+            ...(await this._mergeConfig(options, this.kwargs)),
+            version: options.version,
+        }, streamOptions);
+    }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     thing