@adaline/openai/dist/index.d.mts

Adaline OpenAI

import * as zod from 'zod';
import { z } from 'zod';
import { ChatModelSchemaType, ChatModelV1, UrlType, HeadersType, ParamsType, EmbeddingModelSchemaType, EmbeddingModelV1, ProviderV1 } from '@adaline/provider';
import { MessageType, ConfigType, ToolType, ChatResponseType, PartialChatResponseType, ChatModelPriceType, EmbeddingRequestsType, EmbeddingResponseType } from '@adaline/types';

declare const OpenAIChatModelConfigs: {
    readonly base: (maxOutputTokens: number, maxSequences: number) => {
        def: {
            readonly temperature: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly maxTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly stop: {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            };
            readonly topP: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly frequencyPenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly presencePenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly seed: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly logProbs: {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            };
            readonly topLogProbs: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<{
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
            topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
            logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
            topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, "strip", zod.ZodTypeAny, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
        }, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
        }>;
    };
    readonly responseFormat: (maxOutputTokens: number, maxSequences: number) => {
        def: {
            responseFormat: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            temperature: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            maxTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            stop: {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            };
            topP: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            frequencyPenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            presencePenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            seed: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            logProbs: {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            };
            topLogProbs: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<zod.objectUtil.extendShape<{
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
            topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
            logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
            topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, {
            responseFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }>, "strip", zod.ZodTypeAny, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
            responseFormat?: string | null | undefined;
        }, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
            responseFormat?: string | null | undefined;
        }>;
    };
    readonly responseSchema: (maxOutputTokens: number, maxSequences: number) => {
        def: {
            responseFormat: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            responseSchema: {
                type: "object-schema";
                param: string;
                title: string;
                description: string;
                objectSchema?: any;
            };
            temperature: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            maxTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            stop: {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            };
            topP: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            frequencyPenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            presencePenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            seed: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            logProbs: {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            };
            topLogProbs: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<zod.objectUtil.extendShape<{
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
            topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
            logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
            topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, {
            responseFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
            responseSchema: zod.ZodOptional<zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, {
                [x: string]: any;
            }, {
                [x: string]: any;
            }>>;
        }>, "strip", zod.ZodTypeAny, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
            responseFormat?: string | null | undefined;
            responseSchema?: {
                [x: string]: any;
            } | undefined;
        }, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
            responseFormat?: string | null | undefined;
            responseSchema?: {
                [x: string]: any;
            } | undefined;
        }>;
    };
    readonly oSeries: (maxOutputTokens: number, maxSequences: number) => {
        def: {
            temperature: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            reasoningEffort: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            responseFormat: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            responseSchema: {
                type: "object-schema";
                param: string;
                title: string;
                description: string;
                objectSchema?: any;
            };
            maxTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            stop: {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            };
            topP: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            frequencyPenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            presencePenalty: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            seed: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            logProbs: {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            };
            topLogProbs: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<zod.objectUtil.extendShape<zod.objectUtil.extendShape<{
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
            topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
            logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
            topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, {
            responseFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
            responseSchema: zod.ZodOptional<zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, {
                [x: string]: any;
            }, {
                [x: string]: any;
            }>>;
        }>, {
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            reasoningEffort: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }>, "strip", zod.ZodTypeAny, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
            responseFormat?: string | null | undefined;
            responseSchema?: {
                [x: string]: any;
            } | undefined;
            reasoningEffort?: string | null | undefined;
        }, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            topLogProbs?: number | undefined;
            toolChoice?: string | null | undefined;
            responseFormat?: string | null | undefined;
            responseSchema?: {
                [x: string]: any;
            } | undefined;
            reasoningEffort?: string | null | undefined;
        }>;
    };
};
declare const OpenAIEmbeddingModelConfigs: {
    readonly base: () => {
        def: {
            readonly encodingFormat: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<{
            encodingFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, "strip", zod.ZodTypeAny, {
            encodingFormat?: string | null | undefined;
        }, {
            encodingFormat?: string | null | undefined;
        }>;
    };
    readonly dimensions: (maxDimensions: number) => {
        def: {
            readonly dimensions: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly encodingFormat: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<zod.objectUtil.extendShape<{
            encodingFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, {
            dimensions: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
        }>, "strip", zod.ZodTypeAny, {
            dimensions?: number | undefined;
            encodingFormat?: string | null | undefined;
        }, {
            dimensions?: number | undefined;
            encodingFormat?: string | null | undefined;
        }>;
    };
};

declare const ChatModelBaseConfigSchema: (maxOutputTokens: number, maxSequences: number) => z.ZodObject<{
    temperature: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    maxTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    stop: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
    topP: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    frequencyPenalty: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    presencePenalty: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    seed: z.ZodEffects<z.ZodOptional<z.ZodDefault<z.ZodNumber>>, number | undefined, number | undefined>;
    logProbs: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodBoolean>>>;
    topLogProbs: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    toolChoice: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
}, "strip", z.ZodTypeAny, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
}, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
}>;
declare const ChatModelBaseConfigDef: (maxOutputTokens: number, maxSequences: number) => {
    readonly temperature: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly maxTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly stop: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    readonly topP: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly frequencyPenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly presencePenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly seed: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly logProbs: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    readonly topLogProbs: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};

declare const temperature: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const maxTokens: (maxOutputTokens: number) => {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const stop: (maxSequences: number) => {
    def: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
};
declare const topP: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const frequencyPenalty: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const presencePenalty: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const seed: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const logProbs: {
    def: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
};
declare const topLogProbs: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const toolChoice: {
    def: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
};

declare const ChatModelOSeriesConfigDef: (maxOutputTokens: number, maxSequences: number) => {
    temperature: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    reasoningEffort: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    responseFormat: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    responseSchema: {
        type: "object-schema";
        param: string;
        title: string;
        description: string;
        objectSchema?: any;
    };
    maxTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    stop: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    topP: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    frequencyPenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    presencePenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    seed: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    logProbs: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    topLogProbs: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};
declare const ChatModelOSeriesConfigSchema: (maxOutputTokens: number, maxSequences: number) => zod.ZodObject<zod.objectUtil.extendShape<zod.objectUtil.extendShape<{
    temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
    topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
    logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
    topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}, {
    responseFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
    responseSchema: zod.ZodOptional<zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, {
        [x: string]: any;
    }, {
        [x: string]: any;
    }>>;
}>, {
    temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    reasoningEffort: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}>, "strip", zod.ZodTypeAny, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
    responseFormat?: string | null | undefined;
    responseSchema?: {
        [x: string]: any;
    } | undefined;
    reasoningEffort?: string | null | undefined;
}, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
    responseFormat?: string | null | undefined;
    responseSchema?: {
        [x: string]: any;
    } | undefined;
    reasoningEffort?: string | null | undefined;
}>;

declare const ChatModelResponseFormatConfigDef: (maxOutputTokens: number, maxSequences: number) => {
    responseFormat: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    temperature: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    maxTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    stop: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    topP: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    frequencyPenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    presencePenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    seed: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    logProbs: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    topLogProbs: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};
declare const ChatModelResponseFormatConfigSchema: (maxOutputTokens: number, maxSequences: number) => zod.ZodObject<zod.objectUtil.extendShape<{
    temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
    topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
    logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
    topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}, {
    responseFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}>, "strip", zod.ZodTypeAny, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
    responseFormat?: string | null | undefined;
}, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
    responseFormat?: string | null | undefined;
}>;

declare const ChatModelResponseSchemaConfigDef: (maxOutputTokens: number, maxSequences: number) => {
    responseFormat: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    responseSchema: {
        type: "object-schema";
        param: string;
        title: string;
        description: string;
        objectSchema?: any;
    };
    temperature: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    maxTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    stop: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    topP: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    frequencyPenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    presencePenalty: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    seed: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    logProbs: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    topLogProbs: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};
declare const ChatModelResponseSchemaConfigSchema: (maxOutputTokens: number, maxSequences: number) => zod.ZodObject<zod.objectUtil.extendShape<{
    temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
    topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    seed: zod.ZodEffects<zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>, number | undefined, number | undefined>;
    logProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
    topLogProbs: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}, {
    responseFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
    responseSchema: zod.ZodOptional<zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, {
        [x: string]: any;
    }, {
        [x: string]: any;
    }>>;
}>, "strip", zod.ZodTypeAny, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
    responseFormat?: string | null | undefined;
    responseSchema?: {
        [x: string]: any;
    } | undefined;
}, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    topLogProbs?: number | undefined;
    toolChoice?: string | null | undefined;
    responseFormat?: string | null | undefined;
    responseSchema?: {
        [x: string]: any;
    } | undefined;
}>;

declare const EmbeddingModelBaseConfigSchema: () => z.ZodObject<{
    encodingFormat: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
}, "strip", z.ZodTypeAny, {
    encodingFormat?: string | null | undefined;
}, {
    encodingFormat?: string | null | undefined;
}>;
declare const EmbeddingModelBaseConfigDef: () => {
    readonly encodingFormat: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};

declare const encodingFormat: {
    def: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
};
declare const dimensions: (maxDimensions: number) => {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};

declare const EmbeddingModelDimensionsConfigSchema: (maxDimensions: number) => zod.ZodObject<zod.objectUtil.extendShape<{
    encodingFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}, {
    dimensions: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
}>, "strip", zod.ZodTypeAny, {
    dimensions?: number | undefined;
    encodingFormat?: string | null | undefined;
}, {
    dimensions?: number | undefined;
    encodingFormat?: string | null | undefined;
}>;
declare const EmbeddingModelDimensionsConfigDef: (maxDimensions: number) => {
    readonly dimensions: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly encodingFormat: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};

declare const OpenAIChatModelRoles: z.ZodEnum<["system", "user", "assistant", "tool"]>;
declare const OpenAIChatModelRolesMap: {
    readonly system: "system";
    readonly user: "user";
    readonly assistant: "assistant";
    readonly tool: "tool";
};

declare const OpenAIChatModelModalities: ChatModelSchemaType["modalities"];
declare const OpenAIChatModelModalitiesEnum: z.ZodEnum<["text", "image", "tool-call", "tool-response"]>;
declare const OpenAIChatModelTextModalities: ChatModelSchemaType["modalities"];
declare const OpenAIChatModelTextModalitiesEnum: z.ZodEnum<["text"]>;
declare const OpenAIChatModelTextToolModalities: ChatModelSchemaType["modalities"];
declare const OpenAIChatModelTextToolModalitiesEnum: z.ZodEnum<["text", "tool-call", "tool-response"]>;

declare const OpenAIToolCallsCompleteChatResponse: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["function"]>;
    function: z.ZodObject<{
        name: z.ZodString;
        arguments: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        arguments: string;
    }, {
        name: string;
        arguments: string;
    }>;
}, "strip", z.ZodTypeAny, {
    function: {
        name: string;
        arguments: string;
    };
    type: "function";
    id: string;
}, {
    function: {
        name: string;
        arguments: string;
    };
    type: "function";
    id: string;
}>, "many">;
declare const OpenAICompleteChatResponse: z.ZodObject<{
    id: z.ZodString;
    object: z.ZodLiteral<"chat.completion">;
    created: z.ZodNumber;
    model: z.ZodString;
    system_fingerprint: z.ZodNullable<z.ZodString>;
    choices: z.ZodArray<z.ZodObject<{
        index: z.ZodNumber;
        message: z.ZodObject<{
            role: z.ZodString;
            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                type: z.ZodEnum<["function"]>;
                function: z.ZodObject<{
                    name: z.ZodString;
                    arguments: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    arguments: string;
                }, {
                    name: string;
                    arguments: string;
                }>;
            }, "strip", z.ZodTypeAny, {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
            }, {
                function: {
                    name: string;