@langchain/core 0.1.13 → 0.1.14

package/dist/runnables/base.d.ts

@@ -147,15 +147,15 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @param coerceable A runnable, function, or object whose values are functions or runnables.
      * @returns A new runnable sequence.
      */
-    pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, Exclude<NewRunOutput, Error>>;
+    pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>>;
     /**
      * Pick keys from the dict output of this runnable. Returns a new runnable.
      */
-    pick(keys: string | string[]): RunnableSequence;
+    pick(keys: string | string[]): Runnable;
     /**
      * Assigns new fields to the dict output of this runnable. Returns a new runnable.
      */
-    assign(mapping: RunnableMapLike<Record<string, unknown>, Record<string, unknown>>): RunnableSequence;
+    assign(mapping: RunnableMapLike<Record<string, unknown>, Record<string, unknown>>): Runnable;
     /**
      * Default implementation of transform, which buffers input and then calls stream.
      * Subclasses should override this method if they can start producing output while
@@ -357,7 +357,7 @@ export declare class RunnableSequence<RunInput = any, RunOutput = any> extends R
         last: Runnable<any, RunOutput>;
         name?: string;
     });
-    get steps(): Runnable<RunInput, any, RunnableConfig>[];
+    get steps(): Runnable<any, any, RunnableConfig>[];
     invoke(input: RunInput, options?: RunnableConfig): Promise<RunOutput>;
     batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
         returnExceptions?: false;

package/dist/runnables/passthrough.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnablePassthrough = void 0;
+const stream_js_1 = require("../utils/stream.cjs");
 const base_js_1 = require("./base.cjs");
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.
@@ -29,8 +30,11 @@ const base_js_1 = require("./base.cjs");
  * ```
  */
 class RunnablePassthrough extends base_js_1.Runnable {
-    constructor() {
-        super(...arguments);
+    static lc_name() {
+        return "RunnablePassthrough";
+    }
+    constructor(fields) {
+        super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -43,15 +47,46 @@ class RunnablePassthrough extends base_js_1.Runnable {
             writable: true,
             value: true
         });
-    }
-    static lc_name() {
-        return "RunnablePassthrough";
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (fields) {
+            this.func = fields.func;
+        }
     }
     async invoke(input, options) {
+        if (this.func) {
+            await this.func(input, options);
+        }
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
-    transform(generator, options) {
-        return this._transformStreamWithConfig(generator, (input) => input, options);
+    async *transform(generator, options) {
+        let finalOutput;
+        let finalOutputSupported = true;
+        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, options)) {
+            yield chunk;
+            if (finalOutputSupported) {
+                if (finalOutput === undefined) {
+                    finalOutput = chunk;
+                }
+                else {
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        finalOutput = (0, stream_js_1.concat)(finalOutput, chunk);
+                    }
+                    catch {
+                        finalOutput = undefined;
+                        finalOutputSupported = false;
+                    }
+                }
+            }
+        }
+        if (this.func && finalOutput !== undefined) {
+            await this.func(finalOutput, options);
+        }
     }
     /**
      * A runnable that assigns key-value pairs to the input.

package/dist/runnables/passthrough.d.ts

@@ -1,5 +1,6 @@
 import { Runnable, RunnableAssign, RunnableMapLike } from "./base.js";
 import type { RunnableConfig } from "./config.js";
+type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((input: RunInput, config?: RunnableConfig) => void) | ((input: RunInput) => Promise<void>) | ((input: RunInput, config?: RunnableConfig) => Promise<void>);
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.
  *
@@ -30,6 +31,10 @@ export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, Ru
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;
+    func?: RunnablePassthroughFunc<RunInput>;
+    constructor(fields?: {
+        func?: RunnablePassthroughFunc<RunInput>;
+    });
     invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
     transform(generator: AsyncGenerator<RunInput>, options: Partial<RunnableConfig>): AsyncGenerator<RunInput>;
     /**
@@ -62,3 +67,4 @@ export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, Ru
      */
     static assign<RunInput extends Record<string, unknown>, RunOutput extends Record<string, unknown>>(mapping: RunnableMapLike<RunInput, RunOutput>): RunnableAssign<RunInput, RunInput & RunOutput>;
 }
+export {};

package/dist/runnables/passthrough.js

@@ -1,3 +1,4 @@
+import { concat } from "../utils/stream.js";
 import { Runnable, RunnableAssign, RunnableMap, } from "./base.js";
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.
@@ -26,8 +27,11 @@ import { Runnable, RunnableAssign, RunnableMap, } from "./base.js";
  * ```
  */
 export class RunnablePassthrough extends Runnable {
-    constructor() {
-        super(...arguments);
+    static lc_name() {
+        return "RunnablePassthrough";
+    }
+    constructor(fields) {
+        super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -40,15 +44,46 @@ export class RunnablePassthrough extends Runnable {
             writable: true,
             value: true
         });
-    }
-    static lc_name() {
-        return "RunnablePassthrough";
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (fields) {
+            this.func = fields.func;
+        }
     }
     async invoke(input, options) {
+        if (this.func) {
+            await this.func(input, options);
+        }
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
-    transform(generator, options) {
-        return this._transformStreamWithConfig(generator, (input) => input, options);
+    async *transform(generator, options) {
+        let finalOutput;
+        let finalOutputSupported = true;
+        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, options)) {
+            yield chunk;
+            if (finalOutputSupported) {
+                if (finalOutput === undefined) {
+                    finalOutput = chunk;
+                }
+                else {
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        finalOutput = concat(finalOutput, chunk);
+                    }
+                    catch {
+                        finalOutput = undefined;
+                        finalOutputSupported = false;
+                    }
+                }
+            }
+        }
+        if (this.func && finalOutput !== undefined) {
+            await this.func(finalOutput, options);
+        }
     }
     /**
      * A runnable that assigns key-value pairs to the input.

package/package.json

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