modelfusion 0.132.0 → 0.134.0

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

@@ -1,232 +0,0 @@
-import { z } from "zod";
-import { FunctionCallOptions } from "../../core/FunctionOptions.js";
-import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { ResponseHandler } from "../../core/api/postToApi.js";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/generate-transcription/TranscriptionModel.js";
-import { DataContent } from "../../util/format/DataContent.js";
-/**
- * @see https://openai.com/pricing
- */
-export declare const OPENAI_TRANSCRIPTION_MODELS: {
-    "whisper-1": {
-        costInMillicentsPerSecond: number;
-    };
-};
-export type OpenAITranscriptionModelType = keyof typeof OPENAI_TRANSCRIPTION_MODELS;
-export declare const calculateOpenAITranscriptionCostInMillicents: ({ model, response, }: {
-    model: OpenAITranscriptionModelType;
-    response: OpenAITranscriptionVerboseJsonResponse;
-}) => number | null;
-export interface OpenAITranscriptionModelSettings extends TranscriptionModelSettings {
-    api?: ApiConfiguration;
-    /**
-     * ID of the model to use. Only whisper-1 is currently available.
-     */
-    model: OpenAITranscriptionModelType;
-    /**
-     * The language of the input audio. Supplying the input language in ISO-639-1 format will improve accuracy and latency.
-     */
-    language?: string;
-    /**
-     * The sampling temperature, between 0 and 1.
-     * Higher values like 0.8 will make the output more random,
-     * while lower values like 0.2 will make it more focused and deterministic.
-     * If set to 0, the model will use log probability to automatically
-     * increase the temperature until certain thresholds are hit.
-     */
-    temperature?: number;
-    /**
-     * An optional text to guide the model's style or continue a previous audio segment. The prompt should match the audio language.
-     */
-    prompt?: string;
-}
-/**
- * Create a transcription model that calls the OpenAI transcription API.
- *
- * @see https://platform.openai.com/docs/api-reference/audio/create
- *
- * @example
- * const data = await fs.promises.readFile("data/test.mp3");
- *
- * const transcription = await transcribe(
- *   new OpenAITranscriptionModel({ model: "whisper-1" }),
- *   {
- *     type: "mp3",
- *     data,
- *   }
- * );
- */
-export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITranscriptionModelSettings> implements TranscriptionModel<OpenAITranscriptionModelSettings> {
-    constructor(settings: OpenAITranscriptionModelSettings);
-    readonly provider: "openai";
-    get modelName(): "whisper-1";
-    doTranscribe({ audioData, mimeType, }: {
-        audioData: DataContent;
-        mimeType: string;
-    }, options: FunctionCallOptions): Promise<{
-        rawResponse: {
-            text: string;
-            duration: number;
-            task: "transcribe";
-            language: string;
-            segments: {
-                text: string;
-                id: number;
-                temperature: number;
-                tokens: number[];
-                start: number;
-                seek: number;
-                end: number;
-                avg_logprob: number;
-                compression_ratio: number;
-                no_speech_prob: number;
-                transient?: boolean | undefined;
-            }[];
-        };
-        transcription: string;
-    }>;
-    callAPI<RESULT>(input: {
-        fileExtension: string;
-        audioData: Uint8Array;
-    }, callOptions: FunctionCallOptions, options: {
-        responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
-    }): Promise<RESULT>;
-    get settingsForEvent(): Partial<OpenAITranscriptionModelSettings>;
-    withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
-}
-declare const openAITranscriptionJsonSchema: z.ZodObject<{
-    text: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    text: string;
-}, {
-    text: string;
-}>;
-export type OpenAITranscriptionJsonResponse = z.infer<typeof openAITranscriptionJsonSchema>;
-declare const openAITranscriptionVerboseJsonSchema: z.ZodObject<{
-    task: z.ZodLiteral<"transcribe">;
-    language: z.ZodString;
-    duration: z.ZodNumber;
-    segments: z.ZodArray<z.ZodObject<{
-        id: z.ZodNumber;
-        seek: z.ZodNumber;
-        start: z.ZodNumber;
-        end: z.ZodNumber;
-        text: z.ZodString;
-        tokens: z.ZodArray<z.ZodNumber, "many">;
-        temperature: z.ZodNumber;
-        avg_logprob: z.ZodNumber;
-        compression_ratio: z.ZodNumber;
-        no_speech_prob: z.ZodNumber;
-        transient: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        text: string;
-        id: number;
-        temperature: number;
-        tokens: number[];
-        start: number;
-        seek: number;
-        end: number;
-        avg_logprob: number;
-        compression_ratio: number;
-        no_speech_prob: number;
-        transient?: boolean | undefined;
-    }, {
-        text: string;
-        id: number;
-        temperature: number;
-        tokens: number[];
-        start: number;
-        seek: number;
-        end: number;
-        avg_logprob: number;
-        compression_ratio: number;
-        no_speech_prob: number;
-        transient?: boolean | undefined;
-    }>, "many">;
-    text: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    text: string;
-    duration: number;
-    task: "transcribe";
-    language: string;
-    segments: {
-        text: string;
-        id: number;
-        temperature: number;
-        tokens: number[];
-        start: number;
-        seek: number;
-        end: number;
-        avg_logprob: number;
-        compression_ratio: number;
-        no_speech_prob: number;
-        transient?: boolean | undefined;
-    }[];
-}, {
-    text: string;
-    duration: number;
-    task: "transcribe";
-    language: string;
-    segments: {
-        text: string;
-        id: number;
-        temperature: number;
-        tokens: number[];
-        start: number;
-        seek: number;
-        end: number;
-        avg_logprob: number;
-        compression_ratio: number;
-        no_speech_prob: number;
-        transient?: boolean | undefined;
-    }[];
-}>;
-export type OpenAITranscriptionVerboseJsonResponse = z.infer<typeof openAITranscriptionVerboseJsonSchema>;
-export type OpenAITranscriptionResponseFormatType<T> = {
-    type: "json" | "text" | "srt" | "verbose_json" | "vtt";
-    handler: ResponseHandler<T>;
-};
-export declare const OpenAITranscriptionResponseFormat: {
-    json: {
-        type: "json";
-        handler: ResponseHandler<{
-            text: string;
-        }>;
-    };
-    verboseJson: {
-        type: "verbose_json";
-        handler: ResponseHandler<{
-            text: string;
-            duration: number;
-            task: "transcribe";
-            language: string;
-            segments: {
-                text: string;
-                id: number;
-                temperature: number;
-                tokens: number[];
-                start: number;
-                seek: number;
-                end: number;
-                avg_logprob: number;
-                compression_ratio: number;
-                no_speech_prob: number;
-                transient?: boolean | undefined;
-            }[];
-        }>;
-    };
-    text: {
-        type: "text";
-        handler: ResponseHandler<string>;
-    };
-    srt: {
-        type: "srt";
-        handler: ResponseHandler<string>;
-    };
-    vtt: {
-        type: "vtt";
-        handler: ResponseHandler<string>;
-    };
-};
-export {};

package/model-provider/openai/OpenAITranscriptionModel.js

@@ -1,166 +0,0 @@
-import { z } from "zod";
-import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
-import { createJsonResponseHandler, createTextResponseHandler, postToApi, } from "../../core/api/postToApi.js";
-import { zodSchema } from "../../core/schema/ZodSchema.js";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { getAudioFileExtension } from "../../util/audio/getAudioFileExtension.js";
-import { convertDataContentToUint8Array, } from "../../util/format/DataContent.js";
-import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
-import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
-/**
- * @see https://openai.com/pricing
- */
-export const OPENAI_TRANSCRIPTION_MODELS = {
-    "whisper-1": {
-        costInMillicentsPerSecond: 10, // = 600 / 60,
-    },
-};
-export const calculateOpenAITranscriptionCostInMillicents = ({ model, response, }) => {
-    if (model !== "whisper-1") {
-        return null;
-    }
-    const durationInSeconds = response.duration;
-    return (Math.ceil(durationInSeconds) *
-        OPENAI_TRANSCRIPTION_MODELS[model].costInMillicentsPerSecond);
-};
-/**
- * Create a transcription model that calls the OpenAI transcription API.
- *
- * @see https://platform.openai.com/docs/api-reference/audio/create
- *
- * @example
- * const data = await fs.promises.readFile("data/test.mp3");
- *
- * const transcription = await transcribe(
- *   new OpenAITranscriptionModel({ model: "whisper-1" }),
- *   {
- *     type: "mp3",
- *     data,
- *   }
- * );
- */
-export class OpenAITranscriptionModel extends AbstractModel {
-    constructor(settings) {
-        super({ settings });
-        Object.defineProperty(this, "provider", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "openai"
-        });
-    }
-    get modelName() {
-        return this.settings.model;
-    }
-    async doTranscribe({ audioData, mimeType, }, options) {
-        const rawResponse = await this.callAPI({
-            fileExtension: getAudioFileExtension(mimeType),
-            audioData: convertDataContentToUint8Array(audioData),
-        }, options, { responseFormat: OpenAITranscriptionResponseFormat.verboseJson });
-        return {
-            rawResponse,
-            transcription: rawResponse.text,
-        };
-    }
-    async callAPI(input, callOptions, options) {
-        const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const abortSignal = callOptions?.run?.abortSignal;
-        return callWithRetryAndThrottle({
-            retry: api.retry,
-            throttle: api.throttle,
-            call: async () => {
-                const fileName = `audio.${input.fileExtension}`;
-                const formData = new FormData();
-                formData.append("file", new Blob([input.audioData]), fileName);
-                formData.append("model", this.settings.model);
-                if (this.settings.prompt != null) {
-                    formData.append("prompt", this.settings.prompt);
-                }
-                if (options.responseFormat != null) {
-                    formData.append("response_format", options.responseFormat.type);
-                }
-                if (this.settings.temperature != null) {
-                    formData.append("temperature", this.settings.temperature.toString());
-                }
-                if (this.settings.language != null) {
-                    formData.append("language", this.settings.language);
-                }
-                return postToApi({
-                    url: api.assembleUrl("/audio/transcriptions"),
-                    headers: api.headers({
-                        functionType: callOptions.functionType,
-                        functionId: callOptions.functionId,
-                        run: callOptions.run,
-                        callId: callOptions.callId,
-                    }),
-                    body: {
-                        content: formData,
-                        values: {
-                            model: this.settings.model,
-                            prompt: this.settings.prompt,
-                            response_format: options.responseFormat,
-                            temperature: this.settings.temperature,
-                            language: this.settings.language,
-                        },
-                    },
-                    failedResponseHandler: failedOpenAICallResponseHandler,
-                    successfulResponseHandler: options.responseFormat.handler,
-                    abortSignal,
-                });
-            },
-        });
-    }
-    get settingsForEvent() {
-        return {
-            language: this.settings.language,
-            temperature: this.settings.temperature,
-        };
-    }
-    withSettings(additionalSettings) {
-        return new OpenAITranscriptionModel(Object.assign({}, this.settings, additionalSettings));
-    }
-}
-const openAITranscriptionJsonSchema = z.object({
-    text: z.string(),
-});
-const openAITranscriptionVerboseJsonSchema = z.object({
-    task: z.literal("transcribe"),
-    language: z.string(),
-    duration: z.number(),
-    segments: z.array(z.object({
-        id: z.number(),
-        seek: z.number(),
-        start: z.number(),
-        end: z.number(),
-        text: z.string(),
-        tokens: z.array(z.number()),
-        temperature: z.number(),
-        avg_logprob: z.number(),
-        compression_ratio: z.number(),
-        no_speech_prob: z.number(),
-        transient: z.boolean().optional(),
-    })),
-    text: z.string(),
-});
-export const OpenAITranscriptionResponseFormat = {
-    json: {
-        type: "json",
-        handler: createJsonResponseHandler(zodSchema(openAITranscriptionJsonSchema)),
-    },
-    verboseJson: {
-        type: "verbose_json",
-        handler: createJsonResponseHandler(zodSchema(openAITranscriptionVerboseJsonSchema)),
-    },
-    text: {
-        type: "text",
-        handler: createTextResponseHandler(),
-    },
-    srt: {
-        type: "srt",
-        handler: createTextResponseHandler(),
-    },
-    vtt: {
-        type: "vtt",
-        handler: createTextResponseHandler(),
-    },
-};

package/model-provider/openai/TikTokenTokenizer.cjs

@@ -1,85 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TikTokenTokenizer = void 0;
-const lite_1 = require("js-tiktoken/lite");
-const cl100k_base_1 = __importDefault(require("js-tiktoken/ranks/cl100k_base"));
-const never_js_1 = require("../../util/never.cjs");
-/**
- * TikToken tokenizer for OpenAI language models.
- *
- * @see https://github.com/openai/tiktoken
- *
- * @example
- * const tokenizer = new TikTokenTokenizer({ model: "gpt-4" });
- *
- * const text = "At first, Nox didn't know what to do with the pup.";
- *
- * const tokenCount = await countTokens(tokenizer, text);
- * const tokens = await tokenizer.tokenize(text);
- * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
- * const reconstructedText = await tokenizer.detokenize(tokens);
- */
-class TikTokenTokenizer {
-    /**
-     * Get a TikToken tokenizer for a specific model or encoding.
-     */
-    constructor(settings) {
-        Object.defineProperty(this, "tiktoken", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.tiktoken = new lite_1.Tiktoken(getTiktokenBPE(settings.model));
-    }
-    async tokenize(text) {
-        return this.tiktoken.encode(text);
-    }
-    async tokenizeWithTexts(text) {
-        const tokens = this.tiktoken.encode(text);
-        return {
-            tokens,
-            tokenTexts: tokens.map((token) => this.tiktoken.decode([token])),
-        };
-    }
-    async detokenize(tokens) {
-        return this.tiktoken.decode(tokens);
-    }
-}
-exports.TikTokenTokenizer = TikTokenTokenizer;
-// implemented here (instead of using js-tiktoken) to be able to quickly updated it
-// when new models are released
-function getTiktokenBPE(model) {
-    switch (model) {
-        case "gpt-3.5-turbo":
-        case "gpt-3.5-turbo-0301":
-        case "gpt-3.5-turbo-0613":
-        case "gpt-3.5-turbo-1106":
-        case "gpt-3.5-turbo-0125":
-        case "gpt-3.5-turbo-16k":
-        case "gpt-3.5-turbo-16k-0613":
-        case "gpt-3.5-turbo-instruct":
-        case "gpt-4":
-        case "gpt-4-0314":
-        case "gpt-4-0613":
-        case "gpt-4-turbo-preview":
-        case "gpt-4-1106-preview":
-        case "gpt-4-0125-preview":
-        case "gpt-4-vision-preview":
-        case "gpt-4-32k":
-        case "gpt-4-32k-0314":
-        case "gpt-4-32k-0613":
-        case "text-embedding-3-small":
-        case "text-embedding-3-large":
-        case "text-embedding-ada-002": {
-            return cl100k_base_1.default;
-        }
-        default: {
-            (0, never_js_1.never)(model);
-            throw new Error(`Unknown model: ${model}`);
-        }
-    }
-}

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

@@ -1,35 +0,0 @@
-import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { OpenAIChatBaseModelType } from "./OpenAIChatModel.js";
-import { OpenAICompletionModelType } from "./OpenAICompletionModel.js";
-import { OpenAITextEmbeddingModelType } from "./OpenAITextEmbeddingModel.js";
-export type TikTokenTokenizerSettings = {
-    model: OpenAIChatBaseModelType | OpenAICompletionModelType | OpenAITextEmbeddingModelType;
-};
-/**
- * TikToken tokenizer for OpenAI language models.
- *
- * @see https://github.com/openai/tiktoken
- *
- * @example
- * const tokenizer = new TikTokenTokenizer({ model: "gpt-4" });
- *
- * const text = "At first, Nox didn't know what to do with the pup.";
- *
- * const tokenCount = await countTokens(tokenizer, text);
- * const tokens = await tokenizer.tokenize(text);
- * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
- * const reconstructedText = await tokenizer.detokenize(tokens);
- */
-export declare class TikTokenTokenizer implements FullTokenizer {
-    /**
-     * Get a TikToken tokenizer for a specific model or encoding.
-     */
-    constructor(settings: TikTokenTokenizerSettings);
-    private readonly tiktoken;
-    tokenize(text: string): Promise<number[]>;
-    tokenizeWithTexts(text: string): Promise<{
-        tokens: number[];
-        tokenTexts: string[];
-    }>;
-    detokenize(tokens: number[]): Promise<string>;
-}

package/model-provider/openai/TikTokenTokenizer.js

@@ -1,78 +0,0 @@
-import { Tiktoken } from "js-tiktoken/lite";
-import cl100k_base from "js-tiktoken/ranks/cl100k_base";
-import { never } from "../../util/never.js";
-/**
- * TikToken tokenizer for OpenAI language models.
- *
- * @see https://github.com/openai/tiktoken
- *
- * @example
- * const tokenizer = new TikTokenTokenizer({ model: "gpt-4" });
- *
- * const text = "At first, Nox didn't know what to do with the pup.";
- *
- * const tokenCount = await countTokens(tokenizer, text);
- * const tokens = await tokenizer.tokenize(text);
- * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
- * const reconstructedText = await tokenizer.detokenize(tokens);
- */
-export class TikTokenTokenizer {
-    /**
-     * Get a TikToken tokenizer for a specific model or encoding.
-     */
-    constructor(settings) {
-        Object.defineProperty(this, "tiktoken", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.tiktoken = new Tiktoken(getTiktokenBPE(settings.model));
-    }
-    async tokenize(text) {
-        return this.tiktoken.encode(text);
-    }
-    async tokenizeWithTexts(text) {
-        const tokens = this.tiktoken.encode(text);
-        return {
-            tokens,
-            tokenTexts: tokens.map((token) => this.tiktoken.decode([token])),
-        };
-    }
-    async detokenize(tokens) {
-        return this.tiktoken.decode(tokens);
-    }
-}
-// implemented here (instead of using js-tiktoken) to be able to quickly updated it
-// when new models are released
-function getTiktokenBPE(model) {
-    switch (model) {
-        case "gpt-3.5-turbo":
-        case "gpt-3.5-turbo-0301":
-        case "gpt-3.5-turbo-0613":
-        case "gpt-3.5-turbo-1106":
-        case "gpt-3.5-turbo-0125":
-        case "gpt-3.5-turbo-16k":
-        case "gpt-3.5-turbo-16k-0613":
-        case "gpt-3.5-turbo-instruct":
-        case "gpt-4":
-        case "gpt-4-0314":
-        case "gpt-4-0613":
-        case "gpt-4-turbo-preview":
-        case "gpt-4-1106-preview":
-        case "gpt-4-0125-preview":
-        case "gpt-4-vision-preview":
-        case "gpt-4-32k":
-        case "gpt-4-32k-0314":
-        case "gpt-4-32k-0613":
-        case "text-embedding-3-small":
-        case "text-embedding-3-large":
-        case "text-embedding-ada-002": {
-            return cl100k_base;
-        }
-        default: {
-            never(model);
-            throw new Error(`Unknown model: ${model}`);
-        }
-    }
-}

package/model-provider/openai/countOpenAIChatMessageTokens.cjs

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.countOpenAIChatPromptTokens = exports.countOpenAIChatMessageTokens = exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = void 0;
-const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
-const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
-const OpenAIChatModel_js_1 = require("./OpenAIChatModel.cjs");
-/**
- * Prompt tokens that are included automatically for every full
- * chat prompt (several messages) that is sent to OpenAI.
- */
-exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = 2;
-/**
- * Prompt tokens that are included automatically for every
- * message that is sent to OpenAI.
- */
-exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = 5;
-async function countOpenAIChatMessageTokens({ message, model, }) {
-    const tokenizer = new TikTokenTokenizer_js_1.TikTokenTokenizer({
-        model: (0, OpenAIChatModel_js_1.getOpenAIChatModelInformation)(model).baseModel,
-    });
-    // case: function call without content
-    if (message.content == null) {
-        return exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT;
-    }
-    // case: simple text content
-    if (typeof message.content === "string") {
-        return (exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT +
-            (await (0, countTokens_js_1.countTokens)(tokenizer, message.content)));
-    }
-    // case: array of content objects
-    let contentTokenCount = exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT;
-    for (const content of message.content) {
-        if (content.type === "text") {
-            contentTokenCount += await (0, countTokens_js_1.countTokens)(tokenizer, content.text);
-        }
-    }
-    return contentTokenCount;
-}
-exports.countOpenAIChatMessageTokens = countOpenAIChatMessageTokens;
-async function countOpenAIChatPromptTokens({ messages, model, }) {
-    let tokens = exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT;
-    for (const message of messages) {
-        tokens += await countOpenAIChatMessageTokens({ message, model });
-    }
-    return tokens;
-}
-exports.countOpenAIChatPromptTokens = countOpenAIChatPromptTokens;

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

@@ -1,20 +0,0 @@
-import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
-import { OpenAIChatModelType } from "./OpenAIChatModel.js";
-/**
- * Prompt tokens that are included automatically for every full
- * chat prompt (several messages) that is sent to OpenAI.
- */
-export declare const OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = 2;
-/**
- * Prompt tokens that are included automatically for every
- * message that is sent to OpenAI.
- */
-export declare const OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = 5;
-export declare function countOpenAIChatMessageTokens({ message, model, }: {
-    message: OpenAIChatMessage;
-    model: OpenAIChatModelType;
-}): Promise<number>;
-export declare function countOpenAIChatPromptTokens({ messages, model, }: {
-    messages: OpenAIChatMessage[];
-    model: OpenAIChatModelType;
-}): Promise<number>;