@langchain/core 0.1.14 → 0.1.16

package/dist/runnables/config.js

@@ -1,27 +1,25 @@
-import { CallbackManager, } from "../callbacks/manager.js";
+import { CallbackManager, ensureHandler, } from "../callbacks/manager.js";
 export const DEFAULT_RECURSION_LIMIT = 25;
 export async function getCallbackManagerForConfig(config) {
     return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
-export function mergeConfigs(config, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options) {
+export function mergeConfigs(...configs) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const copy = { ...config };
-    if (options) {
+    const copy = ensureConfig();
+    for (const options of configs.filter((c) => !!c)) {
         for (const key of Object.keys(options)) {
             if (key === "metadata") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "tags") {
-                copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
+                copy[key] = [...new Set(copy[key].concat(options[key] ?? []))];
             }
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
-                const providedCallbacks = options.callbacks ?? config.callbacks;
+                const providedCallbacks = options.callbacks;
                 // callbacks can be either undefined, Array<handler> or manager
                 // so merging two callbacks values has 6 cases
                 if (Array.isArray(providedCallbacks)) {
@@ -35,7 +33,7 @@ options) {
                         // baseCallbacks is a manager
                         const manager = baseCallbacks.copy();
                         for (const callback of providedCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler(ensureHandler(callback), true);
                         }
                         copy.callbacks = manager;
                     }
@@ -48,13 +46,13 @@ options) {
                     else if (Array.isArray(baseCallbacks)) {
                         const manager = providedCallbacks.copy();
                         for (const callback of baseCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler(ensureHandler(callback), true);
                         }
                         copy.callbacks = manager;
                     }
                     else {
                         // baseCallbacks is also a manager
-                        copy.callbacks = new CallbackManager(providedCallbacks.parentRunId, {
+                        copy.callbacks = new CallbackManager(providedCallbacks._parentRunId, {
                             handlers: baseCallbacks.handlers.concat(providedCallbacks.handlers),
                             inheritableHandlers: baseCallbacks.inheritableHandlers.concat(providedCallbacks.inheritableHandlers),
                             tags: Array.from(new Set(baseCallbacks.tags.concat(providedCallbacks.tags))),
@@ -68,9 +66,64 @@ options) {
                 }
             }
             else {
-                copy[key] = options[key] ?? copy[key];
+                const typedKey = key;
+                copy[typedKey] = options[typedKey] ?? copy[typedKey];
             }
         }
     }
     return copy;
 }
+const PRIMITIVES = new Set(["string", "number", "boolean"]);
+/**
+ * Ensure that a passed config is an object with all required keys present.
+ */
+export function ensureConfig(config) {
+    let empty = {
+        tags: [],
+        metadata: {},
+        callbacks: undefined,
+        recursionLimit: 25,
+    };
+    if (config) {
+        empty = { ...empty, ...config };
+    }
+    if (config?.configurable) {
+        for (const key of Object.keys(config.configurable)) {
+            if (PRIMITIVES.has(typeof config.configurable[key]) &&
+                !empty.metadata?.[key]) {
+                if (!empty.metadata) {
+                    empty.metadata = {};
+                }
+                empty.metadata[key] = config.configurable[key];
+            }
+        }
+    }
+    return empty;
+}
+/**
+ * Helper function that patches runnable configs with updated properties.
+ */
+export function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, } = {}) {
+    const newConfig = ensureConfig(config);
+    if (callbacks !== undefined) {
+        /**
+         * If we're replacing callbacks we need to unset runName
+         * since that should apply only to the same run as the original callbacks
+         */
+        delete newConfig.runName;
+        newConfig.callbacks = callbacks;
+    }
+    if (recursionLimit !== undefined) {
+        newConfig.recursionLimit = recursionLimit;
+    }
+    if (maxConcurrency !== undefined) {
+        newConfig.maxConcurrency = maxConcurrency;
+    }
+    if (runName !== undefined) {
+        newConfig.runName = runName;
+    }
+    if (configurable !== undefined) {
+        newConfig.configurable = { ...newConfig.configurable, ...configurable };
+    }
+    return newConfig;
+}

package/dist/runnables/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.patchConfig = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
 Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
@@ -16,6 +16,7 @@ Object.defineProperty(exports, "RunnablePick", { enumerable: true, get: function
 Object.defineProperty(exports, "_coerceToRunnable", { enumerable: true, get: function () { return base_js_1._coerceToRunnable; } });
 var config_js_1 = require("./config.cjs");
 Object.defineProperty(exports, "getCallbackManagerForConfig", { enumerable: true, get: function () { return config_js_1.getCallbackManagerForConfig; } });
+Object.defineProperty(exports, "patchConfig", { enumerable: true, get: function () { return config_js_1.patchConfig; } });
 var passthrough_js_1 = require("./passthrough.cjs");
 Object.defineProperty(exports, "RunnablePassthrough", { enumerable: true, get: function () { return passthrough_js_1.RunnablePassthrough; } });
 var router_js_1 = require("./router.cjs");

package/dist/runnables/index.d.ts

@@ -1,5 +1,5 @@
 export { type RunnableFunc, type RunnableLike, type RunnableBatchOptions, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableInterface, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
-export { type RunnableConfig, getCallbackManagerForConfig } from "./config.js";
+export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { type RouterInput, RouterRunnable } from "./router.js";
 export { RunnableBranch, type Branch, type BranchLike } from "./branch.js";

package/dist/runnables/index.js

@@ -1,5 +1,5 @@
 export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
-export { getCallbackManagerForConfig } from "./config.js";
+export { getCallbackManagerForConfig, patchConfig, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";
 export { RunnableBranch } from "./branch.js";

package/dist/runnables/router.cjs

@@ -49,9 +49,8 @@ class RouterRunnable extends base_js_1.Runnable {
         }
         const runnables = keys.map((key) => this.runnables[key]);
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
+        const maxConcurrency = optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
+        const batchSize = maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;
         const batchResults = [];
         for (let i = 0; i < actualInputs.length; i += batchSize) {
             const batchPromises = actualInputs

package/dist/runnables/router.js

@@ -46,9 +46,8 @@ export class RouterRunnable extends Runnable {
         }
         const runnables = keys.map((key) => this.runnables[key]);
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
+        const maxConcurrency = optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
+        const batchSize = maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;
         const batchResults = [];
         for (let i = 0; i < actualInputs.length; i += batchSize) {
             const batchPromises = actualInputs

package/dist/tools.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
+exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
 const zod_1 = require("zod");
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./language_models/base.cjs");
@@ -109,3 +109,104 @@ class Tool extends StructuredTool {
     }
 }
 exports.Tool = Tool;
+/**
+ * A tool that can be created dynamically from a function, name, and description.
+ */
+class DynamicTool extends Tool {
+    static lc_name() {
+        return "DynamicTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+    }
+    async call(arg, configArg) {
+        const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config);
+    }
+    /** @ignore */
+    async _call(input, runManager) {
+        return this.func(input, runManager);
+    }
+}
+exports.DynamicTool = DynamicTool;
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ */
+class DynamicStructuredTool extends StructuredTool {
+    static lc_name() {
+        return "DynamicStructuredTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+        this.schema = fields.schema;
+    }
+    async call(arg, configArg, 
+    /** @deprecated */
+    tags) {
+        const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config, tags);
+    }
+    _call(arg, runManager) {
+        return this.func(arg, runManager);
+    }
+}
+exports.DynamicStructuredTool = DynamicStructuredTool;

package/dist/tools.d.ts

@@ -100,3 +100,52 @@ export declare abstract class Tool extends StructuredTool {
      */
     call(arg: string | undefined | z.input<this["schema"]>, callbacks?: Callbacks | RunnableConfig): Promise<string>;
 }
+export interface BaseDynamicToolInput extends ToolParams {
+    name: string;
+    description: string;
+    returnDirect?: boolean;
+}
+/**
+ * Interface for the input parameters of the DynamicTool class.
+ */
+export interface DynamicToolInput extends BaseDynamicToolInput {
+    func: (input: string, runManager?: CallbackManagerForToolRun) => Promise<string>;
+}
+/**
+ * Interface for the input parameters of the DynamicStructuredTool class.
+ */
+export interface DynamicStructuredToolInput<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends BaseDynamicToolInput {
+    func: (input: z.infer<T>, runManager?: CallbackManagerForToolRun) => Promise<string>;
+    schema: T;
+}
+/**
+ * A tool that can be created dynamically from a function, name, and description.
+ */
+export declare class DynamicTool extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    func: DynamicToolInput["func"];
+    constructor(fields: DynamicToolInput);
+    call(arg: string | undefined | z.input<this["schema"]>, configArg?: RunnableConfig | Callbacks): Promise<string>;
+    /** @ignore */
+    _call(input: string, runManager?: CallbackManagerForToolRun): Promise<string>;
+}
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ */
+export declare class DynamicStructuredTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends StructuredTool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    func: DynamicStructuredToolInput["func"];
+    schema: T;
+    constructor(fields: DynamicStructuredToolInput<T>);
+    call(arg: z.output<T>, configArg?: RunnableConfig | Callbacks, 
+    /** @deprecated */
+    tags?: string[]): Promise<string>;
+    protected _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun): Promise<string>;
+}

package/dist/tools.js

@@ -103,3 +103,102 @@ export class Tool extends StructuredTool {
         return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
     }
 }
+/**
+ * A tool that can be created dynamically from a function, name, and description.
+ */
+export class DynamicTool extends Tool {
+    static lc_name() {
+        return "DynamicTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+    }
+    async call(arg, configArg) {
+        const config = parseCallbackConfigArg(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config);
+    }
+    /** @ignore */
+    async _call(input, runManager) {
+        return this.func(input, runManager);
+    }
+}
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ */
+export class DynamicStructuredTool extends StructuredTool {
+    static lc_name() {
+        return "DynamicStructuredTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+        this.schema = fields.schema;
+    }
+    async call(arg, configArg, 
+    /** @deprecated */
+    tags) {
+        const config = parseCallbackConfigArg(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config, tags);
+    }
+    _call(arg, runManager) {
+        return this.func(arg, runManager);
+    }
+}

package/dist/tracers/base.cjs

@@ -47,9 +47,16 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
                     ].join(".");
                 }
                 else {
-                    console.warn(`Parent run with UUID ${storedRun.parent_run_id} not found.`);
+                    // This can happen naturally for callbacks added within a run
+                    // console.debug(`Parent run with UUID ${storedRun.parent_run_id} has no dotted order.`);
                 }
             }
+            else {
+                // This can happen naturally for callbacks added within a run
+                // console.debug(
+                //   `Parent run with UUID ${storedRun.parent_run_id} not found.`
+                // );
+            }
         }
         else {
             storedRun.trace_id = storedRun.id;

package/dist/tracers/base.js

@@ -44,9 +44,16 @@ export class BaseTracer extends BaseCallbackHandler {
                     ].join(".");
                 }
                 else {
-                    console.warn(`Parent run with UUID ${storedRun.parent_run_id} not found.`);
+                    // This can happen naturally for callbacks added within a run
+                    // console.debug(`Parent run with UUID ${storedRun.parent_run_id} has no dotted order.`);
                 }
             }
+            else {
+                // This can happen naturally for callbacks added within a run
+                // console.debug(
+                //   `Parent run with UUID ${storedRun.parent_run_id} not found.`
+                // );
+            }
         }
         else {
             storedRun.trace_id = storedRun.id;

package/dist/tracers/log_stream.cjs

@@ -101,6 +101,12 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "rootId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "keyMapByRunId", {
             enumerable: true,
             configurable: true,
@@ -156,7 +162,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
         // and is therefore not useful here
     }
     _includeRun(run) {
-        if (run.parent_run_id === undefined) {
+        if (run.id === this.rootId) {
             return false;
         }
         const runTags = run.tags ?? [];
@@ -186,8 +192,32 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
         }
         return include;
     }
+    async *tapOutputIterable(runId, output) {
+        // Tap an output async iterator to stream its values to the log.
+        for await (const chunk of output) {
+            // root run is handled in .streamLog()
+            if (runId !== this.rootId) {
+                // if we can't find the run silently ignore
+                // eg. because this run wasn't included in the log
+                const key = this.keyMapByRunId[runId];
+                if (key) {
+                    await this.writer.write(new RunLogPatch({
+                        ops: [
+                            {
+                                op: "add",
+                                path: `/logs/${key}/streamed_output/-`,
+                                value: chunk,
+                            },
+                        ],
+                    }));
+                }
+            }
+            yield chunk;
+        }
+    }
     async onRunCreate(run) {
-        if (run.parent_run_id === undefined) {
+        if (this.rootId === undefined) {
+            this.rootId = run.id;
             await this.writer.write(new RunLogPatch({
                 ops: [
                     {
@@ -220,6 +250,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             tags: run.tags ?? [],
             metadata: run.extra?.metadata ?? {},
             start_time: new Date(run.start_time).toISOString(),
+            streamed_output: [],
             streamed_output_str: [],
             final_output: undefined,
             end_time: undefined,
@@ -258,7 +289,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             await this.writer.write(patch);
         }
         finally {
-            if (run.parent_run_id === undefined) {
+            if (run.id === this.rootId) {
                 const patch = new RunLogPatch({
                     ops: [
                         {

package/dist/tracers/log_stream.d.ts

@@ -19,6 +19,8 @@ export type LogEntry = {
     metadata: Record<string, any>;
     /** ISO-8601 timestamp of when the run started. */
     start_time: string;
+    /** List of general output chunks streamed by this run. */
+    streamed_output: any[];
     /** List of LLM tokens streamed by this run, if applicable. */
     streamed_output_str: string[];
     /** Final output of this run. Only available after the run has finished successfully. */
@@ -84,6 +86,7 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     protected excludeNames?: string[];
     protected excludeTypes?: string[];
     protected excludeTags?: string[];
+    protected rootId?: string;
     private keyMapByRunId;
     private counterMapByRunName;
     protected transformStream: TransformStream;
@@ -94,6 +97,7 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     [Symbol.asyncIterator](): IterableReadableStream<RunLogPatch>;
     protected persistRun(_run: Run): Promise<void>;
     _includeRun(run: Run): boolean;
+    tapOutputIterable<T>(runId: string, output: AsyncGenerator<T>): AsyncGenerator<T>;
     onRunCreate(run: Run): Promise<void>;
     onRunUpdate(run: Run): Promise<void>;
     onLLMNewToken(run: Run, token: string): Promise<void>;

package/dist/tracers/log_stream.js

@@ -96,6 +96,12 @@ export class LogStreamCallbackHandler extends BaseTracer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "rootId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "keyMapByRunId", {
             enumerable: true,
             configurable: true,
@@ -151,7 +157,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
         // and is therefore not useful here
     }
     _includeRun(run) {
-        if (run.parent_run_id === undefined) {
+        if (run.id === this.rootId) {
             return false;
         }
         const runTags = run.tags ?? [];
@@ -181,8 +187,32 @@ export class LogStreamCallbackHandler extends BaseTracer {
         }
         return include;
     }
+    async *tapOutputIterable(runId, output) {
+        // Tap an output async iterator to stream its values to the log.
+        for await (const chunk of output) {
+            // root run is handled in .streamLog()
+            if (runId !== this.rootId) {
+                // if we can't find the run silently ignore
+                // eg. because this run wasn't included in the log
+                const key = this.keyMapByRunId[runId];
+                if (key) {
+                    await this.writer.write(new RunLogPatch({
+                        ops: [
+                            {
+                                op: "add",
+                                path: `/logs/${key}/streamed_output/-`,
+                                value: chunk,
+                            },
+                        ],
+                    }));
+                }
+            }
+            yield chunk;
+        }
+    }
     async onRunCreate(run) {
-        if (run.parent_run_id === undefined) {
+        if (this.rootId === undefined) {
+            this.rootId = run.id;
             await this.writer.write(new RunLogPatch({
                 ops: [
                     {
@@ -215,6 +245,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
             tags: run.tags ?? [],
             metadata: run.extra?.metadata ?? {},
             start_time: new Date(run.start_time).toISOString(),
+            streamed_output: [],
             streamed_output_str: [],
             final_output: undefined,
             end_time: undefined,
@@ -253,7 +284,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
             await this.writer.write(patch);
         }
         finally {
-            if (run.parent_run_id === undefined) {
+            if (run.id === this.rootId) {
                 const patch = new RunLogPatch({
                     ops: [
                         {