modelfusion 0.0.44

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

@@ -0,0 +1,279 @@
+import z from "zod";
+import { AbstractModel } from "../../../model-function/AbstractModel.js";
+import { PromptMappingTextGenerationModel } from "../../../prompt/PromptMappingTextGenerationModel.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";
+import { createOpenAIChatFullDeltaIterableQueue, } from "./OpenAIChatStreamIterable.js";
+import { countOpenAIChatPromptTokens } from "./countOpenAIChatMessageTokens.js";
+/*
+ * Available OpenAI chat models, their token limits, and pricing.
+ *
+ * @see https://platform.openai.com/docs/models/
+ * @see https://openai.com/pricing
+ */
+export const 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,
+    },
+};
+export const isOpenAIChatModel = (model) => model in OPENAI_CHAT_MODELS;
+export const calculateOpenAIChatCostInMillicents = ({ model, response, }) => response.usage.prompt_tokens *
+    OPENAI_CHAT_MODELS[model].promptTokenCostInMillicents +
+    response.usage.completion_tokens *
+        OPENAI_CHAT_MODELS[model].completionTokenCostInMillicents;
+/**
+ * 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 class OpenAIChatModel extends 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({ model: this.settings.model });
+        this.contextWindowSize =
+            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 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 callWithRetryAndThrottle({
+            retry: callSettings.retry,
+            throttle: callSettings.throttle,
+            call: async () => callOpenAIChatCompletionAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: OpenAIChatResponseFormat.json,
+        });
+    }
+    extractText(response) {
+        return response.choices[0].message.content;
+    }
+    generateDeltaStreamResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: 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: OpenAIChatResponseFormat.json,
+            functionId: options?.functionId,
+            settings: settingsWithFunctionCall,
+            run: options?.run,
+        });
+    }
+    mapPrompt(promptMapping) {
+        return new 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 });
+    }
+}
+const openAIChatResponseSchema = z.object({
+    id: z.string(),
+    object: z.literal("chat.completion"),
+    created: z.number(),
+    model: z.string(),
+    choices: z.array(z.object({
+        message: z.object({
+            role: z.literal("assistant"),
+            content: z.string().nullable(),
+            function_call: z
+                .object({
+                name: z.string(),
+                arguments: z.string(),
+            })
+                .optional(),
+        }),
+        index: z.number(),
+        logprobs: z.nullable(z.any()),
+        finish_reason: z.string(),
+    })),
+    usage: z.object({
+        prompt_tokens: z.number(),
+        completion_tokens: z.number(),
+        total_tokens: z.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 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: failedOpenAICallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+export const OpenAIChatResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(openAIChatResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the text deltas (only the tex different of the first choice).
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createOpenAIChatFullDeltaIterableQueue(response.body),
+    },
+};

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

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIChatAutoFunctionPrompt = exports.OpenAIChatSingleFunctionPrompt = exports.OpenAIChatFunctionPrompt = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+exports.OpenAIChatFunctionPrompt = {
+    forOpenAIFunctionDescription(options) {
+        return new OpenAIChatSingleFunctionPrompt(options);
+    },
+    forSchema({ messages, schemaDefinition, }) {
+        return this.forOpenAIFunctionDescription({
+            messages,
+            fn: {
+                name: schemaDefinition.name,
+                description: schemaDefinition.description,
+                parameters: schemaDefinition.schema,
+            },
+        });
+    },
+    forSchemaCurried(messages) {
+        return (schemaDefinition) => this.forSchema({
+            messages,
+            schemaDefinition,
+        });
+    },
+    forTool({ messages, tool, }) {
+        return this.forSchema({
+            messages,
+            schemaDefinition: tool.inputSchemaDefinition,
+        });
+    },
+    forToolCurried(messages) {
+        return (tool) => this.forTool({ messages, tool });
+    },
+    forOpenAIFunctionDescriptions(options) {
+        return new OpenAIChatAutoFunctionPrompt(options);
+    },
+    forSchemas({ messages, schemaDefinitions, }) {
+        return this.forOpenAIFunctionDescriptions({
+            messages,
+            fns: schemaDefinitions.map((schemaDefinition) => ({
+                name: schemaDefinition.name,
+                description: schemaDefinition.description,
+                parameters: schemaDefinition.schema,
+            })),
+        });
+    },
+    forSchemasCurried(messages) {
+        return (schemaDefinitions) => this.forSchemas({ messages, schemaDefinitions });
+    },
+    forTools({ messages, tools, }) {
+        return this.forSchemas({
+            messages,
+            schemaDefinitions: tools.map((tool) => tool.inputSchemaDefinition),
+        });
+    },
+    forToolsCurried(messages) {
+        return (tools) => this.forTools({ messages, tools });
+    },
+};
+class OpenAIChatSingleFunctionPrompt {
+    constructor({ messages, fn, }) {
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.messages = messages;
+        this.fn = fn;
+    }
+    extractJson(response) {
+        const jsonText = response.choices[0].message.function_call.arguments;
+        return secure_json_parse_1.default.parse(jsonText);
+    }
+    get functionCall() {
+        return { name: this.fn.name };
+    }
+    get functions() {
+        return [
+            {
+                name: this.fn.name,
+                description: this.fn.description,
+                parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(this.fn.parameters),
+            },
+        ];
+    }
+}
+exports.OpenAIChatSingleFunctionPrompt = OpenAIChatSingleFunctionPrompt;
+class OpenAIChatAutoFunctionPrompt {
+    constructor({ messages, fns, }) {
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.messages = messages;
+        this.fns = fns;
+    }
+    extractJsonAndText(response) {
+        const message = response.choices[0].message;
+        const content = message.content;
+        const functionCall = message.function_call;
+        return functionCall == null
+            ? {
+                schema: null,
+                value: null,
+                text: content ?? "",
+            }
+            : {
+                schema: functionCall.name,
+                value: secure_json_parse_1.default.parse(functionCall.arguments),
+                text: content,
+            };
+    }
+    get functionCall() {
+        return "auto";
+    }
+    get functions() {
+        return this.fns.map((fn) => ({
+            name: fn.name,
+            description: fn.description,
+            parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(fn.parameters),
+        }));
+    }
+}
+exports.OpenAIChatAutoFunctionPrompt = OpenAIChatAutoFunctionPrompt;

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

@@ -0,0 +1,108 @@
+import z from "zod";
+import { Tool } from "../../../composed-function/use-tool/Tool.js";
+import { GenerateJsonPrompt } from "../../../model-function/generate-json/GenerateJsonModel.js";
+import { GenerateJsonOrTextPrompt } from "../../../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { SchemaDefinition } from "../../../model-function/generate-json/SchemaDefinition.js";
+import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
+import { OpenAIChatResponse } from "./OpenAIChatModel.js";
+export type OpenAIFunctionDescription<T> = {
+    name: string;
+    description?: string;
+    parameters: z.Schema<T>;
+};
+export declare const OpenAIChatFunctionPrompt: {
+    forOpenAIFunctionDescription<T>(options: {
+        messages: OpenAIChatMessage[];
+        fn: OpenAIFunctionDescription<T>;
+    }): OpenAIChatSingleFunctionPrompt<T>;
+    forSchema<STRUCTURE>({ messages, schemaDefinition, }: {
+        messages: OpenAIChatMessage[];
+        schemaDefinition: SchemaDefinition<any, STRUCTURE>;
+    }): OpenAIChatSingleFunctionPrompt<STRUCTURE>;
+    forSchemaCurried<STRUCTURE_1>(messages: OpenAIChatMessage[]): (schemaDefinition: SchemaDefinition<any, STRUCTURE_1>) => OpenAIChatSingleFunctionPrompt<STRUCTURE_1>;
+    forTool<INPUT, OUTPUT>({ messages, tool, }: {
+        messages: OpenAIChatMessage[];
+        tool: Tool<any, INPUT, OUTPUT>;
+    }): OpenAIChatSingleFunctionPrompt<INPUT>;
+    forToolCurried<INPUT_1, OUTPUT_1>(messages: OpenAIChatMessage[]): (tool: Tool<any, INPUT_1, OUTPUT_1>) => OpenAIChatSingleFunctionPrompt<INPUT_1>;
+    forOpenAIFunctionDescriptions<FUNCTIONS extends OpenAIFunctionDescription<any>[]>(options: {
+        messages: OpenAIChatMessage[];
+        fns: FUNCTIONS;
+    }): OpenAIChatAutoFunctionPrompt<FUNCTIONS>;
+    forSchemas<SCHEMAS extends SchemaDefinition<any, any>[]>({ messages, schemaDefinitions, }: {
+        messages: OpenAIChatMessage[];
+        schemaDefinitions: SCHEMAS;
+    }): OpenAIChatAutoFunctionPrompt<{
+        name: any;
+        description: string | undefined;
+        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+    }[]>;
+    forSchemasCurried<SCHEMAS_1 extends SchemaDefinition<any, any>[]>(messages: OpenAIChatMessage[]): (schemaDefinitions: SCHEMAS_1) => OpenAIChatAutoFunctionPrompt<{
+        name: any;
+        description: string | undefined;
+        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+    }[]>;
+    forTools<TOOLS extends Tool<any, any, any>[]>({ messages, tools, }: {
+        messages: OpenAIChatMessage[];
+        tools: TOOLS;
+    }): OpenAIChatAutoFunctionPrompt<{
+        name: any;
+        description: string | undefined;
+        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+    }[]>;
+    forToolsCurried<TOOLS_1 extends Tool<any, any, any>[]>(messages: OpenAIChatMessage[]): (tools: TOOLS_1) => OpenAIChatAutoFunctionPrompt<{
+        name: any;
+        description: string | undefined;
+        parameters: z.ZodType<any, z.ZodTypeDef, any>;
+    }[]>;
+};
+export declare class OpenAIChatSingleFunctionPrompt<T> implements GenerateJsonPrompt<OpenAIChatResponse> {
+    readonly messages: OpenAIChatMessage[];
+    readonly fn: OpenAIFunctionDescription<T>;
+    constructor({ messages, fn, }: {
+        messages: OpenAIChatMessage[];
+        fn: OpenAIFunctionDescription<T>;
+    });
+    extractJson(response: OpenAIChatResponse): any;
+    get functionCall(): {
+        name: string;
+    };
+    get functions(): {
+        name: string;
+        description: string | undefined;
+        parameters: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type;
+            } | undefined;
+        };
+    }[];
+}
+export declare class OpenAIChatAutoFunctionPrompt<FUNCTIONS extends Array<OpenAIFunctionDescription<any>>> implements GenerateJsonOrTextPrompt<OpenAIChatResponse> {
+    readonly messages: OpenAIChatMessage[];
+    readonly fns: FUNCTIONS;
+    constructor({ messages, fns, }: {
+        messages: OpenAIChatMessage[];
+        fns: FUNCTIONS;
+    });
+    extractJsonAndText(response: OpenAIChatResponse): {
+        schema: null;
+        value: null;
+        text: string;
+    } | {
+        schema: string;
+        value: any;
+        text: string | null;
+    };
+    get functionCall(): "auto";
+    get functions(): {
+        name: string;
+        description: string | undefined;
+        parameters: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type;
+            } | undefined;
+        };
+    }[];
+}

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

@@ -0,0 +1,135 @@
+import SecureJSON from "secure-json-parse";
+import { zodToJsonSchema } from "zod-to-json-schema";
+export const OpenAIChatFunctionPrompt = {
+    forOpenAIFunctionDescription(options) {
+        return new OpenAIChatSingleFunctionPrompt(options);
+    },
+    forSchema({ messages, schemaDefinition, }) {
+        return this.forOpenAIFunctionDescription({
+            messages,
+            fn: {
+                name: schemaDefinition.name,
+                description: schemaDefinition.description,
+                parameters: schemaDefinition.schema,
+            },
+        });
+    },
+    forSchemaCurried(messages) {
+        return (schemaDefinition) => this.forSchema({
+            messages,
+            schemaDefinition,
+        });
+    },
+    forTool({ messages, tool, }) {
+        return this.forSchema({
+            messages,
+            schemaDefinition: tool.inputSchemaDefinition,
+        });
+    },
+    forToolCurried(messages) {
+        return (tool) => this.forTool({ messages, tool });
+    },
+    forOpenAIFunctionDescriptions(options) {
+        return new OpenAIChatAutoFunctionPrompt(options);
+    },
+    forSchemas({ messages, schemaDefinitions, }) {
+        return this.forOpenAIFunctionDescriptions({
+            messages,
+            fns: schemaDefinitions.map((schemaDefinition) => ({
+                name: schemaDefinition.name,
+                description: schemaDefinition.description,
+                parameters: schemaDefinition.schema,
+            })),
+        });
+    },
+    forSchemasCurried(messages) {
+        return (schemaDefinitions) => this.forSchemas({ messages, schemaDefinitions });
+    },
+    forTools({ messages, tools, }) {
+        return this.forSchemas({
+            messages,
+            schemaDefinitions: tools.map((tool) => tool.inputSchemaDefinition),
+        });
+    },
+    forToolsCurried(messages) {
+        return (tools) => this.forTools({ messages, tools });
+    },
+};
+export class OpenAIChatSingleFunctionPrompt {
+    constructor({ messages, fn, }) {
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.messages = messages;
+        this.fn = fn;
+    }
+    extractJson(response) {
+        const jsonText = response.choices[0].message.function_call.arguments;
+        return SecureJSON.parse(jsonText);
+    }
+    get functionCall() {
+        return { name: this.fn.name };
+    }
+    get functions() {
+        return [
+            {
+                name: this.fn.name,
+                description: this.fn.description,
+                parameters: zodToJsonSchema(this.fn.parameters),
+            },
+        ];
+    }
+}
+export class OpenAIChatAutoFunctionPrompt {
+    constructor({ messages, fns, }) {
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.messages = messages;
+        this.fns = fns;
+    }
+    extractJsonAndText(response) {
+        const message = response.choices[0].message;
+        const content = message.content;
+        const functionCall = message.function_call;
+        return functionCall == null
+            ? {
+                schema: null,
+                value: null,
+                text: content ?? "",
+            }
+            : {
+                schema: functionCall.name,
+                value: SecureJSON.parse(functionCall.arguments),
+                text: content,
+            };
+    }
+    get functionCall() {
+        return "auto";
+    }
+    get functions() {
+        return this.fns.map((fn) => ({
+            name: fn.name,
+            description: fn.description,
+            parameters: zodToJsonSchema(fn.parameters),
+        }));
+    }
+}