modelfusion 0.40.1 → 0.41.1

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

@@ -1,7 +1,7 @@
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
 export interface HuggingFaceTextEmbeddingModelSettings extends EmbeddingModelSettings {
     api?: ApiConfiguration;
@@ -33,7 +33,7 @@ export interface HuggingFaceTextEmbeddingModelSettings extends EmbeddingModelSet
  *   ]
  * );
  */
-export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<HuggingFaceTextEmbeddingModelSettings> implements EmbeddingModel<string, HuggingFaceTextEmbeddingResponse, HuggingFaceTextEmbeddingModelSettings> {
+export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<HuggingFaceTextEmbeddingModelSettings> implements EmbeddingModel<string, HuggingFaceTextEmbeddingModelSettings> {
     constructor(settings: HuggingFaceTextEmbeddingModelSettings);
     readonly provider = "huggingface";
     get modelName(): string;
@@ -41,11 +41,13 @@ export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<Hugging
     readonly contextWindowSize: undefined;
     readonly embeddingDimensions: number | undefined;
     readonly tokenizer: undefined;
-    callAPI(texts: Array<string>, options?: ModelFunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<HuggingFaceTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<HuggingFaceTextEmbeddingResponse>;
     get settingsForEvent(): Partial<HuggingFaceTextEmbeddingModelSettings>;
     readonly countPromptTokens: undefined;
-    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<number[][]>;
-    extractEmbeddings(response: HuggingFaceTextEmbeddingResponse): number[][];
+    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+        response: number[][];
+        embeddings: number[][];
+    }>;
     withSettings(additionalSettings: Partial<HuggingFaceTextEmbeddingModelSettings>): this;
 }
 declare const huggingFaceTextEmbeddingResponseSchema: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.js

@@ -1,9 +1,9 @@
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { failedHuggingFaceCallResponseHandler } from "./HuggingFaceError.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { HuggingFaceApiConfiguration } from "./HuggingFaceApiConfiguration.js";
+import { failedHuggingFaceCallResponseHandler } from "./HuggingFaceError.js";
 /**
  * Create a text embedding model that calls a Hugging Face Inference API Feature Extraction Task.
  *
@@ -74,25 +74,18 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The HuggingFace feature extraction API is configured to only support ${this.maxValuesPerCall} texts per API call.`);
         }
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            options: {
-                useCache: true,
-                waitForModel: true,
-            },
-            ...combinedSettings,
-            abortSignal: run?.abortSignal,
-            inputs: texts,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callHuggingFaceTextGenerationAPI({
+                options: {
+                    useCache: true,
+                    waitForModel: true,
+                },
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                inputs: texts,
+            }),
         });
     }
     get settingsForEvent() {
@@ -101,11 +94,12 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
             options: this.settings.options,
         };
     }
-    generateEmbeddingResponse(texts, options) {
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return response;
+    async doEmbedValues(texts, options) {
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: response,
+        };
     }
     withSettings(additionalSettings) {
         return new HuggingFaceTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/huggingface/HuggingFaceTextGenerationModel.cjs

@@ -61,26 +61,19 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            options: {
-                useCache: true,
-                waitForModel: true,
-            },
-            ...combinedSettings,
-            maxNewTokens: combinedSettings.maxCompletionTokens,
-            abortSignal: run?.abortSignal,
-            inputs: prompt,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callHuggingFaceTextGenerationAPI({
+                options: {
+                    useCache: true,
+                    waitForModel: true,
+                },
+                ...this.settings,
+                maxNewTokens: this.settings.maxCompletionTokens,
+                abortSignal: options?.run?.abortSignal,
+                inputs: prompt,
+            }),
         });
     }
     get settingsForEvent() {
@@ -98,11 +91,12 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, options);
-    }
-    extractText(response) {
-        return response[0].generated_text;
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, options);
+        return {
+            response,
+            text: response[0].generated_text,
+        };
     }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({

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

@@ -1,7 +1,7 @@
 import z from "zod";
 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 { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
@@ -38,20 +38,22 @@ export interface HuggingFaceTextGenerationModelSettings extends TextGenerationMo
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare class HuggingFaceTextGenerationModel extends AbstractModel<HuggingFaceTextGenerationModelSettings> implements TextGenerationModel<string, HuggingFaceTextGenerationResponse, undefined, HuggingFaceTextGenerationModelSettings> {
+export declare class HuggingFaceTextGenerationModel extends AbstractModel<HuggingFaceTextGenerationModelSettings> implements TextGenerationModel<string, HuggingFaceTextGenerationModelSettings> {
     constructor(settings: HuggingFaceTextGenerationModelSettings);
     readonly provider = "huggingface";
     get modelName(): string;
     readonly contextWindowSize: undefined;
     readonly tokenizer: undefined;
-    callAPI(prompt: string, options?: ModelFunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<HuggingFaceTextGenerationResponse>;
+    callAPI(prompt: string, options?: FunctionOptions): Promise<HuggingFaceTextGenerationResponse>;
     get settingsForEvent(): Partial<HuggingFaceTextGenerationModelSettings>;
     readonly countPromptTokens: undefined;
-    generateTextResponse(prompt: string, options?: ModelFunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<{
-        generated_text: string;
-    }[]>;
-    extractText(response: HuggingFaceTextGenerationResponse): string;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, HuggingFaceTextGenerationResponse, undefined, HuggingFaceTextGenerationModelSettings, this>;
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            generated_text: string;
+        }[];
+        text: string;
+    }>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, HuggingFaceTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<HuggingFaceTextGenerationModelSettings>): this;
 }
 declare const huggingFaceTextGenerationResponseSchema: z.ZodArray<z.ZodObject<{

package/model-provider/huggingface/HuggingFaceTextGenerationModel.js

@@ -55,26 +55,19 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            options: {
-                useCache: true,
-                waitForModel: true,
-            },
-            ...combinedSettings,
-            maxNewTokens: combinedSettings.maxCompletionTokens,
-            abortSignal: run?.abortSignal,
-            inputs: prompt,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callHuggingFaceTextGenerationAPI({
+                options: {
+                    useCache: true,
+                    waitForModel: true,
+                },
+                ...this.settings,
+                maxNewTokens: this.settings.maxCompletionTokens,
+                abortSignal: options?.run?.abortSignal,
+                inputs: prompt,
+            }),
         });
     }
     get settingsForEvent() {
@@ -92,11 +85,12 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, options);
-    }
-    extractText(response) {
-        return response[0].generated_text;
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, options);
+        return {
+            response,
+            text: response[0].generated_text,
+        };
     }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel({

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.cjs

@@ -57,18 +57,14 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            content: texts[0],
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLlamaCppEmbeddingAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLlamaCppEmbeddingAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                content: texts[0],
+            }),
         });
     }
     get settingsForEvent() {
@@ -76,11 +72,12 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             embeddingDimensions: this.settings.embeddingDimensions,
         };
     }
-    generateEmbeddingResponse(texts, options) {
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return [response.embedding];
+    async doEmbedValues(texts, options) {
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: [response.embedding],
+        };
     }
     withSettings(additionalSettings) {
         return new LlamaCppTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

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

@@ -1,13 +1,13 @@
 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 { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
 export interface LlamaCppTextEmbeddingModelSettings extends EmbeddingModelSettings {
     api?: ApiConfiguration;
     embeddingDimensions?: number;
 }
-export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTextEmbeddingModelSettings> implements EmbeddingModel<string, LlamaCppTextEmbeddingResponse, LlamaCppTextEmbeddingModelSettings> {
+export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTextEmbeddingModelSettings> implements EmbeddingModel<string, LlamaCppTextEmbeddingModelSettings> {
     constructor(settings?: LlamaCppTextEmbeddingModelSettings);
     readonly provider: "llamacpp";
     get modelName(): null;
@@ -16,12 +16,14 @@ export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTe
     readonly embeddingDimensions: number | undefined;
     private readonly tokenizer;
     tokenize(text: string): Promise<number[]>;
-    callAPI(texts: Array<string>, options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<LlamaCppTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<LlamaCppTextEmbeddingResponse>;
     get settingsForEvent(): Partial<LlamaCppTextEmbeddingModelSettings>;
-    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<{
-        embedding: number[];
+    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+        response: {
+            embedding: number[];
+        };
+        embeddings: number[][];
     }>;
-    extractEmbeddings(response: LlamaCppTextEmbeddingResponse): number[][];
     withSettings(additionalSettings: Partial<LlamaCppTextEmbeddingModelSettings>): this;
 }
 declare const llamaCppTextEmbeddingResponseSchema: z.ZodObject<{

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.js

@@ -51,18 +51,14 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            content: texts[0],
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLlamaCppEmbeddingAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLlamaCppEmbeddingAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                content: texts[0],
+            }),
         });
     }
     get settingsForEvent() {
@@ -70,11 +66,12 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
             embeddingDimensions: this.settings.embeddingDimensions,
         };
     }
-    generateEmbeddingResponse(texts, options) {
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return [response.embedding];
+    async doEmbedValues(texts, options) {
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: [response.embedding],
+        };
     }
     withSettings(additionalSettings) {
         return new LlamaCppTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/llamacpp/LlamaCppTextGenerationModel.cjs

@@ -11,7 +11,7 @@ const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 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 PromptFormatTextGenerationModel_js_1 = require("../../prompt/PromptFormatTextGenerationModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../prompt/PromptFormatTextStreamingModel.cjs");
 const LlamaCppApiConfiguration_js_1 = require("./LlamaCppApiConfiguration.cjs");
 const LlamaCppError_js_1 = require("./LlamaCppError.cjs");
 const LlamaCppTokenizer_js_1 = require("./LlamaCppTokenizer.cjs");
@@ -39,25 +39,19 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.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 (0, callWithRetryAndThrottle_js_1.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() {
@@ -87,16 +81,22 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.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: exports.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: exports.LlamaCppTextGenerationResponseFormat.deltaIterable,
@@ -106,7 +106,7 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return fullDelta.delta;
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
@@ -116,13 +116,6 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             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));
     }
@@ -242,6 +235,7 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                         isComplete: eventData.stop,
                         delta: eventData.content,
                     },
+                    valueDelta: eventData.content,
                 });
                 if (eventData.stop) {
                     queue.close();

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 {};