modelfusion 0.51.0 → 0.53.0

package/README.md

@@ -65,8 +65,8 @@ const textStream = await streamText(
   "Write a short story about a robot learning to love:\n\n"
 );
 
-for await (const textFragment of textStream) {
-  process.stdout.write(textFragment);
+for await (const textPart of textStream) {
+  process.stdout.write(textPart);
 }
 ```
 
@@ -664,11 +664,3 @@ Generate text on a Cloudflare Worker using ModelFusion and OpenAI.
 ### [Contributing Guide](https://github.com/lgrammel/modelfusion/blob/main/CONTRIBUTING.md)
 
 Read the [ModelFusion contributing guide](https://github.com/lgrammel/modelfusion/blob/main/CONTRIBUTING.md) to learn about the development process, how to propose bugfixes and improvements, and how to build and test your changes.
-
-```
-
-```
-
-```
-
-```

package/core/ExecuteFunctionEvent.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/ExecuteFunctionEvent.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "./FunctionEvent.js";
+export interface ExecuteFunctionStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "execute-function";
+}
+export interface ExecuteFunctionFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "execute-function";
+}

package/core/ExecuteFunctionEvent.js

@@ -0,0 +1 @@
+export {};

package/core/FunctionEvent.d.ts

@@ -1,3 +1,4 @@
+import { ExecuteFunctionFinishedEvent, ExecuteFunctionStartedEvent } from "./ExecuteFunctionEvent.js";
 import { GuardFinishedEvent, GuardStartedEvent } from "../guard/GuardEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
 import { RetrieveFinishedEvent, RetrieveStartedEvent } from "../retriever/RetrieveEvent.js";
@@ -81,4 +82,4 @@ export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
      */
     result: BaseFunctionFinishedEventResult;
 }
-export type FunctionEvent = ExecuteToolStartedEvent | ExecuteToolFinishedEvent | GuardStartedEvent | GuardFinishedEvent | ModelCallStartedEvent | ModelCallFinishedEvent | RetrieveStartedEvent | RetrieveFinishedEvent | UpsertIntoVectorIndexStartedEvent | UpsertIntoVectorIndexFinishedEvent | UseToolStartedEvent | UseToolFinishedEvent | UseToolOrGenerateTextStartedEvent | UseToolOrGenerateTextFinishedEvent;
+export type FunctionEvent = ExecuteFunctionStartedEvent | ExecuteFunctionFinishedEvent | ExecuteToolStartedEvent | ExecuteToolFinishedEvent | GuardStartedEvent | GuardFinishedEvent | ModelCallStartedEvent | ModelCallFinishedEvent | RetrieveStartedEvent | RetrieveFinishedEvent | UpsertIntoVectorIndexStartedEvent | UpsertIntoVectorIndexFinishedEvent | UseToolStartedEvent | UseToolFinishedEvent | UseToolOrGenerateTextStartedEvent | UseToolOrGenerateTextFinishedEvent;

package/core/api/loadApiKey.cjs

@@ -6,11 +6,11 @@ function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName = "ap
         return apiKey;
     }
     if (typeof process === "undefined") {
-        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`);
+        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter into the API configuration. Environment variables is not supported in this environment.`);
     }
     apiKey = process.env[environmentVariableName];
     if (apiKey == null) {
-        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or set it as an environment variable named ${environmentVariableName}.`);
+        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter into the API configuration or set it as an environment variable named ${environmentVariableName}.`);
     }
     return apiKey;
 }

package/core/api/loadApiKey.js

@@ -3,11 +3,11 @@ export function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterNam
         return apiKey;
     }
     if (typeof process === "undefined") {
-        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`);
+        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter into the API configuration. Environment variables is not supported in this environment.`);
     }
     apiKey = process.env[environmentVariableName];
     if (apiKey == null) {
-        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or set it as an environment variable named ${environmentVariableName}.`);
+        throw new Error(`${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter into the API configuration or set it as an environment variable named ${environmentVariableName}.`);
     }
     return apiKey;
 }

package/core/executeFunction.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFunction = void 0;
+const executeFunctionCall_js_1 = require("./executeFunctionCall.cjs");
+async function executeFunction(fn, input, options) {
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input,
+        functionType: "execute-function",
+        execute: async (options) => fn(input, {
+            // omit functionId
+            logging: options?.logging,
+            observers: options?.observers,
+            run: options?.run,
+            parentCallId: options?.parentCallId,
+        }),
+    });
+}
+exports.executeFunction = executeFunction;

package/core/executeFunction.d.ts

@@ -0,0 +1,2 @@
+import { FunctionOptions } from "./FunctionOptions.js";
+export declare function executeFunction<INPUT, OUTPUT>(fn: (input: INPUT, options?: FunctionOptions) => PromiseLike<OUTPUT>, input: INPUT, options?: FunctionOptions): Promise<OUTPUT>;

package/core/executeFunction.js

@@ -0,0 +1,15 @@
+import { executeFunctionCall } from "./executeFunctionCall.js";
+export async function executeFunction(fn, input, options) {
+    return executeFunctionCall({
+        options,
+        input,
+        functionType: "execute-function",
+        execute: async (options) => fn(input, {
+            // omit functionId
+            logging: options?.logging,
+            observers: options?.observers,
+            run: options?.run,
+            parentCallId: options?.parentCallId,
+        }),
+    });
+}

package/core/index.cjs

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DefaultRun.cjs"), exports);
+__exportStar(require("./ExecuteFunctionEvent.cjs"), exports);
 __exportStar(require("./FunctionEvent.cjs"), exports);
 __exportStar(require("./FunctionEventSource.cjs"), exports);
 __exportStar(require("./FunctionObserver.cjs"), exports);
@@ -24,5 +25,6 @@ __exportStar(require("./GlobalFunctionObservers.cjs"), exports);
 __exportStar(require("./Run.cjs"), exports);
 __exportStar(require("./Vector.cjs"), exports);
 __exportStar(require("./api/index.cjs"), exports);
+__exportStar(require("./executeFunction.cjs"), exports);
 __exportStar(require("./getRun.cjs"), exports);
 __exportStar(require("./structure/index.cjs"), exports);

package/core/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./DefaultRun.js";
+export * from "./ExecuteFunctionEvent.js";
 export * from "./FunctionEvent.js";
 export * from "./FunctionEventSource.js";
 export * from "./FunctionObserver.js";
@@ -8,5 +9,6 @@ export * from "./GlobalFunctionObservers.js";
 export * from "./Run.js";
 export * from "./Vector.js";
 export * from "./api/index.js";
+export * from "./executeFunction.js";
 export * from "./getRun.js";
 export * from "./structure/index.js";

package/core/index.js

@@ -1,4 +1,5 @@
 export * from "./DefaultRun.js";
+export * from "./ExecuteFunctionEvent.js";
 export * from "./FunctionEvent.js";
 export * from "./FunctionEventSource.js";
 export * from "./FunctionObserver.js";
@@ -8,5 +9,6 @@ export * from "./GlobalFunctionObservers.js";
 export * from "./Run.js";
 export * from "./Vector.js";
 export * from "./api/index.js";
+export * from "./executeFunction.js";
 export * from "./getRun.js";
 export * from "./structure/index.js";

package/event-source/index.cjs

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./AsyncQueue.cjs"), exports);
 __exportStar(require("./createEventSourceStream.cjs"), exports);
 __exportStar(require("./readEventSource.cjs"), exports);
 __exportStar(require("./readEventSourceStream.cjs"), exports);

package/event-source/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./AsyncQueue.js";
 export * from "./createEventSourceStream.js";
 export * from "./readEventSource.js";
 export * from "./readEventSourceStream.js";

package/event-source/index.js

@@ -1,4 +1,3 @@
-export * from "./AsyncQueue.js";
 export * from "./createEventSourceStream.js";
 export * from "./readEventSource.js";
 export * from "./readEventSourceStream.js";

package/event-source/readEventSourceStream.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEventSourceStream = void 0;
 const parseJSON_js_1 = require("../util/parseJSON.cjs");
-const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../util/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("./parseEventSourceStream.cjs");
 function readEventSourceStream({ stream, schema, errorHandler, }) {
     const queue = new AsyncQueue_js_1.AsyncQueue();

package/event-source/readEventSourceStream.js

@@ -1,5 +1,5 @@
 import { safeParseJsonWithSchema } from "../util/parseJSON.js";
-import { AsyncQueue } from "./AsyncQueue.js";
+import { AsyncQueue } from "../util/AsyncQueue.js";
 import { parseEventSourceStream } from "./parseEventSourceStream.js";
 export function readEventSourceStream({ stream, schema, errorHandler, }) {
     const queue = new AsyncQueue();

package/model-function/executeStreamCall.cjs

@@ -8,6 +8,7 @@ const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cj
 const AbortError_js_1 = require("../core/api/AbortError.cjs");
 const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
 const getRun_js_1 = require("../core/getRun.cjs");
+const AsyncQueue_js_1 = require("../util/AsyncQueue.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
 async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
@@ -50,7 +51,10 @@ async function executeStreamCall({ model, options, input, functionType, startStr
             run,
             parentCallId: startMetadata.callId,
         });
-        return (async function* () {
+        // Return a queue that can be iterated over several times:
+        const responseQueue = new AsyncQueue_js_1.AsyncQueue();
+        // run async:
+        (async function () {
             for await (const event of deltaIterable) {
                 if (event?.type === "error") {
                     const error = event.error;
@@ -74,16 +78,17 @@ async function executeStreamCall({ model, options, input, functionType, startStr
                 if (event?.type === "delta") {
                     const value = processDelta(event);
                     if (value !== undefined) {
-                        yield value;
+                        responseQueue.push(value);
                     }
                 }
             }
             if (processFinished != null) {
                 const value = processFinished();
                 if (value !== undefined) {
-                    yield value;
+                    responseQueue.push(value);
                 }
             }
+            responseQueue.close();
             const finishMetadata = {
                 eventType: "finished",
                 ...startMetadata,
@@ -98,6 +103,7 @@ async function executeStreamCall({ model, options, input, functionType, startStr
                 },
             });
         })();
+        return responseQueue;
     });
     if (!result.ok) {
         const finishMetadata = {

package/model-function/executeStreamCall.js

@@ -5,6 +5,7 @@ import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
 import { AbortError } from "../core/api/AbortError.js";
 import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { getRun } from "../core/getRun.js";
+import { AsyncQueue } from "../util/AsyncQueue.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { runSafe } from "../util/runSafe.js";
 export async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
@@ -47,7 +48,10 @@ export async function executeStreamCall({ model, options, input, functionType, s
             run,
             parentCallId: startMetadata.callId,
         });
-        return (async function* () {
+        // Return a queue that can be iterated over several times:
+        const responseQueue = new AsyncQueue();
+        // run async:
+        (async function () {
             for await (const event of deltaIterable) {
                 if (event?.type === "error") {
                     const error = event.error;
@@ -71,16 +75,17 @@ export async function executeStreamCall({ model, options, input, functionType, s
                 if (event?.type === "delta") {
                     const value = processDelta(event);
                     if (value !== undefined) {
-                        yield value;
+                        responseQueue.push(value);
                     }
                 }
             }
             if (processFinished != null) {
                 const value = processFinished();
                 if (value !== undefined) {
-                    yield value;
+                    responseQueue.push(value);
                 }
             }
+            responseQueue.close();
             const finishMetadata = {
                 eventType: "finished",
                 ...startMetadata,
@@ -95,6 +100,7 @@ export async function executeStreamCall({ model, options, input, functionType, s
                 },
             });
         })();
+        return responseQueue;
     });
     if (!result.ok) {
         const finishMetadata = {

package/model-function/generate-speech/streamSpeech.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamSpeech = void 0;
-const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.cjs");
 const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
 /**

package/model-function/generate-speech/streamSpeech.js

@@ -1,4 +1,4 @@
-import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
 import { executeStreamCall } from "../executeStreamCall.js";
 /**

package/model-provider/anthropic/AnthropicTextGenerationModel.cjs

@@ -4,10 +4,10 @@ exports.AnthropicTextGenerationResponseFormat = exports.AnthropicTextGenerationM
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const parseJSON_js_1 = require("../../util/parseJSON.cjs");
 const AnthropicApiConfiguration_js_1 = require("./AnthropicApiConfiguration.cjs");
 const AnthropicError_js_1 = require("./AnthropicError.cjs");

package/model-provider/anthropic/AnthropicTextGenerationModel.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseJsonWithZod } from "../../util/parseJSON.js";
 import { AnthropicApiConfiguration } from "./AnthropicApiConfiguration.js";
 import { failedAnthropicCallResponseHandler } from "./AnthropicError.js";

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -4,7 +4,7 @@ exports.CohereTextGenerationResponseFormat = exports.CohereTextGenerationModel =
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
 const TextPromptFormat_js_1 = require("../../model-function/generate-text/TextPromptFormat.cjs");

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
 import { mapChatPromptToTextFormat, mapInstructionPromptToTextFormat, } from "../../model-function/generate-text/TextPromptFormat.js";

package/model-provider/elevenlabs/ElevenLabsSpeechModel.cjs

@@ -4,7 +4,7 @@ exports.ElevenLabsSpeechModel = void 0;
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const SimpleWebSocket_js_1 = require("../../util/SimpleWebSocket.cjs");
 const parseJSON_js_1 = require("../../util/parseJSON.cjs");

package/model-provider/elevenlabs/ElevenLabsSpeechModel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createAudioMpegResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { createSimpleWebSocket } from "../../util/SimpleWebSocket.js";
 import { safeParseJsonWithZod } from "../../util/parseJSON.js";

package/model-provider/llamacpp/LlamaCppTextGenerationModel.cjs

@@ -4,7 +4,7 @@ exports.LlamaCppTextGenerationResponseFormat = exports.LlamaCppTextGenerationMod
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";

package/model-provider/openai/OpenAICompletionModel.cjs

@@ -4,7 +4,7 @@ exports.OpenAITextResponseFormat = exports.OpenAICompletionModel = exports.calcu
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");

package/model-provider/openai/OpenAICompletionModel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAIChatDeltaIterableQueue = void 0;
 const zod_1 = require("zod");
-const AsyncQueue_js_1 = require("../../../event-source/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../../util/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../../event-source/parseEventSourceStream.cjs");
 const parseJSON_js_1 = require("../../../util/parseJSON.cjs");
 const chatResponseStreamEventSchema = zod_1.z.object({

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { AsyncQueue } from "../../../event-source/AsyncQueue.js";
+import { AsyncQueue } from "../../../util/AsyncQueue.js";
 import { parseEventSourceStream } from "../../../event-source/parseEventSourceStream.js";
 import { safeParseJsonWithZod } from "../../../util/parseJSON.js";
 const chatResponseStreamEventSchema = z.object({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -48,7 +48,7 @@
     "build:esm": "tsc --outDir dist/",
     "build:cjs": "tsc --outDir build/cjs/ -p tsconfig.cjs.json && node bin/prepare-cjs.js",
     "test": "vitest run src",
-    "test-interactive": "vitest run",
+    "test-interactive": "vitest watch",
     "dist": "npm run clean && npm run lint && npm run test && npm run build && npm run dist:copy-files",
     "dist:copy-files": "copyfiles package.json README.md LICENSE dist"
   },

package/util/AsyncQueue.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+/**
+ * `AsyncQueue` is a class that represents an asynchronous queue.
+ * It allows values to be pushed onto it and consumed (pulled) by an iterator.
+ * The queue is async-iterable, making it compatible with async/await syntax.
+ *
+ * @template T The type of elements contained in the queue.
+ * @example
+ * const queue = new AsyncQueue<number>();
+ * queue.push(1);
+ * (async () => {
+ *   for await (const value of queue) {
+ *     console.log(value);
+ *   }
+ * })();
+ */
+class AsyncQueue {
+    constructor() {
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pendingResolvers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Pushes an element onto the queue. If the queue is closed, an error is thrown.
+     *
+     * @param {T} value - The element to add to the queue.
+     * @throws {Error} Throws an error if the queue is closed.
+     * @example
+     * queue.push(2);
+     */
+    push(value) {
+        if (this.closed) {
+            throw new Error("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+        }
+        this.values.push(value);
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Closes the queue, preventing more elements from being pushed onto it.
+     *
+     * @example
+     * queue.close();
+     */
+    close() {
+        this.closed = true;
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Creates and returns an async iterator that allows the queue to be consumed.
+     * You can create multiple iterators for the same queue.
+     *
+     * @returns {AsyncIterator<T>} An async iterator for the queue.
+     * @example
+     * (async () => {
+     *   for await (const value of queue) {
+     *     console.log(value);
+     *   }
+     * })();
+     */
+    [Symbol.asyncIterator]() {
+        let position = 0;
+        return {
+            next: () => new Promise((resolve) => {
+                const attemptResolve = () => {
+                    if (position < this.values.length) {
+                        // There's an available value, resolve it immediately.
+                        resolve({ value: this.values[position++], done: false });
+                    }
+                    else if (this.closed) {
+                        // The queue is closed, and there are no more values. Complete the iteration.
+                        resolve({ value: undefined, done: true }); // eslint-disable-line @typescript-eslint/no-explicit-any
+                    }
+                    else {
+                        // No values are currently available, and the queue is not closed.
+                        // The consumer is now pending and will be resolved when a new value is pushed
+                        // or when the queue is closed.
+                        this.pendingResolvers.push(attemptResolve);
+                    }
+                };
+                attemptResolve();
+            }),
+        };
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/util/AsyncQueue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `AsyncQueue` is a class that represents an asynchronous queue.
+ * It allows values to be pushed onto it and consumed (pulled) by an iterator.
+ * The queue is async-iterable, making it compatible with async/await syntax.
+ *
+ * @template T The type of elements contained in the queue.
+ * @example
+ * const queue = new AsyncQueue<number>();
+ * queue.push(1);
+ * (async () => {
+ *   for await (const value of queue) {
+ *     console.log(value);
+ *   }
+ * })();
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private values;
+    private pendingResolvers;
+    private closed;
+    /**
+     * Pushes an element onto the queue. If the queue is closed, an error is thrown.
+     *
+     * @param {T} value - The element to add to the queue.
+     * @throws {Error} Throws an error if the queue is closed.
+     * @example
+     * queue.push(2);
+     */
+    push(value: T): void;
+    /**
+     * Closes the queue, preventing more elements from being pushed onto it.
+     *
+     * @example
+     * queue.close();
+     */
+    close(): void;
+    /**
+     * Creates and returns an async iterator that allows the queue to be consumed.
+     * You can create multiple iterators for the same queue.
+     *
+     * @returns {AsyncIterator<T>} An async iterator for the queue.
+     * @example
+     * (async () => {
+     *   for await (const value of queue) {
+     *     console.log(value);
+     *   }
+     * })();
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/util/AsyncQueue.js

@@ -0,0 +1,102 @@
+/**
+ * `AsyncQueue` is a class that represents an asynchronous queue.
+ * It allows values to be pushed onto it and consumed (pulled) by an iterator.
+ * The queue is async-iterable, making it compatible with async/await syntax.
+ *
+ * @template T The type of elements contained in the queue.
+ * @example
+ * const queue = new AsyncQueue<number>();
+ * queue.push(1);
+ * (async () => {
+ *   for await (const value of queue) {
+ *     console.log(value);
+ *   }
+ * })();
+ */
+export class AsyncQueue {
+    constructor() {
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pendingResolvers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Pushes an element onto the queue. If the queue is closed, an error is thrown.
+     *
+     * @param {T} value - The element to add to the queue.
+     * @throws {Error} Throws an error if the queue is closed.
+     * @example
+     * queue.push(2);
+     */
+    push(value) {
+        if (this.closed) {
+            throw new Error("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+        }
+        this.values.push(value);
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Closes the queue, preventing more elements from being pushed onto it.
+     *
+     * @example
+     * queue.close();
+     */
+    close() {
+        this.closed = true;
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Creates and returns an async iterator that allows the queue to be consumed.
+     * You can create multiple iterators for the same queue.
+     *
+     * @returns {AsyncIterator<T>} An async iterator for the queue.
+     * @example
+     * (async () => {
+     *   for await (const value of queue) {
+     *     console.log(value);
+     *   }
+     * })();
+     */
+    [Symbol.asyncIterator]() {
+        let position = 0;
+        return {
+            next: () => new Promise((resolve) => {
+                const attemptResolve = () => {
+                    if (position < this.values.length) {
+                        // There's an available value, resolve it immediately.
+                        resolve({ value: this.values[position++], done: false });
+                    }
+                    else if (this.closed) {
+                        // The queue is closed, and there are no more values. Complete the iteration.
+                        resolve({ value: undefined, done: true }); // eslint-disable-line @typescript-eslint/no-explicit-any
+                    }
+                    else {
+                        // No values are currently available, and the queue is not closed.
+                        // The consumer is now pending and will be resolved when a new value is pushed
+                        // or when the queue is closed.
+                        this.pendingResolvers.push(attemptResolve);
+                    }
+                };
+                attemptResolve();
+            }),
+        };
+    }
+}

package/util/AsyncQueue.test.cjs

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const delay_js_1 = require("./delay.cjs");
+const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
+(0, vitest_1.test)("receive values in order for single iterator created before pushing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    await receiveValuesPromise;
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+});
+(0, vitest_1.test)("receive values in order for single iterator created after closing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    await receiveValuesPromise;
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+});
+(0, vitest_1.test)("handle delayed pushing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    setTimeout(() => {
+        asyncQueue.push(1);
+        asyncQueue.push(2);
+        asyncQueue.close();
+    }, 5);
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+});
+(0, vitest_1.test)("error handling in consumer", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.push(1);
+    await (0, vitest_1.expect)((async () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for await (const _value of asyncQueue) {
+            throw new Error("Consumer error");
+        }
+    })()).rejects.toThrow("Consumer error");
+    // Check the queue is still operational after an error in the consumer
+    asyncQueue.push(2);
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+});
+(0, vitest_1.test)("behavior on empty queue closing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    (0, vitest_1.expect)(receivedValues).toEqual([]);
+});
+(0, vitest_1.test)("multiple closings", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.close();
+    (0, vitest_1.expect)(() => asyncQueue.close()).not.toThrow();
+});
+(0, vitest_1.test)("receive all values in multiple independent consumers", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    const consumerPromises = [1, 2].map(async () => {
+        const receivedValues = [];
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+        return receivedValues;
+    });
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(1);
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(2);
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(3);
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.close();
+    const allReceivedValues = await Promise.all(consumerPromises);
+    allReceivedValues.forEach((receivedValues) => {
+        (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    });
+});
+(0, vitest_1.test)("each consumer receives all pushed values under varying conditions", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    // Start the first consumer, which will await values.
+    const receivedValues1 = [];
+    const consumer1 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues1.push(value);
+        }
+    })();
+    // Simulate some operation delay, then push the first value.
+    await (0, delay_js_1.delay)(5); // Delay is necessary to simulate real-world async operations.
+    asyncQueue.push(1);
+    // Start the second consumer after the first value was pushed.
+    const receivedValues2 = [];
+    const consumer2 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues2.push(value);
+        }
+    })();
+    // Push the remaining values with some delays.
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    // Close the queue and wait for consumers to finish processing.
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.close();
+    await Promise.all([consumer1, consumer2]);
+    // Both consumers should have received all values, even if they started at different times.
+    (0, vitest_1.expect)(receivedValues1).toEqual([1, 2, 3]);
+    (0, vitest_1.expect)(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+});
+(0, vitest_1.test)("throw error when pushing to a closed queue", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.close();
+    (0, vitest_1.expect)(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+});

package/util/AsyncQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/util/AsyncQueue.test.js

@@ -0,0 +1,136 @@
+import { expect, test } from "vitest";
+import { delay } from "./delay.js";
+import { AsyncQueue } from "./AsyncQueue.js";
+test("receive values in order for single iterator created before pushing", async () => {
+    const asyncQueue = new AsyncQueue();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    await receiveValuesPromise;
+    expect(receivedValues).toEqual([1, 2, 3]);
+});
+test("receive values in order for single iterator created after closing", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    await receiveValuesPromise;
+    expect(receivedValues).toEqual([1, 2, 3]);
+});
+test("handle delayed pushing", async () => {
+    const asyncQueue = new AsyncQueue();
+    setTimeout(() => {
+        asyncQueue.push(1);
+        asyncQueue.push(2);
+        asyncQueue.close();
+    }, 5);
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    expect(receivedValues).toEqual([1, 2]);
+});
+test("error handling in consumer", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.push(1);
+    await expect((async () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for await (const _value of asyncQueue) {
+            throw new Error("Consumer error");
+        }
+    })()).rejects.toThrow("Consumer error");
+    // Check the queue is still operational after an error in the consumer
+    asyncQueue.push(2);
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    expect(receivedValues).toEqual([1, 2]);
+});
+test("behavior on empty queue closing", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    expect(receivedValues).toEqual([]);
+});
+test("multiple closings", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.close();
+    expect(() => asyncQueue.close()).not.toThrow();
+});
+test("receive all values in multiple independent consumers", async () => {
+    const asyncQueue = new AsyncQueue();
+    const consumerPromises = [1, 2].map(async () => {
+        const receivedValues = [];
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+        return receivedValues;
+    });
+    await delay(5);
+    asyncQueue.push(1);
+    await delay(5);
+    asyncQueue.push(2);
+    await delay(5);
+    asyncQueue.push(3);
+    await delay(5);
+    asyncQueue.close();
+    const allReceivedValues = await Promise.all(consumerPromises);
+    allReceivedValues.forEach((receivedValues) => {
+        expect(receivedValues).toEqual([1, 2, 3]);
+    });
+});
+test("each consumer receives all pushed values under varying conditions", async () => {
+    const asyncQueue = new AsyncQueue();
+    // Start the first consumer, which will await values.
+    const receivedValues1 = [];
+    const consumer1 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues1.push(value);
+        }
+    })();
+    // Simulate some operation delay, then push the first value.
+    await delay(5); // Delay is necessary to simulate real-world async operations.
+    asyncQueue.push(1);
+    // Start the second consumer after the first value was pushed.
+    const receivedValues2 = [];
+    const consumer2 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues2.push(value);
+        }
+    })();
+    // Push the remaining values with some delays.
+    await delay(5);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    // Close the queue and wait for consumers to finish processing.
+    await delay(5);
+    asyncQueue.close();
+    await Promise.all([consumer1, consumer2]);
+    // Both consumers should have received all values, even if they started at different times.
+    expect(receivedValues1).toEqual([1, 2, 3]);
+    expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+});
+test("throw error when pushing to a closed queue", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.close();
+    expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+});

package/util/delay.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.delay = delay;

package/util/delay.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<void>;

package/util/delay.js

@@ -0,0 +1,3 @@
+export async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/util/index.cjs

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AsyncQueue.cjs"), exports);
 __exportStar(require("./JSONParseError.cjs"), exports);
 __exportStar(require("./cosineSimilarity.cjs"), exports);
 __exportStar(require("./getAudioFileExtension.cjs"), exports);

package/util/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./AsyncQueue.js";
 export * from "./JSONParseError.js";
 export * from "./cosineSimilarity.js";
 export * from "./getAudioFileExtension.js";

package/util/index.js

@@ -1,3 +1,4 @@
+export * from "./AsyncQueue.js";
 export * from "./JSONParseError.js";
 export * from "./cosineSimilarity.js";
 export * from "./getAudioFileExtension.js";

package/event-source/AsyncQueue.cjs

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncQueue = void 0;
-class AsyncQueue {
-    constructor() {
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "resolvers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "closed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    push(value) {
-        if (this.closed) {
-            throw new Error("Pushing to a closed queue");
-        }
-        const resolve = this.resolvers.shift();
-        if (resolve) {
-            resolve({ value, done: false });
-        }
-        else {
-            this.queue.push(value);
-        }
-    }
-    close() {
-        while (this.resolvers.length) {
-            const resolve = this.resolvers.shift();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            resolve?.({ value: undefined, done: true });
-        }
-        this.closed = true;
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    return Promise.resolve({
-                        value: this.queue.shift(),
-                        done: false,
-                    });
-                }
-                else if (this.closed) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                else {
-                    return new Promise((resolve) => {
-                        this.resolvers.push(resolve);
-                    });
-                }
-            },
-        };
-    }
-}
-exports.AsyncQueue = AsyncQueue;

package/event-source/AsyncQueue.d.ts

@@ -1,8 +0,0 @@
-export declare class AsyncQueue<T> implements AsyncIterable<T> {
-    private queue;
-    private resolvers;
-    private closed;
-    push(value: T): void;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}

package/event-source/AsyncQueue.js

@@ -1,63 +0,0 @@
-export class AsyncQueue {
-    constructor() {
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "resolvers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "closed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    push(value) {
-        if (this.closed) {
-            throw new Error("Pushing to a closed queue");
-        }
-        const resolve = this.resolvers.shift();
-        if (resolve) {
-            resolve({ value, done: false });
-        }
-        else {
-            this.queue.push(value);
-        }
-    }
-    close() {
-        while (this.resolvers.length) {
-            const resolve = this.resolvers.shift();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            resolve?.({ value: undefined, done: true });
-        }
-        this.closed = true;
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    return Promise.resolve({
-                        value: this.queue.shift(),
-                        done: false,
-                    });
-                }
-                else if (this.closed) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                else {
-                    return new Promise((resolve) => {
-                        this.resolvers.push(resolve);
-                    });
-                }
-            },
-        };
-    }
-}