agent

type Agent interface {
	// Name returns the unique identifier for this agent instance
	Name() string

	// Role returns the agent type/role (e.g., "react", "classifier", "planner")
	Role() string

	// Start runs the agent asynchronously (e.g., listening on inputs)
	// Returns when context is canceled or agent encounters fatal error
	Start(ctx context.Context) error

	// Execute performs synchronous request-response execution
	// Used by orchestration patterns for direct invocation
	Execute(ctx context.Context, input *Message) (*Message, error)

	// Stop gracefully shuts down the agent
	Stop(ctx context.Context) error

	// Ready returns true if the agent is ready to accept requests
	Ready() bool
}

type AgentDef struct {
	Name       string         `yaml:"name"`
	Role       string         `yaml:"role"`
	Interval   Duration       `yaml:"interval,omitempty"`
	Listen     string         `yaml:"listen,omitempty"`
	Inputs     []Input        `yaml:"inputs,omitempty"`
	Outputs    []Output       `yaml:"outputs,omitempty"`
	DependsOn  []string       `yaml:"depends_on,omitempty"` // Startup dependencies
	Model      string         `yaml:"model,omitempty"`
	Prompt     string         `yaml:"prompt,omitempty"`
	Tools      []Tool         `yaml:"tools,omitempty"`       // Deprecated: use MCPServers
	MCPServers []string       `yaml:"mcp_servers,omitempty"` // MCP server names
	Extra      map[string]any `yaml:",inline"`
}

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

type Duration struct{ time.Duration }

type FactoryFunc func(AgentDef, Runtime) (Agent, error)

type Input struct {
	Source string `yaml:"source"`
}

type Message struct{ *pb.Message }

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

type NotImplementedError struct {
	AgentName string
	Method    string
}

type Output struct {
	Target string `yaml:"target"`
	Addr   string `yaml:"addr,omitempty"`
}

type Registry interface {
	Register(role string, factory FactoryFunc)
	GetFactory(role string) (FactoryFunc, bool)
}

type Runtime interface {
	// Send sends a message to a target agent asynchronously
	Send(target string, msg *Message) error

	// Recv returns a channel to receive messages from a source agent
	Recv(source string) (<-chan *Message, error)

	// Call invokes an agent synchronously and waits for response
	// Used by orchestration patterns for request-response execution
	Call(ctx context.Context, target string, input *Message) (*Message, error)

	// CallParallel invokes multiple agents concurrently and returns all results
	// Execution continues even if some agents fail (partial results returned)
	CallParallel(ctx context.Context, targets []string, input *Message) (map[string]*Message, map[string]error)

	// Broadcast sends a message to all registered agents asynchronously
	Broadcast(msg *Message) error

	// Register registers an agent instance with the runtime
	Register(agent Agent) error

	// Unregister removes an agent from the runtime
	Unregister(name string) error

	// Get retrieves a registered agent by name
	Get(name string) (Agent, error)

	// List returns all registered agent names
	List() []string

	// Start starts the runtime (e.g., gRPC server for distributed mode)
	Start(ctx context.Context) error

	// Stop gracefully shuts down the runtime
	Stop(ctx context.Context) error
}

type RuntimeKey struct{}

type SendCall struct {
	Target  string
	Message *Message
}

type Tool struct {
	Name        string         `yaml:"name"`
	Description string         `yaml:"description"`
	InputSchema map[string]any `yaml:"input_schema"`
}