modelfusion 0.21.0 → 0.23.0

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

@@ -40,10 +40,10 @@ export interface CohereTextGenerationModelSettings extends TextGenerationModelSe
     p?: number;
     frequencyPenalty?: number;
     presencePenalty?: number;
-    stopSequences?: string[];
     returnLikelihoods?: "GENERATION" | "ALL" | "NONE";
     logitBias?: Record<string, number>;
     truncate?: "NONE" | "START" | "END";
+    cohereStopSequences?: string[];
 }
 /**
  * Create a text generation model that calls the Cohere Co.Generate API.
@@ -73,6 +73,7 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: CohereTextGenerationResponseFormatType<RESPONSE>;
     } & ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<RESPONSE>;
+    get settingsForEvent(): Partial<CohereTextGenerationModelSettings>;
     generateTextResponse(prompt: string, options?: ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<{
         prompt: string;
         id: string;

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

@@ -1,6 +1,6 @@
 import z from "zod";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { Run } from "../../run/Run.js";
+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";

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/llamacpp/LlamaCppTokenizer.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import { BasicTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
 export interface LlamaCppTokenizerSettings {

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

@@ -155,6 +155,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 +198,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));
     }

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

@@ -120,16 +120,17 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
     } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
+    get settingsForEvent(): Partial<OpenAITextGenerationModelSettings>;
     generateTextResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
         object: "text_completion";
         model: string;
-        id: string;
-        created: number;
         usage: {
             prompt_tokens: number;
             total_tokens: number;
             completion_tokens: number;
         };
+        id: string;
+        created: number;
         choices: {
             text: string;
             finish_reason: string;
@@ -141,6 +142,11 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
     generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
     extractTextDelta(fullDelta: OpenAITextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings, this>;
+    extractUsage(response: OpenAITextGenerationResponse): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
     withSettings(additionalSettings: Partial<OpenAITextGenerationModelSettings>): this;
 }
 declare const openAITextGenerationResponseSchema: z.ZodObject<{
@@ -180,13 +186,13 @@ declare const openAITextGenerationResponseSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     object: "text_completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
         total_tokens: number;
         completion_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         text: string;
         finish_reason: string;
@@ -196,13 +202,13 @@ declare const openAITextGenerationResponseSchema: z.ZodObject<{
 }, {
     object: "text_completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
         total_tokens: number;
         completion_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         text: string;
         finish_reason: string;
@@ -224,13 +230,13 @@ export declare const OpenAITextResponseFormat: {
         handler: ResponseHandler<{
             object: "text_completion";
             model: string;
-            id: string;
-            created: number;
             usage: {
                 prompt_tokens: number;
                 total_tokens: number;
                 completion_tokens: number;
             };
+            id: string;
+            created: number;
             choices: {
                 text: string;
                 finish_reason: string;

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -147,6 +147,23 @@ export class OpenAITextGenerationModel extends 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,
@@ -173,6 +190,13 @@ export class OpenAITextGenerationModel extends 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));
     }

package/model-provider/openai/OpenAITranscriptionModel.cjs

@@ -93,6 +93,13 @@ class OpenAITranscriptionModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callOpenAITranscriptionAPI(callSettings),
         });
     }
+    getEventSettingProperties() {
+        return ["baseUrl"];
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = ["baseUrl"];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     withSettings(additionalSettings) {
         return new OpenAITranscriptionModel(Object.assign({}, this.settings, additionalSettings));
     }