modelfusion 0.0.44

package/model-provider/openai/OpenAIImageGenerationModel.js

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
+/**
+ * @see https://openai.com/pricing
+ */
+const sizeToCostInMillicents = {
+    "1024x1024": 2000,
+    "512x512": 1800,
+    "256x256": 1600,
+};
+export const calculateOpenAIImageGenerationCostInMillicents = ({ settings, }) => (settings.n ?? 1) * sizeToCostInMillicents[settings.size ?? "1024x1024"];
+/**
+ * Create an image generation model that calls the OpenAI AI image creation API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/images/create
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new OpenAIImageGenerationModel({ size: "512x512" }),
+ *   "the wicked witch of the west in the style of early 19th century painting"
+ * );
+ */
+export class OpenAIImageGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.OPENAI_API_KEY;
+        if (apiKey == null) {
+            throw new Error(`OpenAI API key is missing. Pass it as an argument to the constructor or set it as an environment variable named OPENAI_API_KEY.`);
+        }
+        return apiKey;
+    }
+    async callAPI(prompt, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const responseFormat = options?.responseFormat;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            prompt,
+            responseFormat,
+        });
+        return callWithRetryAndThrottle({
+            retry: callSettings.retry,
+            throttle: callSettings.throttle,
+            call: async () => callOpenAIImageGenerationAPI(callSettings),
+        });
+    }
+    generateImageResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            responseFormat: OpenAIImageGenerationResponseFormat.base64Json,
+            functionId: options?.functionId,
+            settings: options?.settings,
+            run: options?.run,
+        });
+    }
+    extractBase64Image(response) {
+        return response.data[0].b64_json;
+    }
+    withSettings(additionalSettings) {
+        return new OpenAIImageGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const openAIImageGenerationUrlSchema = z.object({
+    created: z.number(),
+    data: z.array(z.object({
+        url: z.string(),
+    })),
+});
+const openAIImageGenerationBase64JsonSchema = z.object({
+    created: z.number(),
+    data: z.array(z.object({
+        b64_json: z.string(),
+    })),
+});
+export const OpenAIImageGenerationResponseFormat = {
+    url: {
+        type: "url",
+        handler: createJsonResponseHandler(openAIImageGenerationUrlSchema),
+    },
+    base64Json: {
+        type: "b64_json",
+        handler: createJsonResponseHandler(openAIImageGenerationBase64JsonSchema),
+    },
+};
+async function callOpenAIImageGenerationAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, apiKey, prompt, n, size, responseFormat, user, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/images/generations`,
+        apiKey,
+        body: {
+            prompt,
+            n,
+            size,
+            response_format: responseFormat.type,
+            user,
+        },
+        failedResponseHandler: failedOpenAICallResponseHandler,
+        successfulResponseHandler: responseFormat?.handler,
+        abortSignal,
+    });
+}

package/model-provider/openai/OpenAIModelSettings.cjs

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

package/model-provider/openai/OpenAIModelSettings.d.ts

@@ -0,0 +1,8 @@
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+export interface OpenAIModelSettings {
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+}

package/model-provider/openai/OpenAIModelSettings.js

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

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAITextEmbeddingModel = exports.calculateOpenAIEmbeddingCostInMillicents = exports.isOpenAIEmbeddingModel = exports.OPENAI_TEXT_EMBEDDING_MODELS = void 0;
+const zod_1 = __importDefault(require("zod"));
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const OpenAIError_js_1 = require("./OpenAIError.cjs");
+const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
+exports.OPENAI_TEXT_EMBEDDING_MODELS = {
+    "text-embedding-ada-002": {
+        contextWindowSize: 8192,
+        embeddingDimensions: 1536,
+        tokenCostInMillicents: 0.01,
+    },
+};
+const isOpenAIEmbeddingModel = (model) => model in exports.OPENAI_TEXT_EMBEDDING_MODELS;
+exports.isOpenAIEmbeddingModel = isOpenAIEmbeddingModel;
+const calculateOpenAIEmbeddingCostInMillicents = ({ model, responses, }) => {
+    let amountInMilliseconds = 0;
+    for (const response of responses) {
+        amountInMilliseconds +=
+            response.usage.total_tokens *
+                exports.OPENAI_TEXT_EMBEDDING_MODELS[model].tokenCostInMillicents;
+    }
+    return amountInMilliseconds;
+};
+exports.calculateOpenAIEmbeddingCostInMillicents = calculateOpenAIEmbeddingCostInMillicents;
+/**
+ * Create a text embedding model that calls the OpenAI embedding API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/embeddings
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new OpenAITextEmbeddingModel({ model: "text-embedding-ada-002" }),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+        Object.defineProperty(this, "maxTextsPerCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "embeddingDimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({ model: this.modelName });
+        this.contextWindowSize =
+            exports.OPENAI_TEXT_EMBEDDING_MODELS[this.modelName].contextWindowSize;
+        this.embeddingDimensions =
+            exports.OPENAI_TEXT_EMBEDDING_MODELS[this.modelName].embeddingDimensions;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.OPENAI_API_KEY;
+        if (apiKey == null) {
+            throw new Error(`OpenAI API key is missing. Pass it as an argument to the constructor or set it as an environment variable named OPENAI_API_KEY.`);
+        }
+        return apiKey;
+    }
+    async countTokens(input) {
+        return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
+    }
+    async callAPI(text, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            input: text,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callOpenAITextEmbeddingAPI(callSettings),
+        });
+    }
+    generateEmbeddingResponse(texts, options) {
+        if (texts.length > this.maxTextsPerCall) {
+            throw new Error(`The OpenAI embedding API only supports ${this.maxTextsPerCall} texts per API call.`);
+        }
+        return this.callAPI(texts[0], options);
+    }
+    extractEmbeddings(response) {
+        return [response.data[0].embedding];
+    }
+    withSettings(additionalSettings) {
+        return new OpenAITextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.OpenAITextEmbeddingModel = OpenAITextEmbeddingModel;
+const openAITextEmbeddingResponseSchema = zod_1.default.object({
+    object: zod_1.default.literal("list"),
+    data: zod_1.default
+        .array(zod_1.default.object({
+        object: zod_1.default.literal("embedding"),
+        embedding: zod_1.default.array(zod_1.default.number()),
+        index: zod_1.default.number(),
+    }))
+        .length(1),
+    model: zod_1.default.string(),
+    usage: zod_1.default.object({
+        prompt_tokens: zod_1.default.number(),
+        total_tokens: zod_1.default.number(),
+    }),
+});
+/**
+ * Call the OpenAI Embedding API to generate an embedding for the given input.
+ *
+ * @see https://platform.openai.com/docs/api-reference/embeddings
+ *
+ * @example
+ * const response = await callOpenAITextEmbeddingAPI({
+ *   apiKey: OPENAI_API_KEY,
+ *   model: "text-embedding-ada-002",
+ *   input: "At first, Nox didn't know what to do with the pup.",
+ * });
+ *
+ * console.log(response.data[0].embedding);
+ */
+async function callOpenAITextEmbeddingAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, apiKey, model, input, user, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/embeddings`,
+        apiKey,
+        body: {
+            model,
+            input,
+            user,
+        },
+        failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(openAITextEmbeddingResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/openai/OpenAITextEmbeddingModel.d.ts

@@ -0,0 +1,122 @@
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../../model-function/embed-text/TextEmbeddingModel.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
+export declare const OPENAI_TEXT_EMBEDDING_MODELS: {
+    "text-embedding-ada-002": {
+        contextWindowSize: number;
+        embeddingDimensions: number;
+        tokenCostInMillicents: number;
+    };
+};
+export type OpenAITextEmbeddingModelType = keyof typeof OPENAI_TEXT_EMBEDDING_MODELS;
+export declare const isOpenAIEmbeddingModel: (model: string) => model is "text-embedding-ada-002";
+export declare const calculateOpenAIEmbeddingCostInMillicents: ({ model, responses, }: {
+    model: OpenAITextEmbeddingModelType;
+    responses: OpenAITextEmbeddingResponse[];
+}) => number;
+export interface OpenAITextEmbeddingModelSettings extends TextEmbeddingModelSettings {
+    model: OpenAITextEmbeddingModelType;
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+    isUserIdForwardingEnabled?: boolean;
+}
+/**
+ * Create a text embedding model that calls the OpenAI embedding API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/embeddings
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new OpenAITextEmbeddingModel({ model: "text-embedding-ada-002" }),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEmbeddingModelSettings> implements TextEmbeddingModel<OpenAITextEmbeddingResponse, OpenAITextEmbeddingModelSettings> {
+    constructor(settings: OpenAITextEmbeddingModelSettings);
+    readonly provider: "openai";
+    get modelName(): "text-embedding-ada-002";
+    readonly maxTextsPerCall = 1;
+    readonly embeddingDimensions: number;
+    readonly tokenizer: TikTokenTokenizer;
+    readonly contextWindowSize: number;
+    private get apiKey();
+    countTokens(input: string): Promise<number>;
+    callAPI(text: string, options?: FunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
+        object: "list";
+        model: string;
+        data: {
+            object: "embedding";
+            embedding: number[];
+            index: number;
+        }[];
+        usage: {
+            prompt_tokens: number;
+            total_tokens: number;
+        };
+    }>;
+    extractEmbeddings(response: OpenAITextEmbeddingResponse): number[][];
+    withSettings(additionalSettings: OpenAITextEmbeddingModelSettings): this;
+}
+declare const openAITextEmbeddingResponseSchema: z.ZodObject<{
+    object: z.ZodLiteral<"list">;
+    data: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"embedding">;
+        embedding: z.ZodArray<z.ZodNumber, "many">;
+        index: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        object: "embedding";
+        embedding: number[];
+        index: number;
+    }, {
+        object: "embedding";
+        embedding: number[];
+        index: number;
+    }>, "many">;
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        prompt_tokens: number;
+        total_tokens: number;
+    }, {
+        prompt_tokens: number;
+        total_tokens: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    object: "list";
+    model: string;
+    data: {
+        object: "embedding";
+        embedding: number[];
+        index: number;
+    }[];
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}, {
+    object: "list";
+    model: string;
+    data: {
+        object: "embedding";
+        embedding: number[];
+        index: number;
+    }[];
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}>;
+export type OpenAITextEmbeddingResponse = z.infer<typeof openAITextEmbeddingResponseSchema>;
+export {};

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -0,0 +1,162 @@
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
+import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
+export const OPENAI_TEXT_EMBEDDING_MODELS = {
+    "text-embedding-ada-002": {
+        contextWindowSize: 8192,
+        embeddingDimensions: 1536,
+        tokenCostInMillicents: 0.01,
+    },
+};
+export const isOpenAIEmbeddingModel = (model) => model in OPENAI_TEXT_EMBEDDING_MODELS;
+export const calculateOpenAIEmbeddingCostInMillicents = ({ model, responses, }) => {
+    let amountInMilliseconds = 0;
+    for (const response of responses) {
+        amountInMilliseconds +=
+            response.usage.total_tokens *
+                OPENAI_TEXT_EMBEDDING_MODELS[model].tokenCostInMillicents;
+    }
+    return amountInMilliseconds;
+};
+/**
+ * Create a text embedding model that calls the OpenAI embedding API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/embeddings
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new OpenAITextEmbeddingModel({ model: "text-embedding-ada-002" }),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+export class OpenAITextEmbeddingModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+        Object.defineProperty(this, "maxTextsPerCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "embeddingDimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokenizer = new TikTokenTokenizer({ model: this.modelName });
+        this.contextWindowSize =
+            OPENAI_TEXT_EMBEDDING_MODELS[this.modelName].contextWindowSize;
+        this.embeddingDimensions =
+            OPENAI_TEXT_EMBEDDING_MODELS[this.modelName].embeddingDimensions;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.OPENAI_API_KEY;
+        if (apiKey == null) {
+            throw new Error(`OpenAI API key is missing. Pass it as an argument to the constructor or set it as an environment variable named OPENAI_API_KEY.`);
+        }
+        return apiKey;
+    }
+    async countTokens(input) {
+        return countTokens(this.tokenizer, input);
+    }
+    async callAPI(text, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            input: text,
+        });
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callOpenAITextEmbeddingAPI(callSettings),
+        });
+    }
+    generateEmbeddingResponse(texts, options) {
+        if (texts.length > this.maxTextsPerCall) {
+            throw new Error(`The OpenAI embedding API only supports ${this.maxTextsPerCall} texts per API call.`);
+        }
+        return this.callAPI(texts[0], options);
+    }
+    extractEmbeddings(response) {
+        return [response.data[0].embedding];
+    }
+    withSettings(additionalSettings) {
+        return new OpenAITextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const openAITextEmbeddingResponseSchema = z.object({
+    object: z.literal("list"),
+    data: z
+        .array(z.object({
+        object: z.literal("embedding"),
+        embedding: z.array(z.number()),
+        index: z.number(),
+    }))
+        .length(1),
+    model: z.string(),
+    usage: z.object({
+        prompt_tokens: z.number(),
+        total_tokens: z.number(),
+    }),
+});
+/**
+ * Call the OpenAI Embedding API to generate an embedding for the given input.
+ *
+ * @see https://platform.openai.com/docs/api-reference/embeddings
+ *
+ * @example
+ * const response = await callOpenAITextEmbeddingAPI({
+ *   apiKey: OPENAI_API_KEY,
+ *   model: "text-embedding-ada-002",
+ *   input: "At first, Nox didn't know what to do with the pup.",
+ * });
+ *
+ * console.log(response.data[0].embedding);
+ */
+async function callOpenAITextEmbeddingAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, apiKey, model, input, user, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/embeddings`,
+        apiKey,
+        body: {
+            model,
+            input,
+            user,
+        },
+        failedResponseHandler: failedOpenAICallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(openAITextEmbeddingResponseSchema),
+        abortSignal,
+    });
+}