/**
 * LLM API Response Examples
 *
 * Type-safe test fixtures for validating LLM provider API responses.
 * These serve as the single source of truth for expected response structures
 * from external LLM APIs (OpenAI, Gemini, Perplexity, etc.).
 *
 * Usage:
 * - Import in backend tests for LLM integration validation
 * - Import in mocks for consistent test responses
 * - Reference for documentation and debugging
 *
 * @see backend/src/tools/*LLMTool.ts - Uses these structures for parsing
 */
/**
 * OpenAI/OpenRouter API Response Structures
 *
 * OpenRouter endpoint: /responses
 * Used by OpenAI models via OpenRouter gateway
 */
export interface OpenAIResponseUsage {
    input_tokens?: number;
    output_tokens?: number;
    total_tokens?: number;
    prompt_tokens?: number;
    completion_tokens?: number;
}
export interface OpenAIResponseTextContent {
    type?: string;
    text?: string;
}
export interface OpenAIResponseOutputItem {
    type?: string;
    text?: string;
    content?: OpenAIResponseTextContent[];
}
export interface OpenAIChatCompletionChoice {
    message?: {
        content?: string;
    };
    finish_reason?: string;
}
export interface OpenAIResponsesResult {
    output?: OpenAIResponseOutputItem[];
    output_text?: string;
    usage?: OpenAIResponseUsage;
    choices?: OpenAIChatCompletionChoice[];
    error?: {
        message?: string;
        type?: string;
    };
}
/**
 * Example OpenAI/OpenRouter successful response
 * Based on actual API response from openrouter.ai/responses endpoint
 */
export declare const OPENAI_OPENROUTER_SUCCESS_EXAMPLE: OpenAIResponsesResult;
/**
 * Example OpenAI/OpenRouter error response
 */
export declare const OPENAI_OPENROUTER_ERROR_EXAMPLE: OpenAIResponsesResult;
/**
 * Cerebras API Response Structures
 *
 * Cerebras endpoint: /chat/completions
 */
export interface CerebrasStreamChunk {
    choices: Array<{
        delta: {
            content?: string;
        };
        finish_reason?: string;
    }>;
}
export interface CerebrasResponse {
    choices: Array<{
        message: {
            content: string;
            annotations?: unknown;
        };
        finish_reason: string;
    }>;
    usage: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
}
/**
 * Example Cerebras successful response
 */
export declare const CEREBRAS_SUCCESS_EXAMPLE: CerebrasResponse;
/**
 * Grok API Response Structures
 *
 * X.AI Grok endpoint: /chat/completions
 */
export interface GrokChatCompletion {
    choices?: Array<{
        message?: {
            content?: string;
        };
    }>;
    usage?: {
        prompt_tokens?: number;
        completion_tokens?: number;
        total_tokens?: number;
        num_sources_used?: number;
    };
    error?: {
        message?: string;
    };
}
/**
 * Example Grok successful response with web search
 */
export declare const GROK_SUCCESS_EXAMPLE: GrokChatCompletion;
/**
 * Perplexity API Response Structures
 *
 * Perplexity endpoint: /chat/completions
 * Similar to OpenAI format with citations
 */
export interface PerplexityMessage {
    role: string;
    content: string;
}
export interface PerplexityCitation {
    url: string;
    title?: string;
    text?: string;
}
export interface PerplexityUsage {
    prompt_tokens: number;
    completion_tokens: number;
    total_tokens: number;
}
export interface PerplexityResponse {
    id: string;
    model: string;
    object: string;
    created: number;
    choices: Array<{
        index: number;
        message: PerplexityMessage;
        finish_reason: string;
    }>;
    usage: PerplexityUsage;
    citations?: PerplexityCitation[];
}
/**
 * Example Perplexity successful response with citations
 */
export declare const PERPLEXITY_SUCCESS_EXAMPLE: PerplexityResponse;
/**
 * Gemini API Response Structures
 *
 * Google GenerativeModel API (via @google/generative-ai SDK)
 * Note: Gemini uses SDK objects, not raw JSON responses
 */
export interface GeminiCandidate {
    content: {
        parts: Array<{
            text: string;
        }>;
        role: string;
    };
    finishReason?: string;
    index?: number;
    safetyRatings?: Array<{
        category: string;
        probability: string;
    }>;
}
export interface GeminiGenerateContentResponse {
    candidates?: GeminiCandidate[];
    promptFeedback?: {
        blockReason?: string;
        safetyRatings?: Array<{
            category: string;
            probability: string;
        }>;
    };
}
/**
 * Example Gemini successful response
 * Note: Actual SDK returns GenerateContentResult with .response.text() method
 */
export declare const GEMINI_SUCCESS_EXAMPLE: GeminiGenerateContentResponse;
/**
 * All LLM response examples indexed by provider
 */
export declare const LLM_RESPONSE_EXAMPLES: {
    readonly 'openai-openrouter-success': OpenAIResponsesResult;
    readonly 'openai-openrouter-error': OpenAIResponsesResult;
    readonly 'cerebras-success': CerebrasResponse;
    readonly 'grok-success': GrokChatCompletion;
    readonly 'perplexity-success': PerplexityResponse;
    readonly 'gemini-success': GeminiGenerateContentResponse;
};
/**
 * Type helper to get the example for a specific provider
 */
export type LLMResponseExample<T extends keyof typeof LLM_RESPONSE_EXAMPLES> = typeof LLM_RESPONSE_EXAMPLES[T];
//# sourceMappingURL=llmResponseExamples.d.ts.map