optimizers

type BootstrapFewShot struct {
	Metric          func(example map[string]interface{}, prediction map[string]interface{}, ctx context.Context) bool
	MaxBootstrapped int
}

type COPRO struct {
	PromptModel     core.LLM // Optional model for generating prompts (if nil, uses default)
	Metric          core.Metric
	Breadth         int     // Number of prompt candidates to generate
	Depth           int     // Iterations of prompt refinement
	InitTemperature float64 // Randomness in prompt generation
	TrackStats      bool    // Optional performance tracking

	// LLM-assisted prompt generation components
	PromptGenerator  *LLMPromptGenerator
	CandidateHistory []PromptCandidate // Track previous attempts for learning
}

type COPROOption func(*COPROOptions)

type COPROOptions struct {
	PromptModel     core.LLM
	Breadth         int
	Depth           int
	InitTemperature float64
	TrackStats      bool
}

type CandidateCaseObservation struct {
	Score             float64
	Passed            bool
	LatencyMS         float64
	TotalTokens       int64
	ToolCalls         int
	RobustnessFailure bool
}

type CandidateMetadata struct {
	// Individual performance metrics
	IndividualScores []float64 `json:"individual_scores"`
	DiversityScore   float64   `json:"diversity_score"`
	ImprovementDelta float64   `json:"improvement_delta"`

	// Multi-criteria scores
	MaxToMinGap float64 `json:"max_to_min_gap"`
	MaxScore    float64 `json:"max_score"`
	MaxToAvgGap float64 `json:"max_to_avg_gap"`

	// Selection tracking
	SelectionRank    int     `json:"selection_rank"`
	BucketAssignment int     `json:"bucket_assignment"`
	CompositeScore   float64 `json:"composite_score"`
}

type CandidateMetrics struct {
	TotalEvaluations int                    `json:"total_evaluations"`
	SuccessCount     int                    `json:"success_count"`
	AverageFitness   float64                `json:"average_fitness"`
	BestFitness      float64                `json:"best_fitness"`
	ExecutionTimes   []time.Duration        `json:"execution_times"`
	ErrorCounts      map[string]int         `json:"error_counts"`
	Metadata         map[string]interface{} `json:"metadata"`
}

type CandidateResult struct {
	Program     core.Program       `json:"-"`
	Score       float64            `json:"score"`
	Step        int                `json:"step"`
	Temperature float64            `json:"temperature"`
	CreatedAt   time.Time          `json:"created_at"`
	Metadata    *CandidateMetadata `json:"metadata,omitempty"`
}

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

type ContextPattern struct {
	PatternID         string                 `json:"pattern_id"`
	ContextFeatures   map[string]interface{} `json:"context_features"`
	SuccessFactors    []string               `json:"success_factors"`
	FailureFactors    []string               `json:"failure_factors"`
	OptimalCandidates []string               `json:"optimal_candidates"`
	Confidence        float64                `json:"confidence"`
	LastUpdated       time.Time              `json:"last_updated"`
}

type ContextPerformanceMetrics struct {
	ContextType      string                 `json:"context_type"`
	ExecutionCount   int                    `json:"execution_count"`
	SuccessRate      float64                `json:"success_rate"`
	AverageLatency   time.Duration          `json:"average_latency"`
	QualityScore     float64                `json:"quality_score"`
	ErrorPatterns    map[string]int         `json:"error_patterns"`
	PerformanceTrend []float64              `json:"performance_trend"`
	LastUpdated      time.Time              `json:"last_updated"`
	Metadata         map[string]interface{} `json:"metadata"`
}

type ConvergenceStatus struct {
	StagnationCount                int     `json:"stagnation_count"`
	PrematureConvergenceRisk       string  `json:"premature_convergence_risk"`
	ExplorationExploitationBalance string  `json:"exploration_exploitation_balance"`
	DiversityIndex                 float64 `json:"diversity_index"`
	IsConverged                    bool    `json:"is_converged"`
}

type EmbeddingService interface {
	GenerateEmbedding(ctx context.Context, text string) ([]float64, error)
	CosineSimilarity(vec1, vec2 []float64) float64
}

type EvolutionLoopConfig struct {
	MaxGenerations int
	ReflectionFreq int
	PhaseName      string
}

type EvolutionLoopHooks struct {
	Initialize         func(ctx context.Context) error
	BeforeGeneration   func(ctx context.Context, generation int) error
	EvaluateGeneration func(ctx context.Context, generation int) error
	// AfterEvaluation runs immediately after EvaluateGeneration for the same generation.
	// Callers can use it to consume state populated during evaluation, such as cached
	// fitness maps needed by archive or frontier updates.
	AfterEvaluation func(ctx context.Context, generation int) error
	Reflect         func(ctx context.Context, generation int) error
	OnNonFatalError func(ctx context.Context, stage string, generation int, err error)
	HasConverged    func(ctx context.Context, generation int) bool
	// Evolve is treated as fatal if it returns an error. Hooks that want retry or
	// best-effort behavior should absorb those failures internally.
	Evolve         func(ctx context.Context, generation int) error
	ReportProgress func(phase string, current, total int)
	Finalize       func(ctx context.Context) error
}

type ExampleSelector struct {
	Config         *MCPOptimizerConfig `json:"config"`
	SuccessHistory map[string][]bool   `json:"success_history"` // Track success history by pattern hash
	// contains filtered or unexported fields
}

type ExecutionPatterns struct {
	SuccessRate         float64        `json:"success_rate"`
	SuccessCount        int            `json:"success_count"`
	TotalExecutions     int            `json:"total_executions"`
	AverageResponseTime time.Duration  `json:"average_response_time"`
	CommonFailures      []string       `json:"common_failures"`
	QualityIndicators   []string       `json:"quality_indicators"`
	RichTraceEvidence   []string       `json:"rich_trace_evidence"`
	ErrorDistribution   map[string]int `json:"error_distribution"`
	PerformanceTrends   []float64      `json:"performance_trends"`
}

type ExecutionTrace struct {
	CandidateID string                 `json:"candidate_id"`
	ModuleName  string                 `json:"module_name"`
	Inputs      map[string]any         `json:"inputs"`
	Outputs     map[string]any         `json:"outputs"`
	Error       error                  `json:"error"`
	Duration    time.Duration          `json:"duration"`
	Success     bool                   `json:"success"`
	Timestamp   time.Time              `json:"timestamp"`
	ContextData map[string]interface{} `json:"context_data"`
}

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

type GEPACandidate struct {
	ID             string                 `json:"id"`
	ModuleName     string                 `json:"module_name"`
	Instruction    string                 `json:"instruction"`
	ComponentTexts map[string]string      `json:"component_texts,omitempty"`
	Demonstrations []core.Example         `json:"demonstrations"`
	Generation     int                    `json:"generation"`
	Fitness        float64                `json:"fitness"`
	ParentIDs      []string               `json:"parent_ids"`
	CreatedAt      time.Time              `json:"created_at"`
	Metadata       map[string]interface{} `json:"metadata"`
}

type GEPAConfig struct {
	// Evolutionary parameters
	PopulationSize int     `json:"population_size"` // Default: 20
	MaxGenerations int     `json:"max_generations"` // Default: 10
	MutationRate   float64 `json:"mutation_rate"`   // Default: 0.3
	CrossoverRate  float64 `json:"crossover_rate"`  // Default: 0.7
	ElitismRate    float64 `json:"elitism_rate"`    // Default: 0.1

	// Reflection parameters
	ReflectionFreq   int     `json:"reflection_frequency"` // Default: 2
	ReflectionDepth  int     `json:"reflection_depth"`     // Default: 3
	SelfCritiqueTemp float64 `json:"self_critique_temp"`   // Default: 0.7

	// Selection parameters
	TournamentSize     int    `json:"tournament_size"`     // Default: 3
	SelectionStrategy  string `json:"selection_strategy"`  // Default: "tournament" | "roulette" | "pareto" | "adaptive_pareto"
	ComponentSelection string `json:"component_selection"` // Default: "round_robin" | "random" | "all"

	// Convergence parameters
	ConvergenceThreshold float64 `json:"convergence_threshold"` // Default: 0.01
	StagnationLimit      int     `json:"stagnation_limit"`      // Default: 3

	// Performance parameters
	EvaluationBatchSize        int                   `json:"evaluation_batch_size"` // Default: 5
	ConcurrencyLevel           int                   `json:"concurrency_level"`     // Default: 3
	ValidationFrequency        int                   `json:"validation_frequency"`  // Default: 1
	ValidationSplit            float64               `json:"validation_split"`      // Default: 0.0 (disabled)
	ValidationExamples         []core.Example        `json:"-"`
	RandomSeed                 int64                 `json:"random_seed"`           // Default: 0 (time-based)
	MaxMergeInvocations        int                   `json:"max_merge_invocations"` // Default: 5
	MaxMetricCalls             int                   `json:"max_metric_calls"`      // Default: 0 (disabled)
	ScoreThreshold             float64               `json:"score_threshold"`       // Default: 0.0 (disabled)
	MaxRuntime                 time.Duration         `json:"max_runtime"`           // Default: 0 (disabled)
	RunDir                     string                `json:"run_dir,omitempty"`
	StopCallbacks              []GEPAStopper         `json:"-"`
	FeedbackEvaluator          GEPAFeedbackEvaluator `json:"-"`
	AddFormatFailureAsFeedback bool                  `json:"add_format_failure_as_feedback"`

	// LLM parameters
	GenerationModel string   `json:"generation_model"` // Default: uses core.GetDefaultLLM()
	ReflectionModel string   `json:"reflection_model"` // Default: uses core.GetTeacherLLM()
	GenerationLLM   core.LLM `json:"-"`
	ReflectionLLM   core.LLM `json:"-"`
	Temperature     float64  `json:"temperature"` // Default: 0.8
	MaxTokens       int      `json:"max_tokens"`  // Default: 500
}

type GEPAFeedback struct {
	Feedback        string                 `json:"feedback,omitempty"`
	TargetComponent string                 `json:"target_component,omitempty"`
	Metadata        map[string]interface{} `json:"metadata,omitempty"`
}

type GEPAFeedbackContext struct {
	Candidate *GEPACandidate
	Example   core.Example
	Outputs   map[string]interface{}
	Err       error
}

type GEPAFeedbackEvaluator interface {
	EvaluateFeedback(ctx context.Context, expected, actual map[string]interface{}, info *GEPAFeedbackContext) *GEPAFeedback
}

type GEPAFeedbackEvaluatorFunc func(ctx context.Context, expected, actual map[string]interface{}, info *GEPAFeedbackContext) *GEPAFeedback

type GEPAState struct {
	CurrentGeneration        int                                  `json:"current_generation"`
	BestCandidate            *GEPACandidate                       `json:"best_candidate"`
	BestFitness              float64                              `json:"best_fitness"`
	BestValidationCandidate  *GEPACandidate                       `json:"best_validation_candidate,omitempty"`
	BestValidationFitness    float64                              `json:"best_validation_fitness"`
	PopulationHistory        []*Population                        `json:"population_history"`
	ReflectionHistory        []*ReflectionResult                  `json:"reflection_history"`
	ConvergenceStatus        *ConvergenceStatus                   `json:"convergence_status"`
	StartTime                time.Time                            `json:"start_time"`
	LastImprovement          time.Time                            `json:"last_improvement"`
	LastValidatedGeneration  int                                  `json:"last_validated_generation"`
	ExecutionTraces          map[string][]ExecutionTrace          `json:"execution_traces"`
	CandidateMetrics         map[string]*CandidateMetrics         `json:"candidate_metrics"`
	MultiObjectiveFitnessMap map[string]*MultiObjectiveFitness    `json:"multi_objective_fitness_map"`
	ValidationFrontier       map[int]*gepaValidationFrontierEntry `json:"validation_frontier,omitempty"`
	ValidationCoverage       map[string]int                       `json:"validation_coverage,omitempty"`
	MergeInvocations         int                                  `json:"merge_invocations,omitempty"`
	PerformedMerges          map[string]bool                      `json:"performed_merges,omitempty"`
	MetricCalls              int                                  `json:"metric_calls,omitempty"`
	StopReason               string                               `json:"stop_reason,omitempty"`
	StopMetadata             map[string]interface{}               `json:"stop_metadata,omitempty"`

	// Pareto archive for elite solution management
	ParetoArchive     []*GEPACandidate                  `json:"pareto_archive"`
	ArchiveFitnessMap map[string]*MultiObjectiveFitness `json:"archive_fitness_map"`
	MaxArchiveSize    int                               `json:"max_archive_size"`
	// contains filtered or unexported fields
}

type GEPAStopDecision struct {
	Reason   string                 `json:"reason"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type GEPAStopper func(context.Context, *GEPA) *GEPAStopDecision

type IndividualReflectionInsights struct {
	CommonStrengths        []string       `json:"common_strengths"`
	CommonWeaknesses       []string       `json:"common_weaknesses"`
	SuccessPatterns        []string       `json:"success_patterns"`
	FailurePatterns        []string       `json:"failure_patterns"`
	ImprovementThemes      []string       `json:"improvement_themes"`
	ConfidenceDistribution map[string]int `json:"confidence_distribution"`
}

type InstructionGenerator struct {
	PromptModel   core.LLM
	MaxCandidates int
	Temperature   float64
}

type IntrospectionResult struct {
	Analysis             string   `json:"analysis"`
	Recommendations      []string `json:"recommendations"`
	Confidence           float64  `json:"confidence"`
	IdentifiedPatterns   []string `json:"identified_patterns"`
	SuggestedAdjustments []string `json:"suggested_adjustments"`
}

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

type MCPInteraction struct {
	ID            string                 `json:"id"`
	Timestamp     time.Time              `json:"timestamp"`
	Context       string                 `json:"context"`                  // The user query or context that triggered this interaction
	ToolName      string                 `json:"tool_name"`                // Name of the MCP tool used
	Parameters    map[string]interface{} `json:"parameters"`               // Parameters passed to the tool
	Result        core.ToolResult        `json:"result"`                   // Result returned by the tool
	Success       bool                   `json:"success"`                  // Whether the interaction was successful
	ExecutionTime time.Duration          `json:"execution_time"`           // Time taken to execute
	ErrorMessage  string                 `json:"error_message,omitempty"`  // Error message if failed
	ContextVector []float64              `json:"context_vector,omitempty"` // Embedding vector for the context
	Metadata      map[string]interface{} `json:"metadata"`                 // Additional metadata
}

type MCPMetrics struct {
	Timestamp             time.Time `json:"timestamp"`
	ToolSelectionAccuracy float64   `json:"tool_selection_accuracy"`
	ParameterOptimality   float64   `json:"parameter_optimality"`
	ExecutionSuccessRate  float64   `json:"execution_success_rate"`
	AverageExecutionTime  float64   `json:"average_execution_time"`
	InteractionsProcessed int       `json:"interactions_processed"`
}

type MCPOptimizer struct {
	core.BaseOptimizer
	PatternCollector  *PatternCollector
	SimilarityMatcher *SimilarityMatcher
	ExampleSelector   *ExampleSelector
	MetricsEvaluator  *MetricsEvaluator
	ToolOrchestrator  *ToolOrchestrator
	Config            *MCPOptimizerConfig
	// contains filtered or unexported fields
}

type MCPOptimizerConfig struct {
	MaxPatterns          int     `json:"max_patterns"`          // Maximum number of patterns to store
	SimilarityThreshold  float64 `json:"similarity_threshold"`  // Minimum similarity for pattern matching
	KNearestNeighbors    int     `json:"k_nearest_neighbors"`   // Number of neighbors for KNN matching
	SuccessWeightFactor  float64 `json:"success_weight_factor"` // Weight factor for successful patterns
	EmbeddingDimensions  int     `json:"embedding_dimensions"`  // Dimensions for context embeddings
	LearningEnabled      bool    `json:"learning_enabled"`      // Whether to learn from new interactions
	MetricsWindowSize    int     `json:"metrics_window_size"`   // Window size for performance metrics
	OptimizationInterval int     `json:"optimization_interval"` // Interval for optimization cycles (in interactions)
}

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

type MIPROConfig struct {
	Mode           RunMode
	NumTrials      int
	ValSize        int
	MiniBatchSize  int
	AdaptiveParams bool
	ScalingFactors struct {
		TrialsPerVariable float64
		BatchSizeScaling  float64
	}
	TeacherSettings map[string]interface{}

	// TPE specific configuration
	TPEGamma        float64
	TPEGenerations  int
	Seed            int64
	NumModules      int // Number of modules to optimize (can be inferred from program)
	MaxLabeledDemos int // Maximum number of labeled demonstrations to use
}

type MIPROMetrics struct {
	TeacherPerformance  float64
	StudentPerformance  float64
	PromptEffectiveness map[string]float64
	OptimizationHistory []OptimizationStep
	TokenUsage          *core.TokenInfo
}

type MIPROOption func(*MIPRO)

type MetricsEvaluator struct {
	Metrics []MCPMetrics        `json:"metrics"`
	Config  *MCPOptimizerConfig `json:"config"`
	// contains filtered or unexported fields
}

type MultiObjectiveFitness struct {
	// Core objectives
	SuccessRate    float64 `json:"success_rate"`   // Objective 1: Basic success rate
	OutputQuality  float64 `json:"output_quality"` // Objective 2: Quality of outputs
	Efficiency     float64 `json:"efficiency"`     // Objective 3: Execution efficiency
	Robustness     float64 `json:"robustness"`     // Objective 4: Error handling capability
	Generalization float64 `json:"generalization"` // Objective 5: Cross-context performance

	// Meta-objectives
	Diversity  float64 `json:"diversity"`  // Population diversity contribution
	Innovation float64 `json:"innovation"` // Novel solution characteristics

	// Aggregated score for backward compatibility
	WeightedScore float64 `json:"weighted_score"`
}

type ObjectiveStats struct {
	Mean   float64 `json:"mean"`
	StdDev float64 `json:"std_dev"`
	Min    float64 `json:"min"`
	Max    float64 `json:"max"`
	Range  float64 `json:"range"`
}

type OptimizationState struct {
	SuccessfulPatterns []string
	PromptEvolution    []PromptVersion
	TeacherScores      map[string]float64
	CurrentIteration   int
	BestScore          float64
	Convergence        float64
}

type OptimizationStep struct {
	Trial         int
	Performance   float64
	Improvements  []string
	FailurePoints []string
}

type ParetoFront struct {
	Candidates []*GEPACandidate `json:"candidates"`
	Rank       int              `json:"rank"` // Pareto rank (1 = best front)
	Size       int              `json:"size"`
}

type PatternCollector struct {
	Patterns    []MCPInteraction    `json:"patterns"`
	IndexByCtx  map[string][]int    `json:"index_by_ctx"`  // Index patterns by context hash
	IndexByTool map[string][]int    `json:"index_by_tool"` // Index patterns by tool name
	Config      *MCPOptimizerConfig `json:"config"`
	// contains filtered or unexported fields
}

type PerformanceContext struct {
	// Execution context
	ExecutionID string `json:"execution_id"`
	CandidateID string `json:"candidate_id"`
	ModuleName  string `json:"module_name"`

	// Input characteristics
	InputTypes      []string `json:"input_types"`
	InputSize       int      `json:"input_size"`
	InputComplexity float64  `json:"input_complexity"`

	// System context
	SystemLoad      float64 `json:"system_load"`
	MemoryUsage     float64 `json:"memory_usage"`
	ConcurrentTasks int     `json:"concurrent_tasks"`

	// Generation context
	Generation        int     `json:"generation"`
	PopulationSize    int     `json:"population_size"`
	SelectionPressure float64 `json:"selection_pressure"`

	// Temporal context
	TimeOfDay      int    `json:"time_of_day"`     // Hour of day
	ExecutionPhase string `json:"execution_phase"` // init, evolution, reflection

	// Custom context data
	CustomData map[string]interface{} `json:"custom_data"`
}

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

type PipelineChannels struct {
	CandidateGeneration chan *PipelineStage
	BatchSampling       chan *PipelineStage
	CandidateEvaluation chan *PipelineStage
	Results             chan *PipelineStage
	Errors              chan error
	Done                chan struct{}
}

type PipelineResult struct {
	StepIndex      int
	BestProgram    core.Program
	BestScore      float64
	AllScores      []float64
	ProcessingTime time.Duration
	StageTimings   map[string]time.Duration
}

type PipelineStage struct {
	StepIndex  int
	Candidates []core.Program
	Batch      []core.Example
	Scores     []float64
	Timestamp  time.Time
	Error      error
}

type Population struct {
	Candidates    []*GEPACandidate `json:"candidates"`
	Generation    int              `json:"generation"`
	BestFitness   float64          `json:"best_fitness"`
	BestCandidate *GEPACandidate   `json:"best_candidate"`
}

type PopulationInsights struct {
	DiversityIndex         float64  `json:"diversity_index"`
	AverageFitness         float64  `json:"average_fitness"`
	BestFitness            float64  `json:"best_fitness"`
	WorstFitness           float64  `json:"worst_fitness"`
	FitnessVariance        float64  `json:"fitness_variance"`
	HighPerformingPatterns []string `json:"high_performing_patterns"`
	CommonWeaknesses       []string `json:"common_weaknesses"`
}

type PromptCandidate struct {
	Instruction     string
	Prefix          string
	Score           float64 // Training score
	ValidationScore float64 // Validation score to prevent overfitting
	Generation      int     // Which depth iteration this was generated in
	Diversity       float64 // Semantic diversity score
	Rank            int     // Performance ranking
	AttemptID       string  // Unique identifier for tracking
}

type PromptComponent struct {
	Type    string
	Content string
	Score   float64
}

type PromptVersion struct {
	Template    string
	Performance float64
	Components  []PromptComponent
}

type ReflectionResult struct {
	CandidateID     string    `json:"candidate_id"`
	Strengths       []string  `json:"strengths"`
	Weaknesses      []string  `json:"weaknesses"`
	Suggestions     []string  `json:"suggestions"`
	ConfidenceScore float64   `json:"confidence_score"`
	Timestamp       time.Time `json:"timestamp"`
	ReflectionDepth int       `json:"reflection_depth"`
}

type RunMode string

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

type SIMBAConfig struct {
	// Mini-batch configuration
	BatchSize     int `json:"batch_size"`     // Default: 32
	MaxSteps      int `json:"max_steps"`      // Default: 8
	NumCandidates int `json:"num_candidates"` // Default: 6

	// Temperature controls
	SamplingTemperature float64 `json:"sampling_temperature"` // Default: 0.2

	// Introspective learning
	IntrospectionFrequency int `json:"introspection_frequency"` // Default: 2

	// Performance thresholds
	ConvergenceThreshold float64 `json:"convergence_threshold"` // Default: 0.001
	MinImprovementRatio  float64 `json:"min_improvement_ratio"` // Default: 0.05

	// Concurrency and resources
	MaxGoroutines  int `json:"max_goroutines"`  // Default: 10 (for non-LLM operations)
	LLMConcurrency int `json:"llm_concurrency"` // Default: 0 (unlimited for LLM calls)

	// Strategy configuration
	StrategyMode  string  `json:"strategy_mode"`  // Default: "both" (both, instruction_only, rule_only)
	StrategyRatio float64 `json:"strategy_ratio"` // Default: 0.5 (percentage of instruction perturbation when using both)

	// Bucket sorting configuration
	UseBucketSorting      bool      `json:"use_bucket_sorting"`      // Default: false
	BucketSortingCriteria []string  `json:"bucket_sorting_criteria"` // Default: ["max_to_min_gap", "max_score", "max_to_avg_gap"]
	BucketSortingWeights  []float64 `json:"bucket_sorting_weights"`  // Default: [0.4, 0.4, 0.2]

	// Pipeline processing configuration
	UsePipelineProcessing bool `json:"use_pipeline_processing"` // Default: false
	PipelineBufferSize    int  `json:"pipeline_buffer_size"`    // Default: 2

	// Early stopping configuration
	EarlyStoppingPatience  int     `json:"early_stopping_patience"`  // Default: 0 (disabled)
	EarlyStoppingThreshold float64 `json:"early_stopping_threshold"` // Default: 0.01

	// Fast mode configuration for Python compatibility
	FastMode                       bool `json:"fast_mode"`                        // Default: false
	DisableTrajectoryTracking      bool `json:"disable_trajectory_tracking"`      // Default: false
	DisableRuleGeneration          bool `json:"disable_rule_generation"`          // Default: false
	DisableInstructionPerturbation bool `json:"disable_instruction_perturbation"` // Default: false
}

type SIMBAOption func(*SIMBA)

type SIMBAState struct {
	CurrentStep      int
	BestScore        float64
	BestProgram      core.Program
	CandidateHistory []CandidateResult
	PerformanceLog   []StepResult
	IntrospectionLog []string
	StartTime        time.Time
	Trajectories     []Trajectory // Track execution trajectories for rule extraction
}

type SearchConfig struct {
	ParamSpace  map[string][]interface{}
	MaxTrials   int
	Seed        int64
	Constraints map[string]interface{}
}

type SearchStrategy interface {
	SuggestParams(ctx context.Context) (map[string]interface{}, error)
	UpdateResults(params map[string]interface{}, score float64) error
	GetBestParams() (map[string]interface{}, float64)
	Initialize(config SearchConfig) error
}

type SimilarityMatcher struct {
	Config *MCPOptimizerConfig `json:"config"`
	// contains filtered or unexported fields
}

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

type StepResult struct {
	Step            int           `json:"step"`
	BestScore       float64       `json:"best_score"`
	CandidateScores []float64     `json:"candidate_scores"`
	Temperature     float64       `json:"temperature"`
	BatchSize       int           `json:"batch_size"`
	Introspection   string        `json:"introspection,omitempty"`
	Duration        time.Duration `json:"duration"`
	Improvement     float64       `json:"improvement"`
}

type StrategyType string

type TPEConfig struct {
	// Gamma is the percentile split between good and bad observations (default: 0.25)
	Gamma float64
	// Seed is used for random number generation
	Seed int64
	// NumEIGenerations is the number of random points to evaluate EI on
	NumEIGenerations int
	// Prior distributions for each parameter (optional)
	PriorWeight float64
	// Kernel bandwidth factor
	BandwidthFactor float64
}

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

type TeacherStudentOptimizer struct {
	Teacher         core.LLM
	Student         core.LLM
	TeacherSettings map[string]interface{}
	MaxExamples     int
	// contains filtered or unexported fields
}

type ToolOrchestrator struct {
	Dependencies map[string][]string `json:"dependencies"` // Tool dependency mapping
	Workflows    []ToolWorkflow      `json:"workflows"`    // Recorded successful workflows
	Config       *MCPOptimizerConfig `json:"config"`
	// contains filtered or unexported fields
}

type ToolWorkflow struct {
	ID        string                 `json:"id"`
	Steps     []WorkflowStep         `json:"steps"`
	Context   string                 `json:"context"`
	Success   bool                   `json:"success"`
	Timestamp time.Time              `json:"timestamp"`
	Metadata  map[string]interface{} `json:"metadata"`
}

type Trajectory struct {
	Example       core.Example
	Prediction    map[string]interface{}
	Score         float64
	Success       bool
	ProgramID     string // To track which program generated this
	ExecutionTime time.Duration
}

type WorkflowStep struct {
	ToolName   string                 `json:"tool_name"`
	Parameters map[string]interface{} `json:"parameters"`
	Result     core.ToolResult        `json:"result"`
	Order      int                    `json:"order"`
	Duration   time.Duration          `json:"duration"`
}