heartbeat

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

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

type DiscoveredModel struct {
	Provider    string    `json:"provider"`
	ModelID     string    `json:"model_id"`
	DisplayName string    `json:"display_name"`
	Size        int64     `json:"size"`
	Discovered  time.Time `json:"discovered"`
}

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

type HealthStatus struct {
	// Provider is the name of the provider being monitored
	Provider string `json:"provider"`

	// Status is the current health status
	Status ProviderStatus `json:"status"`

	// LastCheck is when this status was last updated
	LastCheck time.Time `json:"last_check"`

	// ResponseTime is the time taken for the health check
	ResponseTime time.Duration `json:"response_time"`

	// ModelsCount is the number of available models (if applicable)
	ModelsCount int `json:"models_count"`

	// QuotaUsed is the current quota usage (0.0 to 1.0)
	QuotaUsed float64 `json:"quota_used"`

	// QuotaLimit is the quota limit (requests, tokens, etc.)
	QuotaLimit float64 `json:"quota_limit"`

	// ErrorMessage contains error details if status is not healthy
	ErrorMessage string `json:"error_message,omitempty"`

	// Metadata contains provider-specific health information
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type HeartbeatConfig struct {
	// Enabled controls whether heartbeat monitoring is active
	Enabled bool `yaml:"enabled" json:"enabled"`

	// Interval is the time between heartbeat cycles
	Interval time.Duration `yaml:"interval" json:"interval"`

	// Timeout is the maximum time to wait for a single provider check
	Timeout time.Duration `yaml:"timeout" json:"timeout"`

	// AutoDiscovery enables automatic model discovery
	AutoDiscovery bool `yaml:"auto-discovery" json:"auto-discovery"`

	// QuotaWarningThreshold triggers warnings when quota usage exceeds this (0.0-1.0)
	QuotaWarningThreshold float64 `yaml:"quota-warning-threshold" json:"quota-warning-threshold"`

	// QuotaCriticalThreshold triggers critical alerts when quota usage exceeds this (0.0-1.0)
	QuotaCriticalThreshold float64 `yaml:"quota-critical-threshold" json:"quota-critical-threshold"`

	// MaxConcurrentChecks limits the number of simultaneous health checks
	MaxConcurrentChecks int `yaml:"max-concurrent-checks" json:"max-concurrent-checks"`

	// RetryAttempts is the number of retries for failed health checks
	RetryAttempts int `yaml:"retry-attempts" json:"retry-attempts"`

	// RetryDelay is the delay between retry attempts
	RetryDelay time.Duration `yaml:"retry-delay" json:"retry-delay"`
}

type HeartbeatEvent struct {
	// Type is the event type
	Type HeartbeatEventType `json:"type"`

	// Provider is the provider that triggered the event
	Provider string `json:"provider"`

	// Timestamp is when the event occurred
	Timestamp time.Time `json:"timestamp"`

	// Status is the current health status
	Status *HealthStatus `json:"status,omitempty"`

	// PreviousStatus is the previous health status (for status change events)
	PreviousStatus *HealthStatus `json:"previous_status,omitempty"`

	// Data contains event-specific data
	Data map[string]interface{} `json:"data,omitempty"`
}

type HeartbeatEventHandler interface {
	// HandleEvent processes a heartbeat event
	HandleEvent(event *HeartbeatEvent) error
}

type HeartbeatEventType string

type HeartbeatMonitor interface {
	// Start begins the heartbeat monitoring loop
	Start(ctx context.Context) error

	// Stop gracefully shuts down the monitor
	Stop() error

	// CheckAll performs health checks on all registered providers
	CheckAll(ctx context.Context) error

	// CheckProvider performs a health check on a specific provider
	CheckProvider(ctx context.Context, provider string) (*HealthStatus, error)

	// GetStatus retrieves the last known status for a provider
	GetStatus(provider string) (*HealthStatus, error)

	// GetAllStatuses retrieves the last known status for all providers
	GetAllStatuses() map[string]*HealthStatus

	// RegisterChecker registers a new provider health checker
	RegisterChecker(checker ProviderHealthChecker) error

	// UnregisterChecker removes a provider health checker
	UnregisterChecker(provider string) error

	// SetInterval updates the heartbeat check interval
	SetInterval(interval time.Duration)

	// GetInterval returns the current heartbeat check interval
	GetInterval() time.Duration

	// AddEventHandler registers an event handler for heartbeat events
	AddEventHandler(handler HeartbeatEventHandler)

	// RemoveEventHandler removes an event handler
	RemoveEventHandler(handler HeartbeatEventHandler)
}

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

type HeartbeatStats struct {
	// StartTime is when the monitor was started
	StartTime time.Time `json:"start_time"`

	// LastCycleTime is when the last full cycle completed
	LastCycleTime time.Time `json:"last_cycle_time"`

	// TotalCycles is the number of completed heartbeat cycles
	TotalCycles int64 `json:"total_cycles"`

	// TotalChecks is the total number of provider checks performed
	TotalChecks int64 `json:"total_checks"`

	// SuccessfulChecks is the number of successful checks
	SuccessfulChecks int64 `json:"successful_checks"`

	// FailedChecks is the number of failed checks
	FailedChecks int64 `json:"failed_checks"`

	// AverageCycleTime is the average time per heartbeat cycle
	AverageCycleTime time.Duration `json:"average_cycle_time"`

	// ProvidersMonitored is the number of providers being monitored
	ProvidersMonitored int `json:"providers_monitored"`

	// HealthyProviders is the number of currently healthy providers
	HealthyProviders int `json:"healthy_providers"`

	// DegradedProviders is the number of currently degraded providers
	DegradedProviders int `json:"degraded_providers"`

	// UnavailableProviders is the number of currently unavailable providers
	UnavailableProviders int `json:"unavailable_providers"`
}

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

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

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

type ProviderHealthChecker interface {
	// Check performs a health check and returns the current status
	Check(ctx context.Context) (*HealthStatus, error)

	// GetName returns the provider name this checker handles
	GetName() string

	// GetCheckInterval returns the preferred check interval for this provider
	GetCheckInterval() time.Duration

	// SupportsQuotaMonitoring returns true if this provider supports quota monitoring
	SupportsQuotaMonitoring() bool

	// SupportsAutoDiscovery returns true if this provider supports model auto-discovery
	SupportsAutoDiscovery() bool
}

type ProviderStatus string

type QuotaInfo struct {
	Used      float64
	Limit     float64
	ResetTime time.Time
	Found     bool
}

type QuotaStatusType string

type RecoveryAction struct {
	// Timestamp is when the action was taken
	Timestamp time.Time `json:"timestamp"`

	// Provider is the provider this action was taken for
	Provider string `json:"provider"`

	// ActionType describes the type of recovery action
	ActionType RecoveryActionType `json:"action_type"`

	// Description provides details about the action
	Description string `json:"description"`

	// Success indicates whether the action succeeded
	Success bool `json:"success"`

	// Error contains error details if the action failed
	Error string `json:"error,omitempty"`

	// Metadata contains action-specific data
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type RecoveryActionType string

type RecoveryConfig struct {
	// Enabled controls whether automatic recovery is active
	Enabled bool

	// MaxRecoveryAttempts is the maximum number of recovery attempts per provider
	MaxRecoveryAttempts int

	// RecoveryBackoff is the minimum time between recovery attempts
	RecoveryBackoff time.Duration

	// AutoDisableThreshold is the number of consecutive failures before auto-disable
	AutoDisableThreshold int

	// AutoEnableDelay is how long to wait before re-enabling a disabled provider
	AutoEnableDelay time.Duration

	// EnableFallbackRouting controls whether fallback routing is enabled
	EnableFallbackRouting bool

	// NotifyAdminOnFailure controls whether to notify admins on provider failures
	NotifyAdminOnFailure bool
}

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

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

type RecoveryStats struct {
	// TotalActions is the total number of recovery actions taken
	TotalActions int `json:"total_actions"`

	// SuccessfulActions is the number of successful actions
	SuccessfulActions int `json:"successful_actions"`

	// FailedActions is the number of failed actions
	FailedActions int `json:"failed_actions"`

	// DisabledProviders is the number of currently disabled providers
	DisabledProviders int `json:"disabled_providers"`

	// ActionsByType breaks down actions by type
	ActionsByType map[RecoveryActionType]int `json:"actions_by_type"`

	// ActionsByProvider breaks down actions by provider
	ActionsByProvider map[string]int `json:"actions_by_provider"`
}