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 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 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 EmbeddingService interface {
	GenerateEmbedding(ctx context.Context, text string) ([]float64, error)
	CosineSimilarity(vec1, vec2 []float64) float64
}

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 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 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 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 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 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 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"`
}