modelfusion 0.106.0 → 0.108.0

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

@@ -0,0 +1,199 @@
+import { z } from "zod";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { ResponseHandler } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationFinishReason } from "../../model-function/generate-text/TextGenerationResult.js";
+export interface AbstractOpenAICompletionModelSettings extends TextGenerationModelSettings {
+    api?: ApiConfiguration;
+    model: string;
+    suffix?: string;
+    temperature?: number;
+    topP?: number;
+    logprobs?: number;
+    echo?: boolean;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    bestOf?: number;
+    logitBias?: Record<number, number>;
+    seed?: number | null;
+    isUserIdForwardingEnabled?: boolean;
+}
+/**
+ * Abstract completion model that calls an API that is compatible with the OpenAI completions API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ */
+export declare abstract class AbstractOpenAICompletionModel<SETTINGS extends AbstractOpenAICompletionModelSettings> extends AbstractModel<SETTINGS> {
+    constructor(settings: SETTINGS);
+    callAPI<RESULT>(prompt: string, options: {
+        responseFormat: OpenAITextResponseFormatType<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
+    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            object: "text_completion";
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            model: string;
+            id: string;
+            created: number;
+            choices: {
+                text: string;
+                index: number;
+                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+                logprobs?: any;
+            }[];
+            system_fingerprint?: string | undefined;
+        };
+        textGenerationResults: {
+            finishReason: TextGenerationFinishReason;
+            text: string;
+        }[];
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+    private translateFinishReason;
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
+        object: "text_completion";
+        model: string;
+        id: string;
+        created: number;
+        choices: {
+            text: string;
+            index: number;
+            finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+        }[];
+        system_fingerprint?: string | undefined;
+    }>>>;
+    extractTextDelta(delta: unknown): string | undefined;
+}
+declare const OpenAICompletionResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        finish_reason: z.ZodNullable<z.ZodOptional<z.ZodEnum<["stop", "length", "content_filter"]>>>;
+        index: z.ZodNumber;
+        logprobs: z.ZodNullable<z.ZodAny>;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        index: number;
+        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+        logprobs?: any;
+    }, {
+        text: string;
+        index: number;
+        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+        logprobs?: any;
+    }>, "many">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    system_fingerprint: z.ZodOptional<z.ZodString>;
+    object: z.ZodLiteral<"text_completion">;
+    usage: z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }, {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    object: "text_completion";
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        text: string;
+        index: number;
+        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+        logprobs?: any;
+    }[];
+    system_fingerprint?: string | undefined;
+}, {
+    object: "text_completion";
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        text: string;
+        index: number;
+        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+        logprobs?: any;
+    }[];
+    system_fingerprint?: string | undefined;
+}>;
+export type OpenAICompletionResponse = z.infer<typeof OpenAICompletionResponseSchema>;
+export type OpenAITextResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const OpenAITextResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: boolean;
+        handler: ResponseHandler<{
+            object: "text_completion";
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            model: string;
+            id: string;
+            created: number;
+            choices: {
+                text: string;
+                index: number;
+                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+                logprobs?: any;
+            }[];
+            system_fingerprint?: string | undefined;
+        }>;
+    };
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: boolean;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<import("../../index.js").Delta<{
+            object: "text_completion";
+            model: string;
+            id: string;
+            created: number;
+            choices: {
+                text: string;
+                index: number;
+                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
+            }[];
+            system_fingerprint?: string | undefined;
+        }>>>;
+    };
+};
+export {};

package/model-provider/openai/AbstractOpenAICompletionModel.js

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { createEventSourceResponseHandler } from "../../util/streaming/createEventSourceResponseHandler.js";
+import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
+import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
+/**
+ * Abstract completion model that calls an API that is compatible with the OpenAI completions API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ */
+export class AbstractOpenAICompletionModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+    }
+    async callAPI(prompt, options) {
+        const api = this.settings.api ?? new OpenAIApiConfiguration();
+        const user = this.settings.isUserIdForwardingEnabled
+            ? options.run?.userId
+            : undefined;
+        const abortSignal = options.run?.abortSignal;
+        const openaiResponseFormat = options.responseFormat;
+        // empty arrays are not allowed for stop:
+        const stopSequences = this.settings.stopSequences != null &&
+            Array.isArray(this.settings.stopSequences) &&
+            this.settings.stopSequences.length === 0
+            ? undefined
+            : this.settings.stopSequences;
+        return callWithRetryAndThrottle({
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => {
+                return postJsonToApi({
+                    url: api.assembleUrl("/completions"),
+                    headers: api.headers,
+                    body: {
+                        stream: openaiResponseFormat.stream,
+                        model: this.settings.model,
+                        prompt,
+                        suffix: this.settings.suffix,
+                        max_tokens: this.settings.maxGenerationTokens,
+                        temperature: this.settings.temperature,
+                        top_p: this.settings.topP,
+                        n: this.settings.numberOfGenerations,
+                        logprobs: this.settings.logprobs,
+                        echo: this.settings.echo,
+                        stop: stopSequences,
+                        seed: this.settings.seed,
+                        presence_penalty: this.settings.presencePenalty,
+                        frequency_penalty: this.settings.frequencyPenalty,
+                        best_of: this.settings.bestOf,
+                        logit_bias: this.settings.logitBias,
+                        user,
+                    },
+                    failedResponseHandler: failedOpenAICallResponseHandler,
+                    successfulResponseHandler: openaiResponseFormat.handler,
+                    abortSignal,
+                });
+            },
+        });
+    }
+    async doGenerateTexts(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: OpenAITextResponseFormat.json,
+        });
+        return {
+            response,
+            textGenerationResults: response.choices.map((choice) => {
+                return {
+                    finishReason: this.translateFinishReason(choice.finish_reason),
+                    text: choice.text,
+                };
+            }),
+            usage: {
+                promptTokens: response.usage.prompt_tokens,
+                completionTokens: response.usage.completion_tokens,
+                totalTokens: response.usage.total_tokens,
+            },
+        };
+    }
+    translateFinishReason(finishReason) {
+        switch (finishReason) {
+            case "stop":
+                return "stop";
+            case "length":
+                return "length";
+            case "content_filter":
+                return "content-filter";
+            default:
+                return "unknown";
+        }
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: OpenAITextResponseFormat.deltaIterable,
+        });
+    }
+    extractTextDelta(delta) {
+        const chunk = delta;
+        const firstChoice = chunk.choices[0];
+        if (firstChoice.index > 0) {
+            return undefined;
+        }
+        return chunk.choices[0].text;
+    }
+}
+const OpenAICompletionResponseSchema = z.object({
+    id: z.string(),
+    choices: z.array(z.object({
+        finish_reason: z
+            .enum(["stop", "length", "content_filter"])
+            .optional()
+            .nullable(),
+        index: z.number(),
+        logprobs: z.nullable(z.any()),
+        text: z.string(),
+    })),
+    created: z.number(),
+    model: z.string(),
+    system_fingerprint: z.string().optional(),
+    object: z.literal("text_completion"),
+    usage: z.object({
+        prompt_tokens: z.number(),
+        completion_tokens: z.number(),
+        total_tokens: z.number(),
+    }),
+});
+const openaiCompletionStreamChunkSchema = zodSchema(z.object({
+    choices: z.array(z.object({
+        text: z.string(),
+        finish_reason: z
+            .enum(["stop", "length", "content_filter"])
+            .optional()
+            .nullable(),
+        index: z.number(),
+    })),
+    created: z.number(),
+    id: z.string(),
+    model: z.string(),
+    system_fingerprint: z.string().optional(),
+    object: z.literal("text_completion"),
+}));
+export const OpenAITextResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(OpenAICompletionResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: createEventSourceResponseHandler(openaiCompletionStreamChunkSchema),
+    },
+};

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

@@ -47,8 +47,8 @@ OpenAIChatSettings> {
             object: "chat.completion";
             usage: {
                 prompt_tokens: number;
-                total_tokens: number;
                 completion_tokens: number;
+                total_tokens: number;
             };
             model: string;
             id: string;
@@ -111,8 +111,6 @@ OpenAIChatSettings> {
             finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
         }[];
         system_fingerprint?: string | null | undefined;
-    } | {
-        object: string;
     }>>>;
     extractStructureTextDelta(delta: unknown): string | undefined;
     parseAccumulatedStructureText(accumulatedText: string): unknown;

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

@@ -1,11 +1,11 @@
 import { StructureFromTextPromptTemplate } from "../../model-function/generate-structure/StructureFromTextPromptTemplate.js";
 import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
 import { PromptTemplateFullTextModel } from "../../model-function/generate-text/PromptTemplateFullTextModel.js";
-import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
 import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
 import { ToolCallGenerationModel } from "../../tool/generate-tool-call/ToolCallGenerationModel.js";
 import { ToolCallsOrTextGenerationModel } from "../../tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
-import { AbstractOpenAIChatCallSettings, AbstractOpenAIChatModel, OpenAIChatPrompt, OpenAIChatResponse } from "./AbstractOpenAIChatModel.js";
+import { AbstractOpenAIChatModel, AbstractOpenAIChatSettings, OpenAIChatPrompt, OpenAIChatResponse } from "./AbstractOpenAIChatModel.js";
 import { OpenAIChatFunctionCallStructureGenerationModel } from "./OpenAIChatFunctionCallStructureGenerationModel.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 export declare const OPENAI_CHAT_MODELS: {
@@ -102,12 +102,9 @@ export declare const calculateOpenAIChatCostInMillicents: ({ model, response, }:
     model: OpenAIChatModelType;
     response: OpenAIChatResponse;
 }) => number | null;
-export interface OpenAIChatCallSettings extends AbstractOpenAIChatCallSettings {
+export interface OpenAIChatSettings extends AbstractOpenAIChatSettings {
     model: OpenAIChatModelType;
 }
-export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<OpenAIChatCallSettings, "stop" | "maxTokens"> {
-    isUserIdForwardingEnabled?: boolean;
-}
 /**
  * Create a text generation model that calls the OpenAI chat API.
  *

package/model-provider/openai/OpenAICompletionModel.cjs

@@ -1,18 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAITextResponseFormat = exports.OpenAICompletionModel = exports.calculateOpenAICompletionCostInMillicents = exports.isOpenAICompletionModel = exports.getOpenAICompletionModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS = void 0;
-const zod_1 = require("zod");
-const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
-const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+exports.OpenAICompletionModel = exports.calculateOpenAICompletionCostInMillicents = exports.isOpenAICompletionModel = exports.getOpenAICompletionModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS = void 0;
 const PromptTemplateTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptTemplateTextStreamingModel.cjs");
 const TextGenerationModel_js_1 = require("../../model-function/generate-text/TextGenerationModel.cjs");
 const TextPromptTemplate_js_1 = require("../../model-function/generate-text/prompt-template/TextPromptTemplate.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
-const createEventSourceResponseHandler_js_1 = require("../../util/streaming/createEventSourceResponseHandler.cjs");
-const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
-const OpenAIError_js_1 = require("./OpenAIError.cjs");
+const AbstractOpenAICompletionModel_js_1 = require("./AbstractOpenAICompletionModel.cjs");
 const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
 /**
  * @see https://platform.openai.com/docs/models/
@@ -145,9 +138,9 @@ exports.calculateOpenAICompletionCostInMillicents = calculateOpenAICompletionCos
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
+class OpenAICompletionModel extends AbstractOpenAICompletionModel_js_1.AbstractOpenAICompletionModel {
     constructor(settings) {
-        super({ settings });
+        super(settings);
         Object.defineProperty(this, "provider", {
             enumerable: true,
             configurable: true,
@@ -178,52 +171,6 @@ class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
     async countPromptTokens(input) {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
-    async callAPI(prompt, options) {
-        const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
-        const user = this.settings.isUserIdForwardingEnabled
-            ? options.run?.userId
-            : undefined;
-        const abortSignal = options.run?.abortSignal;
-        const openaiResponseFormat = options.responseFormat;
-        // empty arrays are not allowed for stop:
-        const stopSequences = this.settings.stopSequences != null &&
-            Array.isArray(this.settings.stopSequences) &&
-            this.settings.stopSequences.length === 0
-            ? undefined
-            : this.settings.stopSequences;
-        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: api.retry,
-            throttle: api.throttle,
-            call: async () => {
-                return (0, postToApi_js_1.postJsonToApi)({
-                    url: api.assembleUrl("/completions"),
-                    headers: api.headers,
-                    body: {
-                        stream: openaiResponseFormat.stream,
-                        model: this.settings.model,
-                        prompt,
-                        suffix: this.settings.suffix,
-                        max_tokens: this.settings.maxGenerationTokens,
-                        temperature: this.settings.temperature,
-                        top_p: this.settings.topP,
-                        n: this.settings.numberOfGenerations,
-                        logprobs: this.settings.logprobs,
-                        echo: this.settings.echo,
-                        stop: stopSequences,
-                        seed: this.settings.seed,
-                        presence_penalty: this.settings.presencePenalty,
-                        frequency_penalty: this.settings.frequencyPenalty,
-                        best_of: this.settings.bestOf,
-                        logit_bias: this.settings.logitBias,
-                        user,
-                    },
-                    failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
-                    successfulResponseHandler: openaiResponseFormat.handler,
-                    abortSignal,
-                });
-            },
-        });
-    }
     get settingsForEvent() {
         const eventSettingProperties = [
             ...TextGenerationModel_js_1.textGenerationModelProperties,
@@ -240,52 +187,6 @@ class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateTexts(prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
-            responseFormat: exports.OpenAITextResponseFormat.json,
-        });
-        return {
-            response,
-            textGenerationResults: response.choices.map((choice) => {
-                return {
-                    finishReason: this.translateFinishReason(choice.finish_reason),
-                    text: choice.text,
-                };
-            }),
-            usage: {
-                promptTokens: response.usage.prompt_tokens,
-                completionTokens: response.usage.completion_tokens,
-                totalTokens: response.usage.total_tokens,
-            },
-        };
-    }
-    translateFinishReason(finishReason) {
-        switch (finishReason) {
-            case "stop":
-                return "stop";
-            case "length":
-                return "length";
-            case "content_filter":
-                return "content-filter";
-            default:
-                return "unknown";
-        }
-    }
-    doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
-            responseFormat: exports.OpenAITextResponseFormat.deltaIterable,
-        });
-    }
-    extractTextDelta(delta) {
-        const chunk = delta;
-        const firstChoice = chunk.choices[0];
-        if (firstChoice.index > 0) {
-            return undefined;
-        }
-        return chunk.choices[0].text;
-    }
     /**
      * Returns this model with an instruction prompt template.
      */
@@ -314,56 +215,3 @@ class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
     }
 }
 exports.OpenAICompletionModel = OpenAICompletionModel;
-const OpenAICompletionResponseSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    choices: zod_1.z.array(zod_1.z.object({
-        finish_reason: zod_1.z
-            .enum(["stop", "length", "content_filter"])
-            .optional()
-            .nullable(),
-        index: zod_1.z.number(),
-        logprobs: zod_1.z.nullable(zod_1.z.any()),
-        text: zod_1.z.string(),
-    })),
-    created: zod_1.z.number(),
-    model: zod_1.z.string(),
-    system_fingerprint: zod_1.z.string().optional(),
-    object: zod_1.z.literal("text_completion"),
-    usage: zod_1.z.object({
-        prompt_tokens: zod_1.z.number(),
-        completion_tokens: zod_1.z.number(),
-        total_tokens: zod_1.z.number(),
-    }),
-});
-const openaiCompletionStreamChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({
-    choices: zod_1.z.array(zod_1.z.object({
-        text: zod_1.z.string(),
-        finish_reason: zod_1.z
-            .enum(["stop", "length", "content_filter"])
-            .optional()
-            .nullable(),
-        index: zod_1.z.number(),
-    })),
-    created: zod_1.z.number(),
-    id: zod_1.z.string(),
-    model: zod_1.z.string(),
-    system_fingerprint: zod_1.z.string().optional(),
-    object: zod_1.z.literal("text_completion"),
-}));
-exports.OpenAITextResponseFormat = {
-    /**
-     * Returns the response as a JSON object.
-     */
-    json: {
-        stream: false,
-        handler: (0, postToApi_js_1.createJsonResponseHandler)(OpenAICompletionResponseSchema),
-    },
-    /**
-     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
-     * of the response stream.
-     */
-    deltaIterable: {
-        stream: true,
-        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)(openaiCompletionStreamChunkSchema),
-    },
-};