modelfusion 0.22.0 → 0.24.0

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -96,6 +96,8 @@ export class CohereTextGenerationModel extends AbstractModel {
             // to exclude stop tokens from the generated text
             endSequences: combinedSettings.stopSequences,
             maxTokens: combinedSettings.maxCompletionTokens,
+            // mapped name because of conflict with stopSequences:
+            stopSequences: combinedSettings.cohereStopSequences,
             abortSignal: run?.abortSignal,
             prompt,
             responseFormat,
@@ -106,6 +108,24 @@ export class CohereTextGenerationModel extends AbstractModel {
             call: async () => callCohereTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "baseUrl",
+            "numGenerations",
+            "temperature",
+            "k",
+            "p",
+            "frequencyPenalty",
+            "presencePenalty",
+            "returnLikelihoods",
+            "logitBias",
+            "truncate",
+            "cohereStopSequences",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, {
             ...options,

package/model-provider/cohere/CohereTokenizer.d.ts

@@ -4,7 +4,7 @@ import { Run } from "../../core/Run.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
 import { CohereTextGenerationModelType } from "./CohereTextGenerationModel.js";
-import { CohereTextEmbeddingModelType } from "./index.js";
+import { CohereTextEmbeddingModelType } from "./CohereTextEmbeddingModel.js";
 export type CohereTokenizerModelType = CohereTextGenerationModelType | CohereTextEmbeddingModelType;
 export interface CohereTokenizerSettings {
     model: CohereTokenizerModelType;

package/model-provider/elevenlabs/ElevenLabsSpeechSynthesisModel.cjs

@@ -49,6 +49,14 @@ class ElevenLabsSpeechSynthesisModel extends AbstractModel_js_1.AbstractModel {
             }),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+            model: this.settings.model,
+            voice: this.settings.voice,
+            voiceSettings: this.settings.voiceSettings,
+        };
+    }
     generateSpeechResponse(text, options) {
         return this.callAPI(text, options);
     }

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

@@ -24,6 +24,7 @@ export declare class ElevenLabsSpeechSynthesisModel extends AbstractModel<Eleven
     readonly modelName: null;
     private get apiKey();
     private callAPI;
+    get settingsForEvent(): Partial<ElevenLabsSpeechSynthesisModelSettings>;
     generateSpeechResponse(text: string, options?: ModelFunctionOptions<ElevenLabsSpeechSynthesisModelSettings> | undefined): Promise<Buffer>;
     withSettings(additionalSettings: Partial<ElevenLabsSpeechSynthesisModelSettings>): this;
 }

package/model-provider/elevenlabs/ElevenLabsSpeechSynthesisModel.js

@@ -46,6 +46,14 @@ export class ElevenLabsSpeechSynthesisModel extends AbstractModel {
             }),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+            model: this.settings.model,
+            voice: this.settings.voice,
+            voiceSettings: this.settings.voiceSettings,
+        };
+    }
     generateSpeechResponse(text, options) {
         return this.callAPI(text, options);
     }

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.cjs

@@ -104,6 +104,13 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callHuggingFaceTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+            embeddingDimensions: this.settings.embeddingDimensions,
+            options: this.settings.options,
+        };
+    }
     generateEmbeddingResponse(texts, options) {
         return this.callAPI(texts, options);
     }

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

@@ -47,6 +47,7 @@ export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<Hugging
     readonly tokenizer: undefined;
     private get apiKey();
     callAPI(texts: Array<string>, options?: ModelFunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<HuggingFaceTextEmbeddingResponse>;
+    get settingsForEvent(): Partial<HuggingFaceTextEmbeddingModelSettings>;
     readonly countPromptTokens: undefined;
     generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<number[][]>;
     extractEmbeddings(response: HuggingFaceTextEmbeddingResponse): number[][];

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.js

@@ -98,6 +98,13 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
             call: async () => callHuggingFaceTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+            embeddingDimensions: this.settings.embeddingDimensions,
+            options: this.settings.options,
+        };
+    }
     generateEmbeddingResponse(texts, options) {
         return this.callAPI(texts, options);
     }

package/model-provider/huggingface/HuggingFaceTextGenerationModel.cjs

@@ -102,6 +102,22 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callHuggingFaceTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "stopSequences",
+            "maxCompletionTokens",
+            "baseUrl",
+            "topK",
+            "topP",
+            "temperature",
+            "repetitionPenalty",
+            "maxTime",
+            "numReturnSequences",
+            "doSample",
+            "options",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, options);
     }

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

@@ -50,6 +50,7 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
     readonly tokenizer: undefined;
     private get apiKey();
     callAPI(prompt: string, options?: ModelFunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<HuggingFaceTextGenerationResponse>;
+    get settingsForEvent(): Partial<HuggingFaceTextGenerationModelSettings>;
     readonly countPromptTokens: undefined;
     generateTextResponse(prompt: string, options?: ModelFunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<{
         generated_text: string;

package/model-provider/huggingface/HuggingFaceTextGenerationModel.js

@@ -96,6 +96,22 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
             call: async () => callHuggingFaceTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "stopSequences",
+            "maxCompletionTokens",
+            "baseUrl",
+            "topK",
+            "topP",
+            "temperature",
+            "repetitionPenalty",
+            "maxTime",
+            "numReturnSequences",
+            "doSample",
+            "options",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, options);
     }

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.cjs

@@ -72,6 +72,12 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callLlamaCppEmbeddingAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+            embeddingDimensions: this.settings.embeddingDimensions,
+        };
+    }
     generateEmbeddingResponse(texts, options) {
         return this.callAPI(texts, options);
     }

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

@@ -24,6 +24,7 @@ export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTe
     private readonly tokenizer;
     tokenize(text: string): Promise<number[]>;
     callAPI(texts: Array<string>, options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<LlamaCppTextEmbeddingResponse>;
+    get settingsForEvent(): Partial<LlamaCppTextEmbeddingModelSettings>;
     generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<{
         embedding: number[];
     }>;

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.js

@@ -66,6 +66,12 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
             call: async () => callLlamaCppEmbeddingAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+            embeddingDimensions: this.settings.embeddingDimensions,
+        };
+    }
     generateEmbeddingResponse(texts, options) {
         return this.callAPI(texts, options);
     }

package/model-provider/llamacpp/LlamaCppTextGenerationModel.cjs

@@ -61,6 +61,30 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callLlamaCppTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "baseUrl",
+            "contextWindowSize",
+            "temperature",
+            "topK",
+            "topP",
+            "nKeep",
+            "tfsZ",
+            "typicalP",
+            "repeatPenalty",
+            "repeatLastN",
+            "penalizeNl",
+            "mirostat",
+            "mirostatTau",
+            "mirostatEta",
+            "seed",
+            "ignoreEos",
+            "logitBias",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     async countPromptTokens(prompt) {
         const tokens = await this.tokenizer.tokenize(prompt);
         return tokens.length;
@@ -91,6 +115,13 @@ 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));
     }

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

@@ -47,6 +47,7 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: LlamaCppTextGenerationResponseFormatType<RESPONSE>;
     } & ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): 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;
@@ -101,6 +102,11 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
     generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
     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;
+    };
     withSettings(additionalSettings: Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;
 }
 declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -55,6 +55,30 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
             call: async () => callLlamaCppTextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "baseUrl",
+            "contextWindowSize",
+            "temperature",
+            "topK",
+            "topP",
+            "nKeep",
+            "tfsZ",
+            "typicalP",
+            "repeatPenalty",
+            "repeatLastN",
+            "penalizeNl",
+            "mirostat",
+            "mirostatTau",
+            "mirostatEta",
+            "seed",
+            "ignoreEos",
+            "logitBias",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     async countPromptTokens(prompt) {
         const tokens = await this.tokenizer.tokenize(prompt);
         return tokens.length;
@@ -85,6 +109,13 @@ export class LlamaCppTextGenerationModel extends 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));
     }

package/model-provider/openai/OpenAIImageGenerationModel.cjs

@@ -68,6 +68,14 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callOpenAIImageGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "baseUrl",
+            "n",
+            "size",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateImageResponse(prompt, options) {
         return this.callAPI(prompt, {
             responseFormat: exports.OpenAIImageGenerationResponseFormat.base64Json,

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

@@ -35,6 +35,7 @@ export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImag
     } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
+    get settingsForEvent(): Partial<OpenAIImageGenerationSettings>;
     generateImageResponse(prompt: string, options?: ModelFunctionOptions<OpenAIImageGenerationSettings>): Promise<{
         data: {
             b64_json: string;

package/model-provider/openai/OpenAIImageGenerationModel.js

@@ -64,6 +64,14 @@ export class OpenAIImageGenerationModel extends AbstractModel {
             call: async () => callOpenAIImageGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "baseUrl",
+            "n",
+            "size",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateImageResponse(prompt, options) {
         return this.callAPI(prompt, {
             responseFormat: OpenAIImageGenerationResponseFormat.base64Json,

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -112,6 +112,11 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callOpenAITextEmbeddingAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+        };
+    }
     generateEmbeddingResponse(texts, options) {
         if (texts.length > this.maxTextsPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxTextsPerCall} texts per API call.`);

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

@@ -51,18 +51,19 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     private get apiKey();
     countTokens(input: string): Promise<number>;
     callAPI(text: string, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    get settingsForEvent(): Partial<OpenAITextEmbeddingModelSettings>;
     generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
         object: "list";
         model: string;
+        usage: {
+            prompt_tokens: number;
+            total_tokens: number;
+        };
         data: {
             object: "embedding";
             embedding: number[];
             index: number;
         }[];
-        usage: {
-            prompt_tokens: number;
-            total_tokens: number;
-        };
     }>;
     extractEmbeddings(response: OpenAITextEmbeddingResponse): number[][];
     withSettings(additionalSettings: OpenAITextEmbeddingModelSettings): this;
@@ -96,27 +97,27 @@ declare const openAITextEmbeddingResponseSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     object: "list";
     model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
     data: {
         object: "embedding";
         embedding: number[];
         index: number;
     }[];
+}, {
+    object: "list";
+    model: string;
     usage: {
         prompt_tokens: number;
         total_tokens: number;
     };
-}, {
-    object: "list";
-    model: string;
     data: {
         object: "embedding";
         embedding: number[];
         index: number;
     }[];
-    usage: {
-        prompt_tokens: number;
-        total_tokens: number;
-    };
 }>;
 export type OpenAITextEmbeddingResponse = z.infer<typeof openAITextEmbeddingResponseSchema>;
 export {};

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -104,6 +104,11 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
             call: async () => callOpenAITextEmbeddingAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        return {
+            baseUrl: this.settings.baseUrl,
+        };
+    }
     generateEmbeddingResponse(texts, options) {
         if (texts.length > this.maxTextsPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxTextsPerCall} texts per API call.`);

package/model-provider/openai/OpenAITextGenerationModel.cjs

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAITextResponseFormat = exports.OpenAITextGenerationModel = exports.calculateOpenAITextGenerationCostInMillicents = exports.isOpenAITextGenerationModel = exports.OPENAI_TEXT_GENERATION_MODELS = void 0;
+exports.OpenAITextResponseFormat = exports.OpenAITextGenerationModel = exports.calculateOpenAITextGenerationCostInMillicents = exports.isOpenAITextGenerationModel = exports.getOpenAITextGenerationModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = __importDefault(require("zod"));
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
@@ -23,10 +23,12 @@ exports.OPENAI_TEXT_GENERATION_MODELS = {
     "davinci-002": {
         contextWindowSize: 16384,
         tokenCostInMillicents: 0.2,
+        fineTunedTokenCostInMillicents: 1.2,
     },
     "babbage-002": {
         contextWindowSize: 16384,
         tokenCostInMillicents: 0.04,
+        fineTunedTokenCostInMillicents: 0.16,
     },
     "text-davinci-003": {
         contextWindowSize: 4096,
@@ -69,10 +71,38 @@ exports.OPENAI_TEXT_GENERATION_MODELS = {
         tokenCostInMillicents: 0.04,
     },
 };
-const isOpenAITextGenerationModel = (model) => model in exports.OPENAI_TEXT_GENERATION_MODELS;
+function getOpenAITextGenerationModelInformation(model) {
+    // Model is already a base model:
+    if (model in exports.OPENAI_TEXT_GENERATION_MODELS) {
+        const baseModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS[model];
+        return {
+            baseModel: model,
+            isFineTuned: false,
+            contextWindowSize: baseModelInformation.contextWindowSize,
+            tokenCostInMillicents: baseModelInformation.tokenCostInMillicents,
+        };
+    }
+    // Extract the base model from the fine-tuned model:
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, baseModel, ___, ____, _____] = model.split(":");
+    if (["davinci-002", "babbage-002"].includes(baseModel)) {
+        const baseModelInformation = exports.OPENAI_TEXT_GENERATION_MODELS[baseModel];
+        return {
+            baseModel: baseModel,
+            isFineTuned: true,
+            contextWindowSize: baseModelInformation.contextWindowSize,
+            tokenCostInMillicents: baseModelInformation.fineTunedTokenCostInMillicents,
+        };
+    }
+    throw new Error(`Unknown OpenAI chat base model ${baseModel}.`);
+}
+exports.getOpenAITextGenerationModelInformation = getOpenAITextGenerationModelInformation;
+const isOpenAITextGenerationModel = (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, }) => response.usage.total_tokens *
-    exports.OPENAI_TEXT_GENERATION_MODELS[model].tokenCostInMillicents;
+    getOpenAITextGenerationModelInformation(model).tokenCostInMillicents;
 exports.calculateOpenAITextGenerationCostInMillicents = calculateOpenAITextGenerationCostInMillicents;
 /**
  * Create a text generation model that calls the OpenAI text completion API.
@@ -113,9 +143,11 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: void 0
         });
-        this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({ model: settings.model });
-        this.contextWindowSize =
-            exports.OPENAI_TEXT_GENERATION_MODELS[settings.model].contextWindowSize;
+        const modelInformation = getOpenAITextGenerationModelInformation(this.settings.model);
+        this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({
+            model: modelInformation.baseModel,
+        });
+        this.contextWindowSize = modelInformation.contextWindowSize;
     }
     get modelName() {
         return this.settings.model;
@@ -155,6 +187,23 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callOpenAITextGenerationAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "baseUrl",
+            "suffix",
+            "temperature",
+            "topP",
+            "n",
+            "logprobs",
+            "echo",
+            "presencePenalty",
+            "frequencyPenalty",
+            "bestOf",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
@@ -181,6 +230,13 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
             promptFormat,
         });
     }
+    extractUsage(response) {
+        return {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens,
+        };
+    }
     withSettings(additionalSettings) {
         return new OpenAITextGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }