/**
 * Comprehensive Vendor Response Types
 * Covers all major LLM providers with complete type safety
 */
export interface OpenAIMessage {
    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
    content: string | null;
    name?: string;
    function_call?: {
        name: string;
        arguments: string;
    };
    tool_calls?: OpenAIToolCall[];
    tool_call_id?: string;
}
export interface OpenAIToolCall {
    id: string;
    type: 'function';
    function: {
        name: string;
        arguments: string;
    };
}
export interface OpenAIChatCompletionRequest {
    model: string;
    messages: OpenAIMessage[];
    temperature?: number;
    top_p?: number;
    n?: number;
    stream?: boolean;
    stop?: string | string[];
    max_tokens?: number;
    presence_penalty?: number;
    frequency_penalty?: number;
    logit_bias?: Record<string, number>;
    user?: string;
    functions?: OpenAIFunction[];
    function_call?: 'none' | 'auto' | {
        name: string;
    };
    tools?: OpenAITool[];
    tool_choice?: 'none' | 'auto' | {
        type: 'function';
        function: {
            name: string;
        };
    };
    response_format?: {
        type: 'text' | 'json_object';
    };
    seed?: number;
}
export interface OpenAIFunction {
    name: string;
    description?: string;
    parameters: Record<string, unknown>;
}
export interface OpenAITool {
    type: 'function';
    function: OpenAIFunction;
}
export interface OpenAIChatCompletionResponse {
    id: string;
    object: 'chat.completion';
    created: number;
    model: string;
    choices: OpenAIChoice[];
    usage: OpenAIUsage;
    system_fingerprint?: string;
}
export interface OpenAIChoice {
    index: number;
    message: OpenAIMessage;
    finish_reason: 'stop' | 'length' | 'function_call' | 'tool_calls' | 'content_filter' | null;
    logprobs?: OpenAILogProbs | null;
}
export interface OpenAILogProbs {
    content: OpenAILogProbContent[] | null;
}
export interface OpenAILogProbContent {
    token: string;
    logprob: number;
    bytes: number[] | null;
    top_logprobs: OpenAITopLogProb[];
}
export interface OpenAITopLogProb {
    token: string;
    logprob: number;
    bytes: number[] | null;
}
export interface OpenAIUsage {
    prompt_tokens: number;
    completion_tokens: number;
    total_tokens: number;
}
export interface OpenAIStreamChunk {
    id: string;
    object: 'chat.completion.chunk';
    created: number;
    model: string;
    choices: OpenAIStreamChoice[];
}
export interface OpenAIStreamChoice {
    index: number;
    delta: {
        role?: 'assistant';
        content?: string;
        function_call?: {
            name?: string;
            arguments?: string;
        };
        tool_calls?: OpenAIToolCall[];
    };
    finish_reason: 'stop' | 'length' | 'function_call' | 'tool_calls' | 'content_filter' | null;
}
export interface AnthropicMessage {
    role: 'user' | 'assistant';
    content: string | AnthropicContentBlock[];
}
export type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicToolUseBlock | AnthropicToolResultBlock;
export interface AnthropicTextBlock {
    type: 'text';
    text: string;
}
export interface AnthropicImageBlock {
    type: 'image';
    source: {
        type: 'base64' | 'url';
        media_type: 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp';
        data: string;
    };
}
export interface AnthropicToolUseBlock {
    type: 'tool_use';
    id: string;
    name: string;
    input: Record<string, unknown>;
}
export interface AnthropicToolResultBlock {
    type: 'tool_result';
    tool_use_id: string;
    content: string | AnthropicContentBlock[];
    is_error?: boolean;
}
export interface AnthropicRequest {
    model: string;
    messages: AnthropicMessage[];
    max_tokens: number;
    system?: string | Array<{
        type: 'text';
        text: string;
    }>;
    temperature?: number;
    top_p?: number;
    top_k?: number;
    stop_sequences?: string[];
    stream?: boolean;
    metadata?: {
        user_id?: string;
    };
    tools?: AnthropicTool[];
    tool_choice?: AnthropicToolChoice;
}
export interface AnthropicTool {
    name: string;
    description: string;
    input_schema: Record<string, unknown>;
}
export type AnthropicToolChoice = {
    type: 'auto';
} | {
    type: 'any_tool';
} | {
    type: 'tool';
    name: string;
};
export interface AnthropicResponse {
    id: string;
    type: 'message';
    role: 'assistant';
    content: AnthropicContentBlock[];
    model: string;
    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null;
    stop_sequence: string | null;
    usage: AnthropicUsage;
}
export interface AnthropicUsage {
    input_tokens: number;
    output_tokens: number;
}
export interface AnthropicStreamEvent {
    type: 'message_start' | 'content_block_start' | 'content_block_delta' | 'content_block_stop' | 'message_delta' | 'message_stop' | 'ping';
    message?: Partial<AnthropicResponse>;
    index?: number;
    content_block?: AnthropicContentBlock;
    delta?: {
        type: 'text_delta' | 'input_json_delta';
        text?: string;
        partial_json?: string;
        stop_reason?: string;
        stop_sequence?: string;
    };
    usage?: Partial<AnthropicUsage>;
}
export interface GoogleGenerationConfig {
    temperature?: number;
    topP?: number;
    topK?: number;
    candidateCount?: number;
    maxOutputTokens?: number;
    stopSequences?: string[];
}
export interface GoogleSafetySettings {
    category: 'HARM_CATEGORY_HARASSMENT' | 'HARM_CATEGORY_HATE_SPEECH' | 'HARM_CATEGORY_SEXUALLY_EXPLICIT' | 'HARM_CATEGORY_DANGEROUS_CONTENT';
    threshold: 'BLOCK_NONE' | 'BLOCK_ONLY_HIGH' | 'BLOCK_MEDIUM_AND_ABOVE' | 'BLOCK_LOW_AND_ABOVE';
}
export interface GoogleContent {
    role: 'user' | 'model';
    parts: GooglePart[];
}
export type GooglePart = {
    text: string;
} | {
    inlineData: {
        mimeType: string;
        data: string;
    };
} | {
    fileData: {
        mimeType: string;
        fileUri: string;
    };
} | {
    functionCall: {
        name: string;
        args: Record<string, unknown>;
    };
} | {
    functionResponse: {
        name: string;
        response: Record<string, unknown>;
    };
};
export interface GoogleTool {
    functionDeclarations: GoogleFunctionDeclaration[];
}
export interface GoogleFunctionDeclaration {
    name: string;
    description: string;
    parameters: {
        type: 'object';
        properties: Record<string, unknown>;
        required?: string[];
    };
}
export interface GoogleRequest {
    contents: GoogleContent[];
    generationConfig?: GoogleGenerationConfig;
    safetySettings?: GoogleSafetySettings[];
    tools?: GoogleTool[];
}
export interface GoogleResponse {
    candidates: GoogleCandidate[];
    promptFeedback?: GooglePromptFeedback;
    usageMetadata?: GoogleUsageMetadata;
}
export interface GoogleCandidate {
    content: GoogleContent;
    finishReason: 'FINISH_REASON_UNSPECIFIED' | 'STOP' | 'MAX_TOKENS' | 'SAFETY' | 'RECITATION' | 'OTHER';
    index: number;
    safetyRatings: GoogleSafetyRating[];
    citationMetadata?: GoogleCitationMetadata;
    tokenCount?: number;
}
export interface GoogleSafetyRating {
    category: string;
    probability: 'NEGLIGIBLE' | 'LOW' | 'MEDIUM' | 'HIGH';
    blocked: boolean;
}
export interface GoogleCitationMetadata {
    citationSources: Array<{
        startIndex?: number;
        endIndex?: number;
        uri?: string;
        license?: string;
    }>;
}
export interface GooglePromptFeedback {
    blockReason?: string;
    safetyRatings: GoogleSafetyRating[];
}
export interface GoogleUsageMetadata {
    promptTokenCount: number;
    candidatesTokenCount: number;
    totalTokenCount: number;
}
export interface CohereRequest {
    model: string;
    message: string;
    chat_history?: CohereChatMessage[];
    preamble?: string;
    conversation_id?: string;
    prompt_truncation?: 'AUTO' | 'OFF';
    connectors?: Array<{
        id: string;
        options?: Record<string, unknown>;
    }>;
    search_queries_only?: boolean;
    documents?: Array<Record<string, unknown>>;
    temperature?: number;
    max_tokens?: number;
    k?: number;
    p?: number;
    frequency_penalty?: number;
    presence_penalty?: number;
    stream?: boolean;
    tools?: CohereTool[];
    tool_results?: CohereToolResult[];
}
export interface CohereChatMessage {
    role: 'USER' | 'CHATBOT' | 'SYSTEM' | 'TOOL';
    message?: string;
    tool_calls?: CohereToolCall[];
}
export interface CohereTool {
    name: string;
    description: string;
    parameter_definitions?: Record<string, CohereParameterDefinition>;
}
export interface CohereParameterDefinition {
    description: string;
    type: string;
    required: boolean;
}
export interface CohereToolCall {
    name: string;
    parameters: Record<string, unknown>;
}
export interface CohereToolResult {
    call: CohereToolCall;
    outputs: Array<Record<string, unknown>>;
}
export interface CohereResponse {
    response_id: string;
    text: string;
    generation_id: string;
    chat_history: CohereChatMessage[];
    finish_reason: 'COMPLETE' | 'ERROR' | 'ERROR_TOXIC' | 'ERROR_LIMIT' | 'USER_CANCEL' | 'MAX_TOKENS';
    meta?: {
        api_version: {
            version: string;
        };
        billed_units?: {
            input_tokens: number;
            output_tokens: number;
        };
        tokens?: {
            input_tokens: number;
            output_tokens: number;
        };
    };
    citations?: CohereCitation[];
    documents?: Array<Record<string, unknown>>;
    search_queries?: CohereSearchQuery[];
    search_results?: CohereSearchResult[];
    tool_calls?: CohereToolCall[];
}
export interface CohereCitation {
    start: number;
    end: number;
    text: string;
    document_ids: string[];
}
export interface CohereSearchQuery {
    text: string;
    generation_id: string;
}
export interface CohereSearchResult {
    search_query: CohereSearchQuery;
    connector: {
        id: string;
    };
    document_ids: string[];
}
export interface HuggingFaceRequest {
    inputs: string | string[] | Record<string, unknown>;
    parameters?: HuggingFaceParameters;
    options?: {
        use_cache?: boolean;
        wait_for_model?: boolean;
    };
}
export interface HuggingFaceParameters {
    temperature?: number;
    top_k?: number;
    top_p?: number;
    max_length?: number;
    max_new_tokens?: number;
    min_length?: number;
    do_sample?: boolean;
    early_stopping?: boolean;
    num_beams?: number;
    repetition_penalty?: number;
    length_penalty?: number;
    return_full_text?: boolean;
    truncate?: number;
    stop?: string[];
}
export interface HuggingFaceResponse {
    generated_text?: string;
    generated_tokens?: number;
    details?: {
        finish_reason?: string;
        tokens?: Array<{
            id: number;
            text: string;
            logprob: number;
        }>;
    };
}
export interface HuggingFaceStreamResponse {
    token: {
        id: number;
        text: string;
        logprob: number;
        special: boolean;
    };
    generated_text?: string;
    details?: {
        finish_reason?: string;
        generated_tokens: number;
    };
}
export interface BedrockRequest {
    modelId: string;
    body: string;
    contentType?: string;
    accept?: string;
}
export interface BedrockClaudeRequest {
    prompt: string;
    max_tokens_to_sample: number;
    temperature?: number;
    top_p?: number;
    top_k?: number;
    stop_sequences?: string[];
    anthropic_version?: string;
}
export interface BedrockTitanRequest {
    inputText: string;
    textGenerationConfig?: {
        temperature?: number;
        topP?: number;
        maxTokenCount?: number;
        stopSequences?: string[];
    };
}
export interface BedrockResponse {
    body: ReadableStream<Uint8Array>;
    contentType: string;
}
export interface ReplicateRequest {
    version: string;
    input: Record<string, unknown>;
    webhook?: string;
    webhook_events_filter?: string[];
}
export interface ReplicateResponse {
    id: string;
    version: string;
    status: 'starting' | 'processing' | 'succeeded' | 'failed' | 'canceled';
    input: Record<string, unknown>;
    output: unknown;
    error?: string;
    logs?: string;
    metrics?: {
        predict_time?: number;
    };
    created_at: string;
    started_at?: string;
    completed_at?: string;
    urls?: {
        get: string;
        cancel: string;
    };
}
export interface TogetherRequest {
    model: string;
    prompt?: string;
    messages?: Array<{
        role: 'system' | 'user' | 'assistant';
        content: string;
    }>;
    max_tokens?: number;
    temperature?: number;
    top_p?: number;
    top_k?: number;
    repetition_penalty?: number;
    stop?: string[];
    stream?: boolean;
    logprobs?: number;
    echo?: boolean;
}
export interface TogetherResponse {
    id: string;
    object: string;
    created: number;
    model: string;
    choices: Array<{
        text?: string;
        message?: {
            role: string;
            content: string;
        };
        index: number;
        logprobs?: {
            tokens: string[];
            token_logprobs: number[];
            top_logprobs: Array<Record<string, number>>;
        };
        finish_reason: string;
    }>;
    usage: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
}
export interface OllamaRequest {
    model: string;
    prompt?: string;
    messages?: Array<{
        role: 'system' | 'user' | 'assistant';
        content: string;
        images?: string[];
    }>;
    stream?: boolean;
    format?: 'json';
    options?: {
        temperature?: number;
        top_k?: number;
        top_p?: number;
        num_predict?: number;
        stop?: string[];
    };
    system?: string;
    template?: string;
    context?: number[];
    raw?: boolean;
}
export interface OllamaResponse {
    model: string;
    created_at: string;
    message?: {
        role: string;
        content: string;
    };
    response?: string;
    done: boolean;
    context?: number[];
    total_duration?: number;
    load_duration?: number;
    prompt_eval_count?: number;
    prompt_eval_duration?: number;
    eval_count?: number;
    eval_duration?: number;
}
export type VendorRequest = OpenAIChatCompletionRequest | AnthropicRequest | GoogleRequest | CohereRequest | HuggingFaceRequest | BedrockRequest | ReplicateRequest | TogetherRequest | OllamaRequest;
export type VendorResponse = OpenAIChatCompletionResponse | AnthropicResponse | GoogleResponse | CohereResponse | HuggingFaceResponse | BedrockResponse | ReplicateResponse | TogetherResponse | OllamaResponse;
export type VendorStreamChunk = OpenAIStreamChunk | AnthropicStreamEvent | HuggingFaceStreamResponse | OllamaResponse;
export declare enum ModelProvider {
    OPENAI = "openai",
    AZURE_OPENAI = "azure-openai",
    ANTHROPIC = "anthropic",
    GOOGLE_GEMINI = "google-gemini",
    GOOGLE_VERTEX = "google-vertex",
    COHERE = "cohere",
    MISTRAL = "mistral",
    HUGGINGFACE = "huggingface",
    AWS_BEDROCK = "aws-bedrock",
    REPLICATE = "replicate",
    TOGETHER = "together",
    ANYSCALE = "anyscale",
    FIREWORKS = "fireworks",
    PERPLEXITY = "perplexity",
    OLLAMA = "ollama",
    LM_STUDIO = "lm-studio",
    CUSTOM_HTTP = "custom-http",
    CUSTOM_GRPC = "custom-grpc"
}
//# sourceMappingURL=vendors.d.ts.map