modelfusion 0.133.0 → 0.135.0

package/core/api/retryWithExponentialBackoff.js

@@ -1,46 +0,0 @@
-import { delay } from "../../util/delay.js";
-import { getErrorMessage } from "../../util/getErrorMessage.js";
-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,
-    delayInMs: initialDelayInMs,
-    backoffFactor,
-});
-async function _retryWithExponentialBackoff(f, { maxTries, delayInMs, backoffFactor, }, errors = []) {
-    try {
-        return await f();
-    }
-    catch (error) {
-        const errorMessage = getErrorMessage(error);
-        const newErrors = [...errors, error];
-        const tryNumber = newErrors.length;
-        if (tryNumber >= maxTries) {
-            throw new RetryError({
-                message: `Failed after ${tryNumber} tries. Last error: ${errorMessage}`,
-                reason: "maxTriesExceeded",
-                errors: newErrors,
-            });
-        }
-        if (error instanceof Error) {
-            if (error.name === "AbortError") {
-                throw error;
-            }
-            if (error instanceof ApiCallError &&
-                error.isRetryable &&
-                tryNumber < maxTries) {
-                await delay(delayInMs);
-                return _retryWithExponentialBackoff(f, { maxTries, delayInMs: backoffFactor * delayInMs, backoffFactor }, newErrors);
-            }
-        }
-        throw new RetryError({
-            message: `Failed after ${tryNumber} attempt(s) with non-retryable error: '${errorMessage}'`,
-            reason: "errorNotRetryable",
-            errors: newErrors,
-        });
-    }
-}

package/core/api/throttleMaxConcurrency.cjs

@@ -1,65 +0,0 @@
-"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;

package/core/api/throttleMaxConcurrency.d.ts

@@ -1,7 +0,0 @@
-import { ThrottleFunction } from "./ThrottleFunction.js";
-/**
- * The `throttleMaxConcurrency` strategy limits the number of parallel API calls.
- */
-export declare function throttleMaxConcurrency({ maxConcurrentCalls, }: {
-    maxConcurrentCalls: number;
-}): ThrottleFunction;

package/core/api/throttleMaxConcurrency.js

@@ -1,61 +0,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.
- */
-export function throttleMaxConcurrency({ maxConcurrentCalls, }) {
-    const throttler = new MaxConcurrencyThrottler({ maxConcurrentCalls });
-    return (fn) => throttler.run(fn);
-}

package/core/api/throttleOff.cjs

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.throttleOff = void 0;
-/**
- * The `throttleOff` strategy does not limit parallel API calls.
- */
-const throttleOff = () => (fn) => fn();
-exports.throttleOff = throttleOff;

package/core/api/throttleOff.d.ts

@@ -1,5 +0,0 @@
-import { ThrottleFunction } from "./ThrottleFunction.js";
-/**
- * The `throttleOff` strategy does not limit parallel API calls.
- */
-export declare const throttleOff: () => ThrottleFunction;

package/core/api/throttleOff.js

@@ -1,4 +0,0 @@
-/**
- * The `throttleOff` strategy does not limit parallel API calls.
- */
-export const throttleOff = () => (fn) => fn();

package/core/cache/Cache.cjs

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

package/core/cache/Cache.d.ts

@@ -1,12 +0,0 @@
-export interface Cache {
-    lookupValue(key: {
-        functionType: string;
-        functionId?: string | undefined;
-        input: unknown;
-    }): Promise<object | null>;
-    storeValue(key: {
-        functionType: string;
-        functionId?: string | undefined;
-        input: unknown;
-    }, value: unknown): Promise<void>;
-}

package/core/cache/Cache.js

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

package/core/cache/MemoryCache.cjs

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryCache = void 0;
-class MemoryCache {
-    constructor() {
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    hashKey(key) {
-        return JSON.stringify(key);
-    }
-    async lookupValue(key) {
-        return this.cache.get(this.hashKey(key)) ?? null;
-    }
-    async storeValue(key, value) {
-        this.cache.set(this.hashKey(key), value);
-    }
-}
-exports.MemoryCache = MemoryCache;

package/core/cache/MemoryCache.d.ts

@@ -1,15 +0,0 @@
-import { Cache } from "./Cache.js";
-export declare class MemoryCache implements Cache {
-    private readonly cache;
-    private hashKey;
-    lookupValue(key: {
-        functionType: string;
-        functionId?: string | undefined;
-        input: unknown;
-    }): Promise<object | null>;
-    storeValue(key: {
-        functionType: string;
-        functionId?: string | undefined;
-        input: unknown;
-    }, value: unknown): Promise<void>;
-}

package/core/cache/MemoryCache.js

@@ -1,19 +0,0 @@
-export class MemoryCache {
-    constructor() {
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    hashKey(key) {
-        return JSON.stringify(key);
-    }
-    async lookupValue(key) {
-        return this.cache.get(this.hashKey(key)) ?? null;
-    }
-    async storeValue(key, value) {
-        this.cache.set(this.hashKey(key), value);
-    }
-}

package/core/cache/index.cjs

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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("./Cache.cjs"), exports);
-__exportStar(require("./MemoryCache.cjs"), exports);

package/core/cache/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./Cache.js";
-export * from "./MemoryCache.js";

package/core/cache/index.js

@@ -1,2 +0,0 @@
-export * from "./Cache.js";
-export * from "./MemoryCache.js";

package/core/executeFunction.cjs

@@ -1,13 +0,0 @@
-"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, options),
-    });
-}
-exports.executeFunction = executeFunction;

package/core/executeFunction.d.ts

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

package/core/executeFunction.js

@@ -1,9 +0,0 @@
-import { executeFunctionCall } from "./executeFunctionCall.js";
-export async function executeFunction(fn, input, options) {
-    return executeFunctionCall({
-        options,
-        input,
-        functionType: "execute-function",
-        execute: async (options) => fn(input, options),
-    });
-}

package/core/executeFunctionCall.cjs

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeFunctionCall = void 0;
-const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("./FunctionEventSource.cjs");
-const ModelFusionConfiguration_js_1 = require("./ModelFusionConfiguration.cjs");
-const ModelFusionConfiguration_js_2 = require("./ModelFusionConfiguration.cjs");
-const AbortError_js_1 = require("./api/AbortError.cjs");
-const getFunctionCallLogger_js_1 = require("./getFunctionCallLogger.cjs");
-const getRun_js_1 = require("./getRun.cjs");
-const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
-const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeFunctionCall({ options, input, functionType, execute, inputPropertyName = "input", outputPropertyName = "value", }) {
-    const run = await (0, getRun_js_1.getRun)(options?.run);
-    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
-        observers: [
-            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, ModelFusionConfiguration_js_1.getLogFormat)()),
-            ...(0, ModelFusionConfiguration_js_2.getFunctionObservers)(),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
-        functionType,
-        callId: `call-${(0, nanoid_1.nanoid)()}`,
-        parentCallId: options?.callId,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        [inputPropertyName]: input,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await (0, runSafe_js_1.runSafe)(() => execute({
-        functionType,
-        functionId: options?.functionId,
-        callId: startMetadata.callId,
-        logging: options?.logging,
-        observers: options?.observers,
-        run,
-    }));
-    const finishMetadata = {
-        eventType: "finished",
-        ...startMetadata,
-        finishTimestamp: new Date(),
-        durationInMs: durationMeasurement.durationInMs,
-    };
-    if (!result.ok) {
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError_js_1.AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    eventSource.notify({
-        ...finishMetadata,
-        eventType: "finished",
-        result: {
-            status: "success",
-            [outputPropertyName]: result.value,
-        },
-    });
-    return result.value;
-}
-exports.executeFunctionCall = executeFunctionCall;

package/core/executeFunctionCall.d.ts

@@ -1,10 +0,0 @@
-import { FunctionCallOptions, FunctionOptions } from "./FunctionOptions.js";
-import { FunctionEvent } from "./FunctionEvent.js";
-export declare function executeFunctionCall<VALUE>({ options, input, functionType, execute, inputPropertyName, outputPropertyName, }: {
-    options?: FunctionOptions;
-    input: unknown;
-    functionType: FunctionEvent["functionType"];
-    execute: (options: FunctionCallOptions) => PromiseLike<VALUE>;
-    inputPropertyName?: string;
-    outputPropertyName?: string;
-}): Promise<VALUE>;

package/core/executeFunctionCall.js

@@ -1,82 +0,0 @@
-import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "./FunctionEventSource.js";
-import { getLogFormat } from "./ModelFusionConfiguration.js";
-import { getFunctionObservers } from "./ModelFusionConfiguration.js";
-import { AbortError } from "./api/AbortError.js";
-import { getFunctionCallLogger } from "./getFunctionCallLogger.js";
-import { getRun } from "./getRun.js";
-import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { runSafe } from "../util/runSafe.js";
-export async function executeFunctionCall({ options, input, functionType, execute, inputPropertyName = "input", outputPropertyName = "value", }) {
-    const run = await getRun(options?.run);
-    const eventSource = new FunctionEventSource({
-        observers: [
-            ...getFunctionCallLogger(options?.logging ?? getLogFormat()),
-            ...getFunctionObservers(),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = startDurationMeasurement();
-    const startMetadata = {
-        functionType,
-        callId: `call-${createId()}`,
-        parentCallId: options?.callId,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        [inputPropertyName]: input,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await runSafe(() => execute({
-        functionType,
-        functionId: options?.functionId,
-        callId: startMetadata.callId,
-        logging: options?.logging,
-        observers: options?.observers,
-        run,
-    }));
-    const finishMetadata = {
-        eventType: "finished",
-        ...startMetadata,
-        finishTimestamp: new Date(),
-        durationInMs: durationMeasurement.durationInMs,
-    };
-    if (!result.ok) {
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    eventSource.notify({
-        ...finishMetadata,
-        eventType: "finished",
-        result: {
-            status: "success",
-            [outputPropertyName]: result.value,
-        },
-    });
-    return result.value;
-}

package/core/getFunctionCallLogger.cjs

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionCallLogger = void 0;
-function getFunctionCallLogger(logging) {
-    switch (logging) {
-        case "basic-text":
-            return [basicTextObserver];
-        case "detailed-object":
-            return [detailedObjectObserver];
-        case "detailed-json":
-            return [detailedJsonObserver];
-        case "off":
-        default:
-            return [];
-    }
-}
-exports.getFunctionCallLogger = getFunctionCallLogger;
-const basicTextObserver = {
-    onFunctionEvent(event) {
-        const text = `[${event.timestamp.toISOString()}] ${event.callId}${event.functionId != null ? ` (${event.functionId})` : ""} - ${event.functionType} ${event.eventType}`;
-        // log based on event type:
-        switch (event.eventType) {
-            case "started": {
-                console.log(text);
-                break;
-            }
-            case "finished": {
-                console.log(`${text} in ${event.durationInMs}ms`);
-                break;
-            }
-        }
-    },
-};
-const detailedObjectObserver = {
-    onFunctionEvent(event) {
-        // Remove the "response" property from the result (if any):
-        if (event.eventType === "finished" &&
-            event.result != null &&
-            "rawResponse" in event.result &&
-            event.result?.rawResponse != null) {
-            event = {
-                ...event,
-                result: Object.fromEntries(Object.entries(event.result).filter(([k]) => k !== "rawResponse")
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ),
-            };
-        }
-        // filter all hard-to-read properties from event for cleaner console output:
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        function cleanObject(obj) {
-            if (obj instanceof Date || typeof obj === "string") {
-                return obj;
-            }
-            if (Array.isArray(obj)) {
-                return obj.map((item) => cleanObject(item));
-            }
-            if (obj !== null && typeof obj === "object") {
-                return Object.fromEntries(Object.entries(obj)
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    .map(([k, v]) => {
-                    if (v === undefined) {
-                        return [k, undefined];
-                    }
-                    else if (v instanceof Uint8Array) {
-                        return [k, "omitted<Uint8Array>"];
-                    }
-                    else if (Array.isArray(v) &&
-                        v.length > 20 &&
-                        v.every((v) => typeof v === "number")) {
-                        return [k, "omitted<Array<number>>"];
-                    }
-                    else {
-                        return [k, cleanObject(v)];
-                    }
-                })
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    .filter(([_, v]) => v !== undefined));
-            }
-            return obj;
-        }
-        // Clean the event object
-        const cleanedEvent = cleanObject(event);
-        console.log(cleanedEvent);
-    },
-};
-const detailedJsonObserver = {
-    onFunctionEvent(event) {
-        // Remove the "response" property from the result (if any):
-        if (event.eventType === "finished" &&
-            event.result != null &&
-            "rawResponse" in event.result &&
-            event.result?.rawResponse != null) {
-            event = {
-                ...event,
-                result: Object.fromEntries(Object.entries(event.result).filter(([k]) => k !== "rawResponse")
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ),
-            };
-        }
-        // filter all undefined properties from event for cleaner console output:
-        event = Object.fromEntries(
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        Object.entries(event).filter(([_, v]) => v !== undefined));
-        console.log(JSON.stringify(event));
-    },
-};

package/core/getFunctionCallLogger.d.ts

@@ -1,3 +0,0 @@
-import { FunctionOptions } from "./FunctionOptions.js";
-import { FunctionObserver } from "./FunctionObserver.js";
-export declare function getFunctionCallLogger(logging: FunctionOptions["logging"]): Array<FunctionObserver>;