patterns

type AgentClassification struct {
	AgentName  string
	Confidence float64
	Priority   int
}

type AgentExecutor func(ctx context.Context, agentName, input string) (string, error)

type AggregationConfig struct {
	Method           AggregationMethod
	Timeout          time.Duration
	ConcurrencyLimit int
	Scorer           Scorer     // For AggregationBest
	Summarizer       Summarizer // For AggregationSummarize
	Delimiter        string     // For AggregationMerge
	MinimumResponses int        // Minimum responses required
}

type AggregationMethod string

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

type AggregationResult struct {
	IndividualResults []ExecutionResult
	AggregatedOutput  string
	Method            AggregationMethod
	Scores            map[string]float64 // Agent scores if using scorer
}

type AggregationStrategy string

type ChainOfThoughtConfig struct {
	ReasoningAgent string        // Agent for reasoning steps
	ExecutionAgent string        // Agent for final execution
	MaxSteps       int           // Maximum reasoning steps
	Timeout        time.Duration // Timeout per step
}

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

type ChainOfThoughtResult struct {
	Steps       []ThoughtStep
	FinalAnswer string
	Error       error
}

type ClassificationResult struct {
	ClassifiedAgent string
	Confidence      float64
	ExecutionResult
}

type Classifier func(ctx context.Context, input string) (agentName string, confidence float64, err error)

type ClassifierConfig struct {
	Classifier          Classifier    // Function to classify input
	ConfidenceThreshold float64       // Minimum confidence to proceed
	DefaultAgent        string        // Agent to use if classification fails
	Timeout             time.Duration // Timeout per execution
}

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

type ErrorStrategy string

type ExecutionResult struct {
	AgentName string
	Output    string
	Error     error
	Duration  int64 // milliseconds
}

type MapReduceConfig struct {
	Splitter         Splitter      // Function to split input
	Reducer          Reducer       // Function to reduce results
	ConcurrencyLimit int           // Max concurrent map operations
	Timeout          time.Duration // Timeout per map operation
}

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

type MultiClassifier func(ctx context.Context, input string) (agents []AgentClassification, err error)

type MultiClassifierConfig struct {
	Classifier          MultiClassifier
	ConfidenceThreshold float64
	MaxAgents           int           // Maximum agents to execute
	Timeout             time.Duration // Timeout per agent
	Parallel            bool          // Execute agents in parallel
}

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

type ParallelConfig struct {
	ConcurrencyLimit int                 // Max concurrent executions (0 = unlimited)
	Timeout          time.Duration       // Timeout per agent
	Aggregation      AggregationStrategy // How to aggregate results
}

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

type Plan struct {
	Steps       []PlanStep
	Description string
	Metadata    map[string]string
}

type PlanStep struct {
	ID           string            // Unique step identifier
	AgentName    string            // Agent to execute
	Input        string            // Input for this step
	Dependencies []string          // IDs of steps that must complete first
	Metadata     map[string]string // Optional metadata
}

type PlanValidator func(plan *Plan) error

type Planner func(ctx context.Context, input string) (*Plan, error)

type PlanningConfig struct {
	Planner           Planner
	Validator         PlanValidator
	Timeout           time.Duration // Timeout per step
	MaxSteps          int           // Maximum steps allowed
	ContinueOnError   bool          // Continue executing if a step fails
	ReplanOnFailure   bool          // Attempt to create new plan on failure
	MaxReplanAttempts int
}

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

type PlanningResult struct {
	Plan          *Plan
	StepResults   []StepResult
	FinalOutput   string
	ReplanCount   int
	TotalDuration int64
}

type QualityAssessor func(ctx context.Context, iteration int, output string) (score float64, continueIterating bool)

type Reducer func(results []ExecutionResult) (string, error)

type ReflectionConfig struct {
	MaxIterations      int             // Maximum iterations
	Timeout            time.Duration   // Timeout per iteration
	QualityThreshold   float64         // Stop when quality reaches this level
	ConvergenceWindow  int             // Number of iterations to check for convergence
	ConvergenceEpsilon float64         // Minimum improvement to not be considered converged
	QualityAssessor    QualityAssessor // Function to assess quality
}

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

type ReflectionResult struct {
	Iteration int
	Output    string
	Score     float64
	Error     error
	Duration  int64
}

type Scorer func(ctx context.Context, agentName, output string) float64

type SequentialConfig struct {
	ErrorStrategy ErrorStrategy       // How to handle errors
	Timeout       time.Duration       // Timeout per agent
	BranchFn      func(string) string // Optional: determine next agent based on output
}

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

type Splitter func(input string) []string

type StepResult struct {
	StepID    string
	AgentName string
	Output    string
	Error     error
	Duration  int64
	Skipped   bool
}

type Summarizer func(ctx context.Context, outputs []string) (string, error)

type ThoughtStep struct {
	Step     int
	Thought  string
	Action   string
	Result   string
	Error    error
	Duration int64
}