modelfusion 0.0.44

package/util/SafeResult.d.ts

@@ -0,0 +1,8 @@
+export type SafeResult<OUTPUT> = {
+    ok: true;
+    output: OUTPUT;
+} | {
+    ok: false;
+    isAborted?: boolean;
+    error?: unknown;
+};

package/util/SafeResult.js

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

package/util/api/AbortError.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortError = void 0;
+class AbortError extends Error {
+    constructor(message = "Aborted") {
+        super(message);
+    }
+}
+exports.AbortError = AbortError;

package/util/api/AbortError.d.ts

@@ -0,0 +1,3 @@
+export declare class AbortError extends Error {
+    constructor(message?: string);
+}

package/util/api/AbortError.js

@@ -0,0 +1,5 @@
+export class AbortError extends Error {
+    constructor(message = "Aborted") {
+        super(message);
+    }
+}

package/util/api/ApiCallError.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiCallError = void 0;
+class ApiCallError extends Error {
+    constructor({ message, url, requestBodyValues, statusCode, cause, isRetryable = statusCode === 429 || statusCode >= 500, }) {
+        super(message);
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requestBodyValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isRetryable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ApiCallError";
+        this.url = url;
+        this.requestBodyValues = requestBodyValues;
+        this.statusCode = statusCode;
+        this.cause = cause;
+        this.isRetryable = isRetryable;
+    }
+}
+exports.ApiCallError = ApiCallError;

package/util/api/ApiCallError.d.ts

@@ -0,0 +1,15 @@
+export declare class ApiCallError extends Error {
+    readonly url: string;
+    readonly requestBodyValues: unknown;
+    readonly statusCode: number;
+    readonly cause?: unknown;
+    readonly isRetryable: boolean;
+    constructor({ message, url, requestBodyValues, statusCode, cause, isRetryable, }: {
+        message: string;
+        url: string;
+        requestBodyValues: unknown;
+        statusCode: number;
+        cause?: unknown;
+        isRetryable?: boolean;
+    });
+}

package/util/api/ApiCallError.js

@@ -0,0 +1,41 @@
+export class ApiCallError extends Error {
+    constructor({ message, url, requestBodyValues, statusCode, cause, isRetryable = statusCode === 429 || statusCode >= 500, }) {
+        super(message);
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requestBodyValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isRetryable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ApiCallError";
+        this.url = url;
+        this.requestBodyValues = requestBodyValues;
+        this.statusCode = statusCode;
+        this.cause = cause;
+        this.isRetryable = isRetryable;
+    }
+}

package/util/api/RetryError.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryError = void 0;
+class RetryError extends Error {
+    constructor({ message, reason, errors, }) {
+        super(message);
+        Object.defineProperty(this, "errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "RetryError";
+        this.reason = reason;
+        this.errors = errors;
+    }
+}
+exports.RetryError = RetryError;

package/util/api/RetryError.d.ts

@@ -0,0 +1,10 @@
+export type RetryErrorReason = "maxTriesExceeded" | "errorNotRetryable" | "abort";
+export declare class RetryError extends Error {
+    readonly errors: Array<unknown>;
+    readonly reason: RetryErrorReason;
+    constructor({ message, reason, errors, }: {
+        message: string;
+        reason: RetryErrorReason;
+        errors: Array<unknown>;
+    });
+}

package/util/api/RetryError.js

@@ -0,0 +1,20 @@
+export class RetryError extends Error {
+    constructor({ message, reason, errors, }) {
+        super(message);
+        Object.defineProperty(this, "errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "RetryError";
+        this.reason = reason;
+        this.errors = errors;
+    }
+}

package/util/api/RetryFunction.cjs

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

package/util/api/RetryFunction.d.ts

@@ -0,0 +1 @@
+export type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;

package/util/api/RetryFunction.js

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

package/util/api/ThrottleFunction.cjs

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

package/util/api/ThrottleFunction.d.ts

@@ -0,0 +1 @@
+export type ThrottleFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;

package/util/api/ThrottleFunction.js

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

package/util/api/callWithRetryAndThrottle.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callWithRetryAndThrottle = void 0;
+const retryWithExponentialBackoff_js_1 = require("./retryWithExponentialBackoff.cjs");
+const throttleUnlimitedConcurrency_js_1 = require("./throttleUnlimitedConcurrency.cjs");
+const callWithRetryAndThrottle = async ({ retry = (0, retryWithExponentialBackoff_js_1.retryWithExponentialBackoff)(), throttle = (0, throttleUnlimitedConcurrency_js_1.throttleUnlimitedConcurrency)(), call, }) => retry(async () => throttle(call));
+exports.callWithRetryAndThrottle = callWithRetryAndThrottle;

package/util/api/callWithRetryAndThrottle.d.ts

@@ -0,0 +1,7 @@
+import { RetryFunction } from "./RetryFunction.js";
+import { ThrottleFunction } from "./ThrottleFunction.js";
+export declare const callWithRetryAndThrottle: <OUTPUT>({ retry, throttle, call, }: {
+    retry?: RetryFunction | undefined;
+    throttle?: ThrottleFunction | undefined;
+    call: () => PromiseLike<OUTPUT>;
+}) => Promise<OUTPUT>;

package/util/api/callWithRetryAndThrottle.js

@@ -0,0 +1,3 @@
+import { retryWithExponentialBackoff } from "./retryWithExponentialBackoff.js";
+import { throttleUnlimitedConcurrency } from "./throttleUnlimitedConcurrency.js";
+export const callWithRetryAndThrottle = async ({ retry = retryWithExponentialBackoff(), throttle = throttleUnlimitedConcurrency(), call, }) => retry(async () => throttle(call));

package/util/api/postToApi.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postToApi = exports.postJsonToApi = exports.createTextResponseHandler = exports.createJsonResponseHandler = void 0;
+const ApiCallError_js_1 = require("./ApiCallError.cjs");
+const createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
+    const parsedResult = responseSchema.safeParse(await response.json());
+    if (!parsedResult.success) {
+        throw new ApiCallError_js_1.ApiCallError({
+            message: "Invalid JSON response",
+            cause: parsedResult.error,
+            statusCode: response.status,
+            url,
+            requestBodyValues,
+        });
+    }
+    return parsedResult.data;
+};
+exports.createJsonResponseHandler = createJsonResponseHandler;
+const createTextResponseHandler = () => async ({ response }) => response.text();
+exports.createTextResponseHandler = createTextResponseHandler;
+const postJsonToApi = async ({ url, apiKey, body, failedResponseHandler, successfulResponseHandler, abortSignal, }) => (0, exports.postToApi)({
+    url,
+    apiKey,
+    contentType: "application/json",
+    body: {
+        content: JSON.stringify(body),
+        values: body,
+    },
+    failedResponseHandler,
+    successfulResponseHandler,
+    abortSignal,
+});
+exports.postJsonToApi = postJsonToApi;
+const postToApi = async ({ url, apiKey, contentType, body, successfulResponseHandler, failedResponseHandler, abortSignal, }) => {
+    try {
+        const headers = {};
+        if (apiKey !== undefined) {
+            headers["Authorization"] = `Bearer ${apiKey}`;
+        }
+        if (contentType !== null) {
+            headers["Content-Type"] = contentType;
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: body.content,
+            signal: abortSignal,
+        });
+        if (!response.ok) {
+            try {
+                throw await failedResponseHandler({
+                    response,
+                    url,
+                    requestBodyValues: body.values,
+                });
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (error.name === "AbortError" || error instanceof ApiCallError_js_1.ApiCallError) {
+                        throw error;
+                    }
+                }
+                throw new ApiCallError_js_1.ApiCallError({
+                    message: "Failed to process error response",
+                    cause: error,
+                    statusCode: response.status,
+                    url,
+                    requestBodyValues: body.values,
+                });
+            }
+        }
+        try {
+            return await successfulResponseHandler({
+                response,
+                url,
+                requestBodyValues: body.values,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === "AbortError" || error instanceof ApiCallError_js_1.ApiCallError) {
+                    throw error;
+                }
+            }
+            throw new ApiCallError_js_1.ApiCallError({
+                message: "Failed to process successful response",
+                cause: error,
+                statusCode: response.status,
+                url,
+                requestBodyValues: body.values,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "AbortError") {
+                throw error;
+            }
+        }
+        throw error;
+    }
+};
+exports.postToApi = postToApi;

package/util/api/postToApi.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { ApiCallError } from "./ApiCallError.js";
+export type ResponseHandler<T> = (options: {
+    url: string;
+    requestBodyValues: unknown;
+    response: Response;
+}) => PromiseLike<T>;
+export declare const createJsonResponseHandler: <T>(responseSchema: z.ZodType<T, z.ZodTypeDef, T>) => ResponseHandler<T>;
+export declare const createTextResponseHandler: () => ResponseHandler<string>;
+export declare const postJsonToApi: <T>({ url, apiKey, body, failedResponseHandler, successfulResponseHandler, abortSignal, }: {
+    url: string;
+    apiKey?: string | undefined;
+    body: unknown;
+    failedResponseHandler: ResponseHandler<ApiCallError>;
+    successfulResponseHandler: ResponseHandler<T>;
+    abortSignal?: AbortSignal | undefined;
+}) => Promise<T>;
+export declare const postToApi: <T>({ url, apiKey, contentType, body, successfulResponseHandler, failedResponseHandler, abortSignal, }: {
+    url: string;
+    apiKey?: string | undefined;
+    contentType: string | null;
+    body: {
+        content: string | FormData;
+        values: unknown;
+    };
+    failedResponseHandler: ResponseHandler<Error>;
+    successfulResponseHandler: ResponseHandler<T>;
+    abortSignal?: AbortSignal | undefined;
+}) => Promise<T>;

package/util/api/postToApi.js

@@ -0,0 +1,96 @@
+import { ApiCallError } from "./ApiCallError.js";
+export const createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
+    const parsedResult = responseSchema.safeParse(await response.json());
+    if (!parsedResult.success) {
+        throw new ApiCallError({
+            message: "Invalid JSON response",
+            cause: parsedResult.error,
+            statusCode: response.status,
+            url,
+            requestBodyValues,
+        });
+    }
+    return parsedResult.data;
+};
+export const createTextResponseHandler = () => async ({ response }) => response.text();
+export const postJsonToApi = async ({ url, apiKey, body, failedResponseHandler, successfulResponseHandler, abortSignal, }) => postToApi({
+    url,
+    apiKey,
+    contentType: "application/json",
+    body: {
+        content: JSON.stringify(body),
+        values: body,
+    },
+    failedResponseHandler,
+    successfulResponseHandler,
+    abortSignal,
+});
+export const postToApi = async ({ url, apiKey, contentType, body, successfulResponseHandler, failedResponseHandler, abortSignal, }) => {
+    try {
+        const headers = {};
+        if (apiKey !== undefined) {
+            headers["Authorization"] = `Bearer ${apiKey}`;
+        }
+        if (contentType !== null) {
+            headers["Content-Type"] = contentType;
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: body.content,
+            signal: abortSignal,
+        });
+        if (!response.ok) {
+            try {
+                throw await failedResponseHandler({
+                    response,
+                    url,
+                    requestBodyValues: body.values,
+                });
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (error.name === "AbortError" || error instanceof ApiCallError) {
+                        throw error;
+                    }
+                }
+                throw new ApiCallError({
+                    message: "Failed to process error response",
+                    cause: error,
+                    statusCode: response.status,
+                    url,
+                    requestBodyValues: body.values,
+                });
+            }
+        }
+        try {
+            return await successfulResponseHandler({
+                response,
+                url,
+                requestBodyValues: body.values,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === "AbortError" || error instanceof ApiCallError) {
+                    throw error;
+                }
+            }
+            throw new ApiCallError({
+                message: "Failed to process successful response",
+                cause: error,
+                statusCode: response.status,
+                url,
+                requestBodyValues: body.values,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "AbortError") {
+                throw error;
+            }
+        }
+        throw error;
+    }
+};

package/util/api/retryNever.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryNever = void 0;
+/**
+ * The `retryNever` strategy never retries a failed API call.
+ */
+const retryNever = () => async (f) => f();
+exports.retryNever = retryNever;

package/util/api/retryNever.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The `retryNever` strategy never retries a failed API call.
+ */
+export declare const retryNever: () => <OUTPUT>(f: () => PromiseLike<OUTPUT>) => Promise<OUTPUT>;

package/util/api/retryNever.js

@@ -0,0 +1,4 @@
+/**
+ * The `retryNever` strategy never retries a failed API call.
+ */
+export const retryNever = () => async (f) => f();

package/util/api/retryWithExponentialBackoff.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryWithExponentialBackoff = void 0;
+const ApiCallError_js_1 = require("./ApiCallError.cjs");
+const RetryError_js_1 = require("./RetryError.cjs");
+/**
+ * The `retryWithExponentialBackoff` strategy retries a failed API call with an exponential backoff.
+ * You can configure the maximum number of tries, the initial delay, and the backoff factor.
+ */
+const retryWithExponentialBackoff = ({ maxTries = 3, initialDelayInMs = 2000, backoffFactor = 2, } = {}) => async (f) => _retryWithExponentialBackoff(f, {
+    maxTries,
+    delay: initialDelayInMs,
+    backoffFactor,
+});
+exports.retryWithExponentialBackoff = retryWithExponentialBackoff;
+async function _retryWithExponentialBackoff(f, { maxTries, delay, backoffFactor, }, errors = []) {
+    try {
+        return await f();
+    }
+    catch (error) {
+        const newErrors = [...errors, error];
+        const tryNumber = newErrors.length;
+        if (tryNumber > maxTries) {
+            throw new RetryError_js_1.RetryError({
+                message: `Failed after ${tryNumber} tries.`,
+                reason: "maxTriesExceeded",
+                errors: newErrors,
+            });
+        }
+        if (error instanceof Error) {
+            if (error.name === "AbortError") {
+                throw error;
+            }
+            if (error instanceof ApiCallError_js_1.ApiCallError &&
+                error.isRetryable &&
+                tryNumber < maxTries) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return _retryWithExponentialBackoff(f, { maxTries, delay: backoffFactor * delay, backoffFactor }, newErrors);
+            }
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new RetryError_js_1.RetryError({
+            message: `Failed after ${tryNumber} attempt(s) with non-retryable error: '${errorMessage}'`,
+            reason: "errorNotRetryable",
+            errors: newErrors,
+        });
+    }
+}

package/util/api/retryWithExponentialBackoff.d.ts

@@ -0,0 +1,10 @@
+import { RetryFunction } from "./RetryFunction.js";
+/**
+ * The `retryWithExponentialBackoff` strategy retries a failed API call with an exponential backoff.
+ * You can configure the maximum number of tries, the initial delay, and the backoff factor.
+ */
+export declare const retryWithExponentialBackoff: ({ maxTries, initialDelayInMs, backoffFactor, }?: {
+    maxTries?: number | undefined;
+    initialDelayInMs?: number | undefined;
+    backoffFactor?: number | undefined;
+}) => RetryFunction;

package/util/api/retryWithExponentialBackoff.js

@@ -0,0 +1,44 @@
+import { ApiCallError } from "./ApiCallError.js";
+import { RetryError } from "./RetryError.js";
+/**
+ * The `retryWithExponentialBackoff` strategy retries a failed API call with an exponential backoff.
+ * You can configure the maximum number of tries, the initial delay, and the backoff factor.
+ */
+export const retryWithExponentialBackoff = ({ maxTries = 3, initialDelayInMs = 2000, backoffFactor = 2, } = {}) => async (f) => _retryWithExponentialBackoff(f, {
+    maxTries,
+    delay: initialDelayInMs,
+    backoffFactor,
+});
+async function _retryWithExponentialBackoff(f, { maxTries, delay, backoffFactor, }, errors = []) {
+    try {
+        return await f();
+    }
+    catch (error) {
+        const newErrors = [...errors, error];
+        const tryNumber = newErrors.length;
+        if (tryNumber > maxTries) {
+            throw new RetryError({
+                message: `Failed after ${tryNumber} tries.`,
+                reason: "maxTriesExceeded",
+                errors: newErrors,
+            });
+        }
+        if (error instanceof Error) {
+            if (error.name === "AbortError") {
+                throw error;
+            }
+            if (error instanceof ApiCallError &&
+                error.isRetryable &&
+                tryNumber < maxTries) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return _retryWithExponentialBackoff(f, { maxTries, delay: backoffFactor * delay, backoffFactor }, newErrors);
+            }
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new RetryError({
+            message: `Failed after ${tryNumber} attempt(s) with non-retryable error: '${errorMessage}'`,
+            reason: "errorNotRetryable",
+            errors: newErrors,
+        });
+    }
+}

package/util/api/throttleMaxConcurrency.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttleMaxConcurrency = void 0;
+class MaxConcurrencyThrottler {
+    constructor({ maxConcurrentCalls }) {
+        Object.defineProperty(this, "maxConcurrentCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeCallCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxConcurrentCalls = maxConcurrentCalls;
+        this.activeCallCount = 0;
+        this.callQueue = [];
+    }
+    async run(fn) {
+        return new Promise((resolve, reject) => {
+            const tryExecute = async () => {
+                if (this.activeCallCount >= this.maxConcurrentCalls)
+                    return;
+                // mark as active and remove from queue:
+                this.activeCallCount++;
+                const idx = this.callQueue.indexOf(tryExecute);
+                if (idx !== -1)
+                    this.callQueue.splice(idx, 1);
+                try {
+                    resolve(await fn());
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    this.activeCallCount--;
+                    if (this.callQueue.length > 0) {
+                        this.callQueue[0]();
+                    }
+                }
+            };
+            this.callQueue.push(tryExecute);
+            if (this.activeCallCount < this.maxConcurrentCalls) {
+                tryExecute();
+            }
+        });
+    }
+}
+/**
+ * The `throttleMaxConcurrency` strategy limits the number of parallel API calls.
+ */
+function throttleMaxConcurrency({ maxConcurrentCalls, }) {
+    const throttler = new MaxConcurrencyThrottler({ maxConcurrentCalls });
+    return (fn) => throttler.run(fn);
+}
+exports.throttleMaxConcurrency = throttleMaxConcurrency;