proxy

type APIConfig struct {
	// APIs contains configurations for different API providers
	APIs map[string]*APIProviderConfig `yaml:"apis"`
	// DefaultAPI is the default API provider to use if not specified
	DefaultAPI string `yaml:"default_api"`
}

type APIProviderConfig struct {
	// BaseURL is the target API base URL
	BaseURL string `yaml:"base_url"`
	// AllowedEndpoints is a list of endpoint prefixes that are allowed to be accessed
	AllowedEndpoints []string `yaml:"allowed_endpoints"`
	// AllowedMethods is a list of HTTP methods that are allowed
	AllowedMethods []string `yaml:"allowed_methods"`
	// Timeouts for various operations
	Timeouts TimeoutConfig `yaml:"timeouts"`
	// Connection settings
	Connection ConnectionConfig `yaml:"connection"`
	// ParamWhitelist is a map of parameter names to allowed values
	ParamWhitelist  map[string][]string `yaml:"param_whitelist"`
	AllowedOrigins  []string            `yaml:"allowed_origins"`
	RequiredHeaders []string            `yaml:"required_headers"`
}

type AuditLogger interface {
	// Log records an audit event
	Log(event *audit.Event) error
}

type CacheMetricType int

type CacheStatsAggregator struct {
	// contains filtered or unexported fields
}

type CacheStatsAggregatorConfig struct {
	BufferSize    int           // Size of the buffered channel (default: 1000)
	FlushInterval time.Duration // How often to flush stats to DB (default: 5s)
	BatchSize     int           // Max events before flush (default: 100)
}

type CacheStatsStore interface {
	// IncrementCacheHitCountBatch increments cache_hit_count for multiple tokens.
	// The deltas map has token IDs as keys and increment values as values.
	IncrementCacheHitCountBatch(ctx context.Context, deltas map[string]int) error
}

type ConnectionConfig struct {
	// MaxIdleConns is the maximum number of idle connections
	MaxIdleConns int `yaml:"max_idle_conns"`
	// MaxIdleConnsPerHost is the maximum number of idle connections per host
	MaxIdleConnsPerHost int `yaml:"max_idle_conns_per_host"`
}

type ErrorResponse struct {
	Error       string `json:"error"`
	Description string `json:"description,omitempty"`
	Code        string `json:"code,omitempty"`
}

type Middleware func(http.Handler) http.Handler

type Project struct {
	ID            string     `json:"id"`
	Name          string     `json:"name"`
	APIKey        string     `json:"api_key"` // Provider-agnostic API key. Encrypted when ENCRYPTION_KEY is set.
	IsActive      bool       `json:"is_active"`
	DeactivatedAt *time.Time `json:"deactivated_at,omitempty"`
	CreatedAt     time.Time  `json:"created_at"`
	UpdatedAt     time.Time  `json:"updated_at"`
}

type ProjectActiveChecker interface {
	// GetProjectActive checks if a project is active
	GetProjectActive(ctx context.Context, projectID string) (bool, error)
}

type ProjectStore interface {
	// GetAPIKeyForProject retrieves the API key for a project
	GetAPIKeyForProject(ctx context.Context, projectID string) (string, error)
	// GetProjectActive checks if a project is active
	GetProjectActive(ctx context.Context, projectID string) (bool, error)
	// Management API CRUD
	ListProjects(ctx context.Context) ([]Project, error)
	CreateProject(ctx context.Context, project Project) error
	GetProjectByID(ctx context.Context, projectID string) (Project, error)
	UpdateProject(ctx context.Context, project Project) error
	DeleteProject(ctx context.Context, projectID string) error
}

type Proxy interface {
	// Handler returns an http.Handler for the proxy
	Handler() http.Handler

	// Shutdown gracefully shuts down the proxy
	Shutdown(ctx context.Context) error
}

type ProxyConfig struct {
	// TargetBaseURL is the base URL of the API to proxy to
	TargetBaseURL string

	// AllowedEndpoints is a whitelist of endpoints that can be accessed
	AllowedEndpoints []string

	// AllowedMethods is a whitelist of HTTP methods that can be used
	AllowedMethods []string

	// RequestTimeout is the maximum duration for a complete request
	RequestTimeout time.Duration

	// ResponseHeaderTimeout is the time to wait for response headers
	ResponseHeaderTimeout time.Duration

	// FlushInterval is how often to flush streaming responses
	FlushInterval time.Duration

	// MaxIdleConns is the maximum number of idle connections
	MaxIdleConns int

	// MaxIdleConnsPerHost is the maximum number of idle connections per host
	MaxIdleConnsPerHost int

	// IdleConnTimeout is how long to keep idle connections alive
	IdleConnTimeout time.Duration

	// LogLevel controls the verbosity of logging
	LogLevel string
	// LogFormat controls the log output format (json or console)
	LogFormat string
	// LogFile specifies a file path for logs (stdout if empty)
	LogFile string

	// SetXForwardedFor determines whether to set the X-Forwarded-For header
	SetXForwardedFor bool

	// ParamWhitelist is a map of parameter names to allowed values
	ParamWhitelist map[string][]string

	// AllowedOrigins is a list of allowed CORS origins for this provider
	AllowedOrigins []string

	// RequiredHeaders is a list of required request headers (case-insensitive)
	RequiredHeaders []string

	// Project active guard configuration
	EnforceProjectActive bool // Whether to enforce project active status

	// --- HTTP cache (global, opt-in; set programmatically, not via YAML) ---
	// HTTPCacheEnabled toggles the proxy cache for GET/HEAD based on HTTP semantics
	HTTPCacheEnabled bool
	// HTTPCacheDefaultTTL is used only when upstream allows caching but omits explicit TTL
	HTTPCacheDefaultTTL time.Duration
	// HTTPCacheMaxObjectBytes is a guardrail for maximum cacheable response size
	HTTPCacheMaxObjectBytes int64

	// RedisCacheURL enables Redis-backed cache when non-empty (e.g., redis://localhost:6379/0)
	RedisCacheURL string
	// RedisCacheKeyPrefix allows namespacing cache keys (default: llmproxy:cache:)
	RedisCacheKeyPrefix string
}

type ProxyMetrics struct {
	RequestCount      int64
	ErrorCount        int64
	TotalResponseTime time.Duration
	// Cache metrics (provider-agnostic counters)
	CacheHits   int64 // Cache hits (responses served from cache)
	CacheMisses int64 // Cache misses (responses fetched from upstream)
	CacheBypass int64 // Cache bypassed (e.g., due to authorization)
	CacheStores int64 // Cache stores (responses stored in cache)
	// contains filtered or unexported fields
}

type TimeoutConfig struct {
	// Request is the overall request timeout
	Request time.Duration `yaml:"request"`
	// ResponseHeader is the timeout for receiving response headers
	ResponseHeader time.Duration `yaml:"response_header"`
	// IdleConnection is the timeout for idle connections
	IdleConnection time.Duration `yaml:"idle_connection"`
	// FlushInterval controls how often to flush streaming responses
	FlushInterval time.Duration `yaml:"flush_interval"`
}

type TokenValidator interface {
	// ValidateToken validates a token and returns the associated project ID
	ValidateToken(ctx context.Context, token string) (string, error)

	// ValidateTokenWithTracking validates a token, increments its usage, and returns the project ID
	ValidateTokenWithTracking(ctx context.Context, token string) (string, error)
}

type TransparentProxy struct {
	// contains filtered or unexported fields
}