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

package/dist/runnables/utils.cjs

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._RootEventFilter = void 0;
+/**
+ * Utility to filter the root event in the streamEvents implementation.
+ * This is simply binding the arguments to the namespace to make save on
+ * a bit of typing in the streamEvents implementation.
+ *
+ * TODO: Refactor and remove.
+ */
+class _RootEventFilter {
+    constructor(fields) {
+        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
+        });
+        this.includeNames = fields.includeNames;
+        this.includeTypes = fields.includeTypes;
+        this.includeTags = fields.includeTags;
+        this.excludeNames = fields.excludeNames;
+        this.excludeTypes = fields.excludeTypes;
+        this.excludeTags = fields.excludeTags;
+    }
+    includeEvent(event, rootType) {
+        let include = this.includeNames === undefined &&
+            this.includeTypes === undefined &&
+            this.includeTags === undefined;
+        const eventTags = event.tags ?? [];
+        if (this.includeNames !== undefined) {
+            include = include || this.includeNames.includes(event.name);
+        }
+        if (this.includeTypes !== undefined) {
+            include = include || this.includeTypes.includes(rootType);
+        }
+        if (this.includeTags !== undefined) {
+            include =
+                include || eventTags.some((tag) => this.includeTags?.includes(tag));
+        }
+        if (this.excludeNames !== undefined) {
+            include = include && !this.excludeNames.includes(event.name);
+        }
+        if (this.excludeTypes !== undefined) {
+            include = include && !this.excludeTypes.includes(rootType);
+        }
+        if (this.excludeTags !== undefined) {
+            include =
+                include && eventTags.every((tag) => !this.excludeTags?.includes(tag));
+        }
+        return include;
+    }
+}
+exports._RootEventFilter = _RootEventFilter;

package/dist/runnables/utils.d.ts

@@ -0,0 +1,25 @@
+import { StreamEvent } from "../tracers/log_stream.js";
+/**
+ * Utility to filter the root event in the streamEvents implementation.
+ * This is simply binding the arguments to the namespace to make save on
+ * a bit of typing in the streamEvents implementation.
+ *
+ * TODO: Refactor and remove.
+ */
+export declare class _RootEventFilter {
+    includeNames?: string[];
+    includeTypes?: string[];
+    includeTags?: string[];
+    excludeNames?: string[];
+    excludeTypes?: string[];
+    excludeTags?: string[];
+    constructor(fields: {
+        includeNames?: string[];
+        includeTypes?: string[];
+        includeTags?: string[];
+        excludeNames?: string[];
+        excludeTypes?: string[];
+        excludeTags?: string[];
+    });
+    includeEvent(event: StreamEvent, rootType: string): boolean;
+}

package/dist/runnables/utils.js

@@ -0,0 +1,80 @@
+/**
+ * Utility to filter the root event in the streamEvents implementation.
+ * This is simply binding the arguments to the namespace to make save on
+ * a bit of typing in the streamEvents implementation.
+ *
+ * TODO: Refactor and remove.
+ */
+export class _RootEventFilter {
+    constructor(fields) {
+        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
+        });
+        this.includeNames = fields.includeNames;
+        this.includeTypes = fields.includeTypes;
+        this.includeTags = fields.includeTags;
+        this.excludeNames = fields.excludeNames;
+        this.excludeTypes = fields.excludeTypes;
+        this.excludeTags = fields.excludeTags;
+    }
+    includeEvent(event, rootType) {
+        let include = this.includeNames === undefined &&
+            this.includeTypes === undefined &&
+            this.includeTags === undefined;
+        const eventTags = event.tags ?? [];
+        if (this.includeNames !== undefined) {
+            include = include || this.includeNames.includes(event.name);
+        }
+        if (this.includeTypes !== undefined) {
+            include = include || this.includeTypes.includes(rootType);
+        }
+        if (this.includeTags !== undefined) {
+            include =
+                include || eventTags.some((tag) => this.includeTags?.includes(tag));
+        }
+        if (this.excludeNames !== undefined) {
+            include = include && !this.excludeNames.includes(event.name);
+        }
+        if (this.excludeTypes !== undefined) {
+            include = include && !this.excludeTypes.includes(rootType);
+        }
+        if (this.excludeTags !== undefined) {
+            include =
+                include && eventTags.every((tag) => !this.excludeTags?.includes(tag));
+        }
+        return include;
+    }
+}

package/dist/tracers/base.cjs

@@ -400,7 +400,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             time: new Date().toISOString(),
             kwargs: { token, idx, chunk: fields?.chunk },
         });
-        await this.onLLMNewToken?.(run, token);
+        await this.onLLMNewToken?.(run, token, { chunk: fields?.chunk });
         return run;
     }
 }

package/dist/tracers/base.d.ts

@@ -71,5 +71,7 @@ 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, token: string): void | Promise<void>;
+    onLLMNewToken?(run: Run, token: string, kwargs?: {
+        chunk: any;
+    }): void | Promise<void>;
 }

package/dist/tracers/base.js

@@ -397,7 +397,7 @@ export class BaseTracer extends BaseCallbackHandler {
             time: new Date().toISOString(),
             kwargs: { token, idx, chunk: fields?.chunk },
         });
-        await this.onLLMNewToken?.(run, token);
+        await this.onLLMNewToken?.(run, token, { chunk: fields?.chunk });
         return run;
     }
 }

package/dist/tracers/log_stream.cjs

@@ -4,6 +4,7 @@ exports.LogStreamCallbackHandler = exports.RunLog = exports.RunLogPatch = void 0
 const index_js_1 = require("../utils/fast-json-patch/index.cjs");
 const base_js_1 = require("./base.cjs");
 const stream_js_1 = require("../utils/stream.cjs");
+const index_js_2 = require("../messages/index.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
@@ -19,7 +20,7 @@ class RunLogPatch {
             writable: true,
             value: void 0
         });
-        this.ops = fields.ops;
+        this.ops = fields.ops ?? [];
     }
     concat(other) {
         const ops = this.ops.concat(other.ops);
@@ -48,8 +49,69 @@ class RunLog extends RunLogPatch {
         const states = (0, index_js_1.applyPatch)(this.state, other.ops);
         return new RunLog({ ops, state: states[states.length - 1].newDocument });
     }
+    static fromRunLogPatch(patch) {
+        const states = (0, index_js_1.applyPatch)({}, patch.ops);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunLog({
+            ops: patch.ops,
+            state: states[states.length - 1].newDocument,
+        });
+    }
 }
 exports.RunLog = RunLog;
+/**
+ * Extract standardized inputs from a run.
+ *
+ * Standardizes the inputs based on the type of the runnable used.
+ *
+ * @param run - Run object
+ * @param schemaFormat - The schema format to use.
+ *
+ * @returns Valid inputs are only dict. By conventions, inputs always represented
+ * invocation using named arguments.
+ * A null means that the input is not yet known!
+ */
+async function _getStandardizedInputs(run, schemaFormat) {
+    if (schemaFormat === "original") {
+        throw new Error("Do not assign inputs with original schema drop the key for now. " +
+            "When inputs are added to streamLog they should be added with " +
+            "standardized schema for streaming events.");
+    }
+    const { inputs } = run;
+    if (["retriever", "llm", "prompt"].includes(run.run_type)) {
+        return inputs;
+    }
+    if (Object.keys(inputs).length === 1 && inputs?.input === "") {
+        return undefined;
+    }
+    // new style chains
+    // These nest an additional 'input' key inside the 'inputs' to make sure
+    // the input is always a dict. We need to unpack and user the inner value.
+    // We should try to fix this in Runnables and callbacks/tracers
+    // Runnables should be using a null type here not a placeholder
+    // dict.
+    return inputs.input;
+}
+async function _getStandardizedOutputs(run, schemaFormat) {
+    const { outputs } = run;
+    if (schemaFormat === "original") {
+        // Return the old schema, without standardizing anything
+        return outputs;
+    }
+    if (["retriever", "llm", "prompt"].includes(run.run_type)) {
+        return outputs;
+    }
+    // TODO: Remove this hacky check
+    if (outputs !== undefined &&
+        Object.keys(outputs).length === 1 &&
+        outputs?.output !== undefined) {
+        return outputs.output;
+    }
+    return outputs;
+}
+function isChatGenerationChunk(x) {
+    return x !== undefined && x.message !== undefined;
+}
 /**
  * Class that extends the `BaseTracer` class from the
  * `langchain.callbacks.tracers.base` module. It represents a callback
@@ -101,6 +163,12 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_schemaFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "original"
+        });
         Object.defineProperty(this, "rootId", {
             enumerable: true,
             configurable: true,
@@ -150,6 +218,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
         this.excludeNames = fields?.excludeNames;
         this.excludeTypes = fields?.excludeTypes;
         this.excludeTags = fields?.excludeTags;
+        this._schemaFormat = fields?._schemaFormat ?? this._schemaFormat;
         this.transformStream = new TransformStream();
         this.writer = this.transformStream.writable.getWriter();
         this.receiveStream = stream_js_1.IterableReadableStream.fromReadableStream(this.transformStream.readable);
@@ -225,6 +294,8 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
                         path: "",
                         value: {
                             id: run.id,
+                            name: run.name,
+                            type: run.run_type,
                             streamed_output: [],
                             final_output: undefined,
                             logs: {},
@@ -255,6 +326,9 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             final_output: undefined,
             end_time: undefined,
         };
+        if (this._schemaFormat === "streaming_events") {
+            logEntry.inputs = await _getStandardizedInputs(run, this._schemaFormat);
+        }
         await this.writer.write(new RunLogPatch({
             ops: [
                 {
@@ -271,13 +345,19 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             if (runName === undefined) {
                 return;
             }
-            const ops = [
-                {
-                    op: "add",
-                    path: `/logs/${runName}/final_output`,
-                    value: run.outputs,
-                },
-            ];
+            const ops = [];
+            if (this._schemaFormat === "streaming_events") {
+                ops.push({
+                    op: "replace",
+                    path: `/logs/${runName}/inputs`,
+                    value: await _getStandardizedInputs(run, this._schemaFormat),
+                });
+            }
+            ops.push({
+                op: "add",
+                path: `/logs/${runName}/final_output`,
+                value: await _getStandardizedOutputs(run, this._schemaFormat),
+            });
             if (run.end_time !== undefined) {
                 ops.push({
                     op: "add",
@@ -295,7 +375,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
                         {
                             op: "replace",
                             path: "/final_output",
-                            value: run.outputs,
+                            value: await _getStandardizedOutputs(run, this._schemaFormat),
                         },
                     ],
                 });
@@ -306,11 +386,25 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             }
         }
     }
-    async onLLMNewToken(run, token) {
+    async onLLMNewToken(run, token, kwargs) {
         const runName = this.keyMapByRunId[run.id];
         if (runName === undefined) {
             return;
         }
+        // TODO: Remove hack
+        const isChatModel = run.inputs.messages !== undefined;
+        let streamedOutputValue;
+        if (isChatModel) {
+            if (isChatGenerationChunk(kwargs?.chunk)) {
+                streamedOutputValue = kwargs?.chunk;
+            }
+            else {
+                streamedOutputValue = new index_js_2.AIMessageChunk(token);
+            }
+        }
+        else {
+            streamedOutputValue = token;
+        }
         const patch = new RunLogPatch({
             ops: [
                 {
@@ -318,6 +412,11 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
                     path: `/logs/${runName}/streamed_output_str/-`,
                     value: token,
                 },
+                {
+                    op: "add",
+                    path: `/logs/${runName}/streamed_output/-`,
+                    value: streamedOutputValue,
+                },
             ],
         });
         await this.writer.write(patch);

package/dist/tracers/log_stream.d.ts

@@ -1,6 +1,6 @@
 import { type Operation as JSONPatchOperation } from "../utils/fast-json-patch/index.js";
 import { BaseTracer, type Run } from "./base.js";
-import { BaseCallbackHandlerInput } from "../callbacks/base.js";
+import { BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields } from "../callbacks/base.js";
 import { IterableReadableStream } from "../utils/stream.js";
 /**
  * Interface that represents the structure of a log entry in the
@@ -23,6 +23,8 @@ export type LogEntry = {
     streamed_output: any[];
     /** List of LLM tokens streamed by this run, if applicable. */
     streamed_output_str: string[];
+    /** Inputs to this run. Not available currently via streamLog. */
+    inputs?: any;
     /** 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. */
@@ -40,6 +42,10 @@ export type RunState = {
      * If filters were supplied, this list will contain only the runs that matched the filters.
      */
     logs: Record<string, LogEntry>;
+    /** Name of the object being run. */
+    name: string;
+    /** Type of the object being run, eg. prompt, chain, llm, etc. */
+    type: string;
 };
 /**
  * List of jsonpatch JSONPatchOperations, which describe how to create the run state
@@ -51,18 +57,97 @@ export type RunState = {
 export declare class RunLogPatch {
     ops: JSONPatchOperation[];
     constructor(fields: {
-        ops: JSONPatchOperation[];
+        ops?: JSONPatchOperation[];
     });
     concat(other: RunLogPatch): RunLog;
 }
 export declare class RunLog extends RunLogPatch {
     state: RunState;
     constructor(fields: {
-        ops: JSONPatchOperation[];
+        ops?: JSONPatchOperation[];
         state: RunState;
     });
     concat(other: RunLogPatch): RunLog;
+    static fromRunLogPatch(patch: RunLogPatch): RunLog;
 }
+/**
+ * Data associated with a StreamEvent.
+ */
+export type StreamEventData = {
+    /**
+     * The input passed to the runnable that generated the event.
+     * Inputs will sometimes be available at the *START* of the runnable, and
+     * sometimes at the *END* of the runnable.
+     * If a runnable is able to stream its inputs, then its input by definition
+     * won't be known until the *END* of the runnable when it has finished streaming
+     * its inputs.
+     */
+    input?: any;
+    /**
+     * The output of the runnable that generated the event.
+     * Outputs will only be available at the *END* of the runnable.
+     * For most runnables, this field can be inferred from the `chunk` field,
+     * though there might be some exceptions for special cased runnables (e.g., like
+     * chat models), which may return more information.
+     */
+    output?: any;
+    /**
+     * A streaming chunk from the output that generated the event.
+     * chunks support addition in general, and adding them up should result
+     * in the output of the runnable that generated the event.
+     */
+    chunk?: any;
+};
+/**
+ * A streaming event.
+ *
+ * Schema of a streaming event which is produced from the astream_events method.
+ */
+export type StreamEvent = {
+    /**
+     * Event names are of the format: on_[runnable_type]_(start|stream|end).
+     *
+     * Runnable types are one of:
+     * - llm - used by non chat models
+     * - chat_model - used by chat models
+     * - prompt --  e.g., ChatPromptTemplate
+     * - tool -- from tools defined via @tool decorator or inheriting from Tool/BaseTool
+     * - chain - most Runnables are of this type
+     *
+     * Further, the events are categorized as one of:
+     * - start - when the runnable starts
+     * - stream - when the runnable is streaming
+     * - end - when the runnable ends
+     *
+     * start, stream and end are associated with slightly different `data` payload.
+     *
+     * Please see the documentation for `EventData` for more details.
+     */
+    event: string;
+    /** The name of the runnable that generated the event. */
+    name: string;
+    /**
+     * An randomly generated ID to keep track of the execution of the given runnable.
+     *
+     * Each child runnable that gets invoked as part of the execution of a parent runnable
+     * is assigned its own unique ID.
+     */
+    run_id: string;
+    /**
+     * Tags associated with the runnable that generated this event.
+     * Tags are always inherited from parent runnables.
+     */
+    tags?: string[];
+    /** Metadata associated with the runnable that generated this event. */
+    metadata: Record<string, any>;
+    /**
+     * Event data.
+     *
+     * The contents of the event data depend on the event type.
+     */
+    data: StreamEventData;
+};
+export type SchemaFormat = "original" | "streaming_events";
 export interface LogStreamCallbackHandlerInput extends BaseCallbackHandlerInput {
     autoClose?: boolean;
     includeNames?: string[];
@@ -71,6 +156,7 @@ export interface LogStreamCallbackHandlerInput extends BaseCallbackHandlerInput
     excludeNames?: string[];
     excludeTypes?: string[];
     excludeTags?: string[];
+    _schemaFormat?: SchemaFormat;
 }
 /**
  * Class that extends the `BaseTracer` class from the
@@ -86,6 +172,7 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     protected excludeNames?: string[];
     protected excludeTypes?: string[];
     protected excludeTags?: string[];
+    protected _schemaFormat: SchemaFormat;
     protected rootId?: string;
     private keyMapByRunId;
     private counterMapByRunName;
@@ -100,5 +187,5 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     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>;
+    onLLMNewToken(run: Run, token: string, kwargs?: HandleLLMNewTokenCallbackFields): Promise<void>;
 }