client

type APIKeyConfig struct {
	HeaderName          string        `json:"header_name" yaml:"header_name"`
	QueryParam          string        `json:"query_param" yaml:"query_param"`
	Prefix              string        `json:"prefix" yaml:"prefix"`
	KeysFile            string        `json:"keys_file" yaml:"keys_file"`
	HashingAlgorithm    string        `json:"hashing_algorithm" yaml:"hashing_algorithm"`
	EnableKeyRotation   bool          `json:"enable_key_rotation" yaml:"enable_key_rotation"`
	KeyRotationInterval time.Duration `json:"key_rotation_interval" yaml:"key_rotation_interval"`
}

type APIKeyInfo struct {
	ID          string                 `json:"id"`
	Key         string                 `json:"key"`
	HashedKey   string                 `json:"hashed_key"`
	UserID      string                 `json:"user_id"`
	Username    string                 `json:"username"`
	Email       string                 `json:"email"`
	Roles       []string               `json:"roles"`
	Permissions []string               `json:"permissions"`
	Scopes      []string               `json:"scopes"`
	CreatedAt   time.Time              `json:"created_at"`
	ExpiresAt   *time.Time             `json:"expires_at,omitempty"`
	LastUsedAt  *time.Time             `json:"last_used_at,omitempty"`
	IsActive    bool                   `json:"is_active"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`

	// Usage tracking
	UsageCount int64     `json:"usage_count"`
	RateLimit  int       `json:"rate_limit,omitempty"`  // requests per minute
	QuotaLimit int64     `json:"quota_limit,omitempty"` // total requests allowed
	QuotaUsed  int64     `json:"quota_used"`
	QuotaReset time.Time `json:"quota_reset,omitempty"`
}

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

type APIKeyStore struct {
	Keys        map[string]*APIKeyInfo `json:"keys"`
	LastUpdated time.Time              `json:"last_updated"`
	Version     string                 `json:"version"`
}

type Agent interface {
	LifecycleManager
	AgentEventProcessor
	StateManager
	ToolRunner
	AgentMetadata
}

type AgentCapabilities struct {
	Tools              []string               `json:"tools"`
	Streaming          bool                   `json:"streaming"`
	StateSync          bool                   `json:"state_sync"`
	MessageHistory     bool                   `json:"message_history"`
	CustomCapabilities map[string]interface{} `json:"custom_capabilities,omitempty"`
}

type AgentConfig struct {
	Name            string                 `json:"name" yaml:"name"`
	Description     string                 `json:"description" yaml:"description"`
	Capabilities    AgentCapabilities      `json:"capabilities" yaml:"capabilities"`
	EventProcessing EventProcessingConfig  `json:"event_processing" yaml:"event_processing"`
	State           StateConfig            `json:"state" yaml:"state"`
	Tools           ToolsConfig            `json:"tools" yaml:"tools"`
	History         HistoryConfig          `json:"history" yaml:"history"`
	Custom          map[string]interface{} `json:"custom,omitempty" yaml:"custom,omitempty"`
}

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

type AgentEventProcessor interface {
	// ProcessEvent handles a single incoming event and returns response events.
	// The agent must be running for this to succeed.
	ProcessEvent(ctx context.Context, event events.Event) ([]events.Event, error)

	// StreamEvents returns a channel for receiving events from the agent.
	// The agent must be running and support streaming for this to succeed.
	StreamEvents(ctx context.Context) (<-chan events.Event, error)
}

type AgentHealthStatus struct {
	Status    string                 `json:"status"`
	LastCheck time.Time              `json:"last_check"`
	Details   map[string]interface{} `json:"details,omitempty"`
	Errors    []string               `json:"errors,omitempty"`
}

type AgentMetadata interface {
	// Name returns the unique identifier for this agent instance.
	Name() string

	// Description returns a human-readable description of the agent's purpose.
	Description() string

	// Capabilities returns information about what this agent can do.
	Capabilities() AgentCapabilities

	// Health returns the current health status of the agent.
	Health() AgentHealthStatus
}

type AgentMetrics struct {
	EventsProcessed int64 `json:"events_processed"`

	EventsPerSecond       float64       `json:"events_per_second"`
	AverageProcessingTime time.Duration `json:"average_processing_time"`
	ToolsExecuted         int64         `json:"tools_executed"`

	StateUpdates int64 `json:"state_updates"`

	ErrorCount int64 `json:"error_count"`

	MemoryUsage int64 `json:"memory_usage"`

	StartTime    time.Time `json:"start_time"`
	LastActivity time.Time `json:"last_activity"`
	// contains filtered or unexported fields
}

type AgentState struct {
	// Status is the current lifecycle status
	Status AgentStatus `json:"status"`

	// Name is the agent identifier
	Name string `json:"name"`

	// Version is the state version for conflict resolution
	Version int64 `json:"version"`

	// Data contains the agent's custom state data
	Data map[string]interface{} `json:"data"`

	// Metadata contains additional state information
	Metadata map[string]interface{} `json:"metadata"`

	// LastModified is when the state was last updated
	LastModified time.Time `json:"last_modified"`

	// Checksum for state integrity verification
	Checksum string `json:"checksum,omitempty"`
}

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

type AgentStatus string

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

type AuditLogEntry struct {
	Timestamp time.Time              `json:"timestamp"`
	Level     string                 `json:"level"`
	EventType string                 `json:"event_type"`
	UserID    string                 `json:"user_id,omitempty"`
	SessionID string                 `json:"session_id,omitempty"`
	IPAddress string                 `json:"ip_address,omitempty"`
	UserAgent string                 `json:"user_agent,omitempty"`
	Resource  string                 `json:"resource,omitempty"`
	Action    string                 `json:"action,omitempty"`
	Result    string                 `json:"result"`
	Error     string                 `json:"error,omitempty"`
	Duration  string                 `json:"duration,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
	Sensitive bool                   `json:"sensitive,omitempty"`
	TraceID   string                 `json:"trace_id,omitempty"`
	RequestID string                 `json:"request_id,omitempty"`
}

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

type AuditLoggingConfig struct {
	Enabled             bool     `json:"enabled" yaml:"enabled"`
	LogLevel            string   `json:"log_level" yaml:"log_level"`
	LogFile             string   `json:"log_file" yaml:"log_file"`
	LogFormat           string   `json:"log_format" yaml:"log_format"`
	RotateSize          int64    `json:"rotate_size" yaml:"rotate_size"`
	RotateCount         int      `json:"rotate_count" yaml:"rotate_count"`
	LogSensitiveData    bool     `json:"log_sensitive_data" yaml:"log_sensitive_data"`
	EventTypes          []string `json:"event_types" yaml:"event_types"`
	IncludeRequestBody  bool     `json:"include_request_body" yaml:"include_request_body"`
	IncludeResponseBody bool     `json:"include_response_body" yaml:"include_response_body"`
}

type AuthMethod string

type AuthenticationResult struct {
	Success        bool         `json:"success"`
	User           *UserInfo    `json:"user,omitempty"`
	Token          *TokenInfo   `json:"token,omitempty"`
	Session        *SessionInfo `json:"session,omitempty"`
	Error          error        `json:"error,omitempty"`
	RequiredScopes []string     `json:"required_scopes,omitempty"`
	GrantedScopes  []string     `json:"granted_scopes,omitempty"`
}

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

type BackpressureMode int

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

type BasicAuthConfig struct {
	Realm                string         `json:"realm" yaml:"realm"`
	UsersFile            string         `json:"users_file" yaml:"users_file"`
	HashingAlgorithm     string         `json:"hashing_algorithm" yaml:"hashing_algorithm"`
	EnablePasswordPolicy bool           `json:"enable_password_policy" yaml:"enable_password_policy"`
	PasswordPolicy       PasswordPolicy `json:"password_policy" yaml:"password_policy"`
}

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

type BasicAuthStore struct {
	Users       map[string]*BasicAuthUser `json:"users"`
	LastUpdated time.Time                 `json:"last_updated"`
	Version     string                    `json:"version"`
}

type BasicAuthUser struct {
	Username           string                 `json:"username"`
	PasswordHash       string                 `json:"password_hash"`
	UserID             string                 `json:"user_id"`
	Email              string                 `json:"email"`
	FullName           string                 `json:"full_name"`
	Roles              []string               `json:"roles"`
	Permissions        []string               `json:"permissions"`
	IsActive           bool                   `json:"is_active"`
	CreatedAt          time.Time              `json:"created_at"`
	UpdatedAt          time.Time              `json:"updated_at"`
	LastLoginAt        *time.Time             `json:"last_login_at,omitempty"`
	LoginCount         int64                  `json:"login_count"`
	PasswordSet        time.Time              `json:"password_set"`
	MustChangePassword bool                   `json:"must_change_password"`
	Metadata           map[string]interface{} `json:"metadata,omitempty"`

	// Account security
	FailedLoginAttempts int        `json:"failed_login_attempts"`
	LastFailedLogin     *time.Time `json:"last_failed_login,omitempty"`
	AccountLockedUntil  *time.Time `json:"account_locked_until,omitempty"`
}

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

type BulkheadConfig struct {
	// Enabled indicates if bulkhead isolation is active
	Enabled bool `json:"enabled"`

	// MaxConcurrentRequests is the maximum concurrent requests
	MaxConcurrentRequests int `json:"max_concurrent_requests"`

	// QueueSize is the size of the request queue
	QueueSize int `json:"queue_size"`

	// QueueTimeout is the maximum time to wait in queue
	QueueTimeout time.Duration `json:"queue_timeout"`

	// SemaphoreTimeout is the timeout for acquiring semaphore
	SemaphoreTimeout time.Duration `json:"semaphore_timeout"`
}

type CORSConfig struct {
	Enabled          bool     `json:"enabled" yaml:"enabled"`
	AllowedOrigins   []string `json:"allowed_origins" yaml:"allowed_origins"`
	AllowedMethods   []string `json:"allowed_methods" yaml:"allowed_methods"`
	AllowedHeaders   []string `json:"allowed_headers" yaml:"allowed_headers"`
	ExposedHeaders   []string `json:"exposed_headers" yaml:"exposed_headers"`
	AllowCredentials bool     `json:"allow_credentials" yaml:"allow_credentials"`
	MaxAge           int      `json:"max_age" yaml:"max_age"`
}

type CachedConfig struct {
	Data      map[string]interface{} `json:"data"`
	Source    string                 `json:"source"`
	LoadTime  time.Time              `json:"load_time"`
	ExpiresAt time.Time              `json:"expires_at"`
	Version   string                 `json:"version"`
	Checksum  string                 `json:"checksum"`
}

type CachedResult struct {
	Result    interface{} `json:"result"`
	Error     string      `json:"error,omitempty"`
	Cached    time.Time   `json:"cached"`
	Hits      int64       `json:"hits"`
	ExpiresAt time.Time   `json:"expires_at"`
}

type CertValidationConfig struct {
	ValidateCertChain bool `json:"validate_cert_chain" yaml:"validate_cert_chain"`
	ValidateHostname  bool `json:"validate_hostname" yaml:"validate_hostname"`
	CustomCAPool      bool `json:"custom_ca_pool" yaml:"custom_ca_pool"`
	CRLCheckEnabled   bool `json:"crl_check_enabled" yaml:"crl_check_enabled"`
	OCSPCheckEnabled  bool `json:"ocsp_check_enabled" yaml:"ocsp_check_enabled"`
}

type CertificateInfo struct {
	Subject         string    `json:"subject"`
	Issuer          string    `json:"issuer"`
	SerialNumber    string    `json:"serial_number"`
	NotBefore       time.Time `json:"not_before"`
	NotAfter        time.Time `json:"not_after"`
	DNSNames        []string  `json:"dns_names"`
	IPAddresses     []string  `json:"ip_addresses"`
	KeyUsage        []string  `json:"key_usage"`
	IsCA            bool      `json:"is_ca"`
	IsExpired       bool      `json:"is_expired"`
	DaysUntilExpiry int       `json:"days_until_expiry"`
}

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

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

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

type CircuitBreakerConfig struct {
	// Enabled indicates if circuit breaker is active
	Enabled bool `json:"enabled"`

	// FailureThreshold is the number of failures before opening
	FailureThreshold int `json:"failure_threshold"`

	// SuccessThreshold is the number of successes needed to close
	SuccessThreshold int `json:"success_threshold"`

	// Timeout is how long to wait before attempting to close
	Timeout time.Duration `json:"timeout"`

	// HalfOpenMaxCalls is max calls allowed in half-open state
	HalfOpenMaxCalls int `json:"half_open_max_calls"`

	// FailureRateThreshold is the failure rate threshold (0.0 to 1.0)
	FailureRateThreshold float64 `json:"failure_rate_threshold"`

	// MinimumRequestThreshold is minimum requests before rate calculation
	MinimumRequestThreshold int `json:"minimum_request_threshold"`
}

type CircuitBreakerState int

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

type Config struct {
	// BaseURL is the base URL of the AG-UI server
	BaseURL string

	// Timeout for requests (default: 30 seconds)
	Timeout time.Duration

	// Authentication configuration
	AuthToken string

	// Retry configuration
	MaxRetries int

	// User agent string
	UserAgent string
}

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

type ConfigChangeEvent struct {
	Source    string                 `json:"source"`
	Path      string                 `json:"path,omitempty"`
	OldValue  interface{}            `json:"old_value"`
	NewValue  interface{}            `json:"new_value"`
	Timestamp time.Time              `json:"timestamp"`
	Version   string                 `json:"version"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

type ConfigChangeListener func(ConfigChangeEvent)

type ConfigFormat string

type ConfigMetrics struct {
	ConfigLoads      int64         `json:"config_loads"`
	ConfigReloads    int64         `json:"config_reloads"`
	ValidationErrors int64         `json:"validation_errors"`
	SourceErrors     int64         `json:"source_errors"`
	WatcherErrors    int64         `json:"watcher_errors"`
	AverageLoadTime  time.Duration `json:"average_load_time"`
	LastLoadTime     time.Time     `json:"last_load_time"`
	ActiveWatchers   int32         `json:"active_watchers"`
}

type ConfigProfile string

type ConfigSchema struct {
	Name       string                   `json:"name" yaml:"name"`
	Version    string                   `json:"version" yaml:"version"`
	Properties map[string]*PropertySpec `json:"properties" yaml:"properties"`
	Required   []string                 `json:"required" yaml:"required"`
	Defaults   map[string]interface{}   `json:"defaults" yaml:"defaults"`
	Validators []ConfigValidator        `json:"-" yaml:"-"`
}

type ConfigSource interface {
	// Load loads configuration data
	Load(ctx context.Context) (map[string]interface{}, error)

	// Watch watches for configuration changes
	Watch(ctx context.Context, callback func(map[string]interface{})) error

	// Name returns the name of the configuration source
	Name() string

	// Priority returns the priority of this source (higher = more important)
	Priority() int
}

type ConfigTemplate struct {
	Name        string
	Description string
	Builder     func() *ConfigBuilder
}

type ConfigValidator func(config map[string]interface{}) error

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

type ConflictResolutionStrategy string

type ConflictResolver interface {
	ResolveConflict(local, remote interface{}, path string) (interface{}, error)
}

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

type ConnectionPoolStats struct {
	TotalConnections   int64         `json:"total_connections"`
	ActiveConnections  int64         `json:"active_connections"`
	IdleConnections    int64         `json:"idle_connections"`
	ConnectionsReused  int64         `json:"connections_reused"`
	ConnectionsCreated int64         `json:"connections_created"`
	AverageLifetime    time.Duration `json:"average_lifetime"`
}

type Conversation struct {
	ID           string                 `json:"id"`
	Title        string                 `json:"title,omitempty"`
	Participants []string               `json:"participants"`
	Messages     []string               `json:"messages"` // Message IDs in order
	StartTime    time.Time              `json:"start_time"`
	LastActivity time.Time              `json:"last_activity"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
	ThreadCount  int                    `json:"thread_count"`
}

type DatabaseConfig struct {
	Driver           string `json:"driver" yaml:"driver"`
	ConnectionString string `json:"connection_string" yaml:"connection_string"`
	TableName        string `json:"table_name" yaml:"table_name"`
}

type DropStrategy int

type EncryptedTokenData struct {
	Nonce      []byte `json:"nonce"`
	Ciphertext []byte `json:"ciphertext"`
}

type EncryptionConfig struct {
	Enabled             bool          `json:"enabled" yaml:"enabled"`
	Algorithm           string        `json:"algorithm" yaml:"algorithm"`
	KeyFile             string        `json:"key_file" yaml:"key_file"`
	KeyRotationInterval time.Duration `json:"key_rotation_interval" yaml:"key_rotation_interval"`
}

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

type EventHandler func(ctx context.Context, event events.Event) ([]events.Event, error)

type EventProcessingConfig struct {
	BufferSize       int           `json:"buffer_size" yaml:"buffer_size"`
	BatchSize        int           `json:"batch_size" yaml:"batch_size"`
	Timeout          time.Duration `json:"timeout" yaml:"timeout"`
	EnableValidation bool          `json:"enable_validation" yaml:"enable_validation"`
	EnableMetrics    bool          `json:"enable_metrics" yaml:"enable_metrics"`
}

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

type EventProcessorMetrics struct {
	EventsReceived     int64         `json:"events_received"`
	EventsProcessed    int64         `json:"events_processed"`
	EventsDropped      int64         `json:"events_dropped"`
	BatchesProcessed   int64         `json:"batches_processed"`
	AverageLatency     time.Duration `json:"average_latency"`
	ThroughputPerSec   float64       `json:"throughput_per_sec"`
	BackpressureEvents int64         `json:"backpressure_events"`
	ValidationErrors   int64         `json:"validation_errors"`
	HandlerErrors      int64         `json:"handler_errors"`
	LastProcessedTime  time.Time     `json:"last_processed_time"`
}

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

type EvictionPolicy int

type ExecutionStatus string

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

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

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

type FirstWriterWinsResolver struct{}

type HMACConfig struct {
	SecretKey       string        `json:"secret_key" yaml:"secret_key"`
	Algorithm       string        `json:"algorithm" yaml:"algorithm"`
	HeaderName      string        `json:"header_name" yaml:"header_name"`
	TimestampHeader string        `json:"timestamp_header" yaml:"timestamp_header"`
	NonceHeader     string        `json:"nonce_header" yaml:"nonce_header"`
	MaxClockSkew    time.Duration `json:"max_clock_skew" yaml:"max_clock_skew"`
	IncludeHeaders  []string      `json:"include_headers" yaml:"include_headers"`
}

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

type HMACSignatureInfo struct {
	Signature string            `json:"signature"`
	KeyID     string            `json:"key_id"`
	Timestamp time.Time         `json:"timestamp"`
	Nonce     string            `json:"nonce"`
	Headers   map[string]string `json:"headers"`
	Method    string            `json:"method"`
	Path      string            `json:"path"`
	Body      string            `json:"body,omitempty"`
}

type HTTPMetrics struct {
	// Request metrics
	TotalRequests      int64 `json:"total_requests"`
	SuccessfulRequests int64 `json:"successful_requests"`
	FailedRequests     int64 `json:"failed_requests"`

	// Timing metrics
	TotalDuration   time.Duration `json:"total_duration"`
	AverageDuration time.Duration `json:"average_duration"`
	MinDuration     time.Duration `json:"min_duration"`
	MaxDuration     time.Duration `json:"max_duration"`

	// Data transfer
	BytesSent     int64 `json:"bytes_sent"`
	BytesReceived int64 `json:"bytes_received"`

	// Protocol statistics
	HTTP1Requests int64 `json:"http1_requests"`
	HTTP2Requests int64 `json:"http2_requests"`

	// Error breakdown
	ConnectionErrors int64 `json:"connection_errors"`
	TimeoutErrors    int64 `json:"timeout_errors"`
	ProtocolErrors   int64 `json:"protocol_errors"`

	// Compression stats
	CompressionRatio   float64 `json:"compression_ratio"`
	CompressedRequests int64   `json:"compressed_requests"`
	// contains filtered or unexported fields
}

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

type HTTPTransportConfig struct {
	// Core connection settings
	BaseURL   string            `json:"base_url" yaml:"base_url"`
	Headers   map[string]string `json:"headers" yaml:"headers"`
	AuthToken string            `json:"auth_token" yaml:"auth_token"`
	UserAgent string            `json:"user_agent" yaml:"user_agent"`

	// Protocol settings
	ForceHTTP1  bool `json:"force_http1" yaml:"force_http1"`
	EnableHTTP2 bool `json:"enable_http2" yaml:"enable_http2"`

	// Connection pooling
	MaxIdleConns        int           `json:"max_idle_conns" yaml:"max_idle_conns"`
	MaxIdleConnsPerHost int           `json:"max_idle_conns_per_host" yaml:"max_idle_conns_per_host"`
	MaxConnsPerHost     int           `json:"max_conns_per_host" yaml:"max_conns_per_host"`
	IdleConnTimeout     time.Duration `json:"idle_conn_timeout" yaml:"idle_conn_timeout"`

	// Timeouts
	ConnectTimeout      time.Duration `json:"connect_timeout" yaml:"connect_timeout"`
	RequestTimeout      time.Duration `json:"request_timeout" yaml:"request_timeout"`
	ResponseTimeout     time.Duration `json:"response_timeout" yaml:"response_timeout"`
	KeepAliveTimeout    time.Duration `json:"keep_alive_timeout" yaml:"keep_alive_timeout"`
	TLSHandshakeTimeout time.Duration `json:"tls_handshake_timeout" yaml:"tls_handshake_timeout"`

	// Retry and resilience
	MaxRetries           int                   `json:"max_retries" yaml:"max_retries"`
	BaseRetryDelay       time.Duration         `json:"base_retry_delay" yaml:"base_retry_delay"`
	MaxRetryDelay        time.Duration         `json:"max_retry_delay" yaml:"max_retry_delay"`
	RetryJitter          bool                  `json:"retry_jitter" yaml:"retry_jitter"`
	CircuitBreakerConfig *CircuitBreakerConfig `json:"circuit_breaker" yaml:"circuit_breaker"`

	// Security
	TLSConfig          *tls.Config       `json:"-" yaml:"-"`
	InsecureSkipVerify bool              `json:"insecure_skip_verify" yaml:"insecure_skip_verify"`
	SecurityHeaders    map[string]string `json:"security_headers" yaml:"security_headers"`

	// Performance
	EnableCompression bool `json:"enable_compression" yaml:"enable_compression"`
	CompressionLevel  int  `json:"compression_level" yaml:"compression_level"`
	BufferSize        int  `json:"buffer_size" yaml:"buffer_size"`

	// Monitoring
	EnableMetrics bool   `json:"enable_metrics" yaml:"enable_metrics"`
	MetricsPrefix string `json:"metrics_prefix" yaml:"metrics_prefix"`
}

type HealthCheckConfig struct {
	// Enabled indicates if health checks are active
	Enabled bool `json:"enabled"`

	// Interval is the health check interval
	Interval time.Duration `json:"interval"`

	// Timeout is the health check timeout
	Timeout time.Duration `json:"timeout"`

	// FailureThreshold is failures needed to mark unhealthy
	FailureThreshold int `json:"failure_threshold"`

	// RecoveryThreshold is successes needed to mark healthy
	RecoveryThreshold int `json:"recovery_threshold"`

	// Endpoint is the health check endpoint
	Endpoint string `json:"endpoint"`

	// ExpectedStatusCodes are the expected healthy status codes
	ExpectedStatusCodes []int `json:"expected_status_codes"`
}

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

type HealthStatus int

type HistoryConfig struct {
	MaxMessages       int           `json:"max_messages" yaml:"max_messages"`
	Retention         time.Duration `json:"retention" yaml:"retention"`
	EnablePersistence bool          `json:"enable_persistence" yaml:"enable_persistence"`
	EnableCompression bool          `json:"enable_compression" yaml:"enable_compression"`
}

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

type HistoryMetrics struct {
	TotalMessages      int64         `json:"total_messages"`
	TotalConversations int64         `json:"total_conversations"`
	TotalThreads       int64         `json:"total_threads"`
	MessagesAdded      int64         `json:"messages_added"`
	MessagesDeleted    int64         `json:"messages_deleted"`
	SearchQueries      int64         `json:"search_queries"`
	AverageSearchTime  time.Duration `json:"average_search_time"`
	MemoryUsage        int64         `json:"memory_usage"`
	CompressionRatio   float64       `json:"compression_ratio"`
	PersistenceOps     int64         `json:"persistence_ops"`
	LastCleanupTime    time.Time     `json:"last_cleanup_time"`
}

type HistoryPersister interface {
	SaveMessage(message *StoredMessage) error
	LoadMessage(messageID string) (*StoredMessage, error)
	SaveConversation(conversation *Conversation) error
	LoadConversation(conversationID string) (*Conversation, error)
	SaveThread(thread *Thread) error
	LoadThread(threadID string) (*Thread, error)
	DeleteMessage(messageID string) error
	DeleteConversation(conversationID string) error
	DeleteThread(threadID string) error
	LoadAllMessages() ([]*StoredMessage, error)
}

type HttpAgent struct {
	*BaseAgent
	// contains filtered or unexported fields
}

type HttpConfig struct {
	// Protocol settings
	ProtocolVersion HttpProtocolVersion `json:"protocol_version" yaml:"protocol_version"`
	EnableHTTP2     bool                `json:"enable_http2" yaml:"enable_http2"`
	ForceHTTP2      bool                `json:"force_http2" yaml:"force_http2"`

	// Connection settings
	MaxIdleConns        int           `json:"max_idle_conns" yaml:"max_idle_conns"`
	MaxIdleConnsPerHost int           `json:"max_idle_conns_per_host" yaml:"max_idle_conns_per_host"`
	MaxConnsPerHost     int           `json:"max_conns_per_host" yaml:"max_conns_per_host"`
	IdleConnTimeout     time.Duration `json:"idle_conn_timeout" yaml:"idle_conn_timeout"`
	KeepAlive           time.Duration `json:"keep_alive" yaml:"keep_alive"`

	// Timeout settings
	DialTimeout         time.Duration `json:"dial_timeout" yaml:"dial_timeout"`
	RequestTimeout      time.Duration `json:"request_timeout" yaml:"request_timeout"`
	ResponseTimeout     time.Duration `json:"response_timeout" yaml:"response_timeout"`
	TLSHandshakeTimeout time.Duration `json:"tls_handshake_timeout" yaml:"tls_handshake_timeout"`

	// TLS settings
	TLSConfig          *tls.Config `json:"-" yaml:"-"` // Not serializable
	InsecureSkipVerify bool        `json:"insecure_skip_verify" yaml:"insecure_skip_verify"`

	// Advanced settings
	DisableCompression  bool   `json:"disable_compression" yaml:"disable_compression"`
	DisableKeepAlives   bool   `json:"disable_keep_alives" yaml:"disable_keep_alives"`
	UserAgent           string `json:"user_agent" yaml:"user_agent"`
	MaxResponseBodySize int64  `json:"max_response_body_size" yaml:"max_response_body_size"`

	// Circuit breaker settings
	EnableCircuitBreaker bool                  `json:"enable_circuit_breaker" yaml:"enable_circuit_breaker"`
	CircuitBreakerConfig *CircuitBreakerConfig `json:"circuit_breaker" yaml:"circuit_breaker"`
}

type HttpMetrics struct {
	RequestCount        int64         `json:"request_count"`
	ResponseCount       int64         `json:"response_count"`
	ErrorCount          int64         `json:"error_count"`
	ActiveConnections   int64         `json:"active_connections"`
	PooledConnections   int64         `json:"pooled_connections"`
	AverageResponseTime time.Duration `json:"average_response_time"`
	TotalBytesReceived  int64         `json:"total_bytes_received"`
	TotalBytesSent      int64         `json:"total_bytes_sent"`
}

type HttpProtocolVersion string

type JWTConfig struct {
	// Signing configuration
	SigningMethod  string `json:"signing_method" yaml:"signing_method"`
	SecretKey      string `json:"secret_key,omitempty" yaml:"secret_key,omitempty"`
	PrivateKeyPath string `json:"private_key_path,omitempty" yaml:"private_key_path,omitempty"`
	PublicKeyPath  string `json:"public_key_path,omitempty" yaml:"public_key_path,omitempty"`

	// Token lifecycle
	AccessTokenTTL   time.Duration `json:"access_token_ttl" yaml:"access_token_ttl"`
	RefreshTokenTTL  time.Duration `json:"refresh_token_ttl" yaml:"refresh_token_ttl"`
	AutoRefresh      bool          `json:"auto_refresh" yaml:"auto_refresh"`
	RefreshThreshold time.Duration `json:"refresh_threshold" yaml:"refresh_threshold"`

	// Validation settings
	Issuer     string        `json:"issuer" yaml:"issuer"`
	Audience   []string      `json:"audience" yaml:"audience"`
	Subject    string        `json:"subject" yaml:"subject"`
	LeewayTime time.Duration `json:"leeway_time" yaml:"leeway_time"`

	// Claims configuration
	CustomClaims map[string]interface{} `json:"custom_claims,omitempty" yaml:"custom_claims,omitempty"`
}

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

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

type LastWriterWinsResolver struct{}

type LifecycleManager interface {
	// Initialize prepares the agent with the given configuration.
	// The agent must be in an uninitialized state for this to succeed.
	Initialize(ctx context.Context, config *AgentConfig) error

	// Start begins the agent's operation.
	// The agent must be initialized or stopped for this to succeed.
	Start(ctx context.Context) error

	// Stop gracefully shuts down the agent.
	// The agent must be running for this to succeed.
	Stop(ctx context.Context) error

	// Cleanup releases all resources held by the agent.
	// This can be called from any state and should be idempotent.
	Cleanup() error
}

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

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

type MergeResolver struct{}

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

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

type MessageQuery struct {
	ConversationID string                 `json:"conversation_id,omitempty"`
	ThreadID       string                 `json:"thread_id,omitempty"`
	Sender         string                 `json:"sender,omitempty"`
	Content        string                 `json:"content,omitempty"`
	TimeRange      *TimeRange             `json:"time_range,omitempty"`
	MessageType    string                 `json:"message_type,omitempty"`
	Metadata       map[string]interface{} `json:"metadata,omitempty"`
	Limit          int                    `json:"limit,omitempty"`
	Offset         int                    `json:"offset,omitempty"`
	SortBy         string                 `json:"sort_by,omitempty"`
	SortOrder      string                 `json:"sort_order,omitempty"`
}

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

type MetricsConfig struct {
	// Enabled indicates if metrics collection is active
	Enabled bool `json:"enabled"`

	// CollectionInterval is the metrics collection interval
	CollectionInterval time.Duration `json:"collection_interval"`

	// RetentionPeriod is how long to retain metrics
	RetentionPeriod time.Duration `json:"retention_period"`

	// HistogramBuckets defines histogram bucket boundaries
	HistogramBuckets []float64 `json:"histogram_buckets"`

	// EnableDetailedMetrics enables detailed metric collection
	EnableDetailedMetrics bool `json:"enable_detailed_metrics"`
}

type Middleware interface {
	// ProcessRequest is called before sending the request
	ProcessRequest(ctx context.Context, req *http.Request, correlation *RequestCorrelation) error

	// ProcessResponse is called after receiving the response
	ProcessResponse(ctx context.Context, resp *http.Response, correlation *RequestCorrelation) error

	// HandleError is called when an error occurs during request processing
	HandleError(ctx context.Context, err error, correlation *RequestCorrelation) error
}

type NetworkPolicy struct {
	AllowOutbound bool     `json:"allow_outbound"`
	AllowedHosts  []string `json:"allowed_hosts"`
	BlockedHosts  []string `json:"blocked_hosts"`
	AllowedPorts  []int    `json:"allowed_ports"`
}

type PasswordPolicy struct {
	MinLength           int           `json:"min_length" yaml:"min_length"`
	RequireUppercase    bool          `json:"require_uppercase" yaml:"require_uppercase"`
	RequireLowercase    bool          `json:"require_lowercase" yaml:"require_lowercase"`
	RequireNumbers      bool          `json:"require_numbers" yaml:"require_numbers"`
	RequireSpecialChars bool          `json:"require_special_chars" yaml:"require_special_chars"`
	MaxAge              time.Duration `json:"max_age" yaml:"max_age"`
}

type PerformanceStats struct {
	// Connection performance
	ConnectionSetupTime time.Duration `json:"connection_setup_time"`
	TLSHandshakeTime    time.Duration `json:"tls_handshake_time"`
	DNSLookupTime       time.Duration `json:"dns_lookup_time"`

	// Request performance
	TimeToFirstByte     time.Duration `json:"time_to_first_byte"`
	ContentDownloadTime time.Duration `json:"content_download_time"`

	// Throughput
	RequestsPerSecond float64 `json:"requests_per_second"`
	BytesPerSecond    float64 `json:"bytes_per_second"`

	// Resource utilization
	GoroutineCount int   `json:"goroutine_count"`
	MemoryUsage    int64 `json:"memory_usage"`
	// contains filtered or unexported fields
}

type PropertyConstraints struct {
	Min       *float64      `json:"min" yaml:"min"`
	Max       *float64      `json:"max" yaml:"max"`
	MinLength *int          `json:"min_length" yaml:"min_length"`
	MaxLength *int          `json:"max_length" yaml:"max_length"`
	Pattern   string        `json:"pattern" yaml:"pattern"`
	Enum      []interface{} `json:"enum" yaml:"enum"`
	Format    string        `json:"format" yaml:"format"`
}

type PropertySpec struct {
	Type        string               `json:"type" yaml:"type"`
	Description string               `json:"description" yaml:"description"`
	Default     interface{}          `json:"default" yaml:"default"`
	Required    bool                 `json:"required" yaml:"required"`
	Constraints *PropertyConstraints `json:"constraints" yaml:"constraints"`
	EnvVar      string               `json:"env_var" yaml:"env_var"`
	Sensitive   bool                 `json:"sensitive" yaml:"sensitive"`
}

type RateLimitConfig struct {
	// Enabled indicates if rate limiting is active
	Enabled bool `json:"enabled"`

	// RequestsPerSecond is the maximum requests per second
	RequestsPerSecond float64 `json:"requests_per_second"`

	// BurstSize is the maximum burst of requests allowed
	BurstSize int `json:"burst_size"`

	// WindowSize is the time window for rate calculation
	WindowSize time.Duration `json:"window_size"`

	// ThrottleDelay is the delay when throttling is applied
	ThrottleDelay time.Duration `json:"throttle_delay"`
}

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

type RedisConfig struct {
	Address  string `json:"address" yaml:"address"`
	Password string `json:"password" yaml:"password"`
	Database int    `json:"database" yaml:"database"`
	PoolSize int    `json:"pool_size" yaml:"pool_size"`
}

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

type RequestCorrelation struct {
	ID         string
	Method     string
	URL        string
	StartTime  time.Time
	Headers    http.Header
	UserAgent  string
	RemoteAddr string
	TraceSpan  trace.Span
	Context    context.Context
	Retries    int
	Metadata   map[string]interface{}
}

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

type RequestManagerConfig struct {
	// Timeout for requests (default: 30 seconds)
	Timeout time.Duration

	// Maximum number of idle connections
	MaxIdleConns int

	// Maximum idle connections per host
	MaxIdleConnsPerHost int

	// Keep-alive timeout
	KeepAlive time.Duration

	// TLS handshake timeout
	TLSHandshakeTimeout time.Duration

	// Response header timeout
	ResponseHeaderTimeout time.Duration

	// Expect continue timeout
	ExpectContinueTimeout time.Duration

	// Maximum response size (default: 100MB)
	MaxResponseSize int64

	// Rate limit requests per second (0 = no limit)
	RateLimit float64

	// Rate limit burst size
	RateLimitBurst int

	// Circuit breaker configuration
	CircuitBreakerConfig CircuitBreakerConfig

	// Security headers to validate
	RequiredSecurityHeaders []string

	// Allowed content types
	AllowedContentTypes []string

	// User agent string
	UserAgent string

	// Enable request/response logging
	EnableLogging bool

	// Enable metrics collection
	EnableMetrics bool

	// Enable tracing
	EnableTracing bool

	// Custom headers to add to all requests
	DefaultHeaders map[string]string
}

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

type ResilienceConfig struct {
	// RetryConfig configures retry behavior
	Retry RetryConfig `json:"retry"`

	// CircuitBreakerConfig configures circuit breaker behavior
	CircuitBreaker CircuitBreakerConfig `json:"circuit_breaker"`

	// RateLimiterConfig configures rate limiting
	RateLimit RateLimitConfig `json:"rate_limit"`

	// TimeoutConfig configures timeout behavior
	Timeout TimeoutConfig `json:"timeout"`

	// BulkheadConfig configures resource isolation
	Bulkhead BulkheadConfig `json:"bulkhead"`

	// HealthCheckConfig configures health monitoring
	HealthCheck HealthCheckConfig `json:"health_check"`

	// MetricsConfig configures metrics collection
	Metrics MetricsConfig `json:"metrics"`
}

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

type ResourceLimits struct {
	MaxMemory    int64         `json:"max_memory"`     // In bytes
	MaxCPUTime   time.Duration `json:"max_cpu_time"`   // CPU time limit
	MaxDiskSpace int64         `json:"max_disk_space"` // In bytes
	MaxNetworkIO int64         `json:"max_network_io"` // In bytes
}