langchain 0.0.154 → 0.0.155

package/dist/callbacks/handlers/log_stream.js

@@ -0,0 +1,277 @@
+import { applyPatch, } from "../../util/fast-json-patch/index.js";
+import { BaseTracer } from "./tracer.js";
+import { IterableReadableStream } from "../../util/stream.js";
+/**
+ * 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 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 = applyPatch({}, ops);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunLog({
+            ops,
+            state: states[states.length - 1].newDocument,
+        });
+    }
+}
+export 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 = applyPatch(this.state, other.ops);
+        return new RunLog({ ops, state: states[states.length - 1].newDocument });
+    }
+}
+/**
+ * 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 class LogStreamCallbackHandler extends 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 = 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);
+    }
+}

package/dist/callbacks/handlers/tracer.cjs

@@ -24,7 +24,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     _addChildRun(parentRun, childRun) {
         parentRun.child_runs.push(childRun);
     }
-    _startTrace(run) {
+    async _startTrace(run) {
         if (run.parent_run_id !== undefined) {
             const parentRun = this.runMap.get(run.parent_run_id);
             if (parentRun) {
@@ -33,6 +33,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             }
         }
         this.runMap.set(run.id, run);
+        await this.onRunCreate?.(run);
     }
     async _endTrace(run) {
         const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
@@ -43,6 +44,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             await this.persistRun(run);
         }
         this.runMap.delete(run.id);
+        await this.onRunUpdate?.(run);
     }
     _getExecutionOrder(parentRunId) {
         const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
@@ -52,7 +54,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         }
         return parentRun.child_execution_order + 1;
     }
-    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -60,7 +62,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             : extraParams;
         const run = {
             id: runId,
-            name: llm.id[llm.id.length - 1],
+            name: name ?? llm.id[llm.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: llm,
@@ -78,10 +80,11 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onLLMStart?.(run);
+        return run;
     }
-    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata) {
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -89,7 +92,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             : extraParams;
         const run = {
             id: runId,
-            name: llm.id[llm.id.length - 1],
+            name: name ?? llm.id[llm.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: llm,
@@ -107,8 +110,9 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onLLMStart?.(run);
+        return run;
     }
     async handleLLMEnd(output, runId) {
         const run = this.runMap.get(runId);
@@ -123,6 +127,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onLLMEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleLLMError(error, runId) {
         const run = this.runMap.get(runId);
@@ -137,13 +142,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onLLMError?.(run);
         await this._endTrace(run);
+        return run;
     }
-    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType) {
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
             id: runId,
-            name: chain.id[chain.id.length - 1],
+            name: name ?? chain.id[chain.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: chain,
@@ -161,8 +167,9 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onChainStart?.(run);
+        return run;
     }
     async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
         const run = this.runMap.get(runId);
@@ -180,6 +187,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         }
         await this.onChainEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
         const run = this.runMap.get(runId);
@@ -197,13 +205,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         }
         await this.onChainError?.(run);
         await this._endTrace(run);
+        return run;
     }
-    async handleToolStart(tool, input, runId, parentRunId, tags, metadata) {
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
             id: runId,
-            name: tool.id[tool.id.length - 1],
+            name: name ?? tool.id[tool.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: tool,
@@ -221,8 +230,9 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onToolStart?.(run);
+        return run;
     }
     async handleToolEnd(output, runId) {
         const run = this.runMap.get(runId);
@@ -237,6 +247,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onToolEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleToolError(error, runId) {
         const run = this.runMap.get(runId);
@@ -251,6 +262,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onToolError?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleAgentAction(action, runId) {
         const run = this.runMap.get(runId);
@@ -279,12 +291,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onAgentEnd?.(run);
     }
-    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata) {
+    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
             id: runId,
-            name: retriever.id[retriever.id.length - 1],
+            name: name ?? retriever.id[retriever.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: retriever,
@@ -302,8 +314,9 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onRetrieverStart?.(run);
+        return run;
     }
     async handleRetrieverEnd(documents, runId) {
         const run = this.runMap.get(runId);
@@ -318,6 +331,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onRetrieverEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleRetrieverError(error, runId) {
         const run = this.runMap.get(runId);
@@ -332,6 +346,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onRetrieverError?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleText(text, runId) {
         const run = this.runMap.get(runId);
@@ -348,14 +363,15 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
-            return;
+            throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
         }
         run.events.push({
             name: "new_token",
             time: new Date().toISOString(),
             kwargs: { token, idx, chunk: fields?.chunk },
         });
-        await this.onLLMNewToken?.(run);
+        await this.onLLMNewToken?.(run, token);
+        return run;
     }
 }
 exports.BaseTracer = BaseTracer;

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

@@ -25,30 +25,32 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     copy(): this;
     protected abstract persistRun(run: Run): Promise<void>;
     protected _addChildRun(parentRun: Run, childRun: Run): void;
-    protected _startTrace(run: Run): void;
+    protected _startTrace(run: Run): Promise<void>;
     protected _endTrace(run: Run): Promise<void>;
     protected _getExecutionOrder(parentRunId: string | undefined): number;
-    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap): Promise<void>;
-    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap): Promise<void>;
-    handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
-    handleLLMError(error: Error, runId: string): Promise<void>;
-    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string): Promise<void>;
+    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleLLMEnd(output: LLMResult, runId: string): Promise<Run>;
+    handleLLMError(error: Error, runId: string): Promise<Run>;
+    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;
     handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
-    }): Promise<void>;
+    }): Promise<Run>;
     handleChainError(error: Error, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
-    }): Promise<void>;
-    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap): Promise<void>;
-    handleToolEnd(output: string, runId: string): Promise<void>;
-    handleToolError(error: Error, runId: string): Promise<void>;
+    }): Promise<Run>;
+    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleToolEnd(output: string, runId: string): Promise<Run>;
+    handleToolError(error: Error, runId: string): Promise<Run>;
     handleAgentAction(action: AgentAction, runId: string): Promise<void>;
     handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;
-    handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap): Promise<void>;
-    handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<void>;
-    handleRetrieverError(error: Error, runId: string): Promise<void>;
+    handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;
+    handleRetrieverError(error: Error, runId: string): Promise<Run>;
     handleText(text: string, runId: string): Promise<void>;
-    handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<void>;
+    handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;
+    onRunCreate?(run: Run): void | Promise<void>;
+    onRunUpdate?(run: Run): void | Promise<void>;
     onLLMStart?(run: Run): void | Promise<void>;
     onLLMEnd?(run: Run): void | Promise<void>;
     onLLMError?(run: Run): void | Promise<void>;
@@ -64,5 +66,5 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     onRetrieverEnd?(run: Run): void | Promise<void>;
     onRetrieverError?(run: Run): void | Promise<void>;
     onText?(run: Run): void | Promise<void>;
-    onLLMNewToken?(run: Run): void | Promise<void>;
+    onLLMNewToken?(run: Run, token: string): void | Promise<void>;
 }