scorer

type CircuitBreakerConfig struct {
	MaxRequests   uint32                                      // Max requests in half-open state
	Interval      time.Duration                               // Interval for closed state
	Timeout       time.Duration                               // Timeout for open state
	ReadyToTrip   func(counts gobreaker.Counts) bool          // Custom trip condition
	OnStateChange func(name string, from, to gobreaker.State) // State change callback
}

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

type Config struct {
	APIKey               string                // OpenAI API key (required)
	Model                string                // OpenAI model to use
	PromptText           string                // Custom prompt template
	MaxConcurrent        int                   // Maximum concurrent API calls
	MaxContentLength     int                   // Maximum content length per text item (0 = use default)
	EnableCircuitBreaker bool                  // Enable circuit breaker pattern
	EnableRetry          bool                  // Enable retry with backoff
	Timeout              time.Duration         // Request timeout
	CircuitBreakerConfig *CircuitBreakerConfig // Circuit breaker configuration
	RetryConfig          *RetryConfig          // Retry configuration
}

type HealthStatus struct {
	Healthy bool                   // Overall health status
	Status  string                 // Human-readable status message
	Details map[string]interface{} // Additional health details
}

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

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

type OpenAIClient interface {
	CreateChatCompletion(context.Context, openai.ChatCompletionRequest) (openai.ChatCompletionResponse, error)
}

type RetryConfig struct {
	MaxAttempts  int           // Maximum number of retry attempts
	Strategy     RetryStrategy // Backoff strategy to use
	InitialDelay time.Duration // Initial delay between retries
	MaxDelay     time.Duration // Maximum delay between retries
}

type RetryStrategy string

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

type ScoredItem struct {
	Item   TextItem // Original text item
	Score  int      // Score between 0-100
	Reason string   // AI explanation for the score
}

type Scorer interface {
	// ScoreTexts scores a slice of text items
	ScoreTexts(ctx context.Context, items []TextItem, opts ...ScoringOption) ([]ScoredItem, error)

	// ScoreTextsWithOptions scores text items with runtime options
	ScoreTextsWithOptions(ctx context.Context, items []TextItem, opts ...ScoringOption) ([]ScoredItem, error)

	// GetHealth returns the current health status of the scorer
	GetHealth(ctx context.Context) HealthStatus
}

type ScoringOption func(*scoringOptions)

type ScoringOptions struct {
	Model        string                 // Model to use for this request
	PromptText   string                 // Custom prompt for this request
	ExtraContext map[string]interface{} // Additional context data
}

type TextItem struct {
	ID       string                 // Unique identifier for the text item
	Content  string                 // The text content to be scored
	Metadata map[string]interface{} // Optional metadata for context
}

type ValidationOptions struct {
	MaxLength       int
	MinLength       int
	AllowEmpty      bool
	AllowWhitespace bool
	TrimWhitespace  bool
}

type ValidationResult struct {
	Valid       bool
	Issues      []string
	Suggestions []string
}