@langchain/core 0.2.18 → 0.2.20

package/dist/tools/index.d.ts

@@ -141,9 +141,9 @@ export interface DynamicToolInput extends BaseDynamicToolInput {
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
  */
-export interface DynamicStructuredToolInput<T extends ZodObjectAny = ZodObjectAny> extends BaseDynamicToolInput {
-    func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : z.infer<T>, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
-    schema: T;
+export interface DynamicStructuredToolInput<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends BaseDynamicToolInput {
+    func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : T extends ZodObjectAny ? z.infer<T> : T, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
+    schema: T extends ZodObjectAny ? T : T;
 }
 /**
  * A tool that can be created dynamically from a function, name, and description.
@@ -166,21 +166,24 @@ export declare class DynamicTool extends Tool {
  * description, designed to work with structured data. It extends the
  * StructuredTool class and overrides the _call method to execute the
  * provided function when the tool is called.
+ *
+ * Schema can be passed as Zod or JSON schema. The tool will not validate
+ * input if JSON schema is passed.
  */
-export declare class DynamicStructuredTool<T extends ZodObjectAny = ZodObjectAny> extends StructuredTool<T> {
+export declare class DynamicStructuredTool<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends StructuredTool<T extends ZodObjectAny ? T : ZodObjectAny> {
     static lc_name(): string;
     name: string;
     description: string;
     func: DynamicStructuredToolInput<T>["func"];
-    schema: T;
+    schema: T extends ZodObjectAny ? T : ZodObjectAny;
     constructor(fields: DynamicStructuredToolInput<T>);
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call(arg: z.output<T> | ToolCall, configArg?: RunnableConfig | Callbacks, 
+    call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, configArg?: RunnableConfig | Callbacks, 
     /** @deprecated */
     tags?: string[]): Promise<ToolReturnType>;
-    protected _call(arg: z.output<T> | ToolCall, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
+    protected _call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
 }
 /**
  * Abstract base class for toolkits in LangChain. Toolkits are collections
@@ -193,9 +196,11 @@ export declare abstract class BaseToolkit {
 }
 /**
  * Parameters for the tool function.
- * @template {ZodObjectAny | z.ZodString = ZodObjectAny} RunInput The input schema for the tool. Either any Zod object, or a Zod string.
+ * Schema can be provided as Zod or JSON schema.
+ * If you pass JSON schema, tool inputs will not be validated.
+ * @template {ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny} RunInput The input schema for the tool. Either any Zod object, a Zod string, or JSON schema.
  */
-interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString = ZodObjectAny> extends ToolParams {
+interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -226,8 +231,11 @@ interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString = ZodObj
 /**
  * Creates a new StructuredTool instance with the provided function, name, description, and schema.
  *
+ * Schema can be provided as Zod or JSON schema.
+ * If you pass JSON schema, tool inputs will not be validated.
+ *
  * @function
- * @template {ZodObjectAny | z.ZodString = ZodObjectAny} T The input schema for the tool. Either any Zod object, or a Zod string.
+ * @template {ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny} T The input schema for the tool. Either any Zod object, a Zod string, or JSON schema instance.
  *
  * @param {RunnableFunc<z.output<T>, ToolReturnType>} func - The function to invoke when the tool is called.
  * @param {ToolWrapperParams<T>} fields - An object containing the following properties:
@@ -237,5 +245,6 @@ interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString = ZodObj
  *
  * @returns {DynamicStructuredTool<T>} A new StructuredTool instance.
  */
-export declare function tool<T extends z.ZodString = z.ZodString>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicTool;
-export declare function tool<T extends ZodObjectAny = ZodObjectAny>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
+export declare function tool<T extends z.ZodString>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicTool;
+export declare function tool<T extends ZodObjectAny>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
+export declare function tool<T extends Record<string, any>>(func: RunnableFunc<T, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;

package/dist/tools/index.js

@@ -5,6 +5,7 @@ import { ensureConfig, patchConfig, } from "../runnables/config.js";
 import { ToolMessage } from "../messages/tool.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { _isToolCall, ToolInputParsingException } from "./utils.js";
+import { isZodSchema } from "../utils/types/is_zod_schema.js";
 export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
@@ -91,6 +92,7 @@ export class StructuredTool extends BaseLangChain {
         let result;
         try {
             result = await this._call(parsed, runManager, config);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             await runManager?.handleToolError(e);
@@ -204,6 +206,9 @@ export class DynamicTool extends Tool {
  * description, designed to work with structured data. It extends the
  * StructuredTool class and overrides the _call method to execute the
  * provided function when the tool is called.
+ *
+ * Schema can be passed as Zod or JSON schema. The tool will not validate
+ * input if JSON schema is passed.
  */
 export class DynamicStructuredTool extends StructuredTool {
     static lc_name() {
@@ -239,7 +244,7 @@ export class DynamicStructuredTool extends StructuredTool {
         this.description = fields.description;
         this.func = fields.func;
         this.returnDirect = fields.returnDirect ?? this.returnDirect;
-        this.schema = fields.schema;
+        this.schema = (isZodSchema(fields.schema) ? fields.schema : z.object({}));
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -254,6 +259,7 @@ export class DynamicStructuredTool extends StructuredTool {
         return super.call(arg, config, tags);
     }
     _call(arg, runManager, parentConfig) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.func(arg, runManager, parentConfig);
     }
 }
@@ -271,18 +277,20 @@ export function tool(func, fields) {
     // If the schema is not provided, or it's a string schema, create a DynamicTool
     if (!fields.schema || !("shape" in fields.schema) || !fields.schema.shape) {
         return new DynamicTool({
-            name: fields.name,
+            ...fields,
             description: fields.description ??
                 fields.schema?.description ??
                 `${fields.name} tool`,
-            responseFormat: fields.responseFormat,
-            func,
+            // TS doesn't restrict the type here based on the guard above
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            func: func,
         });
     }
     const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
     return new DynamicStructuredTool({
-        name: fields.name,
+        ...fields,
         description,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         schema: fields.schema,
         // TODO: Consider moving into DynamicStructuredTool constructor
         func: async (input, runManager, config) => {
@@ -292,6 +300,8 @@ export function tool(func, fields) {
                 });
                 void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                     try {
+                        // TS doesn't restrict the type here based on the guard above
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         resolve(func(input, childConfig));
                     }
                     catch (e) {
@@ -300,7 +310,6 @@ export function tool(func, fields) {
                 });
             });
         },
-        responseFormat: fields.responseFormat,
     });
 }
 function _formatToolOutput(params) {

package/dist/utils/math.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maximalMarginalRelevance = exports.euclideanDistance = exports.innerProduct = exports.cosineSimilarity = exports.normalize = exports.matrixFunc = void 0;
-const ml_distance_1 = require("ml-distance");
+const similarities_js_1 = require("./ml-distance/similarities.cjs");
+const distances_js_1 = require("./ml-distance/distances.cjs");
+const euclidean_js_1 = require("./ml-distance-euclidean/euclidean.cjs");
 /**
  * Apply a row-wise function between two matrices with the same number of columns.
  *
@@ -45,15 +47,15 @@ exports.normalize = normalize;
  * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
  */
 function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, ml_distance_1.similarity.cosine);
+    return matrixFunc(X, Y, similarities_js_1.cosine);
 }
 exports.cosineSimilarity = cosineSimilarity;
 function innerProduct(X, Y) {
-    return matrixFunc(X, Y, ml_distance_1.distance.innerProduct);
+    return matrixFunc(X, Y, distances_js_1.innerProduct);
 }
 exports.innerProduct = innerProduct;
 function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, ml_distance_1.distance.euclidean);
+    return matrixFunc(X, Y, euclidean_js_1.euclidean);
 }
 exports.euclideanDistance = euclideanDistance;
 /**

package/dist/utils/math.js

@@ -1,4 +1,6 @@
-import { similarity as ml_distance_similarity, distance as ml_distance, } from "ml-distance";
+import { cosine } from "./ml-distance/similarities.js";
+import { innerProduct as innerProductDistance } from "./ml-distance/distances.js";
+import { euclidean } from "./ml-distance-euclidean/euclidean.js";
 /**
  * Apply a row-wise function between two matrices with the same number of columns.
  *
@@ -40,13 +42,13 @@ export function normalize(M, similarity = false) {
  * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
  */
 export function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, ml_distance_similarity.cosine);
+    return matrixFunc(X, Y, cosine);
 }
 export function innerProduct(X, Y) {
-    return matrixFunc(X, Y, ml_distance.innerProduct);
+    return matrixFunc(X, Y, innerProductDistance);
 }
 export function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, ml_distance.euclidean);
+    return matrixFunc(X, Y, euclidean);
 }
 /**
  * This function implements the Maximal Marginal Relevance algorithm

package/dist/utils/ml-distance/distances.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.innerProduct = void 0;
+/**
+ *Returns the Inner Product similarity between vectors a and b
+ * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function innerProduct(a, b) {
+    let ans = 0;
+    for (let i = 0; i < a.length; i++) {
+        ans += a[i] * b[i];
+    }
+    return ans;
+}
+exports.innerProduct = innerProduct;

package/dist/utils/ml-distance/distances.d.ts

@@ -0,0 +1,8 @@
+/**
+ *Returns the Inner Product similarity between vectors a and b
+ * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function innerProduct(a: number[], b: number[]): number;

package/dist/utils/ml-distance/distances.js

@@ -0,0 +1,14 @@
+/**
+ *Returns the Inner Product similarity between vectors a and b
+ * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function innerProduct(a, b) {
+    let ans = 0;
+    for (let i = 0; i < a.length; i++) {
+        ans += a[i] * b[i];
+    }
+    return ans;
+}

package/dist/utils/ml-distance/similarities.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosine = void 0;
+/**
+ * Returns the average of cosine distances between vectors a and b
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function cosine(a, b) {
+    let p = 0;
+    let p2 = 0;
+    let q2 = 0;
+    for (let i = 0; i < a.length; i++) {
+        p += a[i] * b[i];
+        p2 += a[i] * a[i];
+        q2 += b[i] * b[i];
+    }
+    return p / (Math.sqrt(p2) * Math.sqrt(q2));
+}
+exports.cosine = cosine;

package/dist/utils/ml-distance/similarities.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the average of cosine distances between vectors a and b
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function cosine(a: number[], b: number[]): number;

package/dist/utils/ml-distance/similarities.js

@@ -0,0 +1,17 @@
+/**
+ * Returns the average of cosine distances between vectors a and b
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function cosine(a, b) {
+    let p = 0;
+    let p2 = 0;
+    let q2 = 0;
+    for (let i = 0; i < a.length; i++) {
+        p += a[i] * b[i];
+        p2 += a[i] * a[i];
+        q2 += b[i] * b[i];
+    }
+    return p / (Math.sqrt(p2) * Math.sqrt(q2));
+}

package/dist/utils/ml-distance-euclidean/euclidean.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.euclidean = exports.squaredEuclidean = void 0;
+function squaredEuclidean(p, q) {
+    let d = 0;
+    for (let i = 0; i < p.length; i++) {
+        d += (p[i] - q[i]) * (p[i] - q[i]);
+    }
+    return d;
+}
+exports.squaredEuclidean = squaredEuclidean;
+function euclidean(p, q) {
+    return Math.sqrt(squaredEuclidean(p, q));
+}
+exports.euclidean = euclidean;

package/dist/utils/ml-distance-euclidean/euclidean.d.ts

@@ -0,0 +1,2 @@
+export declare function squaredEuclidean(p: number[], q: number[]): number;
+export declare function euclidean(p: number[], q: number[]): number;

package/dist/utils/ml-distance-euclidean/euclidean.js

@@ -0,0 +1,10 @@
+export function squaredEuclidean(p, q) {
+    let d = 0;
+    for (let i = 0; i < p.length; i++) {
+        d += (p[i] - q[i]) * (p[i] - q[i]);
+    }
+    return d;
+}
+export function euclidean(p, q) {
+    return Math.sqrt(squaredEuclidean(p, q));
+}

package/dist/utils/signal.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raceWithSignal = void 0;
+async function raceWithSignal(promise, signal) {
+    if (signal === undefined) {
+        return promise;
+    }
+    return Promise.race([
+        promise.catch((err) => {
+            if (!signal?.aborted) {
+                throw err;
+            }
+            else {
+                return undefined;
+            }
+        }),
+        new Promise((_, reject) => {
+            signal.addEventListener("abort", () => {
+                reject(new Error("Aborted"));
+            });
+            // Must be here inside the promise to avoid a race condition
+            if (signal.aborted) {
+                reject(new Error("Aborted"));
+            }
+        }),
+    ]);
+}
+exports.raceWithSignal = raceWithSignal;

package/dist/utils/signal.d.ts

@@ -0,0 +1 @@
+export declare function raceWithSignal<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/utils/signal.js

@@ -0,0 +1,24 @@
+export async function raceWithSignal(promise, signal) {
+    if (signal === undefined) {
+        return promise;
+    }
+    return Promise.race([
+        promise.catch((err) => {
+            if (!signal?.aborted) {
+                throw err;
+            }
+            else {
+                return undefined;
+            }
+        }),
+        new Promise((_, reject) => {
+            signal.addEventListener("abort", () => {
+                reject(new Error("Aborted"));
+            });
+            // Must be here inside the promise to avoid a race condition
+            if (signal.aborted) {
+                reject(new Error("Aborted"));
+            }
+        }),
+    ]);
+}

package/dist/utils/stream.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipeGeneratorWithSetup = exports.AsyncGeneratorWithSetup = exports.concat = exports.atee = exports.IterableReadableStream = void 0;
 const index_js_1 = require("../singletons/index.cjs");
+const signal_js_1 = require("./signal.cjs");
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
@@ -187,6 +188,12 @@ class AsyncGeneratorWithSetup {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "signal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "firstResult", {
             enumerable: true,
             configurable: true,
@@ -201,6 +208,8 @@ class AsyncGeneratorWithSetup {
         });
         this.generator = params.generator;
         this.config = params.config;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.signal = params.signal ?? this.config?.signal;
         // setup is a promise that resolves only after the first iterator value
         // is available. this is useful when setup of several piped generators
         // needs to happen in logical order, ie. in the order in which input to
@@ -218,13 +227,18 @@ class AsyncGeneratorWithSetup {
         });
     }
     async next(...args) {
+        this.signal?.throwIfAborted();
         if (!this.firstResultUsed) {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(this.config, async () => {
-            return this.generator.next(...args);
-        }, true);
+        return index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(this.config, this.signal
+            ? async () => {
+                return (0, signal_js_1.raceWithSignal)(this.generator.next(...args), this.signal);
+            }
+            : async () => {
+                return this.generator.next(...args);
+            }, true);
     }
     async return(value) {
         return this.generator.return(value);
@@ -237,10 +251,11 @@ class AsyncGeneratorWithSetup {
     }
 }
 exports.AsyncGeneratorWithSetup = AsyncGeneratorWithSetup;
-async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) {
+async function pipeGeneratorWithSetup(to, generator, startSetup, signal, ...args) {
     const gen = new AsyncGeneratorWithSetup({
         generator,
         startSetup,
+        signal,
     });
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };

package/dist/utils/stream.d.ts

@@ -15,19 +15,21 @@ export declare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn =
     private generator;
     setup: Promise<S>;
     config?: unknown;
+    signal?: AbortSignal;
     private firstResult;
     private firstResultUsed;
     constructor(params: {
         generator: AsyncGenerator<T>;
         startSetup?: () => Promise<S>;
         config?: unknown;
+        signal?: AbortSignal;
     });
     next(...args: [] | [TNext]): Promise<IteratorResult<T>>;
     return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;
     throw(e: Error): Promise<IteratorResult<T>>;
     [Symbol.asyncIterator](): this;
 }
-export declare function pipeGeneratorWithSetup<S, A extends unknown[], T, TReturn, TNext, U, UReturn, UNext>(to: (g: AsyncGenerator<T, TReturn, TNext>, s: S, ...args: A) => AsyncGenerator<U, UReturn, UNext>, generator: AsyncGenerator<T, TReturn, TNext>, startSetup: () => Promise<S>, ...args: A): Promise<{
+export declare function pipeGeneratorWithSetup<S, A extends unknown[], T, TReturn, TNext, U, UReturn, UNext>(to: (g: AsyncGenerator<T, TReturn, TNext>, s: S, ...args: A) => AsyncGenerator<U, UReturn, UNext>, generator: AsyncGenerator<T, TReturn, TNext>, startSetup: () => Promise<S>, signal: AbortSignal | undefined, ...args: A): Promise<{
     output: AsyncGenerator<U, UReturn, UNext>;
     setup: Awaited<S>;
 }>;

package/dist/utils/stream.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
+import { raceWithSignal } from "./signal.js";
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
@@ -181,6 +182,12 @@ export class AsyncGeneratorWithSetup {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "signal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "firstResult", {
             enumerable: true,
             configurable: true,
@@ -195,6 +202,8 @@ export class AsyncGeneratorWithSetup {
         });
         this.generator = params.generator;
         this.config = params.config;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.signal = params.signal ?? this.config?.signal;
         // setup is a promise that resolves only after the first iterator value
         // is available. this is useful when setup of several piped generators
         // needs to happen in logical order, ie. in the order in which input to
@@ -212,13 +221,18 @@ export class AsyncGeneratorWithSetup {
         });
     }
     async next(...args) {
+        this.signal?.throwIfAborted();
         if (!this.firstResultUsed) {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return AsyncLocalStorageProviderSingleton.runWithConfig(this.config, async () => {
-            return this.generator.next(...args);
-        }, true);
+        return AsyncLocalStorageProviderSingleton.runWithConfig(this.config, this.signal
+            ? async () => {
+                return raceWithSignal(this.generator.next(...args), this.signal);
+            }
+            : async () => {
+                return this.generator.next(...args);
+            }, true);
     }
     async return(value) {
         return this.generator.return(value);
@@ -230,10 +244,11 @@ export class AsyncGeneratorWithSetup {
         return this;
     }
 }
-export async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) {
+export async function pipeGeneratorWithSetup(to, generator, startSetup, signal, ...args) {
     const gen = new AsyncGeneratorWithSetup({
         generator,
         startSetup,
+        signal,
     });
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };