@varlabs/ai.openai/src/index.d.ts

AI sdk for interfacing with AI models

import { type ProviderContext } from '@varlabs/ai/provider';
import type { Tool } from '@varlabs/ai/utils/tool';
type ContentType = {
    type: 'input_text';
    text: string;
} | {
    type: 'input_image';
    image_url: string;
} | {
    type: 'input_file';
    file_id: string;
    filename: string;
    file_data: string;
};
type InputMessage = {
    type: 'message';
    role: 'developer' | 'user' | 'assistant' | 'system';
    content: string | ContentType[];
};
type BaseModels = 'babbage-002' | 'davinci-002';
type ReasoningModels = 'o4-mini' | 'o3' | 'o3-mini' | 'o1' | 'o1-pro' | 'o4-mini' | 'o3-mini';
type ChatModels = 'gpt-4.1' | 'gpt-4o' | 'chatgpt-4o' | 'gpt-4.1-mini' | 'gpt-4.1-nano' | 'gpt-4o-mini' | 'gpt-4-turbo' | 'gpt-4' | 'gpt-3.5-turbo';
type ImageGenerationModels = 'dall-e-2' | 'dall-e-3' | 'gpt-image-1';
type TextToSpeechModels = 'tts-1' | 'tts-1-hd' | 'gpt-4o-mini-tts';
type TranscriptionModels = 'whisper-1' | 'gpt-4o-transcribe' | 'gpt-4o-mini-transcribe';
type EmbeddingModels = 'text-embedding-3-small' | 'text-embedding-3-large' | 'text-embedding-ada-002';
type TextResponseModels = BaseModels | ChatModels | ReasoningModels | string & {};
type StructuredOutputModels = 'gpt-4o' | 'o1' | 'o3' | 'gpt-4.1' | 'gpt-4o' | 'chatgpt-4o' | 'gpt-4.1-mini' | 'gpt-4.1-nano' | 'gpt-4o-mini';
type EmbedInput = {
    model: EmbeddingModels | string & {};
    text: string | string[];
};
type ComparisonFilter = {
    key: string;
    type: 'eq' | 'gt' | 'lt' | 'gte' | 'lte' | 'ne';
    value: string | number | boolean;
};
type CompoundFilter = {
    type: 'and' | 'or';
    filters: (ComparisonFilter | CompoundFilter)[];
};
type ReasoningOptionType = {
    effort: 'low' | 'medium' | 'high';
    summary: 'auto' | 'concise' | 'detailed';
    encrypted_content?: string;
};
type FileSearchToolType = {
    type: 'file_search';
    vector_store_ids: string[];
    max_num_results?: number;
    ranking_options?: {
        ranker: string;
        score_threshold: number;
    };
    filters?: ComparisonFilter | CompoundFilter;
};
type WebSearchToolType = {
    type: 'web_search_preview' | 'web_search_preview_2025_03_11';
    search_context_size?: 'low' | 'medium' | 'high';
    user_location?: {
        type: string;
        city?: string;
        country?: string;
        region?: string;
        timezone?: string;
    };
};
type ComputerUseToolType = {
    type: 'computer_use_preview';
    environment: string;
    display_height: number;
    display_width: number;
};
type ToolParameterBase = {
    type: 'string' | 'number' | 'boolean';
    description?: string;
    required?: boolean;
};
type ToolParameterArray = {
    type: 'array';
    items: (ToolParameterBase | ToolParameterObject | ToolParameterArray)[];
    description?: string;
    required?: boolean;
};
type ToolParameterObject = {
    type: 'object';
    properties: Record<string, ToolParameterObject | ToolParameterBase | ToolParameterArray>;
    description?: string;
    required?: boolean;
};
type ToolParameters = {
    type: 'object';
    properties: Record<string, ToolParameterObject | ToolParameterBase | ToolParameterArray>;
    additionalProperties?: boolean;
};
type InferParameter<T> = T extends {
    type: 'string';
} ? string : T extends {
    type: 'number';
} ? number : T extends {
    type: 'boolean';
} ? boolean : T extends {
    type: 'array';
    items: infer Items;
} ? InferArray<Items> : T extends {
    type: 'object';
    properties: infer Properties;
} ? Properties extends Record<string, any> ? InferObject<Properties> : never : never;
type InferArray<T> = T extends (infer U)[] ? InferParameter<U>[] : never;
type InferObject<T extends Record<string, any>> = {
    [K in keyof T as T[K]['required'] extends true ? K : never]: InferParameter<T[K]>;
} & {
    [K in keyof T as T[K]['required'] extends true ? never : K]?: InferParameter<T[K]>;
};
type InferToolParameters<T extends ToolParameters> = T extends {
    properties: infer Props;
} ? Props extends Record<string, any> ? InferObject<Props> : never : never;
type CustomTool<TParams extends ToolParameters = any, TResult = any> = Omit<Tool<TParams, TResult>, 'name' | 'execute'> & {
    strict?: boolean;
    execute: (args: InferToolParameters<TParams>) => Promise<TResult>;
};
export declare const customTool: <TParams extends ToolParameters, TResult = any>(tool: CustomTool<TParams, TResult>) => CustomTool<TParams, TResult>;
type CustomToolSet = Record<string, CustomTool>;
type FunctionToolCallOutputType = {
    id?: string;
    call_id: string;
    output: string;
    type: 'function_call_output';
    status?: 'in_progress' | 'completed' | 'incomplete';
};
type Annotation = {
    index: number;
    type: 'file_citation';
    file_id: string;
} | {
    type: 'url_citation';
    url: string;
    title: string;
    start_index: number;
    end_index: number;
} | {
    type: 'file_path';
    file_id: string;
    index: number;
};
type OutputText = {
    annotations: Annotation[];
    text: string;
    type: 'output_text';
    structured_output?: any;
};
type Refusal = {
    type: 'refusal';
    refusal: string;
};
type TextResponseOutput<T extends string | undefined> = {
    id: string;
    role: 'assistant';
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'message';
    content: (OutputText | Refusal)[];
} | {
    id: string;
    type: 'reasoning';
    status: 'in_progress' | 'completed' | 'incomplete';
    encrypted_content: T extends string ? string : null;
    summary: {
        type: 'summary_text';
        text: string;
    }[];
} | {
    id: string;
    type: 'file_search_call';
    status: 'in_progress' | 'completed' | 'incomplete' | 'failed';
    queries: string[];
    results: {
        attributes: Record<string, unknown>;
        file_id: string;
        filename: string;
        score: number;
        text: string;
    }[];
} | {
    id: string;
    type: 'web_search_call';
    status: 'in_progress' | 'completed' | 'incomplete' | 'failed';
} | {
    id: string;
    type: 'computer_call';
    status: 'in_progress' | 'completed' | 'incomplete';
    call_id: string;
    pending_safety_checks: {
        id: string;
        code: string;
        message: string;
    }[];
    action: {
        button: 'left' | 'right' | 'wheel' | 'back' | 'forward';
        type: 'click';
        x: number;
        y: number;
    } | {
        type: 'double_click';
        x: number;
        y: number;
    } | {
        type: 'drag';
        path: {
            x: number;
            y: number;
        }[];
    } | {
        type: 'keypress';
        keys: string[];
    } | {
        type: 'move';
        x: number;
        y: number;
    } | {
        type: 'screenshot';
    } | {
        type: 'scroll';
        x: number;
        y: number;
        scroll_x: number;
        scroll_y: number;
    } | {
        type: 'type';
        text: string;
    } | {
        type: 'wait';
    };
} | {
    id: string;
    type: 'function_call';
    status: 'in_progress' | 'completed' | 'incomplete';
    name: string;
    call_id: string;
    arguments: string;
    result?: any;
};
type StructuredSchemaBaseType = {
    type: 'string' | 'number' | 'boolean';
};
type StructuredSchemaObjectType = {
    type: 'object';
    properties: Record<string, StructuredSchemaEnhancedType>;
};
type StructuredSchemaArrayType = {
    type: 'array';
    items: StructuredSchemaEnhancedType[];
};
type StructuredSchemaEnhancedType = {
    description?: string;
    required?: boolean;
} & (StructuredSchemaBaseType | StructuredSchemaObjectType | StructuredSchemaArrayType);
type StructuredSchema = {
    type: 'object';
    description?: string;
    properties: Record<string, StructuredSchemaEnhancedType>;
};
type TextResponsesInput<Model extends TextResponseModels, CustomTools extends CustomToolSet = {}, Stream extends boolean = false> = {
    model: Model;
    instructions?: string;
    input: string | (InputMessage | {
        type: 'item_reference';
        id: string;
    } | TextResponseOutput<any> | FunctionToolCallOutputType)[];
    structured_output?: Model extends StructuredOutputModels ? {
        name: string;
        strict?: boolean;
        schema: StructuredSchema;
    } : never;
    stream?: Stream;
    reasoning?: Model extends ReasoningModels ? ReasoningOptionType : never;
    max_output_tokens?: number;
    metadata?: Record<string, unknown>;
    truncation?: 'auto' | 'disabled';
    user?: string;
    previous_response_id?: string;
    store?: boolean;
    parallel_tool_calls?: boolean;
    tool_choice?: 'none' | 'auto' | 'required' | {
        type: 'file_search' | 'web_search_preview' | 'computer_use_preview';
    } | {
        name: string;
        type: 'function';
    };
    built_in_tools?: (FileSearchToolType | WebSearchToolType | ComputerUseToolType)[];
    custom_tools?: CustomTools;
} & ({
    temperature?: number;
    top_p?: never;
} | {
    temperature?: never;
    top_p?: number;
});
type TextResponseType<Model extends TextResponseModels, Input extends TextResponsesInput<Model>> = {
    id: string;
    object: 'response';
    created_at: number;
    status: 'completed' | 'failed' | 'in_progress' | 'incomplete';
    error?: {
        code: string;
        message: string;
    };
    incomplete_details?: {
        reason: string;
    };
    instructions?: Input['instructions'];
    max_output_tokens: Input['max_output_tokens'];
    metadata: Input['metadata'];
    model: Model;
    parallel_tool_calls: Input['parallel_tool_calls'];
    previous_response_id: Input['previous_response_id'];
    reasoning?: Input['reasoning'];
    temperature: Input['temperature'];
    tool_choice: Input['tool_choice'];
    top_p: Input['top_p'];
    truncation: Input['truncation'];
    user: Input['user'];
    usage: {
        input_tokens: number;
        output_tokens: number;
        total_tokens: number;
        input_token_details: {
            cached_tokens: number;
        };
        output_token_details: {
            reasoning_tokens: number;
        };
    };
    output: TextResponseOutput<Input['reasoning'] extends ReasoningOptionType ? Input['reasoning']['encrypted_content'] : undefined>[];
};
type StreamResponse<Model extends TextResponseModels> = {
    type: 'response.created' | 'response.in_progress' | 'response.completed' | 'response.failed' | 'response.incomplete';
    response: TextResponseType<Model, TextResponsesInput<Model>>;
} | {
    type: 'response.output_item.added' | 'response.output_item.done';
    output_index: number;
    item: (InputMessage | TextResponseOutput<undefined>)[];
} | {
    type: 'response.content_part.added' | 'response.content_part.done';
    content_index: number;
    item_id: string;
    output_index: number;
    part: OutputText | Refusal;
} | {
    type: 'response.output_text.delta';
    item_id: string;
    delta: string;
    content_index: number;
    output_index: number;
} | {
    type: 'response.output_text.annotation.added';
    item_id: string;
    output_index: number;
    content_index: number;
    annotation_index: number;
    annotation: Annotation;
} | {
    type: 'response.output_text.done';
    item_id: string;
    output_index: number;
    content_index: number;
    text: string;
} | {
    type: 'response.refusal.delta';
    item_id: string;
    delta: string;
    content_index: number;
    output_index: number;
} | {
    type: 'response.refusal.done';
    item_id: string;
    output_index: number;
    content_index: number;
    refusal: string;
} | {
    type: 'response.function_call_arguments.delta';
    item_id: string;
    delta: string;
    output_index: number;
} | {
    type: 'response.function_call_arguments.done';
    item_id: string;
    output_index: number;
    arguments: string;
} | {
    type: 'response.file_search_call.in_progress' | 'response.file_search_call.searching' | 'response.file_search_call.completed' | 'response.web_search_call.in_progress' | 'response.web_search_call.searching' | 'response.web_search_call.completed';
    item_id: string;
    output_index: number;
} | {
    type: 'response.reasoning_summary_part.added' | 'response.reasoning_summary_part.done';
    item_id: string;
    output_index: number;
    summary_index: number;
    part: {
        type: 'summary_text';
        text: string;
    };
} | {
    type: 'response.reasoning_summary_text.delta';
    delta: string;
    item_id: string;
    output_index: number;
    summary_index: number;
} | {
    type: 'response.reasoning_summary_text.done';
    item_id: string;
    output_index: number;
    summary_index: number;
    text: string;
} | {
    type: 'error';
    code: string;
    message: string;
    param: string;
};
type CreateResponseOutput<Model extends TextResponseModels, Stream extends boolean = false> = Stream extends true ? StreamResponse<Model> : TextResponseType<Model, TextResponsesInput<Model>>;
type BlobLike = {
    readonly size: number;
    readonly type: string;
    text(): Promise<string>;
    slice(start?: number, end?: number): BlobLike;
};
type FileLike = BlobLike & {
    readonly name: string;
    readonly lastModified: number;
};
type ImageCreateInput<Model extends ImageGenerationModels> = {
    model?: Model;
    background?: Model extends 'gpt-image-1' ? 'transparent' | 'opaque' | 'auto' : never;
    prompt: string;
    moderation?: Model extends 'gpt-image-1' ? 'low' | 'auto' : never;
    n?: number;
    output_compression?: Model extends 'gpt-image-1' ? number : never;
    output_format?: Model extends 'gpt-image-1' ? 'png' | 'jpeg' | 'webp' : never;
    quality?: Model extends 'gpt-image-1' ? 'auto' | 'high' | 'medium' | 'low' : Model extends 'dall-e-3' ? 'auto' | 'hd' | 'standard' : 'auto' | 'standard';
    response_format?: Model extends 'gpt-image-1' ? never : 'url' | 'b64_json';
    size?: Model extends 'gpt-image-1' ? 'auto' | '1024x1024' | '1536x1024' | '1024x1536' : Model extends 'dall-e-3' ? '1024x1024' | '1792x1024' | '1024x1792' : '256x256' | '512x512' | '1024x1024';
    style?: Model extends 'dall-e-3' ? 'vivid' | 'natural' : never;
    user?: string;
};
type ImageEditInput<Model extends Exclude<ImageGenerationModels, 'dall-e-3'>> = {
    image: FileLike | FileLike[];
    prompt: ImageCreateInput<Model>['prompt'];
    background?: ImageCreateInput<Model>['background'];
    mask?: FileLike;
    model?: Model;
    n?: ImageCreateInput<Model>['n'];
    quality?: ImageCreateInput<Model>['quality'];
    response_format?: ImageCreateInput<Model>['response_format'];
    size?: ImageCreateInput<Model>['size'];
    user?: string;
};
type ImageVariationInput = {
    image: FileLike;
    n?: ImageCreateInput<'dall-e-2'>['n'];
    repsonse_format?: ImageCreateInput<'dall-e-2'>['response_format'];
    size?: ImageCreateInput<'dall-e-2'>['size'];
    user?: string;
};
type ImageResponse<Model extends ImageGenerationModels, ResponseFormat extends 'b64_json' | 'url'> = {
    created_at: number;
    usage: {
        total_tokens: number;
        input_tokens: number;
        output_tokens: number;
        input_token_details: {
            image_tokens: number;
            text_tokens: number;
        };
    };
    data: {
        b64_json: ResponseFormat extends 'b64_json' ? string : never;
        revised_prompt: Model extends 'dall-e-3' ? string : never;
        url: ResponseFormat extends 'url' ? string : never;
    };
};
type GenAudioInput = {
    input: string;
    model: TextToSpeechModels;
    voice: 'alloy' | 'ash' | 'ballad' | 'coral' | 'echo' | 'fable' | 'onyx' | 'nova' | 'sage' | 'shimmer' | 'verse';
    instructions?: string;
    response_format?: 'mp3' | 'opus' | 'aac' | 'wav' | 'pcm';
    speed?: number;
};
type TranscribeAudioInputResponseFormat = 'srt' | 'text' | 'json' | 'vtt' | 'verbose_json';
type TranscribeAudioInput<ResponseFormat extends TranscribeAudioInputResponseFormat> = {
    file: FileLike;
    model: TranscriptionModels;
    chunking_strategy?: 'auto' | {
        type: 'server_vad';
        prefix_padding_ms?: number;
        silence_duration_ms?: number;
        threshold?: number;
    };
    language?: string;
    prompt?: string;
    response_format?: ResponseFormat;
    stream?: boolean;
    temperature?: number;
    include?: ('logprobs' | string & {})[];
};
type TranslationAudioInput = {
    file: FileLike;
    model: 'whisper-1' | string & {};
    prompt?: string;
    response_format?: TranscribeAudioInputResponseFormat;
    temperature?: number;
};
type FunctionInput<T> = {
    input: T;
    config?: {
        fetchTimeout?: number;
    };
};
declare const openAiProvider: (config: {
    config: {
        apiKey: string;
        baseUrl: string;
    };
}) => Omit<import("@varlabs/ai/provider").Provider<{
    embedding: {
        embed: (input: FunctionInput<EmbedInput>, ctx: {
            config: {
                apiKey: string;
                baseUrl: string;
            };
        }) => Promise<{
            object: "list";
            data: {
                object: "embedding";
                embedding: number[];
                index: number;
            }[];
            model: EmbeddingModels;
            usage: {
                prompt_tokens: number;
                total_tokens: number;
            };
        }>;
    };
    text: {
        create_response: <Model extends TextResponseModels, CustomTools extends CustomToolSet = {}>(inputArgs: FunctionInput<TextResponsesInput<Model, CustomTools, false>>, ctx: ProviderContext) => Promise<CreateResponseOutput<Model, false>>;
        stream_response: <Model extends TextResponseModels, CustomTools extends CustomToolSet = {}>(inputArgs: FunctionInput<TextResponsesInput<Model, CustomTools, true>>, ctx: ProviderContext) => Promise<AsyncGenerator<StreamResponse<Model>, void, unknown>>;
        get_response: (input: FunctionInput<{
            id: string;
        }>, ctx: ProviderContext) => Promise<TextResponseType<any, any>>;
        delete_response: (input: FunctionInput<{
            id: string;
        }>, ctx: ProviderContext) => Promise<{
            id: string;
            object: "response";
            deleted: boolean;
        }>;
        list_input_item_list: (input: FunctionInput<{
            id: string;
        }>, ctx: ProviderContext) => Promise<{
            object: "list";
            data: (InputMessage | TextResponseOutput<undefined>)[];
            first_id: string;
            last_id: string;
            has_more: boolean;
        }>;
    };
    images: {
        create: <Model extends ImageGenerationModels>(inputArgs: FunctionInput<ImageCreateInput<Model>>, ctx: ProviderContext) => Promise<ImageResponse<Model, Model extends "gpt-image-1" ? "b64_json" : Exclude<Model extends "gpt-image-1" ? never : "url" | "b64_json", undefined>>>;
        edit: <Model extends Exclude<ImageGenerationModels, "dall-e-3">>(inputArgs: FunctionInput<ImageEditInput<Model>>, ctx: ProviderContext) => Promise<ImageResponse<Model, Model extends "gpt-image-1" ? "b64_json" : "url" | "b64_json">>;
        generate_variations: (inputArgs: FunctionInput<ImageVariationInput>, ctx: {
            config: {
                apiKey: string;
                baseUrl: string;
            };
        }) => Promise<ImageResponse<"dall-e-2", "url" | "b64_json">>;
    };
    speech: {
        generate_audio: (inputArgs: FunctionInput<GenAudioInput>, ctx: {
            config: {
                apiKey: string;
                baseUrl: string;
            };
        }) => Promise<{
            blob: Blob;
            contentType: "audio/mpeg" | "audio/ogg" | "audio/mp4" | "audio/wav" | "audio/pcm";
        }>;
        transcribe_audio: <ResponseFormat extends TranscribeAudioInputResponseFormat = "json">(inputArgs: FunctionInput<TranscribeAudioInput<ResponseFormat>>, ctx: ProviderContext) => Promise<{
            text: string;
            logprobs?: {
                bytes: string[];
                logprob: number;
                token: string;
            };
        } | {
            duration: number;
            language: string;
            text: string;
            segments: {
                avg_logprob: number;
                compression_ratio: number;
                end: number;
                id: number;
                no_speech_prob: number;
                seek: number;
                start: number;
                temperature: number;
                text: string;
                tokens: number[];
            };
            words: {
                end: number;
                start: number;
                word: string;
            };
        } | Blob>;
        translate_audio: (inputArgs: FunctionInput<TranslationAudioInput>, ctx: {
            config: {
                apiKey: string;
                baseUrl: string;
            };
        }) => Promise<{
            text: string;
        }>;
    };
}, {
    config: {
        apiKey: string;
        baseUrl: string;
    };
}>, "models"> & {
    models: {
        embedding: {
            embed: (input: FunctionInput<EmbedInput>) => Promise<{
                object: "list";
                data: {
                    object: "embedding";
                    embedding: number[];
                    index: number;
                }[];
                model: EmbeddingModels;
                usage: {
                    prompt_tokens: number;
                    total_tokens: number;
                };
            }>;
        };
        text: {
            create_response: (input: FunctionInput<TextResponsesInput<TextResponseModels, CustomToolSet, false>>) => Promise<TextResponseType<TextResponseModels, TextResponsesInput<TextResponseModels, {}, false>>>;
            stream_response: (input: FunctionInput<TextResponsesInput<TextResponseModels, CustomToolSet, true>>) => Promise<AsyncGenerator<StreamResponse<TextResponseModels>, void, unknown>>;
            get_response: (input: FunctionInput<{
                id: string;
            }>) => Promise<TextResponseType<any, any>>;
            delete_response: (input: FunctionInput<{
                id: string;
            }>) => Promise<{
                id: string;
                object: "response";
                deleted: boolean;
            }>;
            list_input_item_list: (input: FunctionInput<{
                id: string;
            }>) => Promise<{
                object: "list";
                data: (InputMessage | TextResponseOutput<undefined>)[];
                first_id: string;
                last_id: string;
                has_more: boolean;
            }>;
        };
        images: {
            create: (input: FunctionInput<ImageCreateInput<ImageGenerationModels>>) => Promise<ImageResponse<ImageGenerationModels, "url" | "b64_json">>;
            edit: (input: FunctionInput<ImageEditInput<"dall-e-2" | "gpt-image-1">>) => Promise<ImageResponse<"dall-e-2" | "gpt-image-1", "url" | "b64_json">>;
            generate_variations: (input: FunctionInput<ImageVariationInput>) => Promise<ImageResponse<"dall-e-2", "url" | "b64_json">>;
        };
        speech: {
            generate_audio: (input: FunctionInput<GenAudioInput>) => Promise<{
                blob: Blob;
                contentType: "audio/mpeg" | "audio/ogg" | "audio/mp4" | "audio/wav" | "audio/pcm";
            }>;
            transcribe_audio: (input: FunctionInput<TranscribeAudioInput<TranscribeAudioInputResponseFormat>>) => Promise<Blob | {
                text: string;
                logprobs?: {
                    bytes: string[];
                    logprob: number;
                    token: string;
                } | undefined;
            } | {
                duration: number;
                language: string;
                text: string;
                segments: {
                    avg_logprob: number;
                    compression_ratio: number;
                    end: number;
                    id: number;
                    no_speech_prob: number;
                    seek: number;
                    start: number;
                    temperature: number;
                    text: string;
                    tokens: number[];
                };
                words: {
                    end: number;
                    start: number;
                    word: string;
                };
            }>;
            translate_audio: (input: FunctionInput<TranslationAudioInput>) => Promise<{
                text: string;
            }>;
        };
    };
};
export default openAiProvider;
//# sourceMappingURL=index.d.ts.map