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 AgentEvent struct {
	Type      string
	Data      map[string]any
	Timestamp time.Time
}

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 LLMRequest struct {
	Prompt       string
	Content      []core.ContentBlock
	Functions    []map[string]interface{}
	ChatMessages []core.ChatMessage
	Options      []core.GenerateOption
}

type LLMResult struct {
	TextResponse     *core.LLMResponse
	FunctionResponse map[string]interface{}
	ModuleResponse   map[string]any
}

type LoopAction struct {
	ToolCalls  []core.ToolCall
	Thought    string
	Result     map[string]any
	StopReason string
}

type LoopConfig struct {
	LLM                core.LLM
	Tools              core.ToolRegistry
	Strategy           LoopStrategy
	MaxIterations      int
	TransformContext   func(ctx context.Context, messages []Message) ([]Message, error)
	OnEvent            func(AgentEvent)
	GenerateOpts       []core.GenerateOption
	ModuleOpts         []core.Option
	ParallelTools      bool
	MaxToolConcurrency int
	ToolTimeout        time.Duration
}

type LoopEnv struct {
	LLM          core.LLM
	Tools        core.ToolRegistry
	GenerateOpts []core.GenerateOption
	ModuleOpts   []core.Option
}

type LoopResult struct {
	Messages []Message
	Output   map[string]any
	// StopReason is one of the StopReason* constants.
	StopReason string
	Iterations int
	Usage      *core.TokenInfo
}

type LoopStrategy interface {
	PrepareRequest(ctx context.Context, messages []Message, tools []core.Tool) (*LLMRequest, error)
	CallLLM(ctx context.Context, env *LoopEnv, req *LLMRequest) (*LLMResult, error)
	ParseResponse(ctx context.Context, response *LLMResult) (*LoopAction, error)
	ShouldContinue(ctx context.Context, action *LoopAction, iteration int) bool
	ToolUsePolicy() string
}

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 Message struct {
	ID         string              `json:"id"`
	Role       MessageRole         `json:"role"`
	Content    []core.ContentBlock `json:"content"`
	ToolCalls  []core.ToolCall     `json:"tool_calls,omitempty"`
	ToolResult *MessageToolResult  `json:"tool_result,omitempty"`
	Metadata   map[string]any      `json:"metadata,omitempty"`
}

type MessageRole string

type MessageToolResult struct {
	ToolCallID string              `json:"tool_call_id"`
	Name       string              `json:"name"`
	Content    []core.ContentBlock `json:"content"`
	IsError    bool                `json:"is_error,omitempty"`
	Raw        map[string]any      `json:"raw,omitempty"`
}

type NeedsLLM interface {
	SetLLM(llm core.LLM)
}

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 SignatureStrategy interface {
	LoopStrategy
	Signature() core.Signature
	SetSignature(sig core.Signature)
	Demos() []core.Example
	SetDemos(demos []core.Example)
}

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
}