modelfusion 0.0.44

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

@@ -0,0 +1,288 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIChatResponseFormat = exports.OpenAIChatModel = exports.calculateOpenAIChatCostInMillicents = exports.isOpenAIChatModel = exports.OPENAI_CHAT_MODELS = void 0;
+const zod_1 = __importDefault(require("zod"));
+const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
+const PromptMappingTextGenerationModel_js_1 = require("../../../prompt/PromptMappingTextGenerationModel.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");
+const OpenAIChatStreamIterable_js_1 = require("./OpenAIChatStreamIterable.cjs");
+const countOpenAIChatMessageTokens_js_1 = require("./countOpenAIChatMessageTokens.cjs");
+/*
+ * Available OpenAI chat models, their token limits, and pricing.
+ *
+ * @see https://platform.openai.com/docs/models/
+ * @see https://openai.com/pricing
+ */
+exports.OPENAI_CHAT_MODELS = {
+    "gpt-4": {
+        contextWindowSize: 8192,
+        promptTokenCostInMillicents: 3,
+        completionTokenCostInMillicents: 6,
+    },
+    "gpt-4-0314": {
+        contextWindowSize: 8192,
+        promptTokenCostInMillicents: 3,
+        completionTokenCostInMillicents: 6,
+    },
+    "gpt-4-0613": {
+        contextWindowSize: 8192,
+        promptTokenCostInMillicents: 3,
+        completionTokenCostInMillicents: 6,
+    },
+    "gpt-4-32k": {
+        contextWindowSize: 32768,
+        promptTokenCostInMillicents: 6,
+        completionTokenCostInMillicents: 12,
+    },
+    "gpt-4-32k-0314": {
+        contextWindowSize: 32768,
+        promptTokenCostInMillicents: 6,
+        completionTokenCostInMillicents: 12,
+    },
+    "gpt-4-32k-0613": {
+        contextWindowSize: 32768,
+        promptTokenCostInMillicents: 6,
+        completionTokenCostInMillicents: 12,
+    },
+    "gpt-3.5-turbo": {
+        contextWindowSize: 4096,
+        promptTokenCostInMillicents: 0.15,
+        completionTokenCostInMillicents: 0.2,
+    },
+    "gpt-3.5-turbo-0301": {
+        contextWindowSize: 4096,
+        promptTokenCostInMillicents: 0.15,
+        completionTokenCostInMillicents: 0.2,
+    },
+    "gpt-3.5-turbo-0613": {
+        contextWindowSize: 4096,
+        promptTokenCostInMillicents: 0.15,
+        completionTokenCostInMillicents: 0.2,
+    },
+    "gpt-3.5-turbo-16k": {
+        contextWindowSize: 16384,
+        promptTokenCostInMillicents: 0.3,
+        completionTokenCostInMillicents: 0.4,
+    },
+    "gpt-3.5-turbo-16k-0613": {
+        contextWindowSize: 16384,
+        promptTokenCostInMillicents: 0.3,
+        completionTokenCostInMillicents: 0.4,
+    },
+};
+const isOpenAIChatModel = (model) => model in exports.OPENAI_CHAT_MODELS;
+exports.isOpenAIChatModel = isOpenAIChatModel;
+const calculateOpenAIChatCostInMillicents = ({ model, response, }) => response.usage.prompt_tokens *
+    exports.OPENAI_CHAT_MODELS[model].promptTokenCostInMillicents +
+    response.usage.completion_tokens *
+        exports.OPENAI_CHAT_MODELS[model].completionTokenCostInMillicents;
+exports.calculateOpenAIChatCostInMillicents = calculateOpenAIChatCostInMillicents;
+/**
+ * Create a text generation model that calls the OpenAI chat completion API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/chat/create
+ *
+ * @example
+ * const model = new OpenAIChatModel({
+ *   model: "gpt-3.5-turbo",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ * });
+ *
+ * const { text } = await generateText([
+ *   model,
+ *   OpenAIChatMessage.system(
+ *     "Write a short story about a robot learning to love:"
+ *   ),
+ * ]);
+ */
+class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({ model: this.settings.model });
+        this.contextWindowSize =
+            exports.OPENAI_CHAT_MODELS[this.settings.model].contextWindowSize;
+    }
+    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;
+    }
+    /**
+     * Counts the prompt tokens required for the messages. This includes the message base tokens
+     * and the prompt base tokens.
+     */
+    countPromptTokens(messages) {
+        return (0, countOpenAIChatMessageTokens_js_1.countOpenAIChatPromptTokens)({
+            messages,
+            model: this.modelName,
+        });
+    }
+    async callAPI(messages, options) {
+        const { run, settings, responseFormat } = options;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            messages,
+            responseFormat,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: callSettings.retry,
+            throttle: callSettings.throttle,
+            call: async () => callOpenAIChatCompletionAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.json,
+        });
+    }
+    extractText(response) {
+        return response.choices[0].message.content;
+    }
+    generateDeltaStreamResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
+        });
+    }
+    extractTextDelta(fullDelta) {
+        return fullDelta[0]?.delta.content ?? undefined;
+    }
+    /**
+     * JSON generation uses the OpenAI GPT function calling API.
+     * It provides a single function specification and instructs the model to provide parameters for calling the function.
+     * The result is returned as parsed JSON.
+     *
+     * @see https://platform.openai.com/docs/guides/gpt/function-calling
+     */
+    generateJsonResponse(prompt, options) {
+        const settingsWithFunctionCall = Object.assign({}, options, {
+            functionCall: prompt.functionCall,
+            functions: prompt.functions,
+        });
+        return this.callAPI(prompt.messages, {
+            responseFormat: exports.OpenAIChatResponseFormat.json,
+            functionId: options?.functionId,
+            settings: settingsWithFunctionCall,
+            run: options?.run,
+        });
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel_js_1.PromptMappingTextGenerationModel({
+            model: this.withStopTokens(promptMapping.stopTokens),
+            promptMapping,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAIChatModel(Object.assign({}, this.settings, additionalSettings));
+    }
+    get maxCompletionTokens() {
+        return this.settings.maxTokens;
+    }
+    withMaxCompletionTokens(maxCompletionTokens) {
+        return this.withSettings({ maxTokens: maxCompletionTokens });
+    }
+    withStopTokens(stopTokens) {
+        return this.withSettings({ stop: stopTokens });
+    }
+}
+exports.OpenAIChatModel = OpenAIChatModel;
+const openAIChatResponseSchema = zod_1.default.object({
+    id: zod_1.default.string(),
+    object: zod_1.default.literal("chat.completion"),
+    created: zod_1.default.number(),
+    model: zod_1.default.string(),
+    choices: zod_1.default.array(zod_1.default.object({
+        message: zod_1.default.object({
+            role: zod_1.default.literal("assistant"),
+            content: zod_1.default.string().nullable(),
+            function_call: zod_1.default
+                .object({
+                name: zod_1.default.string(),
+                arguments: zod_1.default.string(),
+            })
+                .optional(),
+        }),
+        index: zod_1.default.number(),
+        logprobs: zod_1.default.nullable(zod_1.default.any()),
+        finish_reason: zod_1.default.string(),
+    })),
+    usage: zod_1.default.object({
+        prompt_tokens: zod_1.default.number(),
+        completion_tokens: zod_1.default.number(),
+        total_tokens: zod_1.default.number(),
+    }),
+});
+async function callOpenAIChatCompletionAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, responseFormat, apiKey, model, messages, functions, functionCall, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, user, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/chat/completions`,
+        apiKey,
+        body: {
+            stream: responseFormat.stream,
+            model,
+            messages,
+            functions,
+            function_call: functionCall,
+            temperature,
+            top_p: topP,
+            n,
+            stop,
+            max_tokens: maxTokens,
+            presence_penalty: presencePenalty,
+            frequency_penalty: frequencyPenalty,
+            user,
+        },
+        failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+exports.OpenAIChatResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAIChatResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the text deltas (only the tex different of the first choice).
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatFullDeltaIterableQueue)(response.body),
+    },
+};

package/model-provider/openai/chat/OpenAIChatModel.d.ts

@@ -0,0 +1,344 @@
+import z from "zod";
+import { AbstractModel } from "../../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../../model-function/FunctionOptions.js";
+import { GenerateJsonOrTextModel } from "../../../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { DeltaEvent } from "../../../model-function/generate-text/DeltaEvent.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../../model-function/generate-text/TextGenerationModel.js";
+import { PromptMapping } from "../../../prompt/PromptMapping.js";
+import { PromptMappingTextGenerationModel } from "../../../prompt/PromptMappingTextGenerationModel.js";
+import { ResponseHandler } from "../../../util/api/postToApi.js";
+import { OpenAIModelSettings } from "../OpenAIModelSettings.js";
+import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
+import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
+import { OpenAIChatAutoFunctionPrompt, OpenAIChatSingleFunctionPrompt, OpenAIFunctionDescription } from "./OpenAIChatPrompt.js";
+import { OpenAIChatDelta } from "./OpenAIChatStreamIterable.js";
+export declare const OPENAI_CHAT_MODELS: {
+    "gpt-4": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-4-0314": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-4-0613": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-4-32k": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-4-32k-0314": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-4-32k-0613": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-3.5-turbo": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-3.5-turbo-0301": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-3.5-turbo-0613": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-3.5-turbo-16k": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+    "gpt-3.5-turbo-16k-0613": {
+        contextWindowSize: number;
+        promptTokenCostInMillicents: number;
+        completionTokenCostInMillicents: number;
+    };
+};
+export type OpenAIChatModelType = keyof typeof OPENAI_CHAT_MODELS;
+export declare const isOpenAIChatModel: (model: string) => model is "gpt-4" | "gpt-4-0314" | "gpt-4-0613" | "gpt-4-32k" | "gpt-4-32k-0314" | "gpt-4-32k-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0301" | "gpt-3.5-turbo-0613" | "gpt-3.5-turbo-16k" | "gpt-3.5-turbo-16k-0613";
+export declare const calculateOpenAIChatCostInMillicents: ({ model, response, }: {
+    model: OpenAIChatModelType;
+    response: OpenAIChatResponse;
+}) => number;
+export interface OpenAIChatCallSettings {
+    model: OpenAIChatModelType;
+    functions?: Array<{
+        name: string;
+        description?: string;
+        parameters: unknown;
+    }>;
+    functionCall?: "none" | "auto" | {
+        name: string;
+    };
+    temperature?: number;
+    topP?: number;
+    n?: number;
+    stop?: string | string[];
+    maxTokens?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+}
+export interface OpenAIChatSettings extends TextGenerationModelSettings, OpenAIModelSettings, OpenAIChatCallSettings {
+    isUserIdForwardingEnabled?: boolean;
+}
+/**
+ * Create a text generation model that calls the OpenAI chat completion API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/chat/create
+ *
+ * @example
+ * const model = new OpenAIChatModel({
+ *   model: "gpt-3.5-turbo",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ * });
+ *
+ * const { text } = await generateText([
+ *   model,
+ *   OpenAIChatMessage.system(
+ *     "Write a short story about a robot learning to love:"
+ *   ),
+ * ]);
+ */
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, GenerateJsonOrTextModel<OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, OpenAIChatResponse, OpenAIChatSettings> {
+    constructor(settings: OpenAIChatSettings);
+    readonly provider: "openai";
+    get modelName(): "gpt-4" | "gpt-4-0314" | "gpt-4-0613" | "gpt-4-32k" | "gpt-4-32k-0314" | "gpt-4-32k-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0301" | "gpt-3.5-turbo-0613" | "gpt-3.5-turbo-16k" | "gpt-3.5-turbo-16k-0613";
+    readonly contextWindowSize: number;
+    readonly tokenizer: TikTokenTokenizer;
+    private get apiKey();
+    /**
+     * Counts the prompt tokens required for the messages. This includes the message base tokens
+     * and the prompt base tokens.
+     */
+    countPromptTokens(messages: OpenAIChatMessage[]): Promise<number>;
+    callAPI<RESULT>(messages: Array<OpenAIChatMessage>, options: {
+        responseFormat: OpenAIChatResponseFormatType<RESULT>;
+    } & FunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
+        user?: string;
+    }>>): Promise<RESULT>;
+    generateTextResponse(prompt: OpenAIChatMessage[], options?: FunctionOptions<OpenAIChatSettings>): Promise<{
+        object: "chat.completion";
+        model: string;
+        id: string;
+        created: number;
+        usage: {
+            prompt_tokens: number;
+            total_tokens: number;
+            completion_tokens: number;
+        };
+        choices: {
+            message: {
+                content: string | null;
+                role: "assistant";
+                function_call?: {
+                    name: string;
+                    arguments: string;
+                } | undefined;
+            };
+            finish_reason: string;
+            index: number;
+            logprobs?: any;
+        }[];
+    }>;
+    extractText(response: OpenAIChatResponse): string;
+    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: FunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+    extractTextDelta(fullDelta: OpenAIChatDelta): string | undefined;
+    /**
+     * JSON generation uses the OpenAI GPT function calling API.
+     * It provides a single function specification and instructs the model to provide parameters for calling the function.
+     * The result is returned as parsed JSON.
+     *
+     * @see https://platform.openai.com/docs/guides/gpt/function-calling
+     */
+    generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: FunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
+    mapPrompt<INPUT_PROMPT>(promptMapping: PromptMapping<INPUT_PROMPT, OpenAIChatMessage[]>): PromptMappingTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
+    withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
+    get maxCompletionTokens(): number | undefined;
+    withMaxCompletionTokens(maxCompletionTokens: number): this;
+    withStopTokens(stopTokens: string[]): this;
+}
+declare const openAIChatResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"chat.completion">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        message: z.ZodObject<{
+            role: z.ZodLiteral<"assistant">;
+            content: z.ZodNullable<z.ZodString>;
+            function_call: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string;
+            }, {
+                name: string;
+                arguments: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            content: string | null;
+            role: "assistant";
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+        }, {
+            content: string | null;
+            role: "assistant";
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+        }>;
+        index: z.ZodNumber;
+        logprobs: z.ZodNullable<z.ZodAny>;
+        finish_reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: {
+            content: string | null;
+            role: "assistant";
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+        };
+        finish_reason: string;
+        index: number;
+        logprobs?: any;
+    }, {
+        message: {
+            content: string | null;
+            role: "assistant";
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+        };
+        finish_reason: string;
+        index: number;
+        logprobs?: any;
+    }>, "many">;
+    usage: z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        prompt_tokens: number;
+        total_tokens: number;
+        completion_tokens: number;
+    }, {
+        prompt_tokens: number;
+        total_tokens: number;
+        completion_tokens: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    object: "chat.completion";
+    model: string;
+    id: string;
+    created: number;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+        completion_tokens: number;
+    };
+    choices: {
+        message: {
+            content: string | null;
+            role: "assistant";
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+        };
+        finish_reason: string;
+        index: number;
+        logprobs?: any;
+    }[];
+}, {
+    object: "chat.completion";
+    model: string;
+    id: string;
+    created: number;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+        completion_tokens: number;
+    };
+    choices: {
+        message: {
+            content: string | null;
+            role: "assistant";
+            function_call?: {
+                name: string;
+                arguments: string;
+            } | undefined;
+        };
+        finish_reason: string;
+        index: number;
+        logprobs?: any;
+    }[];
+}>;
+export type OpenAIChatResponse = z.infer<typeof openAIChatResponseSchema>;
+export type OpenAIChatResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const OpenAIChatResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false;
+        handler: ResponseHandler<{
+            object: "chat.completion";
+            model: string;
+            id: string;
+            created: number;
+            usage: {
+                prompt_tokens: number;
+                total_tokens: number;
+                completion_tokens: number;
+            };
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        }>;
+    };
+    /**
+     * Returns an async iterable over the text deltas (only the tex different of the first choice).
+     */
+    deltaIterable: {
+        stream: true;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+    };
+};
+export {};