computing

type AckPayload struct {
	RequestID string `json:"request_id"`
	Success   bool   `json:"success"`
	Message   string `json:"message,omitempty"`
}

type AdaptiveTokenBucket struct {
	*TokenBucket
	// contains filtered or unexported fields
}

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

type BackoffStrategy int

type BenchmarkPayload struct {
	BenchmarkID string            `json:"benchmark_id"`
	TestType    string            `json:"test_type"` // "math", "latency", "code", "reasoning"
	ModelID     string            `json:"model_id"`
	Prompts     []BenchmarkPrompt `json:"prompts"`
	TimeoutMs   int64             `json:"timeout_ms"`
}

type BenchmarkPrompt struct {
	ID             string `json:"id"`
	Prompt         string `json:"prompt"`
	ExpectedAnswer string `json:"expected_answer,omitempty"`
}

type BenchmarkResponsePayload struct {
	RequestID    string            `json:"request_id"`
	BenchmarkID  string            `json:"benchmark_id"`
	Results      []BenchmarkResult `json:"results"`
	TotalLatency int64             `json:"total_latency_ms"`
	Error        string            `json:"error,omitempty"`
}

type BenchmarkResult struct {
	PromptID  string `json:"prompt_id"`
	Answer    string `json:"answer"`
	Correct   bool   `json:"correct"`
	LatencyMs int64  `json:"latency_ms"`
	TokensIn  int64  `json:"tokens_in,omitempty"`
	TokensOut int64  `json:"tokens_out,omitempty"`
	Error     string `json:"error,omitempty"`
}

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

type CircuitState int

type ConcurrencyConfig struct {
	GlobalMaxConcurrent int           // Maximum concurrent requests globally
	DefaultModelMax     int           // Default max concurrent per model
	AcquireTimeout      time.Duration // Timeout for acquiring a slot
	EnableGPUAwareness  bool          // Adjust limits based on GPU memory
	GPUMemoryBufferMB   int           // Buffer to keep free in GPU memory
}

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

type ConcurrencyMetrics struct {
	GlobalActive   int64            `json:"global_active"`
	GlobalMax      int              `json:"global_max"`
	TotalAcquired  int64            `json:"total_acquired"`
	TotalReleased  int64            `json:"total_released"`
	TotalRejected  int64            `json:"total_rejected"`
	TotalTimeouts  int64            `json:"total_timeouts"`
	PerModelActive map[string]int64 `json:"per_model_active"`
	PerModelMax    map[string]int   `json:"per_model_max"`
	AvgHoldTimeMs  float64          `json:"avg_hold_time_ms"`
}

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

type CpInfoService struct {
	*gorm.DB
}

type DeterministicChallengeData struct {
	Prompt    string `json:"prompt"`
	Seed      int    `json:"seed"`
	MaxTokens int    `json:"max_tokens"`
}

type DeterministicResponseData struct {
	Tokens []string `json:"tokens"`
	Text   string   `json:"text"`
}

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

type ErrorLine struct {
	Error       string `json:"error"`
	ErrorDetail struct {
		Message string `json:"message"`
	} `json:"errorDetail"`
}

type ErrorPayload struct {
	RequestID string `json:"request_id,omitempty"`
	Code      int    `json:"code"`
	Message   string `json:"message"`
}

type FingerprintChallengeData struct {
	Files []FingerprintChallengeFile `json:"files"`
}

type FingerprintChallengeFile struct {
	Filename     string `json:"filename"`
	ExpectedHash string `json:"expected_hash"`
}

type FingerprintResponseData struct {
	Files []FingerprintResponseFile `json:"files"`
}

type FingerprintResponseFile struct {
	Filename string `json:"filename"`
	Hash     string `json:"hash"`
	Status   string `json:"status"` // "pass", "fail", "missing"
}

type GPUInfo struct {
	Name      string
	Total     int
	Used      int
	Available int
	FreeIndex []string
}

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

type GPUMetrics struct {
	Index            int     `json:"index"`
	Name             string  `json:"name"`
	UUID             string  `json:"uuid,omitempty"`
	UtilizationPct   float64 `json:"utilization_percent"`
	MemoryUsedMB     float64 `json:"memory_used_mb"`
	MemoryTotalMB    float64 `json:"memory_total_mb"`
	MemoryUsagePct   float64 `json:"memory_usage_percent"`
	TemperatureC     float64 `json:"temperature_c"`
	PowerDrawW       float64 `json:"power_draw_w"`
	PowerLimitW      float64 `json:"power_limit_w"`
	FanSpeedPct      float64 `json:"fan_speed_percent,omitempty"`
	ComputeProcesses int     `json:"compute_processes"`
}

type GPUMetricsCollector struct{}

type HardwareInfo struct {
	GPUType           string `json:"gpu_type"`
	GPUModel          string `json:"gpu_model"`
	VRAMGB            int    `json:"vram_gb"`
	GPUCount          int    `json:"gpu_count"`
	ComputeCapability string `json:"compute_capability"`
	DriverVersion     string `json:"driver_version"`
	CUDAVersion       string `json:"cuda_version"`
	ServingEngine     string `json:"serving_engine,omitempty"` // "vllm", "sglang", "llamacpp", "ollama", "tgi", "unknown"
}

type HealthCheckConfig struct {
	Interval           time.Duration // How often to check health
	Timeout            time.Duration // Timeout for each health check
	UnhealthyThreshold int           // Consecutive failures before marking unhealthy
	HealthyThreshold   int           // Consecutive successes to recover from unhealthy
	CircuitOpenTime    time.Duration // How long to keep circuit open before retrying
}

type HeartbeatPayload struct {
	NodeID      string             `json:"node_id"`               // Local node ID (not the DB provider ID)
	ProviderID  string             `json:"provider_id,omitempty"` // Deprecated: use NodeID
	Timestamp   int64              `json:"timestamp"`
	Metrics     map[string]float64 `json:"metrics,omitempty"`
	Models      []string           `json:"models,omitempty"`       // Current model list (allows dynamic model updates without reconnect)
	ModelHealth map[string]string  `json:"model_health,omitempty"` // modelID -> health status (backup for health updates)
	Hardware    *HardwareInfo      `json:"hardware,omitempty"`     // GPU hardware info (periodically updated)
}

type HistoricalDataPoint struct {
	Timestamp         time.Time `json:"timestamp"`
	TotalRequests     int64     `json:"total_requests"`
	SuccessRate       float64   `json:"success_rate"`
	AvgLatencyMs      float64   `json:"avg_latency_ms"`
	P99LatencyMs      float64   `json:"p99_latency_ms"`
	TokensPerSecond   float64   `json:"tokens_per_second"`
	RequestsPerMinute float64   `json:"requests_per_minute"`
}

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

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

type InferenceHandler func(payload InferencePayload) (*InferenceResponse, error)

type InferenceMetrics struct {

	// Connection metrics
	ConnectionState    string    `json:"connection_state"`
	LastConnectedAt    time.Time `json:"last_connected_at,omitempty"`
	LastDisconnectedAt time.Time `json:"last_disconnected_at,omitempty"`
	ReconnectCount     int64     `json:"reconnect_count"`

	// Request metrics (aggregated)
	TotalRequests     int64   `json:"total_requests"`
	SuccessfulReqs    int64   `json:"successful_requests"`
	FailedReqs        int64   `json:"failed_requests"`
	StreamingReqs     int64   `json:"streaming_requests"`
	AvgLatencyMs      float64 `json:"avg_latency_ms"`
	P50LatencyMs      float64 `json:"p50_latency_ms"`
	P95LatencyMs      float64 `json:"p95_latency_ms"`
	P99LatencyMs      float64 `json:"p99_latency_ms"`
	TotalTokensIn     int64   `json:"total_tokens_in"`
	TotalTokensOut    int64   `json:"total_tokens_out"`
	TokensPerSecond   float64 `json:"tokens_per_second"`
	ActiveRequests    int64   `json:"active_requests"`
	RequestsPerMinute float64 `json:"requests_per_minute"`

	// Per-model metrics
	ModelMetrics map[string]*ModelMetrics `json:"model_metrics"`

	// GPU metrics
	GPUMetrics []GPUMetrics `json:"gpu_metrics"`

	// System metrics
	CPUUsagePercent    float64 `json:"cpu_usage_percent"`
	MemoryUsagePercent float64 `json:"memory_usage_percent"`
	MemoryUsedGB       float64 `json:"memory_used_gb"`
	MemoryTotalGB      float64 `json:"memory_total_gb"`
	// contains filtered or unexported fields
}

type InferencePayload struct {
	EndpointID string          `json:"endpoint_id"`
	ModelID    string          `json:"model_id"`
	Request    json.RawMessage `json:"request"`
	Stream     bool            `json:"stream"` // Whether to stream the response
}

type InferenceResponse struct {
	RequestID  string          `json:"request_id"`
	Response   json.RawMessage `json:"response"`
	Error      string          `json:"error,omitempty"`
	StatusCode int             `json:"status_code,omitempty"` // HTTP status code for Swan Inference to map to proper responses
	Latency    int64           `json:"latency_ms"`
}

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

type Message struct {
	Type      MessageType     `json:"type"`
	RequestID string          `json:"request_id,omitempty"`
	Payload   json.RawMessage `json:"payload"`
}

type MessageType string

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

type MetricsHistoryEntity struct {
	ID                uint      `gorm:"primaryKey;autoIncrement"`
	Timestamp         time.Time `gorm:"index;not null"`
	TotalRequests     int64     `json:"total_requests"`
	SuccessfulReqs    int64     `json:"successful_requests"`
	FailedReqs        int64     `json:"failed_requests"`
	SuccessRate       float64   `json:"success_rate"`
	AvgLatencyMs      float64   `json:"avg_latency_ms"`
	P50LatencyMs      float64   `json:"p50_latency_ms"`
	P95LatencyMs      float64   `json:"p95_latency_ms"`
	P99LatencyMs      float64   `json:"p99_latency_ms"`
	TokensPerSecond   float64   `json:"tokens_per_second"`
	RequestsPerMinute float64   `json:"requests_per_minute"`
	ActiveRequests    int64     `json:"active_requests"`
	TotalTokensIn     int64     `json:"total_tokens_in"`
	TotalTokensOut    int64     `json:"total_tokens_out"`
}

type ModelError struct {
	Message string
}

type ModelHealth int

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

type ModelHealthUpdatePayload struct {
	NodeID      string            `json:"node_id"`               // Local node ID (not the DB provider ID)
	ProviderID  string            `json:"provider_id,omitempty"` // Deprecated: use NodeID
	ModelHealth map[string]string `json:"model_health"`          // modelID -> health status ("healthy", "degraded", "unhealthy")
	Timestamp   int64             `json:"timestamp"`
}

type ModelInfo struct {
	ModelID      string `json:"model_id"`
	WeightHash   string `json:"weight_hash,omitempty"`  // Composite SHA256 of all weight files
	HashAlgo     string `json:"hash_algo,omitempty"`    // Hash algorithm, e.g. "sha256"
	Format       string `json:"format,omitempty"`       // Weight format: "fp16", "fp8", "awq", "gptq", "gguf"
	Quantization string `json:"quantization,omitempty"` // Quantization detail: "q4_k_m", "q8_0", "w4a16", etc.
}

type ModelMapping struct {
	Container    string `json:"container"`
	Endpoint     string `json:"endpoint"`
	GPUMemory    int    `json:"gpu_memory"`
	Category     string `json:"category"`
	LocalModel   string `json:"local_model"`            // Actual model name for local inference server (e.g., Ollama model name)
	Format       string `json:"format,omitempty"`       // Weight format: "fp16", "fp8", "awq", "gptq", "gguf"
	Quantization string `json:"quantization,omitempty"` // Quantization detail: "q4_k_m", "q8_0", "w4a16", etc.
	APIKey       string `json:"api_key,omitempty"`      // API key for authenticated model endpoints (e.g., vLLM --api-key)
}

type ModelMetrics struct {
	ModelName       string  `json:"model_name"`
	TotalRequests   int64   `json:"total_requests"`
	SuccessfulReqs  int64   `json:"successful_requests"`
	FailedReqs      int64   `json:"failed_requests"`
	AvgLatencyMs    float64 `json:"avg_latency_ms"`
	TotalTokensIn   int64   `json:"total_tokens_in"`
	TotalTokensOut  int64   `json:"total_tokens_out"`
	TokensPerSecond float64 `json:"tokens_per_second"`
	ActiveRequests  int64   `json:"active_requests"`
	// contains filtered or unexported fields
}

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

type ModelServerError struct {
	StatusCode int    // HTTP status code from the model server
	Body       []byte // Raw response body
	Message    string // Parsed error message (from OpenAI error format or raw body)
}

type ModelState int

type ModelStatus struct {
	ModelID          string      `json:"model_id"`
	Endpoint         string      `json:"endpoint"`
	Health           ModelHealth `json:"health"`
	HealthString     string      `json:"health_string"`
	LastCheck        time.Time   `json:"last_check"`
	LastSuccess      time.Time   `json:"last_success"`
	LastError        string      `json:"last_error,omitempty"`
	LatencyMs        float64     `json:"latency_ms"`
	AvgLatencyMs     float64     `json:"avg_latency_ms"`
	ConsecutiveFails int         `json:"consecutive_fails"`
	TotalChecks      int64       `json:"total_checks"`
	TotalSuccesses   int64       `json:"total_successes"`
	TotalFailures    int64       `json:"total_failures"`
	CircuitOpen      bool        `json:"circuit_open"`
}

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

type ProviderStatusResponse struct {
	ProviderID      string   `json:"provider_id"`
	Name            string   `json:"name"`
	Status          string   `json:"status"`
	CanConnect      bool     `json:"can_connect"`
	APIKeyValid     bool     `json:"api_key_valid"`
	Message         string   `json:"message"`
	Warning         string   `json:"warning,omitempty"`
	NextSteps       []string `json:"next_steps,omitempty"`
	Step            int      `json:"step"`
	TotalSteps      int      `json:"total_steps"`
	StepLabel       string   `json:"step_label"`
	EarningsEnabled bool     `json:"earnings_enabled"`
}

type QueueConfig struct {
	MaxQueueSize     int           // Maximum total queue size
	MaxPerModelQueue int           // Maximum queue size per model
	DefaultTimeout   time.Duration // Default request timeout
	DrainTimeout     time.Duration // Timeout for draining on shutdown
	EnablePriority   bool          // Enable priority-based queuing
}

type QueueMetrics struct {
	TotalEnqueued  int64            `json:"total_enqueued"`
	TotalDequeued  int64            `json:"total_dequeued"`
	TotalRejected  int64            `json:"total_rejected"`
	TotalTimedOut  int64            `json:"total_timed_out"`
	TotalCancelled int64            `json:"total_cancelled"`
	CurrentDepth   int64            `json:"current_depth"`
	AvgWaitTimeMs  float64          `json:"avg_wait_time_ms"`
	MaxWaitTimeMs  float64          `json:"max_wait_time_ms"`
	PerModelDepth  map[string]int64 `json:"per_model_depth"`
}

type QueueResult struct {
	Response json.RawMessage
	Error    error
}

type QueuedRequest struct {
	ID          string
	ModelID     string
	Priority    RequestPriority
	Payload     json.RawMessage
	EnqueueTime time.Time
	Deadline    time.Time
	ResultChan  chan *QueueResult
	// contains filtered or unexported fields
}

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

type RateLimiterConfig struct {
	// Token bucket settings
	TokensPerSecond float64 // Rate of token replenishment
	BurstSize       int     // Maximum burst capacity

	// Adaptive rate limiting
	EnableAdaptive     bool    // Enable GPU-aware rate limiting
	GPUThresholdHigh   float64 // GPU utilization above which to reduce rate
	GPUThresholdLow    float64 // GPU utilization below which to increase rate
	AdaptiveMinRate    float64 // Minimum tokens per second when adapting
	AdaptiveMaxRate    float64 // Maximum tokens per second when adapting
	AdaptiveAdjustment float64 // Rate adjustment factor per interval
}

type RateLimiterMetrics struct {
	TotalAllowed    int64   `json:"total_allowed"`
	TotalThrottled  int64   `json:"total_throttled"`
	CurrentRate     float64 `json:"current_rate"`
	CurrentTokens   float64 `json:"current_tokens"`
	BurstSize       int     `json:"burst_size"`
	AdaptiveEnabled bool    `json:"adaptive_enabled"`
}

type RegisterPayload struct {
	NodeID       string        `json:"node_id"`               // Local node ID (not the DB provider ID)
	ProviderID   string        `json:"provider_id,omitempty"` // Deprecated: use NodeID
	NodeName     string        `json:"node_name,omitempty"`   // Human-readable provider name from config
	WorkerAddr   string        `json:"worker_addr"`
	OwnerAddr    string        `json:"owner_addr"`
	Token        string        `json:"token,omitempty"` // API key for authentication (sk-prov-*)
	Signature    string        `json:"signature,omitempty"`
	Models       []string      `json:"models"`
	ModelHashes  []ModelInfo   `json:"model_hashes,omitempty"` // Per-model composite hashes for verification
	Capabilities []string      `json:"capabilities"`
	Hardware     *HardwareInfo `json:"hardware,omitempty"`
}

type RegisteredModel struct {
	ID           string      `json:"id"`
	Container    string      `json:"container"`
	Endpoint     string      `json:"endpoint"`
	GPUMemory    int         `json:"gpu_memory"`
	Category     string      `json:"category"`
	LocalModel   string      `json:"local_model,omitempty"`  // Actual model name for local inference server
	Format       string      `json:"format,omitempty"`       // Weight format: fp16, awq, gptq, gguf, etc.
	Quantization string      `json:"quantization,omitempty"` // Quantization detail: q4_k_m, q8_0, w4a16, etc.
	APIKey       string      `json:"api_key,omitempty"`      // API key for authenticated model endpoints
	State        ModelState  `json:"state"`
	StateString  string      `json:"state_string"`
	Health       ModelHealth `json:"health"`
	HealthString string      `json:"health_string"`
	LoadedAt     time.Time   `json:"loaded_at,omitempty"`
	UpdatedAt    time.Time   `json:"updated_at"`
	Enabled      bool        `json:"enabled"`
}

type RequestMetric struct {
	RequestID   string    `json:"request_id"`
	Model       string    `json:"model"`
	StartTime   time.Time `json:"start_time"`
	EndTime     time.Time `json:"end_time,omitempty"`
	LatencyMs   float64   `json:"latency_ms"`
	TokensIn    int       `json:"tokens_in"`
	TokensOut   int       `json:"tokens_out"`
	Streaming   bool      `json:"streaming"`
	Success     bool      `json:"success"`
	ErrorReason string    `json:"error_reason,omitempty"`
}

type RequestPriority int

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

type RestartableService interface {
	Start() error
	Stop()
	IsHealthy() bool
	Name() string
}

type ResultChecker interface {
	Check() error
}

type RetryConfig struct {
	MaxRetries         int           // Maximum number of retry attempts
	InitialDelay       time.Duration // Initial delay before first retry
	MaxDelay           time.Duration // Maximum delay between retries
	Multiplier         float64       // Delay multiplier for exponential backoff
	JitterFactor       float64       // Random jitter factor (0-1)
	RetryableErrors    []string      // Error substrings that are retryable
	NonRetryableErrors []string      // Error substrings that should not be retried
}

type RetryMetrics struct {
	TotalAttempts        int64   `json:"total_attempts"`
	TotalRetries         int64   `json:"total_retries"`
	TotalSuccesses       int64   `json:"total_successes"`
	TotalFailures        int64   `json:"total_failures"`
	TotalNonRetryable    int64   `json:"total_non_retryable"`
	AvgRetriesPerRequest float64 `json:"avg_retries_per_request"`
	RetrySuccessRate     float64 `json:"retry_success_rate"`
}

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

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

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

type ServiceState struct {
	Name           string
	Healthy        bool
	RestartCount   int
	LastRestartAt  time.Time
	LastHealthyAt  time.Time
	CurrentBackoff time.Duration
}

type StreamChunkPayload struct {
	RequestID string          `json:"request_id"`
	Chunk     json.RawMessage `json:"chunk"` // OpenAI-compatible SSE chunk data
	Done      bool            `json:"done"`  // True when stream is complete
}

type StreamEndPayload struct {
	RequestID    string `json:"request_id"`
	Latency      int64  `json:"latency_ms"`
	TokensInput  int64  `json:"tokens_input,omitempty"`
	TokensOutput int64  `json:"tokens_output,omitempty"`
	StatusCode   int    `json:"status_code,omitempty"` // HTTP status code for error responses
	Error        string `json:"error,omitempty"`
}

type StreamResult struct {
	TokensInput  int64
	TokensOutput int64
	Error        error
}

type StreamingInferenceHandler func(requestID string, payload InferencePayload, sendChunk func(chunk []byte, done bool) error) *StreamResult

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

type SupervisorConfig struct {
	HealthCheckInterval time.Duration // How often to check service health
	MaxRestartAttempts  int           // Maximum restart attempts before giving up (0 = unlimited)
	RestartBackoff      time.Duration // Initial backoff between restart attempts
	MaxRestartBackoff   time.Duration // Maximum backoff between restart attempts
}

type SupervisorError struct {
	Message string
}

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

type VerifyPayload struct {
	ChallengeID   string          `json:"challenge_id"`
	ChallengeType string          `json:"challenge_type"`
	ModelID       string          `json:"model_id"`
	Challenge     json.RawMessage `json:"challenge"`
}

type VerifyResponsePayload struct {
	ChallengeID string          `json:"challenge_id"`
	Success     bool            `json:"success"`
	Response    json.RawMessage `json:"response"`
	Error       string          `json:"error,omitempty"`
}

type WarmupHandler func(payload WarmupPayload) (*WarmupResponse, error)

type WarmupPayload struct {
	ModelID    string `json:"model_id"`
	WarmupType string `json:"warmup_type"` // "load" or "inference"
}

type WarmupResponse struct {
	RequestID  string `json:"request_id"`
	ModelID    string `json:"model_id"`
	Success    bool   `json:"success"`
	LoadTimeMs int64  `json:"load_time_ms,omitempty"`
	MemoryMB   int64  `json:"memory_mb,omitempty"`
	Error      string `json:"error,omitempty"`
}

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

type YamlStruct struct {
	Services struct {
		Image      string            `yaml:"image"`
		Cmd        []string          `yaml:"command"`
		ExposePort []int             `yaml:"expose"`
		Envs       map[string]string `yaml:"environment"`
	} `yaml:"services"`
}