modelfusion 0.40.0 → 0.41.0

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.cjs

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HuggingFaceTextEmbeddingModel = 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 HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const HuggingFaceApiConfiguration_js_1 = require("./HuggingFaceApiConfiguration.cjs");
+const HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
 /**
  * Create a text embedding model that calls a Hugging Face Inference API Feature Extraction Task.
  *
@@ -80,25 +80,18 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.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 (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,
+                abortSignal: options?.run?.abortSignal,
+                inputs: texts,
+            }),
         });
     }
     get settingsForEvent() {
@@ -107,11 +100,12 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.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/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,20 +106,16 @@ 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: 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));
     }
@@ -239,6 +235,7 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                         isComplete: eventData.stop,
                         delta: eventData.content,
                     },
+                    valueDelta: eventData.content,
                 });
                 if (eventData.stop) {
                     queue.close();