modelfusion 0.47.3 → 0.49.0

package/model-provider/elevenlabs/ElevenLabsSpeechModel.js

@@ -0,0 +1,187 @@
+import { z } from "zod";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createAudioMpegResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { createSimpleWebSocket } from "../../util/SimpleWebSocket.js";
+import { safeParseJsonWithZod } from "../../util/parseJSON.js";
+import { ElevenLabsApiConfiguration } from "./ElevenLabsApiConfiguration.js";
+import { failedElevenLabsCallResponseHandler } from "./ElevenLabsError.js";
+const elevenLabsModels = [
+    "eleven_multilingual_v2",
+    "eleven_multilingual_v1",
+    "eleven_monolingual_v1",
+];
+const defaultModel = "eleven_multilingual_v2";
+/**
+ * Synthesize speech using the ElevenLabs Text to Speech API.
+ *
+ * @see https://api.elevenlabs.io/docs#/text-to-speech/Text_to_speech_v1_text_to_speech__voice_id__post
+ */
+export class ElevenLabsSpeechModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "elevenlabs"
+        });
+    }
+    get modelName() {
+        return this.settings.voice;
+    }
+    async callAPI(text, options) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callElevenLabsTextToSpeechAPI({
+                api: this.settings.api,
+                abortSignal: options?.run?.abortSignal,
+                text,
+                voiceId: this.settings.voice,
+                modelId: this.settings.model,
+                voiceSettings: this.settings.voiceSettings,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        return {
+            model: this.settings.model,
+            voice: this.settings.voice,
+            voiceSettings: this.settings.voiceSettings,
+        };
+    }
+    doGenerateSpeechStandard(text, options) {
+        return this.callAPI(text, options);
+    }
+    async doGenerateSpeechStreamDuplex(textStream
+    // options?: FunctionOptions | undefined
+    ) {
+        const responseSchema = z.union([
+            z.object({
+                audio: z.string(),
+                isFinal: z.literal(false).nullable(),
+                normalizedAlignment: z
+                    .object({
+                    chars: z.array(z.string()),
+                    charStartTimesMs: z.array(z.number()),
+                    charDurationsMs: z.array(z.number()),
+                })
+                    .nullable(),
+            }),
+            z.object({
+                isFinal: z.literal(true),
+            }),
+            z.object({
+                message: z.string(),
+                error: z.string(),
+                code: z.number(),
+            }),
+        ]);
+        const queue = new AsyncQueue();
+        const model = this.settings.model ?? defaultModel;
+        const socket = await createSimpleWebSocket(`wss://api.elevenlabs.io/v1/text-to-speech/${this.settings.voice}/stream-input?model_id=${model}`);
+        socket.onopen = async () => {
+            const api = this.settings.api ?? new ElevenLabsApiConfiguration();
+            // send begin-of-stream (BOS) message:
+            socket.send(JSON.stringify({
+                // The JS WebSocket API does not support authorization headers, so we send the API key in the BOS message.
+                // See https://stackoverflow.com/questions/4361173/http-headers-in-websockets-client-api
+                xi_api_key: api.apiKey,
+                text: " ",
+                voice_settings: toApiVoiceSettings(this.settings.voiceSettings),
+                generation_config: toGenerationConfig(this.settings.generationConfig),
+            }));
+            // send text in chunks:
+            let textBuffer = "";
+            for await (const textDelta of textStream) {
+                textBuffer += textDelta;
+                // using ". " as separator: sending in full sentences improves the quality
+                // of the audio output significantly.
+                const separator = textBuffer.lastIndexOf(". ");
+                if (separator === -1) {
+                    continue;
+                }
+                const textToProcess = textBuffer.slice(0, separator);
+                textBuffer = textBuffer.slice(separator + 1);
+                socket.send(JSON.stringify({
+                    text: textToProcess,
+                    try_trigger_generation: true,
+                }));
+            }
+            // send remaining text:
+            if (textBuffer.length > 0) {
+                socket.send(JSON.stringify({
+                    text: `${textBuffer} `,
+                    try_trigger_generation: true,
+                }));
+            }
+            // send end-of-stream (EOS) message:
+            socket.send(JSON.stringify({ text: "" }));
+        };
+        socket.onmessage = (event) => {
+            const parseResult = safeParseJsonWithZod(event.data, responseSchema);
+            if (!parseResult.success) {
+                queue.push({ type: "error", error: parseResult.error });
+                return;
+            }
+            const response = parseResult.data;
+            if ("error" in response) {
+                queue.push({ type: "error", error: response });
+                return;
+            }
+            if (!response.isFinal) {
+                queue.push({
+                    type: "delta",
+                    fullDelta: event,
+                    valueDelta: Buffer.from(response.audio, "base64"),
+                });
+            }
+        };
+        socket.onerror = (error) => {
+            queue.push({ type: "error", error });
+        };
+        socket.onclose = () => {
+            queue.close();
+        };
+        return queue;
+    }
+    withSettings(additionalSettings) {
+        return new ElevenLabsSpeechModel({
+            ...this.settings,
+            ...additionalSettings,
+        });
+    }
+}
+async function callElevenLabsTextToSpeechAPI({ api = new ElevenLabsApiConfiguration(), abortSignal, text, voiceId, modelId, voiceSettings, }) {
+    return postJsonToApi({
+        url: api.assembleUrl(`/text-to-speech/${voiceId}`),
+        headers: api.headers,
+        body: {
+            text,
+            model_id: modelId ?? defaultModel,
+            voice_settings: toApiVoiceSettings(voiceSettings),
+        },
+        failedResponseHandler: failedElevenLabsCallResponseHandler,
+        successfulResponseHandler: createAudioMpegResponseHandler(),
+        abortSignal,
+    });
+}
+function toApiVoiceSettings(voiceSettings) {
+    return voiceSettings != null
+        ? {
+            stability: voiceSettings.stability,
+            similarity_boost: voiceSettings.similarityBoost,
+            style: voiceSettings.style,
+            use_speaker_boost: voiceSettings.useSpeakerBoost,
+        }
+        : undefined;
+}
+function toGenerationConfig(generationConfig) {
+    return generationConfig != null
+        ? {
+            chunk_length_schedule: generationConfig.chunkLengthSchedule,
+        }
+        : undefined;
+}

package/model-provider/elevenlabs/index.cjs

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ElevenLabsApiConfiguration.cjs"), exports);
-__exportStar(require("./ElevenLabsSpeechSynthesisModel.cjs"), exports);
+__exportStar(require("./ElevenLabsSpeechModel.cjs"), exports);

package/model-provider/elevenlabs/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./ElevenLabsApiConfiguration.js";
-export * from "./ElevenLabsSpeechSynthesisModel.js";
+export * from "./ElevenLabsSpeechModel.js";

package/model-provider/elevenlabs/index.js

@@ -1,2 +1,2 @@
 export * from "./ElevenLabsApiConfiguration.js";
-export * from "./ElevenLabsSpeechSynthesisModel.js";
+export * from "./ElevenLabsSpeechModel.js";

package/model-provider/huggingface/HuggingFaceImageDescriptionModel.cjs

@@ -5,6 +5,7 @@ const zod_1 = require("zod");
 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 PromptFormatTextGenerationModel_js_1 = require("../../model-function/generate-text/PromptFormatTextGenerationModel.cjs");
 const HuggingFaceApiConfiguration_js_1 = require("./HuggingFaceApiConfiguration.cjs");
 const HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
 /**
@@ -21,6 +22,18 @@ class HuggingFaceImageDescriptionModel extends AbstractModel_js_1.AbstractModel
             writable: true,
             value: "huggingface"
         });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
         Object.defineProperty(this, "countPromptTokens", {
             enumerable: true,
             configurable: true,
@@ -45,13 +58,19 @@ class HuggingFaceImageDescriptionModel extends AbstractModel_js_1.AbstractModel
     get settingsForEvent() {
         return {};
     }
-    async doDescribeImage(data, options) {
+    async doGenerateText(data, options) {
         const response = await this.callAPI(data, options);
         return {
             response,
-            description: response[0].generated_text,
+            text: response[0].generated_text,
         };
     }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
+            model: this,
+            promptFormat,
+        });
+    }
     withSettings(additionalSettings) {
         return new HuggingFaceImageDescriptionModel(Object.assign({}, this.settings, additionalSettings));
     }

package/model-provider/huggingface/HuggingFaceImageDescriptionModel.d.ts

@@ -1,10 +1,12 @@
 /// <reference types="node" />
 import { z } from "zod";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { ImageDescriptionModel, ImageDescriptionModelSettings } from "../../model-function/describe-image/ImageDescriptionModel.js";
-export interface HuggingFaceImageDescriptionModelSettings extends ImageDescriptionModelSettings {
+import { PromptFormatTextGenerationModel } from "../../model-function/generate-text/PromptFormatTextGenerationModel.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationPromptFormat } from "../../model-function/generate-text/TextGenerationPromptFormat.js";
+export interface HuggingFaceImageDescriptionModelSettings extends TextGenerationModelSettings {
     api?: ApiConfiguration;
     model: string;
 }
@@ -13,19 +15,22 @@ export interface HuggingFaceImageDescriptionModelSettings extends ImageDescripti
  *
  * @see https://huggingface.co/tasks/image-to-text
  */
-export declare class HuggingFaceImageDescriptionModel extends AbstractModel<HuggingFaceImageDescriptionModelSettings> implements ImageDescriptionModel<Buffer, HuggingFaceImageDescriptionModelSettings> {
+export declare class HuggingFaceImageDescriptionModel extends AbstractModel<HuggingFaceImageDescriptionModelSettings> implements TextGenerationModel<Buffer, HuggingFaceImageDescriptionModelSettings> {
     constructor(settings: HuggingFaceImageDescriptionModelSettings);
     readonly provider = "huggingface";
     get modelName(): string;
     callAPI(data: Buffer, options?: FunctionOptions): Promise<HuggingFaceImageDescriptionResponse>;
     get settingsForEvent(): Partial<HuggingFaceImageDescriptionModelSettings>;
+    readonly contextWindowSize: undefined;
+    readonly tokenizer: undefined;
     readonly countPromptTokens: undefined;
-    doDescribeImage(data: Buffer, options?: FunctionOptions): Promise<{
+    doGenerateText(data: Buffer, options?: FunctionOptions): Promise<{
         response: {
             generated_text: string;
         }[];
-        description: string;
+        text: string;
     }>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: TextGenerationPromptFormat<INPUT_PROMPT, Buffer>): PromptFormatTextGenerationModel<INPUT_PROMPT, Buffer, HuggingFaceImageDescriptionModelSettings, this>;
     withSettings(additionalSettings: Partial<HuggingFaceImageDescriptionModelSettings>): this;
 }
 declare const huggingFaceImageDescriptionResponseSchema: z.ZodArray<z.ZodObject<{

package/model-provider/huggingface/HuggingFaceImageDescriptionModel.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postToApi, } from "../../core/api/postToApi.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { PromptFormatTextGenerationModel } from "../../model-function/generate-text/PromptFormatTextGenerationModel.js";
 import { HuggingFaceApiConfiguration } from "./HuggingFaceApiConfiguration.js";
 import { failedHuggingFaceCallResponseHandler } from "./HuggingFaceError.js";
 /**
@@ -18,6 +19,18 @@ export class HuggingFaceImageDescriptionModel extends AbstractModel {
             writable: true,
             value: "huggingface"
         });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
         Object.defineProperty(this, "countPromptTokens", {
             enumerable: true,
             configurable: true,
@@ -42,13 +55,19 @@ export class HuggingFaceImageDescriptionModel extends AbstractModel {
     get settingsForEvent() {
         return {};
     }
-    async doDescribeImage(data, options) {
+    async doGenerateText(data, options) {
         const response = await this.callAPI(data, options);
         return {
             response,
-            description: response[0].generated_text,
+            text: response[0].generated_text,
         };
     }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextGenerationModel({
+            model: this,
+            promptFormat,
+        });
+    }
     withSettings(additionalSettings) {
         return new HuggingFaceImageDescriptionModel(Object.assign({}, this.settings, additionalSettings));
     }

package/model-provider/lmnt/{LmntSpeechSynthesisModel.cjs → LmntSpeechModel.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LmntSpeechSynthesisModel = void 0;
+exports.LmntSpeechModel = void 0;
 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");
@@ -11,7 +11,7 @@ const LmntError_js_1 = require("./LmntError.cjs");
  *
  * @see https://www.lmnt.com/docs/rest/#synthesize-speech
  */
-class LmntSpeechSynthesisModel extends AbstractModel_js_1.AbstractModel {
+class LmntSpeechModel extends AbstractModel_js_1.AbstractModel {
     constructor(settings) {
         super({ settings });
         Object.defineProperty(this, "provider", {
@@ -43,17 +43,17 @@ class LmntSpeechSynthesisModel extends AbstractModel_js_1.AbstractModel {
             length: this.settings.length,
         };
     }
-    generateSpeechResponse(text, options) {
+    doGenerateSpeechStandard(text, options) {
         return this.callAPI(text, options);
     }
     withSettings(additionalSettings) {
-        return new LmntSpeechSynthesisModel({
+        return new LmntSpeechModel({
             ...this.settings,
             ...additionalSettings,
         });
     }
 }
-exports.LmntSpeechSynthesisModel = LmntSpeechSynthesisModel;
+exports.LmntSpeechModel = LmntSpeechModel;
 async function callLmntTextToSpeechAPI({ api = new LmntApiConfiguration_js_1.LmntApiConfiguration(), abortSignal, text, voice, speed, seed, length, }) {
     const formData = new FormData();
     formData.append("text", text);

package/model-provider/lmnt/LmntSpeechModel.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { SpeechGenerationModel, SpeechGenerationModelSettings } from "../../model-function/generate-speech/SpeechGenerationModel.js";
+export interface LmntSpeechModelSettings extends SpeechGenerationModelSettings {
+    api?: ApiConfiguration;
+    voice: string;
+    speed?: number;
+    seed?: number;
+    length?: number;
+}
+/**
+ * Synthesize speech using the LMNT API.
+ *
+ * @see https://www.lmnt.com/docs/rest/#synthesize-speech
+ */
+export declare class LmntSpeechModel extends AbstractModel<LmntSpeechModelSettings> implements SpeechGenerationModel<LmntSpeechModelSettings> {
+    constructor(settings: LmntSpeechModelSettings);
+    readonly provider = "lmnt";
+    get modelName(): string;
+    private callAPI;
+    get settingsForEvent(): Partial<LmntSpeechModelSettings>;
+    doGenerateSpeechStandard(text: string, options?: FunctionOptions): Promise<Buffer>;
+    withSettings(additionalSettings: Partial<LmntSpeechModelSettings>): this;
+}

package/model-provider/lmnt/{LmntSpeechSynthesisModel.js → LmntSpeechModel.js}

@@ -8,7 +8,7 @@ import { failedLmntCallResponseHandler } from "./LmntError.js";
  *
  * @see https://www.lmnt.com/docs/rest/#synthesize-speech
  */
-export class LmntSpeechSynthesisModel extends AbstractModel {
+export class LmntSpeechModel extends AbstractModel {
     constructor(settings) {
         super({ settings });
         Object.defineProperty(this, "provider", {
@@ -40,11 +40,11 @@ export class LmntSpeechSynthesisModel extends AbstractModel {
             length: this.settings.length,
         };
     }
-    generateSpeechResponse(text, options) {
+    doGenerateSpeechStandard(text, options) {
         return this.callAPI(text, options);
     }
     withSettings(additionalSettings) {
-        return new LmntSpeechSynthesisModel({
+        return new LmntSpeechModel({
             ...this.settings,
             ...additionalSettings,
         });

package/model-provider/lmnt/index.cjs

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./LmntApiConfiguration.cjs"), exports);
-__exportStar(require("./LmntSpeechSynthesisModel.cjs"), exports);
+__exportStar(require("./LmntSpeechModel.cjs"), exports);

package/model-provider/lmnt/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./LmntApiConfiguration.js";
-export * from "./LmntSpeechSynthesisModel.js";
+export * from "./LmntSpeechModel.js";

package/model-provider/lmnt/index.js

@@ -1,2 +1,2 @@
 export * from "./LmntApiConfiguration.js";
-export * from "./LmntSpeechSynthesisModel.js";
+export * from "./LmntSpeechModel.js";

package/model-provider/openai/{OpenAITextGenerationModel.cjs → OpenAICompletionModel.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAITextResponseFormat = exports.OpenAITextGenerationModel = exports.calculateOpenAITextGenerationCostInMillicents = exports.isOpenAITextGenerationModel = exports.getOpenAITextGenerationModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS = void 0;
+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");
@@ -87,7 +87,7 @@ exports.OPENAI_TEXT_GENERATION_MODELS = {
         completionTokenCostInMillicents: 0.04,
     },
 };
-function getOpenAITextGenerationModelInformation(model) {
+function getOpenAICompletionModelInformation(model) {
     // Model is already a base model:
     if (model in exports.OPENAI_TEXT_GENERATION_MODELS) {
         const baseModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS[model];
@@ -114,26 +114,26 @@ function getOpenAITextGenerationModelInformation(model) {
     }
     throw new Error(`Unknown OpenAI chat base model ${baseModel}.`);
 }
-exports.getOpenAITextGenerationModelInformation = getOpenAITextGenerationModelInformation;
-const isOpenAITextGenerationModel = (model) => model in exports.OPENAI_TEXT_GENERATION_MODELS ||
+exports.getOpenAICompletionModelInformation = getOpenAICompletionModelInformation;
+const isOpenAICompletionModel = (model) => model in exports.OPENAI_TEXT_GENERATION_MODELS ||
     model.startsWith("ft:davinci-002:") ||
     model.startsWith("ft:babbage-002:");
-exports.isOpenAITextGenerationModel = isOpenAITextGenerationModel;
-const calculateOpenAITextGenerationCostInMillicents = ({ model, response, }) => {
-    const modelInformation = getOpenAITextGenerationModelInformation(model);
+exports.isOpenAICompletionModel = isOpenAICompletionModel;
+const calculateOpenAICompletionCostInMillicents = ({ model, response, }) => {
+    const modelInformation = getOpenAICompletionModelInformation(model);
     return (response.usage.prompt_tokens *
         modelInformation.promptTokenCostInMillicents +
         response.usage.completion_tokens *
             modelInformation.completionTokenCostInMillicents);
 };
-exports.calculateOpenAITextGenerationCostInMillicents = calculateOpenAITextGenerationCostInMillicents;
+exports.calculateOpenAICompletionCostInMillicents = calculateOpenAICompletionCostInMillicents;
 /**
  * Create a text generation model that calls the OpenAI text completion API.
  *
  * @see https://platform.openai.com/docs/api-reference/completions/create
  *
  * @example
- * const model = new OpenAITextGenerationModel({
+ * const model = new OpenAICompletionModel({
  *   model: "gpt-3.5-turbo-instruct",
  *   temperature: 0.7,
  *   maxCompletionTokens: 500,
@@ -145,7 +145,7 @@ exports.calculateOpenAITextGenerationCostInMillicents = calculateOpenAITextGener
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
+class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
     constructor(settings) {
         super({ settings });
         Object.defineProperty(this, "provider", {
@@ -166,7 +166,7 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: void 0
         });
-        const modelInformation = getOpenAITextGenerationModelInformation(this.settings.model);
+        const modelInformation = getOpenAICompletionModelInformation(this.settings.model);
         this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({
             model: modelInformation.baseModel,
         });
@@ -195,7 +195,7 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: callSettings.api?.retry,
             throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITextGenerationAPI(callSettings),
+            call: async () => callOpenAICompletionAPI(callSettings),
         });
     }
     get settingsForEvent() {
@@ -260,11 +260,11 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
         });
     }
     withSettings(additionalSettings) {
-        return new OpenAITextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+        return new OpenAICompletionModel(Object.assign({}, this.settings, additionalSettings));
     }
 }
-exports.OpenAITextGenerationModel = OpenAITextGenerationModel;
-const openAITextGenerationResponseSchema = zod_1.z.object({
+exports.OpenAICompletionModel = OpenAICompletionModel;
+const OpenAICompletionResponseSchema = zod_1.z.object({
     id: zod_1.z.string(),
     object: zod_1.z.literal("text_completion"),
     created: zod_1.z.number(),
@@ -281,7 +281,7 @@ const openAITextGenerationResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
-async function callOpenAITextGenerationAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, responseFormat, model, prompt, suffix, maxTokens, temperature, topP, n, logprobs, echo, stop, presencePenalty, frequencyPenalty, bestOf, logitBias, user, }) {
+async function callOpenAICompletionAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, responseFormat, model, prompt, suffix, maxTokens, temperature, topP, n, logprobs, echo, stop, presencePenalty, frequencyPenalty, bestOf, logitBias, user, }) {
     // empty arrays are not allowed for stop:
     if (stop != null && Array.isArray(stop) && stop.length === 0) {
         stop = undefined;
@@ -318,7 +318,7 @@ exports.OpenAITextResponseFormat = {
      */
     json: {
         stream: false,
-        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAITextGenerationResponseSchema),
+        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)