@adaline/together-ai/dist/index.d.mts

Adaline Together AI

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

declare const TogetherAIChatModelConfigs: {
    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 topK: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly minP: {
                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 repetitionPenalty: {
                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 toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            readonly responseSchema: {
                type: "object-schema";
                param: string;
                title: string;
                description: string;
                objectSchema?: any;
            };
            readonly responseFormat: {
                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>>;
            topK: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            minP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            frequencyPenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            presencePenalty: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            repetitionPenalty: 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>>>;
            toolChoice: 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;
            }>>;
            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;
            topK?: number | undefined;
            minP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            repetitionPenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            toolChoice?: string | null | undefined;
            responseSchema?: {
                [x: string]: any;
            } | undefined;
            responseFormat?: string | null | undefined;
        }, {
            temperature?: number | undefined;
            seed?: number | undefined;
            stop?: string[] | undefined;
            maxTokens?: number | undefined;
            topP?: number | undefined;
            topK?: number | undefined;
            minP?: number | undefined;
            frequencyPenalty?: number | undefined;
            presencePenalty?: number | undefined;
            repetitionPenalty?: number | undefined;
            logProbs?: boolean | null | undefined;
            toolChoice?: string | null | undefined;
            responseSchema?: {
                [x: string]: any;
            } | undefined;
            responseFormat?: 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>>;
    topK: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    minP: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    frequencyPenalty: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    presencePenalty: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    repetitionPenalty: 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>>>;
    toolChoice: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
    responseSchema: z.ZodOptional<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, {
        [x: string]: any;
    }, {
        [x: string]: any;
    }>>;
    responseFormat: 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;
    topK?: number | undefined;
    minP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    repetitionPenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    toolChoice?: string | null | undefined;
    responseSchema?: {
        [x: string]: any;
    } | undefined;
    responseFormat?: string | null | undefined;
}, {
    temperature?: number | undefined;
    seed?: number | undefined;
    stop?: string[] | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    topK?: number | undefined;
    minP?: number | undefined;
    frequencyPenalty?: number | undefined;
    presencePenalty?: number | undefined;
    repetitionPenalty?: number | undefined;
    logProbs?: boolean | null | undefined;
    toolChoice?: string | null | undefined;
    responseSchema?: {
        [x: string]: any;
    } | undefined;
    responseFormat?: 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 topK: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly minP: {
        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 repetitionPenalty: {
        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 toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    readonly responseSchema: {
        type: "object-schema";
        param: string;
        title: string;
        description: string;
        objectSchema?: any;
    };
    readonly responseFormat: {
        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 topK: {
    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 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 minP: {
    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 repetitionPenalty: {
    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 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 responseFormat: {
    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 responseSchema: {
    def: {
        type: "object-schema";
        param: string;
        title: string;
        description: string;
        objectSchema?: any;
    };
    schema: zod.ZodOptional<zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, {
        [x: string]: any;
    }, {
        [x: string]: any;
    }>>;
};

declare const BaseChatModelSchema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        schema: zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};

declare const TogetherAIChatRequest: z.ZodObject<{
    model: z.ZodOptional<z.ZodString>;
    messages: z.ZodArray<z.ZodUnion<[z.ZodObject<{
        role: z.ZodLiteral<"system">;
        content: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        role: "system";
        content: string;
    }, {
        role: "system";
        content: string;
    }>, z.ZodObject<{
        role: z.ZodLiteral<"user">;
        content: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        role: "user";
        content: string;
    }, {
        role: "user";
        content: string;
    }>, z.ZodObject<{
        role: z.ZodLiteral<"assistant">;
        content: z.ZodOptional<z.ZodString>;
        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"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">>;
    }, "strip", z.ZodTypeAny, {
        role: "assistant";
        content?: string | undefined;
        tool_calls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
        }[] | undefined;
    }, {
        role: "assistant";
        content?: string | undefined;
        tool_calls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
        }[] | undefined;
    }>, z.ZodObject<{
        role: z.ZodLiteral<"tool">;
        tool_call_id: z.ZodString;
        content: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        role: "tool";
        content: string;
        tool_call_id: string;
    }, {
        role: "tool";
        content: string;
        tool_call_id: string;
    }>]>, "many">;
    frequency_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    logprobs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    max_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    repetition_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    response_format: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
        type: z.ZodEnum<["text", "json_object"]>;
    }, "strip", z.ZodTypeAny, {
        type: "text" | "json_object";
    }, {
        type: "text" | "json_object";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"json_schema">;
        json_schema: z.ZodObject<{
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            strict: z.ZodOptional<z.ZodBoolean>;
            schema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            schema?: any;
        }, {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            schema?: any;
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "json_schema";
        json_schema: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            schema?: any;
        };
    }, {
        type: "json_schema";
        json_schema: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            schema?: any;
        };
    }>]>>;
    seed: z.ZodOptional<z.ZodNumber>;
    stop: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
    temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    top_k: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    min_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    echo: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodLiteral<"function">;
        function: z.ZodObject<{
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            strict: z.ZodOptional<z.ZodBoolean>;
            parameters: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            parameters?: any;
        }, {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            parameters?: any;
        }>;
    }, "strip", z.ZodTypeAny, {
        function: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            parameters?: any;
        };
        type: "function";
    }, {
        function: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            parameters?: any;
        };
        type: "function";
    }>, "many">>;
    tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["none", "auto", "required"]>, z.ZodObject<{
        type: z.ZodLiteral<"function">;
        function: z.ZodObject<{
            name: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
        }, {
            name: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        function: {
            name: string;
        };
        type: "function";
    }, {
        function: {
            name: string;
        };
        type: "function";
    }>]>>;
}, "strip", z.ZodTypeAny, {
    messages: ({
        role: "system";
        content: string;
    } | {
        role: "user";
        content: string;
    } | {
        role: "assistant";
        content?: string | undefined;
        tool_calls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
        }[] | undefined;
    } | {
        role: "tool";
        content: string;
        tool_call_id: string;
    })[];
    temperature?: number | null | undefined;
    top_k?: number | null | undefined;
    top_p?: number | null | undefined;
    min_p?: number | null | undefined;
    frequency_penalty?: number | null | undefined;
    presence_penalty?: number | null | undefined;
    repetition_penalty?: number | null | undefined;
    seed?: number | undefined;
    logprobs?: number | null | undefined;
    tool_choice?: "auto" | "required" | "none" | {
        function: {
            name: string;
        };
        type: "function";
    } | undefined;
    response_format?: {
        type: "text" | "json_object";
    } | {
        type: "json_schema";
        json_schema: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            schema?: any;
        };
    } | undefined;
    max_tokens?: number | null | undefined;
    stop?: string | string[] | null | undefined;
    model?: string | undefined;
    echo?: boolean | null | undefined;
    tools?: {
        function: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            parameters?: any;
        };
        type: "function";
    }[] | undefined;
}, {
    messages: ({
        role: "system";
        content: string;
    } | {
        role: "user";
        content: string;
    } | {
        role: "assistant";
        content?: string | undefined;
        tool_calls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
        }[] | undefined;
    } | {
        role: "tool";
        content: string;
        tool_call_id: string;
    })[];
    temperature?: number | null | undefined;
    top_k?: number | null | undefined;
    top_p?: number | null | undefined;
    min_p?: number | null | undefined;
    frequency_penalty?: number | null | undefined;
    presence_penalty?: number | null | undefined;
    repetition_penalty?: number | null | undefined;
    seed?: number | undefined;
    logprobs?: number | null | undefined;
    tool_choice?: "auto" | "required" | "none" | {
        function: {
            name: string;
        };
        type: "function";
    } | undefined;
    response_format?: {
        type: "text" | "json_object";
    } | {
        type: "json_schema";
        json_schema: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            schema?: any;
        };
    } | undefined;
    max_tokens?: number | null | undefined;
    stop?: string | string[] | null | undefined;
    model?: string | undefined;
    echo?: boolean | null | undefined;
    tools?: {
        function: {
            name: string;
            description?: string | undefined;
            strict?: boolean | undefined;
            parameters?: any;
        };
        type: "function";
    }[] | undefined;
}>;
type TogetherAIChatRequestType = z.infer<typeof TogetherAIChatRequest>;

declare const BaseChatModelOptions: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
}, {
    modelName: string;
    apiKey: string;
}>;
type BaseChatModelOptionsType = z.infer<typeof BaseChatModelOptions>;
declare class BaseChatModel implements ChatModelV1<ChatModelSchemaType> {
    readonly version: "v1";
    modelSchema: ChatModelSchemaType;
    private readonly modelName;
    private readonly apiKey;
    private readonly baseUrl;
    private readonly streamChatUrl;
    private readonly completeChatUrl;
    constructor(modelSchema: ChatModelSchemaType, options: BaseChatModelOptionsType);
    getDefaultBaseUrl(): UrlType;
    getDefaultHeaders(): HeadersType;
    getDefaultParams(): ParamsType;
    getRetryDelay(responseHeaders: HeadersType, _responseData: unknown): {
        shouldRetry: boolean;
        delayMs: number;
    };
    getTokenCount(messages: MessageType[]): number;
    transformModelRequest(request: TogetherAIChatRequestType): {
        modelName: string | undefined;
        config: ConfigType;
        messages: MessageType[];
        tools: ToolType[] | undefined;
    };
    transformConfig(config: ConfigType, messages?: MessageType[], tools?: ToolType[]): ParamsType;
    transformMessages(messages: MessageType[]): ParamsType;
    transformTools(tools: ToolType[]): ParamsType;
    getCompleteChatUrl(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<UrlType>;
    getCompleteChatHeaders(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<HeadersType>;
    getCompleteChatData(config: ConfigType, messages: MessageType[], tools?: ToolType[]): Promise<ParamsType>;
    transformCompleteChatResponse(response: any): ChatResponseType;
    getStreamChatUrl(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<UrlType>;
    getStreamChatHeaders(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<HeadersType>;
    getStreamChatData(config: ConfigType, messages: MessageType[], tools?: ToolType[]): Promise<ParamsType>;
    transformStreamChatResponseChunk(chunk: string, buffer: string): AsyncGenerator<{
        partialResponse: PartialChatResponseType;
        buffer: string;
    }>;
    transformProxyStreamChatResponseChunk(chunk: string, buffer: string, data?: any, headers?: Record<string, string>, query?: Record<string, string>): AsyncGenerator<{
        partialResponse: PartialChatResponseType;
        buffer: string;
    }>;
    getProxyStreamChatUrl(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<UrlType>;
    getProxyCompleteChatUrl(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<UrlType>;
    getProxyCompleteChatHeaders(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<HeadersType>;
    getProxyStreamChatHeaders(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<HeadersType>;
    getModelPricing(): ChatModelPriceType;
}

declare const TogetherAIEmbeddingModelModalities: EmbeddingModelSchemaType["modalities"];
declare const TogetherAIEmbeddingModelModalitiesEnum: z.ZodEnum<["text"]>;

declare const TogetherAIGetEmbeddingsResponse: z.ZodObject<{
    object: z.ZodLiteral<"list">;
    model: z.ZodString;
    data: z.ZodArray<z.ZodObject<{
        index: z.ZodNumber;
        object: z.ZodLiteral<"embedding">;
        embedding: z.ZodUnion<[z.ZodArray<z.ZodNumber, "many">, z.ZodString]>;
    }, "strip", z.ZodTypeAny, {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }, {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }>, "many">;
    usage: z.ZodOptional<z.ZodObject<{
        prompt_tokens: z.ZodNumber;
        total_tokens: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        prompt_tokens: number;
        total_tokens: number;
    }, {
        prompt_tokens: number;
        total_tokens: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    object: "list";
    model: string;
    data: {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }[];
    usage?: {
        prompt_tokens: number;
        total_tokens: number;
    } | undefined;
}, {
    object: "list";
    model: string;
    data: {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }[];
    usage?: {
        prompt_tokens: number;
        total_tokens: number;
    } | undefined;
}>;

declare const TogetherAIEmbeddingRequestInput: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
type TogetherAIEmbeddingRequestInputType = z.infer<typeof TogetherAIEmbeddingRequestInput>;
declare const TogetherAIEmbeddingRequest: z.ZodObject<{
    model: z.ZodOptional<z.ZodString>;
    input: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
}, "strip", z.ZodTypeAny, {
    input: string | string[];
    model?: string | undefined;
}, {
    input: string | string[];
    model?: string | undefined;
}>;
type TogetherAIEmbeddingRequestType = z.infer<typeof TogetherAIEmbeddingRequest>;

declare const BaseEmbeddingModelOptions: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
}, {
    modelName: string;
    apiKey: string;
}>;
type BaseEmbeddingModelOptionsType = z.infer<typeof BaseEmbeddingModelOptions>;
declare class BaseEmbeddingModel implements EmbeddingModelV1<EmbeddingModelSchemaType> {
    readonly version: "v1";
    modelSchema: EmbeddingModelSchemaType;
    private readonly modelName;
    private readonly apiKey;
    private readonly baseUrl;
    private readonly getEmbeddingsUrl;
    constructor(modelSchema: EmbeddingModelSchemaType, options: BaseEmbeddingModelOptionsType);
    getDefaultBaseUrl(): UrlType;
    getDefaultHeaders(): HeadersType;
    getDefaultParams(): ParamsType;
    getRetryDelay(responseHeaders: HeadersType, _responseData: unknown): {
        shouldRetry: boolean;
        delayMs: number;
    };
    getTokenCount(requests: EmbeddingRequestsType): number;
    transformModelRequest(request: any): {
        modelName: string | undefined;
        config: ConfigType;
        embeddingRequests: EmbeddingRequestsType;
    };
    transformConfig(config: ConfigType, requests?: EmbeddingRequestsType): ParamsType;
    transformEmbeddingRequests(requests: EmbeddingRequestsType): ParamsType;
    getGetEmbeddingsUrl(config?: ConfigType, requests?: EmbeddingRequestsType): Promise<UrlType>;
    getGetEmbeddingsHeaders(config?: ConfigType, requests?: EmbeddingRequestsType): Promise<HeadersType>;
    getGetEmbeddingsData(config: ConfigType, requests: EmbeddingRequestsType): Promise<ParamsType>;
    transformGetEmbeddingsResponse(response: any): EmbeddingResponseType;
}

declare const BaseEmbeddingModelSchema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};

declare class TogetherAI<C extends BaseChatModelOptionsType, E extends BaseEmbeddingModelOptionsType> implements ProviderV1<C, E> {
    readonly version: "v1";
    readonly name = "together-ai";
    static readonly baseUrl = "https://api.together.xyz/v1";
    chatModelLiterals(): string[];
    chatModelSchemas(): Record<string, ChatModelSchemaType>;
    chatModel(options: C): ChatModelV1;
    embeddingModelLiterals(): string[];
    embeddingModelSchemas(): Record<string, EmbeddingModelSchemaType>;
    embeddingModel(options: E): EmbeddingModelV1;
}

export { BaseChatModel, BaseChatModelOptions, type BaseChatModelOptionsType, BaseChatModelSchema, BaseEmbeddingModel, BaseEmbeddingModelOptions, type BaseEmbeddingModelOptionsType, BaseEmbeddingModelSchema, ChatModelBaseConfigDef, ChatModelBaseConfigSchema, TogetherAI, TogetherAIChatModelConfigs, TogetherAIEmbeddingModelModalities, TogetherAIEmbeddingModelModalitiesEnum, TogetherAIEmbeddingRequest, TogetherAIEmbeddingRequestInput, type TogetherAIEmbeddingRequestInputType, type TogetherAIEmbeddingRequestType, TogetherAIGetEmbeddingsResponse, frequencyPenalty, logProbs, maxTokens, minP, presencePenalty, repetitionPenalty, responseFormat, responseSchema, seed, stop, temperature, toolChoice, topK, topP };