agents

type Agent interface {
	// Execute runs the agent's task with given input and returns output
	Execute(ctx context.Context, input map[string]interface{}) (map[string]interface{}, error)

	// GetCapabilities returns the tools/capabilities available to this agent
	GetCapabilities() []core.Tool

	// GetMemory returns the agent's memory store
	GetMemory() Memory
}

type AnalyzerConfig struct {
	// The base instruction for task analysis
	BaseInstruction string
	// Additional formatting instructions specific to the implementation
	FormatInstructions string
	// Any extra considerations for task analysis
	Considerations []string
}

type DefaultPlanCreator struct{}

type DefaultTaskParser struct{}

type DependencyPlanCreator struct {
	// Optional configuration for planning
	MaxTasksPerPhase int
}

type ErrorCode int

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

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

type InterceptableAgent interface {
	Agent

	// ExecuteWithInterceptors runs the agent's task with interceptor support
	ExecuteWithInterceptors(ctx context.Context, input map[string]interface{}, interceptors []core.AgentInterceptor) (map[string]interface{}, error)

	// SetInterceptors sets the default interceptors for this agent instance
	SetInterceptors(interceptors []core.AgentInterceptor)

	// GetInterceptors returns the current interceptors for this agent
	GetInterceptors() []core.AgentInterceptor

	// ClearInterceptors removes all interceptors from this agent
	ClearInterceptors()

	// GetAgentID returns the unique identifier for this agent instance
	GetAgentID() string

	// GetAgentType returns the category/type of this agent
	GetAgentType() string
}

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

type Memory interface {
	// Store saves a value with a given key
	Store(key string, value interface{}) error

	// Retrieve gets a value by key
	Retrieve(key string) (interface{}, error)

	// Delete removes a value by key
	Delete(key string) error

	// List returns all stored keys
	List() ([]string, error)

	// Clear removes all stored values
	Clear() error
}

type OrchestrationConfig struct {
	// MaxConcurrent controls maximum parallel task execution
	MaxConcurrent int

	// DefaultTimeout for task execution
	DefaultTimeout time.Duration

	// RetryConfig specifies retry behavior for failed tasks
	RetryConfig *RetryConfig

	// CustomProcessors maps processor types to implementations
	CustomProcessors map[string]TaskProcessor
	TaskParser       TaskParser
	PlanCreator      PlanCreator

	AnalyzerConfig AnalyzerConfig
	Options        core.Option
}

type OrchestratorResult struct {
	// CompletedTasks holds results from successful tasks
	CompletedTasks map[string]interface{}

	// FailedTasks contains tasks that could not be completed
	FailedTasks map[string]error

	// Analysis contains orchestrator's task breakdown reasoning
	Analysis string

	// Metadata holds additional orchestration information
	Metadata map[string]interface{}
	// contains filtered or unexported fields
}

type PlanCreator interface {
	// CreatePlan organizes tasks into execution phases
	CreatePlan(tasks []Task) ([][]Task, error)
}

type RetryConfig struct {
	MaxAttempts       int
	BackoffMultiplier float64
}

type Task struct {
	// ID uniquely identifies the task
	ID string

	// Type indicates the kind of task
	Type string

	// Metadata holds task-specific information
	Metadata map[string]interface{}

	// Dependencies lists task IDs that must complete before this task
	Dependencies []string

	// Priority indicates task importance (lower number = higher priority)
	Priority int

	// ProcessorType indicates which processor should handle this task
	ProcessorType string
}

type TaskParser interface {
	// Parse converts analyzer output into a slice of tasks
	Parse(analyzerOutput map[string]interface{}) ([]Task, error)
}

type TaskProcessor interface {
	// Process handles a single task execution
	Process(ctx context.Context, task Task, taskContext map[string]interface{}) (interface{}, error)
}

type XMLError struct {
	Code    ErrorCode
	Message string
	Details map[string]interface{}
}

type XMLMetadata struct {
	Items []XMLMetadataItem `xml:"item"`
}

type XMLMetadataItem struct {
	Key   string `xml:"key,attr"`
	Value string `xml:",chardata"`
}

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

type XMLTask struct {
	XMLName       xml.Name    `xml:"task"`
	ID            string      `xml:"id,attr"`
	Type          string      `xml:"type,attr"`      // Make sure this maps to the type attribute
	ProcessorType string      `xml:"processor,attr"` // Make sure this maps to the processor attribute
	Priority      int         `xml:"priority,attr"`
	Description   string      `xml:"description"`
	Dependencies  []string    `xml:"dependencies>dep"` // This maps to the <dependencies><dep>...</dep></dependencies> structure
	Metadata      XMLMetadata `xml:"metadata"`
}

type XMLTaskParser struct {
	// Configuration for XML parsing
	RequiredFields []string
}