planning

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

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

type BackwardChainingStrategy struct{}

type DecompositionStrategy struct{}

type DefaultOptimizer struct{}

type DependencyValidator struct{}

type ExecutionState struct {
	Plan        *Plan
	Status      PlanStatus
	StartTime   time.Time
	EndTime     time.Time
	StepResults map[string]*StepResult
	CurrentStep string
	PauseChan   chan struct{}
	CancelChan  chan struct{}
	// contains filtered or unexported fields
}

type ExecutorOption func(*AgentExecutor)

type ExpectedOutcome struct {
	Description string                 `json:"description"`
	Criteria    []string               `json:"criteria"`
	Metrics     map[string]interface{} `json:"metrics,omitempty"`
}

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

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

type MockLLMClient struct {
	CompleteFn    func(ctx context.Context, req *llm.CompletionRequest) (*llm.CompletionResponse, error)
	ChatFn        func(ctx context.Context, messages []llm.Message) (*llm.CompletionResponse, error)
	ProviderFn    func() constants.Provider
	IsAvailableFn func() bool
}

type MockLogger struct{}

type MockMemoryManager struct {
	AddConversationFn        func(ctx context.Context, conv *interfaces.Conversation) error
	GetConversationHistoryFn func(ctx context.Context, sessionID string, limit int) ([]*interfaces.Conversation, error)
	ClearConversationFn      func(ctx context.Context, sessionID string) error
	AddCaseFn                func(ctx context.Context, caseMemory *interfaces.Case) error
	SearchSimilarCasesFn     func(ctx context.Context, query string, limit int) ([]*interfaces.Case, error)
	GetCaseFn                func(ctx context.Context, caseID string) (*interfaces.Case, error)
	UpdateCaseFn             func(ctx context.Context, caseMemory *interfaces.Case) error
	DeleteCaseFn             func(ctx context.Context, caseID string) error
	StoreFn                  func(ctx context.Context, key string, value interface{}) error
	RetrieveFn               func(ctx context.Context, key string) (interface{}, error)
	DeleteFn                 func(ctx context.Context, key string) error
}

type NoOpStrategy struct{}

type OptimizationAgent struct {
	*core.BaseAgent
	// contains filtered or unexported fields
}

type Phase struct {
	Name        string
	Description string
}

type Plan struct {
	ID           string                 `json:"id"`
	Goal         string                 `json:"goal"`
	Strategy     string                 `json:"strategy"`
	Steps        []*Step                `json:"steps"`
	Dependencies map[string][]string    `json:"dependencies"` // step ID -> dependent step IDs
	Context      map[string]interface{} `json:"context"`
	CreatedAt    time.Time              `json:"created_at"`
	UpdatedAt    time.Time              `json:"updated_at"`
	Status       PlanStatus             `json:"status"`
	Metrics      *PlanMetrics           `json:"metrics,omitempty"`
}

type PlanConstraints struct {
	MaxSteps       int                    `json:"max_steps,omitempty"`
	MaxDuration    time.Duration          `json:"max_duration,omitempty"`
	RequiredSteps  []string               `json:"required_steps,omitempty"`
	ForbiddenSteps []string               `json:"forbidden_steps,omitempty"`
	Resources      map[string]interface{} `json:"resources,omitempty"`
	Priority       int                    `json:"priority,omitempty"`
}

type PlanExecutor interface {
	// Execute executes a plan
	Execute(ctx context.Context, plan *Plan) (*PlanResult, error)

	// ExecuteStep executes a single step
	ExecuteStep(ctx context.Context, step *Step) (*StepResult, error)

	// Pause pauses plan execution
	Pause(planID string) error

	// Resume resumes plan execution
	Resume(planID string) error

	// Cancel cancels plan execution
	Cancel(planID string) error

	// GetStatus gets the current status of a plan
	GetStatus(planID string) (*PlanStatus, error)
}

type PlanMetrics struct {
	TotalSteps     int           `json:"total_steps"`
	CompletedSteps int           `json:"completed_steps"`
	FailedSteps    int           `json:"failed_steps"`
	SkippedSteps   int           `json:"skipped_steps"`
	TotalDuration  time.Duration `json:"total_duration"`
	StartTime      time.Time     `json:"start_time"`
	EndTime        time.Time     `json:"end_time,omitempty"`
	SuccessRate    float64       `json:"success_rate"`
}

type PlanOptimizer interface {
	// Optimize optimizes a plan
	Optimize(ctx context.Context, plan *Plan) (*Plan, error)
}

type PlanResult struct {
	PlanID         string                 `json:"plan_id"`
	Success        bool                   `json:"success"`
	CompletedSteps int                    `json:"completed_steps"`
	FailedSteps    int                    `json:"failed_steps"`
	SkippedSteps   int                    `json:"skipped_steps"`
	TotalDuration  time.Duration          `json:"total_duration"`
	StepResults    map[string]*StepResult `json:"step_results"`
	Error          error                  `json:"error,omitempty"`
	Metadata       map[string]interface{} `json:"metadata,omitempty"`
}

type PlanStatus string

type PlanStrategy interface {
	// Apply applies the strategy to a plan
	Apply(ctx context.Context, plan *Plan, constraints PlanConstraints) (*Plan, error)

	// Name returns the strategy name
	Name() string
}

type PlanValidator interface {
	// Validate checks if a plan is valid
	Validate(ctx context.Context, plan *Plan) (bool, []string, error)
}

type Planner interface {
	// CreatePlan creates a plan for achieving a goal
	CreatePlan(ctx context.Context, goal string, constraints PlanConstraints) (*Plan, error)

	// RefinePlan refines an existing plan based on feedback
	RefinePlan(ctx context.Context, plan *Plan, feedback string) (*Plan, error)

	// DecomposePlan breaks down a plan into more detailed steps
	DecomposePlan(ctx context.Context, plan *Plan, step *Step) ([]*Step, error)

	// OptimizePlan optimizes a plan for efficiency
	OptimizePlan(ctx context.Context, plan *Plan) (*Plan, error)

	// ValidatePlan validates that a plan is feasible
	ValidatePlan(ctx context.Context, plan *Plan) (bool, []string, error)
}

type PlannerOption func(*SmartPlanner)

type PlanningAgent struct {
	*core.BaseAgent
	// contains filtered or unexported fields
}

type ResourceValidator struct{}

type RetryPolicy struct {
	MaxRetries    int           `json:"max_retries"`
	RetryDelay    time.Duration `json:"retry_delay"`
	BackoffFactor float64       `json:"backoff_factor"`
}

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

type Step struct {
	ID                string                 `json:"id"`
	Name              string                 `json:"name"`
	Description       string                 `json:"description"`
	Type              StepType               `json:"type"`
	Agent             string                 `json:"agent,omitempty"` // Agent to execute this step
	Parameters        map[string]interface{} `json:"parameters,omitempty"`
	Expected          *ExpectedOutcome       `json:"expected,omitempty"`
	Priority          int                    `json:"priority"`
	EstimatedDuration time.Duration          `json:"estimated_duration,omitempty"`
	Status            StepStatus             `json:"status"`
	Result            *StepResult            `json:"result,omitempty"`
}

type StepResult struct {
	Success   bool                   `json:"success"`
	Output    interface{}            `json:"output"`
	Error     string                 `json:"error,omitempty"`
	Duration  time.Duration          `json:"duration"`
	Timestamp time.Time              `json:"timestamp"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

type StepStatus string

type StepType string

type StrategyAgent struct {
	*core.BaseAgent
	// contains filtered or unexported fields
}

type TaskDecompositionAgent struct {
	*core.BaseAgent
	// contains filtered or unexported fields
}

type TimeValidator struct{}

type ValidationAgent struct {
	*core.BaseAgent
	// contains filtered or unexported fields
}