modelfusion 0.40.0 → 0.41.0

package/model-provider/llamacpp/LlamaCppTextGenerationModel.d.ts

@@ -1,12 +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 { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
 export interface LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends number | undefined> extends TextGenerationModelSettings {
     api?: ApiConfiguration;
@@ -31,7 +31,7 @@ export interface LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends
     ignoreEos?: boolean;
     logitBias?: Array<[number, number | false]>;
 }
-export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> implements TextGenerationModel<string, LlamaCppTextGenerationResponse, LlamaCppTextGenerationDelta, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> {
+export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> implements TextStreamingModel<string, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> {
     constructor(settings?: LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>);
     readonly provider = "llamacpp";
     get modelName(): null;
@@ -39,67 +39,69 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
     readonly tokenizer: LlamaCppTokenizer;
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: LlamaCppTextGenerationResponseFormatType<RESPONSE>;
-    } & ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<RESPONSE>;
+    } & FunctionOptions): Promise<RESPONSE>;
     get settingsForEvent(): Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>;
     countPromptTokens(prompt: string): Promise<number>;
-    generateTextResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<{
-        model: string;
-        prompt: string;
-        content: string;
-        stop: true;
-        generation_settings: {
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
             model: string;
-            stream: boolean;
-            seed: number;
-            mirostat: number;
-            stop: string[];
-            frequency_penalty: number;
-            ignore_eos: boolean;
-            logit_bias: number[];
-            mirostat_eta: number;
-            mirostat_tau: number;
-            n_ctx: number;
-            n_keep: number;
-            n_predict: number;
-            n_probs: number;
-            penalize_nl: boolean;
-            presence_penalty: number;
-            repeat_last_n: number;
-            repeat_penalty: number;
-            temp: number;
-            tfs_z: number;
-            top_k: number;
-            top_p: number;
-            typical_p: number;
+            prompt: string;
+            content: string;
+            stop: true;
+            generation_settings: {
+                model: string;
+                stream: boolean;
+                seed: number;
+                mirostat: number;
+                stop: string[];
+                frequency_penalty: number;
+                ignore_eos: boolean;
+                logit_bias: number[];
+                mirostat_eta: number;
+                mirostat_tau: number;
+                n_ctx: number;
+                n_keep: number;
+                n_predict: number;
+                n_probs: number;
+                penalize_nl: boolean;
+                presence_penalty: number;
+                repeat_last_n: number;
+                repeat_penalty: number;
+                temp: number;
+                tfs_z: number;
+                top_k: number;
+                top_p: number;
+                typical_p: number;
+            };
+            stopped_eos: boolean;
+            stopped_limit: boolean;
+            stopped_word: boolean;
+            stopping_word: string;
+            timings: {
+                predicted_ms: number;
+                predicted_n: number;
+                predicted_per_second: number | null;
+                predicted_per_token_ms: number | null;
+                prompt_ms: number | null;
+                prompt_n: number;
+                prompt_per_second: number | null;
+                prompt_per_token_ms: number | null;
+            };
+            tokens_cached: number;
+            tokens_evaluated: number;
+            tokens_predicted: number;
+            truncated: boolean;
         };
-        stopped_eos: boolean;
-        stopped_limit: boolean;
-        stopped_word: boolean;
-        stopping_word: string;
-        timings: {
-            predicted_ms: number;
-            predicted_n: number;
-            predicted_per_second: number | null;
-            predicted_per_token_ms: number | null;
-            prompt_ms: number | null;
-            prompt_n: number;
-            prompt_per_second: number | null;
-            prompt_per_token_ms: number | null;
+        text: string;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
         };
-        tokens_cached: number;
-        tokens_evaluated: number;
-        tokens_predicted: number;
-        truncated: boolean;
     }>;
-    extractText(response: LlamaCppTextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     extractTextDelta(fullDelta: LlamaCppTextGenerationDelta): string | undefined;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, LlamaCppTextGenerationResponse, LlamaCppTextGenerationDelta, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
-    extractUsage(response: LlamaCppTextGenerationResponse): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     withSettings(additionalSettings: Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;
 }
 declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{
@@ -387,7 +389,7 @@ export declare const LlamaCppTextGenerationResponseFormat: {
         stream: true;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
+        }) => Promise<AsyncIterable<Delta<string>>>;
     };
 };
 export {};

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -5,7 +5,7 @@ import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postTo
 import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
 import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
@@ -33,25 +33,19 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         return this.settings.contextWindowSize;
     }
     async callAPI(prompt, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            ...combinedSettings,
-            // mapping
-            nPredict: combinedSettings.maxCompletionTokens,
-            stop: combinedSettings.stopSequences,
-            // other
-            abortSignal: run?.abortSignal,
-            prompt,
-            responseFormat,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLlamaCppTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLlamaCppTextGenerationAPI({
+                ...this.settings,
+                // mapping
+                nPredict: this.settings.maxCompletionTokens,
+                stop: this.settings.stopSequences,
+                // other
+                abortSignal: options.run?.abortSignal,
+                prompt,
+                responseFormat: options.responseFormat,
+            }),
         });
     }
     get settingsForEvent() {
@@ -81,16 +75,22 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         const tokens = await this.tokenizer.tokenize(prompt);
         return tokens.length;
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: LlamaCppTextGenerationResponseFormat.json,
         });
+        return {
+            response,
+            text: response.content,
+            usage: {
+                promptTokens: response.tokens_evaluated,
+                completionTokens: response.tokens_predicted,
+                totalTokens: response.tokens_evaluated + response.tokens_predicted,
+            },
+        };
     }
-    extractText(response) {
-        return response.content;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: LlamaCppTextGenerationResponseFormat.deltaIterable,
@@ -100,20 +100,16 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         return fullDelta.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.tokens_evaluated,
-            completionTokens: response.tokens_predicted,
-            totalTokens: response.tokens_evaluated + response.tokens_predicted,
-        };
-    }
     withSettings(additionalSettings) {
         return new LlamaCppTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }
@@ -232,6 +228,7 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                         isComplete: eventData.stop,
                         delta: eventData.content,
                     },
+                    valueDelta: eventData.content,
                 });
                 if (eventData.stop) {
                     queue.close();

package/model-provider/lmnt/LmntSpeechSynthesisModel.cjs

@@ -25,19 +25,14 @@ class LmntSpeechSynthesisModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            // copied settings:
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            text,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLmntTextToSpeechAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLmntTextToSpeechAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                text,
+            }),
         });
     }
     get settingsForEvent() {

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { SpeechSynthesisModel, SpeechSynthesisModelSettings } from "../../model-function/synthesize-speech/SpeechSynthesisModel.js";
 export interface LmntSpeechSynthesisModelSettings extends SpeechSynthesisModelSettings {
     api?: ApiConfiguration;
@@ -21,6 +21,6 @@ export declare class LmntSpeechSynthesisModel extends AbstractModel<LmntSpeechSy
     get modelName(): string;
     private callAPI;
     get settingsForEvent(): Partial<LmntSpeechSynthesisModelSettings>;
-    generateSpeechResponse(text: string, options?: ModelFunctionOptions<LmntSpeechSynthesisModelSettings> | undefined): Promise<Buffer>;
+    generateSpeechResponse(text: string, options?: FunctionOptions): Promise<Buffer>;
     withSettings(additionalSettings: Partial<LmntSpeechSynthesisModelSettings>): this;
 }

package/model-provider/lmnt/LmntSpeechSynthesisModel.js

@@ -22,19 +22,14 @@ export class LmntSpeechSynthesisModel extends AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            // copied settings:
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            text,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLmntTextToSpeechAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLmntTextToSpeechAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                text,
+            }),
         });
     }
     get settingsForEvent() {

package/model-provider/openai/OpenAIImageGenerationModel.cjs

@@ -46,17 +46,10 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
     }
     async callAPI(prompt, options) {
         const run = options?.run;
-        const settings = options?.settings;
         const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
         const callSettings = {
+            ...this.settings,
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
             abortSignal: run?.abortSignal,
             responseFormat,
             prompt,
@@ -74,16 +67,15 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, {
             responseFormat: exports.OpenAIImageGenerationResponseFormat.base64Json,
-            functionId: options?.functionId,
-            settings: options?.settings,
-            run: options?.run,
+            ...options,
         });
-    }
-    extractBase64Image(response) {
-        return response.data[0].b64_json;
+        return {
+            response,
+            base64Image: response.data[0].b64_json,
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAIImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

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

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 export interface OpenAIImageGenerationCallSettings {
     n?: number;
     size?: "256x256" | "512x512" | "1024x1024";
@@ -26,23 +26,23 @@ export interface OpenAIImageGenerationSettings extends ImageGenerationModelSetti
  *   "the wicked witch of the west in the style of early 19th century painting"
  * );
  */
-export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImageGenerationSettings> implements ImageGenerationModel<string, OpenAIImageGenerationBase64JsonResponse, OpenAIImageGenerationSettings> {
+export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImageGenerationSettings> implements ImageGenerationModel<string, OpenAIImageGenerationSettings> {
     constructor(settings: OpenAIImageGenerationSettings);
     readonly provider: "openai";
     readonly modelName: null;
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & {
-        user?: string;
-    }>>): Promise<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIImageGenerationSettings>;
-    generateImageResponse(prompt: string, options?: ModelFunctionOptions<OpenAIImageGenerationSettings>): Promise<{
-        data: {
-            b64_json: string;
-        }[];
-        created: number;
+    doGenerateImage(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            data: {
+                b64_json: string;
+            }[];
+            created: number;
+        };
+        base64Image: string;
     }>;
-    extractBase64Image(response: OpenAIImageGenerationBase64JsonResponse): string;
     withSettings(additionalSettings: Partial<OpenAIImageGenerationSettings>): this;
 }
 export type OpenAIImageGenerationResponseFormatType<T> = {

package/model-provider/openai/OpenAIImageGenerationModel.js

@@ -42,17 +42,10 @@ export class OpenAIImageGenerationModel extends AbstractModel {
     }
     async callAPI(prompt, options) {
         const run = options?.run;
-        const settings = options?.settings;
         const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
         const callSettings = {
+            ...this.settings,
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
             abortSignal: run?.abortSignal,
             responseFormat,
             prompt,
@@ -70,16 +63,15 @@ export class OpenAIImageGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, {
             responseFormat: OpenAIImageGenerationResponseFormat.base64Json,
-            functionId: options?.functionId,
-            settings: options?.settings,
-            run: options?.run,
+            ...options,
         });
-    }
-    extractBase64Image(response) {
-        return response.data[0].b64_json;
+        return {
+            response,
+            base64Image: response.data[0].b64_json,
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAIImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAITextEmbeddingModel = exports.calculateOpenAIEmbeddingCostInMillicents = exports.isOpenAIEmbeddingModel = exports.OPENAI_TEXT_EMBEDDING_MODELS = void 0;
 const zod_1 = __importDefault(require("zod"));
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.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 countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
@@ -91,37 +91,31 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         return (0, countTokens_js_1.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 (0, callWithRetryAndThrottle_js_1.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/OpenAITextEmbeddingModel.d.ts

@@ -1,7 +1,7 @@
 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 { AbstractModel } from "../../model-function/AbstractModel.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 export declare const OPENAI_TEXT_EMBEDDING_MODELS: {
@@ -36,7 +36,7 @@ export interface OpenAITextEmbeddingModelSettings extends EmbeddingModelSettings
  *   ]
  * );
  */
-export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEmbeddingModelSettings> implements EmbeddingModel<string, OpenAITextEmbeddingResponse, OpenAITextEmbeddingModelSettings> {
+export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEmbeddingModelSettings> implements EmbeddingModel<string, OpenAITextEmbeddingModelSettings> {
     constructor(settings: OpenAITextEmbeddingModelSettings);
     readonly provider: "openai";
     get modelName(): "text-embedding-ada-002";
@@ -45,22 +45,24 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     readonly tokenizer: TikTokenTokenizer;
     readonly contextWindowSize: number;
     countTokens(input: string): Promise<number>;
-    callAPI(texts: Array<string>, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<OpenAITextEmbeddingResponse>;
     get settingsForEvent(): Partial<OpenAITextEmbeddingModelSettings>;
-    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
-        object: "list";
-        model: string;
-        usage: {
-            prompt_tokens: number;
-            total_tokens: number;
+    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "list";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                total_tokens: number;
+            };
+            data: {
+                object: "embedding";
+                embedding: number[];
+                index: number;
+            }[];
         };
-        data: {
-            object: "embedding";
-            embedding: number[];
-            index: number;
-        }[];
+        embeddings: number[][];
     }>;
-    extractEmbeddings(response: OpenAITextEmbeddingResponse): number[][];
     withSettings(additionalSettings: OpenAITextEmbeddingModelSettings): this;
 }
 declare const openAITextEmbeddingResponseSchema: z.ZodObject<{