langchain 0.0.154 → 0.0.155

package/dist/callbacks/base.d.ts

@@ -35,7 +35,8 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * Called at the start of an LLM or Chat Model run, with the prompt(s)
      * and the run ID.
      */
-    handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>): Promise<void> | void;
+    handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called when an LLM/ChatModel in `streaming` mode produces a new token
      */
@@ -46,50 +47,60 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * idx.completion is the index of the completion that produced the token
      *   (if multiple completions per prompt are requested)
      */
-    idx: NewTokenIndices, runId: string, parentRunId?: string, tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<void> | void;
+    idx: NewTokenIndices, runId: string, parentRunId?: string, tags?: string[], fields?: HandleLLMNewTokenCallbackFields): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called if an LLM/ChatModel run encounters an error
      */
-    handleLLMError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleLLMError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called at the end of an LLM/ChatModel run, with the output and the run ID.
      */
-    handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called at the start of a Chat Model run, with the prompt(s)
      * and the run ID.
      */
-    handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>): Promise<void> | void;
+    handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called at the start of a Chain run, with the chain name and inputs
      * and the run ID.
      */
-    handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string): Promise<void> | void;
+    handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called if a Chain run encounters an error
      */
     handleChainError?(err: Error, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
-    }): Promise<void> | void;
+    }): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called at the end of a Chain run, with the outputs and the run ID.
      */
     handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
-    }): Promise<void> | void;
+    }): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called at the start of a Tool run, with the tool name and input
      * and the run ID.
      */
-    handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>): Promise<void> | void;
+    handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called if a Tool run encounters an error
      */
-    handleToolError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleToolError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     /**
      * Called at the end of a Tool run, with the tool output and the run ID.
      */
-    handleToolEnd?(output: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleToolEnd?(output: string, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
     handleText?(text: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
     /**
      * Called when an agent is about to execute an action,
@@ -101,9 +112,12 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * with the final output and the run ID.
      */
     handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
-    handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>): Promise<void> | void;
-    handleRetrieverEnd?(documents: Document[], runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
-    handleRetrieverError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleRetrieverEnd?(documents: Document[], runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleRetrieverError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
 }
 /**
  * Base interface for callbacks. All methods are optional. If a method is not
@@ -185,54 +199,54 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          * Called at the start of an LLM or Chat Model run, with the prompt(s)
          * and the run ID.
          */
-        handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): void | Promise<void>;
+        handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): any;
         /**
          * Called when an LLM/ChatModel in `streaming` mode produces a new token
          */
-        handleLLMNewToken?(token: string, idx: NewTokenIndices, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, fields?: HandleLLMNewTokenCallbackFields | undefined): void | Promise<void>;
+        handleLLMNewToken?(token: string, idx: NewTokenIndices, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, fields?: HandleLLMNewTokenCallbackFields | undefined): any;
         /**
          * Called if an LLM/ChatModel run encounters an error
          */
-        handleLLMError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleLLMError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
         /**
          * Called at the end of an LLM/ChatModel run, with the output and the run ID.
          */
-        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
         /**
          * Called at the start of a Chat Model run, with the prompt(s)
          * and the run ID.
          */
-        handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): void | Promise<void>;
+        handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): any;
         /**
          * Called at the start of a Chain run, with the chain name and inputs
          * and the run ID.
          */
-        handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runType?: string | undefined): void | Promise<void>;
+        handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runType?: string | undefined): any;
         /**
          * Called if a Chain run encounters an error
          */
         handleChainError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
             inputs?: Record<string, unknown> | undefined;
-        } | undefined): void | Promise<void>;
+        } | undefined): any;
         /**
          * Called at the end of a Chain run, with the outputs and the run ID.
          */
         handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
             inputs?: Record<string, unknown> | undefined;
-        } | undefined): void | Promise<void>;
+        } | undefined): any;
         /**
          * Called at the start of a Tool run, with the tool name and input
          * and the run ID.
          */
-        handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): void | Promise<void>;
+        handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): any;
         /**
          * Called if a Tool run encounters an error
          */
-        handleToolError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleToolError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
         /**
          * Called at the end of a Tool run, with the tool output and the run ID.
          */
-        handleToolEnd?(output: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleToolEnd?(output: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
         handleText?(text: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
         /**
          * Called when an agent is about to execute an action,
@@ -244,9 +258,9 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          * with the final output and the run ID.
          */
         handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
-        handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): void | Promise<void>;
-        handleRetrieverEnd?(documents: Document<Record<string, any>>[], runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
-        handleRetrieverError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined): any;
+        handleRetrieverEnd?(documents: Document<Record<string, any>>[], runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleRetrieverError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
     };
 }
 export {};

package/dist/callbacks/handlers/log_stream.cjs

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStreamCallbackHandler = exports.RunLog = exports.RunLogPatch = void 0;
+const index_js_1 = require("../../util/fast-json-patch/index.cjs");
+const tracer_js_1 = require("./tracer.cjs");
+const stream_js_1 = require("../../util/stream.cjs");
+/**
+ * List of jsonpatch JSONPatchOperations, which describe how to create the run state
+ * from an empty dict. This is the minimal representation of the log, designed to
+ * be serialized as JSON and sent over the wire to reconstruct the log on the other
+ * side. Reconstruction of the state can be done with any jsonpatch-compliant library,
+ * see https://jsonpatch.com for more information.
+ */
+class RunLogPatch {
+    constructor(fields) {
+        Object.defineProperty(this, "ops", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ops = fields.ops;
+    }
+    concat(other) {
+        const ops = this.ops.concat(other.ops);
+        const states = (0, index_js_1.applyPatch)({}, ops);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunLog({
+            ops,
+            state: states[states.length - 1].newDocument,
+        });
+    }
+}
+exports.RunLogPatch = RunLogPatch;
+class RunLog extends RunLogPatch {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.state = fields.state;
+    }
+    concat(other) {
+        const ops = this.ops.concat(other.ops);
+        const states = (0, index_js_1.applyPatch)(this.state, other.ops);
+        return new RunLog({ ops, state: states[states.length - 1].newDocument });
+    }
+}
+exports.RunLog = RunLog;
+/**
+ * Class that extends the `BaseTracer` class from the
+ * `langchain.callbacks.tracers.base` module. It represents a callback
+ * handler that logs the execution of runs and emits `RunLog` instances to a
+ * `RunLogStream`.
+ */
+class LogStreamCallbackHandler extends tracer_js_1.BaseTracer {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "autoClose", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "includeNames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "includeTypes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "includeTags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "excludeNames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "excludeTypes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "excludeTags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "indexMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "transformStream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "writer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "receiveStream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "log_stream_tracer"
+        });
+        this.autoClose = fields?.autoClose ?? true;
+        this.includeNames = fields?.includeNames;
+        this.includeTypes = fields?.includeTypes;
+        this.includeTags = fields?.includeTags;
+        this.excludeNames = fields?.excludeNames;
+        this.excludeTypes = fields?.excludeTypes;
+        this.excludeTags = fields?.excludeTags;
+        this.transformStream = new TransformStream();
+        this.writer = this.transformStream.writable.getWriter();
+        this.receiveStream = stream_js_1.IterableReadableStream.fromReadableStream(this.transformStream.readable);
+    }
+    [Symbol.asyncIterator]() {
+        return this.receiveStream;
+    }
+    async persistRun(_run) {
+        // This is a legacy method only called once for an entire run tree
+        // and is therefore not useful here
+    }
+    _includeRun(run) {
+        if (run.parent_run_id === undefined) {
+            return false;
+        }
+        const runTags = run.tags ?? [];
+        let include = this.includeNames === undefined &&
+            this.includeTags === undefined &&
+            this.includeTypes === undefined;
+        if (this.includeNames !== undefined) {
+            include = include || this.includeNames.includes(run.name);
+        }
+        if (this.includeTypes !== undefined) {
+            include = include || this.includeTypes.includes(run.run_type);
+        }
+        if (this.includeTags !== undefined) {
+            include =
+                include ||
+                    runTags.find((tag) => this.includeTags?.includes(tag)) !== undefined;
+        }
+        if (this.excludeNames !== undefined) {
+            include = include && !this.excludeNames.includes(run.name);
+        }
+        if (this.excludeTypes !== undefined) {
+            include = include && !this.excludeTypes.includes(run.run_type);
+        }
+        if (this.excludeTags !== undefined) {
+            include =
+                include && runTags.every((tag) => !this.excludeTags?.includes(tag));
+        }
+        return include;
+    }
+    async onRunCreate(run) {
+        if (run.parent_run_id === undefined) {
+            await this.writer.write(new RunLogPatch({
+                ops: [
+                    {
+                        op: "replace",
+                        path: "",
+                        value: {
+                            id: run.id,
+                            streamed_output: [],
+                            final_output: undefined,
+                            logs: [],
+                        },
+                    },
+                ],
+            }));
+        }
+        if (!this._includeRun(run)) {
+            return;
+        }
+        this.indexMap[run.id] = Math.max(...Object.values(this.indexMap), -1) + 1;
+        const logEntry = {
+            id: run.id,
+            name: run.name,
+            type: run.run_type,
+            tags: run.tags ?? [],
+            metadata: run.extra?.metadata ?? {},
+            start_time: new Date(run.start_time).toISOString(),
+            streamed_output_str: [],
+            final_output: undefined,
+            end_time: undefined,
+        };
+        await this.writer.write(new RunLogPatch({
+            ops: [
+                {
+                    op: "add",
+                    path: `/logs/${this.indexMap[run.id]}`,
+                    value: logEntry,
+                },
+            ],
+        }));
+    }
+    async onRunUpdate(run) {
+        try {
+            const index = this.indexMap[run.id];
+            if (index === undefined) {
+                return;
+            }
+            const ops = [
+                {
+                    op: "add",
+                    path: `/logs/${index}/final_output`,
+                    value: run.outputs,
+                },
+            ];
+            if (run.end_time !== undefined) {
+                ops.push({
+                    op: "add",
+                    path: `/logs/${index}/end_time`,
+                    value: new Date(run.end_time).toISOString(),
+                });
+            }
+            const patch = new RunLogPatch({ ops });
+            await this.writer.write(patch);
+        }
+        finally {
+            if (run.parent_run_id === undefined) {
+                const patch = new RunLogPatch({
+                    ops: [
+                        {
+                            op: "replace",
+                            path: "/final_output",
+                            value: run.outputs,
+                        },
+                    ],
+                });
+                await this.writer.write(patch);
+                if (this.autoClose) {
+                    await this.writer.close();
+                }
+            }
+        }
+    }
+    async onLLMNewToken(run, token) {
+        const index = this.indexMap[run.id];
+        if (index === undefined) {
+            return;
+        }
+        const patch = new RunLogPatch({
+            ops: [
+                {
+                    op: "add",
+                    path: `/logs/${index}/streamed_output_str/-`,
+                    value: token,
+                },
+            ],
+        });
+        await this.writer.write(patch);
+    }
+}
+exports.LogStreamCallbackHandler = LogStreamCallbackHandler;

package/dist/callbacks/handlers/log_stream.d.ts

@@ -0,0 +1,99 @@
+import { type Operation as JSONPatchOperation } from "../../util/fast-json-patch/index.js";
+import { BaseTracer, type Run } from "./tracer.js";
+import { BaseCallbackHandlerInput } from "../base.js";
+import { IterableReadableStream } from "../../util/stream.js";
+/**
+ * Interface that represents the structure of a log entry in the
+ * `LogStreamCallbackHandler`.
+ */
+export type LogEntry = {
+    /** ID of the sub-run. */
+    id: string;
+    /** Name of the object being run. */
+    name: string;
+    /** Type of the object being run, eg. prompt, chain, llm, etc. */
+    type: string;
+    /** List of tags for the run. */
+    tags: string[];
+    /** Key-value pairs of metadata for the run. */
+    metadata: Record<string, any>;
+    /** ISO-8601 timestamp of when the run started. */
+    start_time: string;
+    /** 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. */
+    final_output?: any;
+    /** ISO-8601 timestamp of when the run ended. Only available after the run has finished. */
+    end_time?: string;
+};
+export type RunState = {
+    /** ID of the sub-run. */
+    id: string;
+    /** List of output chunks streamed by Runnable.stream() */
+    streamed_output: any[];
+    /** Final output of the run, usually the result of aggregating streamed_output. Only available after the run has finished successfully. */
+    final_output?: any;
+    /**
+     * List of sub-runs contained in this run, if any, in the order they were started.
+     * If filters were supplied, this list will contain only the runs that matched the filters.
+     */
+    logs: LogEntry[];
+};
+/**
+ * List of jsonpatch JSONPatchOperations, which describe how to create the run state
+ * from an empty dict. This is the minimal representation of the log, designed to
+ * be serialized as JSON and sent over the wire to reconstruct the log on the other
+ * side. Reconstruction of the state can be done with any jsonpatch-compliant library,
+ * see https://jsonpatch.com for more information.
+ */
+export declare class RunLogPatch {
+    ops: JSONPatchOperation[];
+    constructor(fields: {
+        ops: JSONPatchOperation[];
+    });
+    concat(other: RunLogPatch): RunLog;
+}
+export declare class RunLog extends RunLogPatch {
+    state: RunState;
+    constructor(fields: {
+        ops: JSONPatchOperation[];
+        state: RunState;
+    });
+    concat(other: RunLogPatch): RunLog;
+}
+export interface LogStreamCallbackHandlerInput extends BaseCallbackHandlerInput {
+    autoClose?: boolean;
+    includeNames?: string[];
+    includeTypes?: string[];
+    includeTags?: string[];
+    excludeNames?: string[];
+    excludeTypes?: string[];
+    excludeTags?: string[];
+}
+/**
+ * Class that extends the `BaseTracer` class from the
+ * `langchain.callbacks.tracers.base` module. It represents a callback
+ * handler that logs the execution of runs and emits `RunLog` instances to a
+ * `RunLogStream`.
+ */
+export declare class LogStreamCallbackHandler extends BaseTracer {
+    protected autoClose: boolean;
+    protected includeNames?: string[];
+    protected includeTypes?: string[];
+    protected includeTags?: string[];
+    protected excludeNames?: string[];
+    protected excludeTypes?: string[];
+    protected excludeTags?: string[];
+    private indexMap;
+    protected transformStream: TransformStream;
+    writer: WritableStreamDefaultWriter;
+    receiveStream: IterableReadableStream<RunLogPatch>;
+    name: string;
+    constructor(fields?: LogStreamCallbackHandlerInput);
+    [Symbol.asyncIterator](): IterableReadableStream<RunLogPatch>;
+    protected persistRun(_run: Run): Promise<void>;
+    _includeRun(run: Run): boolean;
+    onRunCreate(run: Run): Promise<void>;
+    onRunUpdate(run: Run): Promise<void>;
+    onLLMNewToken(run: Run, token: string): Promise<void>;
+}