modelfusion 0.40.0 → 0.41.0

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -1,8 +1,8 @@
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
@@ -83,37 +83,31 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
         return countTokens(this.tokenizer, input);
     }
     async callAPI(texts, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            input: texts,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITextEmbeddingAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITextEmbeddingAPI({
+                ...this.settings,
+                user: this.settings.isUserIdForwardingEnabled
+                    ? options?.run?.userId
+                    : undefined,
+                abortSignal: options?.run?.abortSignal,
+                input: texts,
+            }),
         });
     }
     get settingsForEvent() {
         return {};
     }
-    generateEmbeddingResponse(texts, options) {
+    async doEmbedValues(texts, options) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return response.data.map((data) => data.embedding);
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: response.data.map((data) => data.embedding),
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAITextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/openai/OpenAITextGenerationModel.cjs

@@ -12,7 +12,7 @@ const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
-const PromptFormatTextGenerationModel_js_1 = require("../../prompt/PromptFormatTextGenerationModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../prompt/PromptFormatTextStreamingModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
@@ -181,18 +181,14 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
+        const { run, responseFormat } = options;
         const callSettings = {
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
             // Copied settings:
-            ...combinedSettings,
+            ...this.settings,
             // map to OpenAI API names:
-            stop: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
+            stop: this.settings.stopSequences,
+            maxTokens: this.settings.maxCompletionTokens,
             // other settings:
             abortSignal: run?.abortSignal,
             prompt,
@@ -221,39 +217,38 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: exports.OpenAITextResponseFormat.json,
         });
+        return {
+            response,
+            text: response.choices[0].text,
+            usage: {
+                promptTokens: response.usage.prompt_tokens,
+                completionTokens: response.usage.completion_tokens,
+                totalTokens: response.usage.total_tokens,
+            },
+        };
     }
-    extractText(response) {
-        return response.choices[0].text;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: exports.OpenAITextResponseFormat.deltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta[0].delta;
-    }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
             model: this.withSettings({
-                stopSequences: promptFormat.stopSequences,
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
             }),
             promptFormat,
         });
     }
-    extractUsage(response) {
-        return {
-            promptTokens: response.usage.prompt_tokens,
-            completionTokens: response.usage.completion_tokens,
-            totalTokens: response.usage.total_tokens,
-        };
-    }
     withSettings(additionalSettings) {
         return new OpenAITextGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }
@@ -382,6 +377,7 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                 queue.push({
                     type: "delta",
                     fullDelta: streamDeltaDeepCopy,
+                    valueDelta: streamDeltaDeepCopy[0].delta,
                 });
             }
         }

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

@@ -1,13 +1,12 @@
 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 { DeltaEvent } from "../../model-function/DeltaEvent.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { Delta } from "../../model-function/Delta.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { OpenAIImageGenerationCallSettings } from "./OpenAIImageGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 /**
  * @see https://platform.openai.com/docs/models/
@@ -135,7 +134,7 @@ export interface OpenAITextGenerationModelSettings extends TextGenerationModelSe
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextGenerationModelSettings> implements TextGenerationModel<string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings> {
+export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextGenerationModelSettings> implements TextStreamingModel<string, OpenAITextGenerationModelSettings> {
     constructor(settings: OpenAITextGenerationModelSettings);
     readonly provider: "openai";
     get modelName(): OpenAITextGenerationModelType;
@@ -144,36 +143,35 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
     countPromptTokens(input: string): Promise<number>;
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAITextResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & {
-        user?: string;
-    }>>): Promise<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAITextGenerationModelSettings>;
-    generateTextResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
-        object: "text_completion";
-        model: string;
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            object: "text_completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                text: string;
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        text: string;
         usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
         };
-        id: string;
-        created: number;
-        choices: {
-            text: string;
-            finish_reason: string;
-            index: number;
-            logprobs?: any;
-        }[];
     }>;
-    extractText(response: OpenAITextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
-    extractTextDelta(fullDelta: OpenAITextGenerationDelta): string | undefined;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings, this>;
-    extractUsage(response: OpenAITextGenerationResponse): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, OpenAITextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<OpenAITextGenerationModelSettings>): this;
 }
 declare const openAITextGenerationResponseSchema: z.ZodObject<{
@@ -280,7 +278,7 @@ export declare const OpenAITextResponseFormat: {
         stream: true;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
+        }) => Promise<AsyncIterable<Delta<string>>>;
     };
 };
 export type OpenAITextGenerationDelta = Array<{

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -6,7 +6,7 @@ import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
@@ -172,18 +172,14 @@ export class OpenAITextGenerationModel extends AbstractModel {
         return countTokens(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
+        const { run, responseFormat } = options;
         const callSettings = {
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
             // Copied settings:
-            ...combinedSettings,
+            ...this.settings,
             // map to OpenAI API names:
-            stop: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
+            stop: this.settings.stopSequences,
+            maxTokens: this.settings.maxCompletionTokens,
             // other settings:
             abortSignal: run?.abortSignal,
             prompt,
@@ -212,39 +208,38 @@ export class OpenAITextGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: OpenAITextResponseFormat.json,
         });
+        return {
+            response,
+            text: response.choices[0].text,
+            usage: {
+                promptTokens: response.usage.prompt_tokens,
+                completionTokens: response.usage.completion_tokens,
+                totalTokens: response.usage.total_tokens,
+            },
+        };
     }
-    extractText(response) {
-        return response.choices[0].text;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: OpenAITextResponseFormat.deltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta[0].delta;
-    }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel({
             model: this.withSettings({
-                stopSequences: promptFormat.stopSequences,
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
             }),
             promptFormat,
         });
     }
-    extractUsage(response) {
-        return {
-            promptTokens: response.usage.prompt_tokens,
-            completionTokens: response.usage.completion_tokens,
-            totalTokens: response.usage.total_tokens,
-        };
-    }
     withSettings(additionalSettings) {
         return new OpenAITextGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }
@@ -372,6 +367,7 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                 queue.push({
                     type: "delta",
                     fullDelta: streamDeltaDeepCopy,
+                    valueDelta: streamDeltaDeepCopy[0].delta,
                 });
             }
         }

package/model-provider/openai/OpenAITranscriptionModel.cjs

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAITranscriptionResponseFormat = exports.OpenAITranscriptionModel = exports.calculateOpenAITranscriptionCostInMillicents = exports.OPENAI_TRANSCRIPTION_MODELS = void 0;
 const zod_1 = __importDefault(require("zod"));
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 /**
@@ -56,40 +56,31 @@ class OpenAITranscriptionModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    generateTranscriptionResponse(data, options) {
-        return this.callAPI(data, {
+    async doTranscribe(data, options) {
+        const response = await this.callAPI(data, {
             responseFormat: exports.OpenAITranscriptionResponseFormat.verboseJson,
             functionId: options?.functionId,
-            settings: options?.settings,
             run: options?.run,
         });
-    }
-    extractTranscriptionText(response) {
-        return response.text;
+        return {
+            response,
+            transcription: response.text,
+        };
     }
     async callAPI(data, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            file: {
-                name: `audio.${data.type}`,
-                data: data.data,
-            },
-            responseFormat,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITranscriptionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITranscriptionAPI({
+                ...this.settings,
+                // other settings:
+                abortSignal: options?.run?.abortSignal,
+                file: {
+                    name: `audio.${data.type}`,
+                    data: data.data,
+                },
+                responseFormat: options?.responseFormat,
+            }),
         });
     }
     get settingsForEvent() {

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

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-speech/TranscriptionModel.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-speech/TranscriptionModel.js";
 /**
  * @see https://openai.com/pricing
  */
@@ -42,15 +42,35 @@ export type OpenAITranscriptionInput = {
  *   }
  * );
  */
-export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITranscriptionModelSettings> implements TranscriptionModel<OpenAITranscriptionInput, OpenAITranscriptionVerboseJsonResponse, OpenAITranscriptionModelSettings> {
+export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITranscriptionModelSettings> implements TranscriptionModel<OpenAITranscriptionInput, OpenAITranscriptionModelSettings> {
     constructor(settings: OpenAITranscriptionModelSettings);
     readonly provider: "openai";
     get modelName(): "whisper-1";
-    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
-    extractTranscriptionText(response: OpenAITranscriptionVerboseJsonResponse): string;
+    doTranscribe(data: OpenAITranscriptionInput, options?: FunctionOptions): Promise<{
+        response: {
+            text: string;
+            segments: {
+                text: string;
+                temperature: number;
+                id: number;
+                tokens: number[];
+                seek: number;
+                start: number;
+                end: number;
+                avg_logprob: number;
+                compression_ratio: number;
+                no_speech_prob: number;
+                transient?: boolean | undefined;
+            }[];
+            task: "transcribe";
+            language: string;
+            duration: number;
+        };
+        transcription: string;
+    }>;
     callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings>>): Promise<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAITranscriptionModelSettings>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }

package/model-provider/openai/OpenAITranscriptionModel.js

@@ -1,7 +1,7 @@
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, createTextResponseHandler, postToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 /**
@@ -49,40 +49,31 @@ export class OpenAITranscriptionModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    generateTranscriptionResponse(data, options) {
-        return this.callAPI(data, {
+    async doTranscribe(data, options) {
+        const response = await this.callAPI(data, {
             responseFormat: OpenAITranscriptionResponseFormat.verboseJson,
             functionId: options?.functionId,
-            settings: options?.settings,
             run: options?.run,
         });
-    }
-    extractTranscriptionText(response) {
-        return response.text;
+        return {
+            response,
+            transcription: response.text,
+        };
     }
     async callAPI(data, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            file: {
-                name: `audio.${data.type}`,
-                data: data.data,
-            },
-            responseFormat,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITranscriptionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITranscriptionAPI({
+                ...this.settings,
+                // other settings:
+                abortSignal: options?.run?.abortSignal,
+                file: {
+                    name: `audio.${data.type}`,
+                    data: data.data,
+                },
+                responseFormat: options?.responseFormat,
+            }),
         });
     }
     get settingsForEvent() {