modelfusion 0.22.0 → 0.24.0

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

@@ -19,10 +19,12 @@ export declare const OPENAI_TEXT_GENERATION_MODELS: {
     "davinci-002": {
         contextWindowSize: number;
         tokenCostInMillicents: number;
+        fineTunedTokenCostInMillicents: number;
     };
     "babbage-002": {
         contextWindowSize: number;
         tokenCostInMillicents: number;
+        fineTunedTokenCostInMillicents: number;
     };
     "text-davinci-003": {
         contextWindowSize: number;
@@ -65,8 +67,17 @@ export declare const OPENAI_TEXT_GENERATION_MODELS: {
         tokenCostInMillicents: number;
     };
 };
-export type OpenAITextGenerationModelType = keyof typeof OPENAI_TEXT_GENERATION_MODELS;
-export declare const isOpenAITextGenerationModel: (model: string) => model is "davinci-002" | "babbage-002" | "text-davinci-003" | "text-davinci-002" | "code-davinci-002" | "davinci" | "text-curie-001" | "curie" | "text-babbage-001" | "babbage" | "text-ada-001" | "ada";
+export declare function getOpenAITextGenerationModelInformation(model: OpenAITextGenerationModelType): {
+    baseModel: OpenAITextGenerationBaseModelType;
+    isFineTuned: boolean;
+    contextWindowSize: number;
+    tokenCostInMillicents: number;
+};
+type FineTuneableOpenAITextGenerationModelType = "davinci-002" | "babbage-002";
+type FineTunedOpenAITextGenerationModelType = `ft:${FineTuneableOpenAITextGenerationModelType}:${string}:${string}:${string}`;
+export type OpenAITextGenerationBaseModelType = keyof typeof OPENAI_TEXT_GENERATION_MODELS;
+export type OpenAITextGenerationModelType = OpenAITextGenerationBaseModelType | FineTunedOpenAITextGenerationModelType;
+export declare const isOpenAITextGenerationModel: (model: string) => model is OpenAITextGenerationModelType;
 export declare const calculateOpenAITextGenerationCostInMillicents: ({ model, response, }: {
     model: OpenAITextGenerationModelType;
     response: OpenAITextGenerationResponse;
@@ -110,7 +121,7 @@ export interface OpenAITextGenerationModelSettings extends TextGenerationModelSe
 export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextGenerationModelSettings> implements TextGenerationModel<string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings> {
     constructor(settings: OpenAITextGenerationModelSettings);
     readonly provider: "openai";
-    get modelName(): "davinci-002" | "babbage-002" | "text-davinci-003" | "text-davinci-002" | "code-davinci-002" | "davinci" | "text-curie-001" | "curie" | "text-babbage-001" | "babbage" | "text-ada-001" | "ada";
+    get modelName(): OpenAITextGenerationModelType;
     readonly contextWindowSize: number;
     readonly tokenizer: TikTokenTokenizer;
     private get apiKey();
@@ -120,16 +131,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;
+            total_tokens: number;
         };
+        id: string;
+        created: number;
         choices: {
             text: string;
             finish_reason: string;
@@ -141,6 +153,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<{
@@ -170,23 +187,23 @@ declare const openAITextGenerationResponseSchema: z.ZodObject<{
         total_tokens: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     }, {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     }>;
 }, "strip", z.ZodTypeAny, {
     object: "text_completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         text: string;
         finish_reason: string;
@@ -196,13 +213,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;
+        total_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         text: string;
         finish_reason: string;
@@ -224,13 +241,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;
+                total_tokens: number;
             };
+            id: string;
+            created: number;
             choices: {
                 text: string;
                 finish_reason: string;

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -17,10 +17,12 @@ export const 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,
@@ -63,9 +65,36 @@ export const OPENAI_TEXT_GENERATION_MODELS = {
         tokenCostInMillicents: 0.04,
     },
 };
-export const isOpenAITextGenerationModel = (model) => model in OPENAI_TEXT_GENERATION_MODELS;
+export function getOpenAITextGenerationModelInformation(model) {
+    // Model is already a base model:
+    if (model in OPENAI_TEXT_GENERATION_MODELS) {
+        const baseModelInformation = 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 = 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}.`);
+}
+export const isOpenAITextGenerationModel = (model) => model in OPENAI_TEXT_GENERATION_MODELS ||
+    model.startsWith("ft:davinci-002:") ||
+    model.startsWith("ft:babbage-002:");
 export const calculateOpenAITextGenerationCostInMillicents = ({ model, response, }) => response.usage.total_tokens *
-    OPENAI_TEXT_GENERATION_MODELS[model].tokenCostInMillicents;
+    getOpenAITextGenerationModelInformation(model).tokenCostInMillicents;
 /**
  * Create a text generation model that calls the OpenAI text completion API.
  *
@@ -105,9 +134,11 @@ export class OpenAITextGenerationModel extends AbstractModel {
             writable: true,
             value: void 0
         });
-        this.tokenizer = new TikTokenTokenizer({ model: settings.model });
-        this.contextWindowSize =
-            OPENAI_TEXT_GENERATION_MODELS[settings.model].contextWindowSize;
+        const modelInformation = getOpenAITextGenerationModelInformation(this.settings.model);
+        this.tokenizer = new TikTokenTokenizer({
+            model: modelInformation.baseModel,
+        });
+        this.contextWindowSize = modelInformation.contextWindowSize;
     }
     get modelName() {
         return this.settings.model;
@@ -147,6 +178,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 +221,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));
     }

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

@@ -57,6 +57,8 @@ export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITransc
     callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
     } & ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
+    getEventSettingProperties(): (keyof OpenAITranscriptionModelSettings)[];
+    get settingsForEvent(): Partial<OpenAITranscriptionModelSettings>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }
 declare const openAITranscriptionJsonSchema: z.ZodObject<{

package/model-provider/openai/OpenAITranscriptionModel.js

@@ -86,6 +86,13 @@ export class OpenAITranscriptionModel extends 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));
     }

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

@@ -1,6 +1,8 @@
 import { TiktokenEncoding } from "js-tiktoken";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { OpenAIChatModelType, OpenAITextEmbeddingModelType, OpenAITextGenerationModelType } from "./index.js";
+import { OpenAITextEmbeddingModelType } from "./OpenAITextEmbeddingModel.js";
+import { OpenAITextGenerationBaseModelType } from "./OpenAITextGenerationModel.js";
+import { OpenAIChatBaseModelType } from "./chat/OpenAIChatModel.js";
 /**
  * TikToken tokenizer for OpenAI language models.
  *
@@ -21,7 +23,7 @@ export declare class TikTokenTokenizer implements FullTokenizer {
      * Get a TikToken tokenizer for a specific model or encoding.
      */
     constructor(options: {
-        model: OpenAIChatModelType | OpenAITextEmbeddingModelType | OpenAITextGenerationModelType;
+        model: OpenAIChatBaseModelType | OpenAITextGenerationBaseModelType | OpenAITextEmbeddingModelType;
     } | {
         encoding: TiktokenEncoding;
     });

package/model-provider/openai/chat/OpenAIChatModel.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.OpenAIChatResponseFormat = exports.OpenAIChatModel = exports.calculateOpenAIChatCostInMillicents = exports.isOpenAIChatModel = exports.OPENAI_CHAT_MODELS = void 0;
+exports.OpenAIChatResponseFormat = exports.OpenAIChatModel = exports.calculateOpenAIChatCostInMillicents = exports.isOpenAIChatModel = exports.getOpenAIChatModelInformation = exports.OPENAI_CHAT_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");
@@ -55,6 +55,8 @@ exports.OPENAI_CHAT_MODELS = {
         contextWindowSize: 4096,
         promptTokenCostInMillicents: 0.15,
         completionTokenCostInMillicents: 0.2,
+        fineTunedPromptTokenCostInMillicents: 1.2,
+        fineTunedCompletionTokenCostInMillicents: 1.6,
     },
     "gpt-3.5-turbo-0301": {
         contextWindowSize: 4096,
@@ -65,6 +67,8 @@ exports.OPENAI_CHAT_MODELS = {
         contextWindowSize: 4096,
         promptTokenCostInMillicents: 0.15,
         completionTokenCostInMillicents: 0.2,
+        fineTunedPromptTokenCostInMillicents: 1.2,
+        fineTunedCompletionTokenCostInMillicents: 1.6,
     },
     "gpt-3.5-turbo-16k": {
         contextWindowSize: 16384,
@@ -77,12 +81,45 @@ exports.OPENAI_CHAT_MODELS = {
         completionTokenCostInMillicents: 0.4,
     },
 };
-const isOpenAIChatModel = (model) => model in exports.OPENAI_CHAT_MODELS;
+function getOpenAIChatModelInformation(model) {
+    // Model is already a base model:
+    if (model in exports.OPENAI_CHAT_MODELS) {
+        const baseModelInformation = exports.OPENAI_CHAT_MODELS[model];
+        return {
+            baseModel: model,
+            isFineTuned: false,
+            contextWindowSize: baseModelInformation.contextWindowSize,
+            promptTokenCostInMillicents: baseModelInformation.promptTokenCostInMillicents,
+            completionTokenCostInMillicents: baseModelInformation.completionTokenCostInMillicents,
+        };
+    }
+    // Extract the base model from the fine-tuned model:
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, baseModel, ___, ____, _____] = model.split(":");
+    if (["gpt-3.5-turbo", "gpt-3.5-turbo-0613"].includes(baseModel)) {
+        const baseModelInformation = exports.OPENAI_CHAT_MODELS[baseModel];
+        return {
+            baseModel: baseModel,
+            isFineTuned: true,
+            contextWindowSize: baseModelInformation.contextWindowSize,
+            promptTokenCostInMillicents: baseModelInformation.fineTunedPromptTokenCostInMillicents,
+            completionTokenCostInMillicents: baseModelInformation.fineTunedCompletionTokenCostInMillicents,
+        };
+    }
+    throw new Error(`Unknown OpenAI chat base model ${baseModel}.`);
+}
+exports.getOpenAIChatModelInformation = getOpenAIChatModelInformation;
+const isOpenAIChatModel = (model) => model in exports.OPENAI_CHAT_MODELS ||
+    model.startsWith("ft:gpt-3.5-turbo-0613:") ||
+    model.startsWith("ft:gpt-3.5-turbo:");
 exports.isOpenAIChatModel = isOpenAIChatModel;
-const calculateOpenAIChatCostInMillicents = ({ model, response, }) => response.usage.prompt_tokens *
-    exports.OPENAI_CHAT_MODELS[model].promptTokenCostInMillicents +
-    response.usage.completion_tokens *
-        exports.OPENAI_CHAT_MODELS[model].completionTokenCostInMillicents;
+const calculateOpenAIChatCostInMillicents = ({ model, response, }) => {
+    const modelInformation = getOpenAIChatModelInformation(model);
+    return (response.usage.prompt_tokens *
+        modelInformation.promptTokenCostInMillicents +
+        response.usage.completion_tokens *
+            modelInformation.completionTokenCostInMillicents);
+};
 exports.calculateOpenAIChatCostInMillicents = calculateOpenAIChatCostInMillicents;
 /**
  * Create a text generation model that calls the OpenAI chat completion API.
@@ -124,9 +161,11 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: void 0
         });
-        this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({ model: this.settings.model });
-        this.contextWindowSize =
-            exports.OPENAI_CHAT_MODELS[this.settings.model].contextWindowSize;
+        const modelInformation = getOpenAIChatModelInformation(this.settings.model);
+        this.tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({
+            model: modelInformation.baseModel,
+        });
+        this.contextWindowSize = modelInformation.contextWindowSize;
     }
     get modelName() {
         return this.settings.model;
@@ -170,6 +209,19 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             call: async () => callOpenAIChatCompletionAPI(callSettings),
         });
     }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "stopSequences",
+            "maxCompletionTokens",
+            "baseUrl",
+            "functions",
+            "functionCall",
+            "temperature",
+            "topP",
+            "n",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
     generateTextResponse(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
@@ -211,6 +263,13 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         const jsonText = response.choices[0].message.function_call.arguments;
         return secure_json_parse_1.default.parse(jsonText);
     }
+    extractUsage(response) {
+        return {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens,
+        };
+    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
             model: this.withSettings({ stopSequences: promptFormat.stopSequences }),

package/model-provider/openai/chat/OpenAIChatModel.d.ts

@@ -1,8 +1,8 @@
 import z from "zod";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
 import { ModelFunctionOptions } from "../../../model-function/ModelFunctionOptions.js";
-import { GenerateJsonModel } from "../../../model-function/generate-json/GenerateJsonModel.js";
-import { GenerateJsonOrTextModel } from "../../../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { JsonGenerationModel } from "../../../model-function/generate-json/JsonGenerationModel.js";
+import { JsonOrTextGenerationModel } from "../../../model-function/generate-json/JsonOrTextGenerationModel.js";
 import { DeltaEvent } from "../../../model-function/generate-text/DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../../prompt/PromptFormat.js";
@@ -48,6 +48,8 @@ export declare const OPENAI_CHAT_MODELS: {
         contextWindowSize: number;
         promptTokenCostInMillicents: number;
         completionTokenCostInMillicents: number;
+        fineTunedPromptTokenCostInMillicents: number;
+        fineTunedCompletionTokenCostInMillicents: number;
     };
     "gpt-3.5-turbo-0301": {
         contextWindowSize: number;
@@ -58,6 +60,8 @@ export declare const OPENAI_CHAT_MODELS: {
         contextWindowSize: number;
         promptTokenCostInMillicents: number;
         completionTokenCostInMillicents: number;
+        fineTunedPromptTokenCostInMillicents: number;
+        fineTunedCompletionTokenCostInMillicents: number;
     };
     "gpt-3.5-turbo-16k": {
         contextWindowSize: number;
@@ -70,8 +74,18 @@ export declare const OPENAI_CHAT_MODELS: {
         completionTokenCostInMillicents: number;
     };
 };
-export type OpenAIChatModelType = keyof typeof OPENAI_CHAT_MODELS;
-export declare const isOpenAIChatModel: (model: string) => model is "gpt-4" | "gpt-4-0314" | "gpt-4-0613" | "gpt-4-32k" | "gpt-4-32k-0314" | "gpt-4-32k-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0301" | "gpt-3.5-turbo-0613" | "gpt-3.5-turbo-16k" | "gpt-3.5-turbo-16k-0613";
+export declare function getOpenAIChatModelInformation(model: OpenAIChatModelType): {
+    baseModel: OpenAIChatBaseModelType;
+    isFineTuned: boolean;
+    contextWindowSize: number;
+    promptTokenCostInMillicents: number;
+    completionTokenCostInMillicents: number;
+};
+type FineTuneableOpenAIChatModelType = `gpt-3.5-turbo` | `gpt-3.5-turbo-0613`;
+type FineTunedOpenAIChatModelType = `ft:${FineTuneableOpenAIChatModelType}:${string}:${string}:${string}`;
+export type OpenAIChatBaseModelType = keyof typeof OPENAI_CHAT_MODELS;
+export type OpenAIChatModelType = OpenAIChatBaseModelType | FineTunedOpenAIChatModelType;
+export declare const isOpenAIChatModel: (model: string) => model is OpenAIChatModelType;
 export declare const calculateOpenAIChatCostInMillicents: ({ model, response, }: {
     model: OpenAIChatModelType;
     response: OpenAIChatResponse;
@@ -117,10 +131,10 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, OpenAIM
  *   ),
  * ]);
  */
-export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, GenerateJsonModel<OpenAIChatSingleFunctionPrompt<unknown>, OpenAIChatResponse, OpenAIChatSettings>, GenerateJsonOrTextModel<OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, OpenAIChatResponse, OpenAIChatSettings> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, JsonGenerationModel<OpenAIChatSingleFunctionPrompt<unknown>, OpenAIChatResponse, OpenAIChatSettings>, JsonOrTextGenerationModel<OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, OpenAIChatResponse, OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
-    get modelName(): "gpt-4" | "gpt-4-0314" | "gpt-4-0613" | "gpt-4-32k" | "gpt-4-32k-0314" | "gpt-4-32k-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0301" | "gpt-3.5-turbo-0613" | "gpt-3.5-turbo-16k" | "gpt-3.5-turbo-16k-0613";
+    get modelName(): OpenAIChatModelType;
     readonly contextWindowSize: number;
     readonly tokenizer: TikTokenTokenizer;
     private get apiKey();
@@ -134,16 +148,17 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     } & ModelFunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
+    get settingsForEvent(): Partial<OpenAIChatSettings>;
     generateTextResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<{
         object: "chat.completion";
         model: string;
-        id: string;
-        created: number;
         usage: {
             prompt_tokens: number;
-            total_tokens: number;
             completion_tokens: number;
+            total_tokens: number;
         };
+        id: string;
+        created: number;
         choices: {
             message: {
                 content: string | null;
@@ -170,6 +185,11 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
      */
     generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
     extractJson(response: OpenAIChatResponse): unknown;
+    extractUsage(response: OpenAIChatResponse): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
 }
@@ -241,23 +261,23 @@ declare const openAIChatResponseSchema: z.ZodObject<{
         total_tokens: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     }, {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     }>;
 }, "strip", z.ZodTypeAny, {
     object: "chat.completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         message: {
             content: string | null;
@@ -274,13 +294,13 @@ declare const openAIChatResponseSchema: z.ZodObject<{
 }, {
     object: "chat.completion";
     model: string;
-    id: string;
-    created: number;
     usage: {
         prompt_tokens: number;
-        total_tokens: number;
         completion_tokens: number;
+        total_tokens: number;
     };
+    id: string;
+    created: number;
     choices: {
         message: {
             content: string | null;
@@ -309,13 +329,13 @@ export declare const OpenAIChatResponseFormat: {
         handler: ResponseHandler<{
             object: "chat.completion";
             model: string;
-            id: string;
-            created: number;
             usage: {
                 prompt_tokens: number;
-                total_tokens: number;
                 completion_tokens: number;
+                total_tokens: number;
             };
+            id: string;
+            created: number;
             choices: {
                 message: {
                     content: string | null;