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

package/dist/tracers/log_stream.js

@@ -1,6 +1,7 @@
 import { applyPatch, } from "../utils/fast-json-patch/index.js";
 import { BaseTracer } from "./base.js";
 import { IterableReadableStream } from "../utils/stream.js";
+import { AIMessageChunk } from "../messages/index.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
@@ -16,7 +17,7 @@ export class RunLogPatch {
             writable: true,
             value: void 0
         });
-        this.ops = fields.ops;
+        this.ops = fields.ops ?? [];
     }
     concat(other) {
         const ops = this.ops.concat(other.ops);
@@ -44,6 +45,67 @@ export class RunLog extends RunLogPatch {
         const states = applyPatch(this.state, other.ops);
         return new RunLog({ ops, state: states[states.length - 1].newDocument });
     }
+    static fromRunLogPatch(patch) {
+        const states = 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,
+        });
+    }
+}
+/**
+ * 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
@@ -96,6 +158,12 @@ export class LogStreamCallbackHandler extends 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,
@@ -145,6 +213,7 @@ export class LogStreamCallbackHandler extends 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 = IterableReadableStream.fromReadableStream(this.transformStream.readable);
@@ -220,6 +289,8 @@ export class LogStreamCallbackHandler extends BaseTracer {
                         path: "",
                         value: {
                             id: run.id,
+                            name: run.name,
+                            type: run.run_type,
                             streamed_output: [],
                             final_output: undefined,
                             logs: {},
@@ -250,6 +321,9 @@ export class LogStreamCallbackHandler extends 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: [
                 {
@@ -266,13 +340,19 @@ export class LogStreamCallbackHandler extends 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",
@@ -290,7 +370,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
                         {
                             op: "replace",
                             path: "/final_output",
-                            value: run.outputs,
+                            value: await _getStandardizedOutputs(run, this._schemaFormat),
                         },
                     ],
                 });
@@ -301,11 +381,25 @@ export class LogStreamCallbackHandler extends 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 AIMessageChunk(token);
+            }
+        }
+        else {
+            streamedOutputValue = token;
+        }
         const patch = new RunLogPatch({
             ops: [
                 {
@@ -313,6 +407,11 @@ export class LogStreamCallbackHandler extends 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/utils/testing/index.cjs

@@ -274,12 +274,14 @@ class FakeListChatModel extends chat_models_js_1.BaseChatModel {
             text,
         };
     }
-    async *_streamResponseChunks(_messages, _options, _runManager) {
+    async *_streamResponseChunks(_messages, _options, runManager) {
         const response = this._currentResponse();
         this._incrementResponse();
         for await (const text of response) {
             await this._sleepIfRequested();
-            yield this._createResponseChunk(text);
+            const chunk = this._createResponseChunk(text);
+            yield chunk;
+            void runManager?.handleLLMNewToken(text);
         }
     }
     async _sleepIfRequested() {

package/dist/utils/testing/index.d.ts

@@ -107,7 +107,7 @@ export declare class FakeListChatModel extends BaseChatModel {
         message: AIMessage;
         text: string;
     };
-    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     _sleepIfRequested(): Promise<void>;
     _sleep(): Promise<void>;
     _createResponseChunk(text: string): ChatGenerationChunk;

package/dist/utils/testing/index.js

@@ -265,12 +265,14 @@ export class FakeListChatModel extends BaseChatModel {
             text,
         };
     }
-    async *_streamResponseChunks(_messages, _options, _runManager) {
+    async *_streamResponseChunks(_messages, _options, runManager) {
         const response = this._currentResponse();
         this._incrementResponse();
         for await (const text of response) {
             await this._sleepIfRequested();
-            yield this._createResponseChunk(text);
+            const chunk = this._createResponseChunk(text);
+            yield chunk;
+            void runManager?.handleLLMNewToken(text);
         }
     }
     async _sleepIfRequested() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.27-rc.0",
+  "version": "0.1.27-rc.2",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {