modelfusion 0.0.44

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -0,0 +1,317 @@
+import SecureJSON from "secure-json-parse";
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
+import { parseEventSourceReadableStream } from "../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
+import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
+/**
+ * @see https://platform.openai.com/docs/models/
+ * @see https://openai.com/pricing
+ */
+export const OPENAI_TEXT_GENERATION_MODELS = {
+    "text-davinci-003": {
+        contextWindowSize: 4096,
+        tokenCostInMillicents: 2,
+    },
+    "text-davinci-002": {
+        contextWindowSize: 4096,
+        tokenCostInMillicents: 2,
+    },
+    "code-davinci-002": {
+        contextWindowSize: 8000,
+        tokenCostInMillicents: 2,
+    },
+    davinci: {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 2,
+    },
+    "text-curie-001": {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 0.2,
+    },
+    curie: {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 0.2,
+    },
+    "text-babbage-001": {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 0.05,
+    },
+    babbage: {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 0.05,
+    },
+    "text-ada-001": {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 0.04,
+    },
+    ada: {
+        contextWindowSize: 2048,
+        tokenCostInMillicents: 0.04,
+    },
+};
+export const isOpenAITextGenerationModel = (model) => model in OPENAI_TEXT_GENERATION_MODELS;
+export const calculateOpenAITextGenerationCostInMillicents = ({ model, response, }) => response.usage.total_tokens *
+    OPENAI_TEXT_GENERATION_MODELS[model].tokenCostInMillicents;
+/**
+ * Create a text generation model that calls the OpenAI text completion API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ *
+ * @example
+ * const model = new OpenAITextGenerationModel({
+ *   model: "text-davinci-003",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
+ * });
+ *
+ * const { text } = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export class OpenAITextGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokenizer = new TikTokenTokenizer({ model: settings.model });
+        this.contextWindowSize =
+            OPENAI_TEXT_GENERATION_MODELS[settings.model].contextWindowSize;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.OPENAI_API_KEY;
+        if (apiKey == null) {
+            throw new Error(`OpenAI API key is missing. Pass it as an argument to the constructor or set it as an environment variable named OPENAI_API_KEY.`);
+        }
+        return apiKey;
+    }
+    async countPromptTokens(input) {
+        return countTokens(this.tokenizer, input);
+    }
+    async callAPI(prompt, options) {
+        const { run, settings, responseFormat } = options;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            prompt,
+            responseFormat,
+        });
+        return callWithRetryAndThrottle({
+            retry: callSettings.retry,
+            throttle: callSettings.throttle,
+            call: async () => callOpenAITextGenerationAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: OpenAITextResponseFormat.json,
+        });
+    }
+    extractText(response) {
+        return response.choices[0].text;
+    }
+    generateDeltaStreamResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: OpenAITextResponseFormat.deltaIterable,
+        });
+    }
+    extractTextDelta(fullDelta) {
+        return fullDelta[0].delta;
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel({
+            model: this.withStopTokens(promptMapping.stopTokens),
+            promptMapping,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAITextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+    get maxCompletionTokens() {
+        return this.settings.maxTokens;
+    }
+    withMaxCompletionTokens(maxCompletionTokens) {
+        return this.withSettings({ maxTokens: maxCompletionTokens });
+    }
+    withStopTokens(stopTokens) {
+        return this.withSettings({ stop: stopTokens });
+    }
+}
+const openAITextGenerationResponseSchema = z.object({
+    id: z.string(),
+    object: z.literal("text_completion"),
+    created: z.number(),
+    model: z.string(),
+    choices: z.array(z.object({
+        text: z.string(),
+        index: z.number(),
+        logprobs: z.nullable(z.any()),
+        finish_reason: z.string(),
+    })),
+    usage: z.object({
+        prompt_tokens: z.number(),
+        completion_tokens: z.number(),
+        total_tokens: z.number(),
+    }),
+});
+/**
+ * Call the OpenAI Text Completion API to generate a text completion for the given prompt.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ *
+ * @example
+ * const response = await callOpenAITextGenerationAPI({
+ *   apiKey: OPENAI_API_KEY,
+ *   model: "text-davinci-003",
+ *   prompt: "Write a short story about a robot learning to love:\n\n",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ * });
+ *
+ * console.log(response.choices[0].text);
+ */
+async function callOpenAITextGenerationAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, responseFormat, apiKey, model, prompt, suffix, maxTokens, temperature, topP, n, logprobs, echo, stop, presencePenalty, frequencyPenalty, bestOf, user, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/completions`,
+        apiKey,
+        body: {
+            stream: responseFormat.stream,
+            model,
+            prompt,
+            suffix,
+            max_tokens: maxTokens,
+            temperature,
+            top_p: topP,
+            n,
+            logprobs,
+            echo,
+            stop,
+            presence_penalty: presencePenalty,
+            frequency_penalty: frequencyPenalty,
+            best_of: bestOf,
+            user,
+        },
+        failedResponseHandler: failedOpenAICallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+export const OpenAITextResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(openAITextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createOpenAITextFullDeltaIterableQueue(response.body),
+    },
+};
+const textResponseStreamEventSchema = z.object({
+    choices: z.array(z.object({
+        text: z.string(),
+        finish_reason: z.enum(["stop", "length"]).nullable(),
+        index: z.number(),
+    })),
+    created: z.number(),
+    id: z.string(),
+    model: z.string(),
+    object: z.string(),
+});
+async function createOpenAITextFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    const streamDelta = [];
+    // process the stream asynchonously (no 'await' on purpose):
+    parseEventSourceReadableStream({
+        stream,
+        callback: (event) => {
+            if (event.type !== "event") {
+                return;
+            }
+            const data = event.data;
+            if (data === "[DONE]") {
+                queue.close();
+                return;
+            }
+            try {
+                const json = SecureJSON.parse(data);
+                const parseResult = textResponseStreamEventSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const event = parseResult.data;
+                for (let i = 0; i < event.choices.length; i++) {
+                    const eventChoice = event.choices[i];
+                    const delta = eventChoice.text;
+                    if (streamDelta[i] == null) {
+                        streamDelta[i] = {
+                            content: "",
+                            isComplete: false,
+                            delta: "",
+                        };
+                    }
+                    const choice = streamDelta[i];
+                    choice.delta = delta;
+                    if (eventChoice.finish_reason != null) {
+                        choice.isComplete = true;
+                    }
+                    choice.content += delta;
+                }
+                // Since we're mutating the choices array in an async scenario,
+                // we need to make a deep copy:
+                const streamDeltaDeepCopy = JSON.parse(JSON.stringify(streamDelta));
+                queue.push({
+                    type: "delta",
+                    fullDelta: streamDeltaDeepCopy,
+                });
+            }
+            catch (error) {
+                queue.push({ type: "error", error });
+                queue.close();
+                return;
+            }
+        },
+    });
+    return queue;
+}

package/model-provider/openai/OpenAITranscriptionModel.cjs

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAITranscriptionResponseFormat = exports.OpenAITranscriptionModel = exports.calculateOpenAITranscriptionCostInMillicents = exports.OPENAI_TRANSCRIPTION_MODELS = void 0;
+const zod_1 = __importDefault(require("zod"));
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const OpenAIError_js_1 = require("./OpenAIError.cjs");
+/**
+ * @see https://openai.com/pricing
+ */
+exports.OPENAI_TRANSCRIPTION_MODELS = {
+    "whisper-1": {
+        costInMillicentsPerSecond: 10, // = 600 / 60,
+    },
+};
+const calculateOpenAITranscriptionCostInMillicents = ({ model, response, }) => {
+    if (model !== "whisper-1") {
+        return null;
+    }
+    const durationInSeconds = response.duration;
+    return (Math.ceil(durationInSeconds) *
+        exports.OPENAI_TRANSCRIPTION_MODELS[model].costInMillicentsPerSecond);
+};
+exports.calculateOpenAITranscriptionCostInMillicents = calculateOpenAITranscriptionCostInMillicents;
+/**
+ * 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,
+ *   }
+ * );
+ */
+class OpenAITranscriptionModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    generateTranscriptionResponse(data, options) {
+        return this.callAPI(data, {
+            responseFormat: exports.OpenAITranscriptionResponseFormat.verboseJson,
+            functionId: options?.functionId,
+            settings: options?.settings,
+            run: options?.run,
+        });
+    }
+    extractTranscriptionText(response) {
+        return response.text;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.OPENAI_API_KEY;
+        if (apiKey == null) {
+            throw new Error(`OpenAI API key is missing. Pass it as an argument to the constructor or set it as an environment variable named OPENAI_API_KEY.`);
+        }
+        return apiKey;
+    }
+    async callAPI(data, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const responseFormat = options?.responseFormat;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            file: {
+                name: `audio.${data.type}`,
+                data: data.data,
+            },
+            responseFormat,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callOpenAITranscriptionAPI(callSettings),
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAITranscriptionModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.OpenAITranscriptionModel = OpenAITranscriptionModel;
+/**
+ * Call the OpenAI Transcription API to generate a transcription from an audio file.
+ *
+ * @see https://platform.openai.com/docs/api-reference/audio/create
+ *
+ * @example
+ * const transcriptionResponse = await callOpenAITranscriptionAPI({
+ *   apiKey: openAiApiKey,
+ *   model: "whisper-1",
+ *   file: {
+ *     name: "audio.mp3",
+ *     data: fileData, // Buffer
+ *   },
+ *   responseFormat: callOpenAITranscriptionAPI.responseFormat.json,
+ * });
+ */
+async function callOpenAITranscriptionAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, apiKey, model, file, prompt, responseFormat, temperature, language, }) {
+    const formData = new FormData();
+    formData.append("file", new Blob([file.data]), file.name);
+    formData.append("model", model);
+    if (prompt) {
+        formData.append("prompt", prompt);
+    }
+    if (responseFormat) {
+        formData.append("response_format", responseFormat.type);
+    }
+    if (temperature) {
+        formData.append("temperature", temperature.toString());
+    }
+    if (language) {
+        formData.append("language", language);
+    }
+    return (0, postToApi_js_1.postToApi)({
+        url: `${baseUrl}/audio/transcriptions`,
+        apiKey,
+        contentType: null,
+        body: {
+            content: formData,
+            values: {
+                model,
+                prompt,
+                response_format: responseFormat,
+                temperature,
+                language,
+            },
+        },
+        failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+const openAITranscriptionJsonSchema = zod_1.default.object({
+    text: zod_1.default.string(),
+});
+const openAITranscriptionVerboseJsonSchema = zod_1.default.object({
+    task: zod_1.default.literal("transcribe"),
+    language: zod_1.default.string(),
+    duration: zod_1.default.number(),
+    segments: zod_1.default.array(zod_1.default.object({
+        id: zod_1.default.number(),
+        seek: zod_1.default.number(),
+        start: zod_1.default.number(),
+        end: zod_1.default.number(),
+        text: zod_1.default.string(),
+        tokens: zod_1.default.array(zod_1.default.number()),
+        temperature: zod_1.default.number(),
+        avg_logprob: zod_1.default.number(),
+        compression_ratio: zod_1.default.number(),
+        no_speech_prob: zod_1.default.number(),
+        transient: zod_1.default.boolean().optional(),
+    })),
+    text: zod_1.default.string(),
+});
+exports.OpenAITranscriptionResponseFormat = {
+    json: {
+        type: "json",
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAITranscriptionJsonSchema),
+    },
+    verboseJson: {
+        type: "verbose_json",
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAITranscriptionVerboseJsonSchema),
+    },
+    text: {
+        type: "text",
+        handler: (0, postToApi_js_1.createTextResponseHandler)(),
+    },
+    srt: {
+        type: "srt",
+        handler: (0, postToApi_js_1.createTextResponseHandler)(),
+    },
+    vtt: {
+        type: "vtt",
+        handler: (0, postToApi_js_1.createTextResponseHandler)(),
+    },
+};

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

@@ -0,0 +1,196 @@
+/// <reference types="node" resolution-mode="require"/>
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-audio/TranscriptionModel.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+import { OpenAIModelSettings } from "./OpenAIModelSettings.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 {
+    model: OpenAITranscriptionModelType;
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+}
+export type OpenAITranscriptionInput = {
+    type: "mp3" | "mp4" | "mpeg" | "mpga" | "m3a" | "wav" | "webm";
+    data: Buffer;
+};
+/**
+ * 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<OpenAITranscriptionInput, OpenAITranscriptionVerboseJsonResponse, OpenAITranscriptionModelSettings> {
+    constructor(settings: OpenAITranscriptionModelSettings);
+    readonly provider: "openai";
+    get modelName(): "whisper-1";
+    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: FunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
+    extractTranscriptionText(response: OpenAITranscriptionVerboseJsonResponse): string;
+    private get apiKey();
+    callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
+        responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
+    } & FunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
+    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;
+        temperature: number;
+        id: number;
+        tokens: number[];
+        seek: number;
+        start: number;
+        end: number;
+        avg_logprob: number;
+        compression_ratio: number;
+        no_speech_prob: number;
+        transient?: boolean | undefined;
+    }, {
+        text: string;
+        temperature: number;
+        id: number;
+        tokens: number[];
+        seek: number;
+        start: 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;
+    segments: {
+        text: string;
+        temperature: number;
+        id: number;
+        tokens: number[];
+        seek: number;
+        start: number;
+        end: number;
+        avg_logprob: number;
+        compression_ratio: number;
+        no_speech_prob: number;
+        transient?: boolean | undefined;
+    }[];
+    task: "transcribe";
+    language: string;
+    duration: number;
+}, {
+    text: string;
+    segments: {
+        text: string;
+        temperature: number;
+        id: number;
+        tokens: number[];
+        seek: number;
+        start: number;
+        end: number;
+        avg_logprob: number;
+        compression_ratio: number;
+        no_speech_prob: number;
+        transient?: boolean | undefined;
+    }[];
+    task: "transcribe";
+    language: string;
+    duration: number;
+}>;
+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;
+            segments: {
+                text: string;
+                temperature: number;
+                id: number;
+                tokens: number[];
+                seek: number;
+                start: number;
+                end: number;
+                avg_logprob: number;
+                compression_ratio: number;
+                no_speech_prob: number;
+                transient?: boolean | undefined;
+            }[];
+            task: "transcribe";
+            language: string;
+            duration: number;
+        }>;
+    };
+    text: {
+        type: "text";
+        handler: ResponseHandler<string>;
+    };
+    srt: {
+        type: "srt";
+        handler: ResponseHandler<string>;
+    };
+    vtt: {
+        type: "vtt";
+        handler: ResponseHandler<string>;
+    };
+};
+export {};