/**
 * Base Adapter - Abstract foundation for all LLM provider adapters
 * Defines lifecycle hooks, common interfaces, and core functionality
 */
import { ModelProvider, VendorRequest, VendorResponse, VendorStreamChunk } from '../../types/vendors';
import { ConnectorConfig, ModelCapability, ModelMetadata } from '../../types/policies';
export interface AdapterConfig extends ConnectorConfig {
    api_key?: string;
    endpoint_url?: string;
    organization_id?: string;
    project_id?: string;
    custom_config?: Record<string, unknown>;
}
export interface RequestOptions {
    timeout_ms?: number;
    retry_count?: number;
    signal?: AbortSignal;
    trace_id?: string;
    span_id?: string;
    user_id?: string;
    session_id?: string;
    metadata?: Record<string, unknown>;
}
export interface StreamOptions extends RequestOptions {
    on_chunk?: (chunk: VendorStreamChunk) => void;
    on_error?: (error: Error) => void;
    on_complete?: () => void;
}
export interface AdapterResponse<T = VendorResponse> {
    data: T;
    latency_ms: number;
    token_usage?: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
    cost?: number;
    metadata?: {
        model_version?: string;
        request_id?: string;
        finish_reason?: string;
        [key: string]: unknown;
    };
}
export interface HealthCheckResult {
    healthy: boolean;
    latency_ms?: number;
    error?: string;
    last_check: Date;
    metadata?: Record<string, unknown>;
}
export declare enum AdapterErrorCode {
    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
    INSUFFICIENT_QUOTA = "INSUFFICIENT_QUOTA",
    INVALID_REQUEST = "INVALID_REQUEST",
    MODEL_NOT_FOUND = "MODEL_NOT_FOUND",
    TIMEOUT = "TIMEOUT",
    NETWORK_ERROR = "NETWORK_ERROR",
    SERVER_ERROR = "SERVER_ERROR",
    VALIDATION_ERROR = "VALIDATION_ERROR",
    CONTEXT_LENGTH_EXCEEDED = "CONTEXT_LENGTH_EXCEEDED",
    CONTENT_FILTERED = "CONTENT_FILTERED",
    UNKNOWN_ERROR = "UNKNOWN_ERROR"
}
export declare class AdapterError extends Error {
    readonly code: AdapterErrorCode;
    readonly provider: ModelProvider;
    readonly model?: string;
    readonly status_code?: number;
    readonly retry_after_ms?: number;
    readonly details?: Record<string, unknown>;
    constructor(message: string, code: AdapterErrorCode, provider: ModelProvider, options?: {
        model?: string;
        status_code?: number;
        retry_after_ms?: number;
        details?: Record<string, unknown>;
        cause?: Error;
    });
    isRetryable(): boolean;
}
export declare abstract class BaseAdapter {
    protected readonly provider: ModelProvider;
    protected readonly config: AdapterConfig;
    protected metadata?: ModelMetadata;
    constructor(provider: ModelProvider, config: AdapterConfig);
    /**
     * Execute a request to the LLM provider
     */
    abstract execute(request: VendorRequest, options?: RequestOptions): Promise<AdapterResponse>;
    /**
     * Execute a streaming request to the LLM provider
     */
    abstract stream(request: VendorRequest, options: StreamOptions): Promise<AsyncIterable<VendorStreamChunk>>;
    /**
     * Transform provider-specific request format to internal format
     */
    abstract transformRequest(request: VendorRequest): unknown;
    /**
     * Transform provider-specific response format to internal format
     */
    abstract transformResponse(response: unknown): VendorResponse;
    /**
     * Transform provider-specific stream chunk to internal format
     */
    abstract transformStreamChunk(chunk: unknown): VendorStreamChunk;
    /**
     * Health check for the provider endpoint
     */
    abstract healthCheck(): Promise<HealthCheckResult>;
    /**
     * Get model metadata (capabilities, pricing, limits)
     */
    getMetadata(): ModelMetadata | undefined;
    /**
     * Set model metadata
     */
    setMetadata(metadata: ModelMetadata): void;
    /**
     * Check if adapter supports a specific capability
     */
    supportsCapability(capability: ModelCapability): boolean;
    /**
     * Calculate cost for a request based on token usage
     */
    calculateCost(prompt_tokens: number, completion_tokens: number): number;
    /**
     * Backwards compatible wrapper for execute()
     * @deprecated Use execute() instead
     */
    call(request: VendorRequest, options?: RequestOptions): Promise<AdapterResponse>;
    /**
     * Backwards compatible wrapper for stream()
     * @deprecated Use stream() instead
     */
    callStream(request: VendorRequest, options: StreamOptions): Promise<AsyncIterable<VendorStreamChunk>>;
    /**
     * Helper method for calculating cost from usage object (protected for subclasses)
     */
    protected calculateCostFromUsage(prompt_tokens: number, completion_tokens: number): number;
    /**
     * Validate request before execution
     */
    protected validateRequest(request: VendorRequest): void;
    /**
     * Handle errors from provider and convert to AdapterError
     */
    protected handleError(error: unknown, model?: string): AdapterError;
    /**
     * Get request headers with authentication
     */
    protected getHeaders(): Record<string, string>;
    /**
     * Build complete endpoint URL
     */
    protected buildEndpointUrl(path: string): string;
    /**
     * Get default endpoint for the provider
     */
    protected abstract getDefaultEndpoint(): string;
    /**
     * Lifecycle hook - called before request execution
     */
    protected beforeRequest(_request: VendorRequest, _options?: RequestOptions): Promise<void>;
    /**
     * Lifecycle hook - called after successful request
     */
    protected afterRequest(_request: VendorRequest, _response: AdapterResponse, _options?: RequestOptions): Promise<void>;
    /**
     * Lifecycle hook - called after request error
     */
    protected onError(_request: VendorRequest, _error: AdapterError, _options?: RequestOptions): Promise<void>;
    /**
     * Get provider name
     */
    getProvider(): ModelProvider;
    /**
     * Get adapter configuration
     */
    getConfig(): AdapterConfig;
    /**
     * Update adapter configuration
     */
    updateConfig(config: Partial<AdapterConfig>): void;
}
//# sourceMappingURL=base-adapter.d.ts.map