agentboot

type Agent interface {
	Execute(ctx context.Context, prompt string, opts ExecutionOptions) (ExecutionHandle, error)
	IsAvailable() bool
	Type() AgentType
	SetDefaultFormat(format OutputFormat)
	GetDefaultFormat() OutputFormat
}

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

type AgentDriver interface {
	// Prepare returns a LaunchSpec describing how to start the agent.
	// The spec is consumed by a Runner; the Driver itself does not start anything.
	Prepare(ctx context.Context, prompt string, opts ExecutionOptions) (*LaunchSpec, error)

	// IsAvailable reports whether the agent binary is present and usable.
	IsAvailable() bool

	// Type returns the agent type this driver handles.
	Type() AgentType
}

type AgentMessage interface {
	// GetType returns the message type (one of EventType constants)
	GetType() string
	// GetTimestamp returns when the message was created
	GetTimestamp() time.Time
	// GetSessionID returns the session ID if available
	GetSessionID() string
	// GetAgentType returns the source agent type
	GetAgentType() AgentType
	// GetRawData returns the raw message data as a map
	GetRawData() map[string]interface{}
	// ToEvent converts the message to an Event
	ToEvent() Event
}

type AgentTransport interface {
	// Classify reports the kind of the event. For control events it also
	// returns the parsed StreamEvent (ApprovalRequestEvent or
	// AskRequestEvent) ready to emit on the handle.
	//
	// The execution-context fields (sessionID, chatID, platform, botUUID)
	// previously set via SetExecutionContext are stamped onto the StreamEvent
	// during Classify.
	Classify(ev common.Event) (kind EventKind, parsed StreamEvent)

	// AccumulateMessage feeds the event to the per-agent message accumulator
	// and returns 0+ rich message values to emit as [MessageEvent.Raw]. The
	// concrete type of each value is agent-specific (e.g.
	// *claude.AssistantMessage). The runner does not introspect them.
	AccumulateMessage(ev common.Event) []any

	// EncodeControlResponse converts a [ControlResponse] into the wire value
	// sent to the agent process's stdin via [protocol.Encoder].
	//
	// originalInput is the Input field of the corresponding
	// ApprovalRequestEvent / AskRequestEvent; some agents (e.g. claude) use
	// it when constructing the "allow" reply if the response did not supply
	// an UpdatedInput.
	EncodeControlResponse(reqID string, resp ControlResponse, originalInput map[string]any) any

	// SetExecutionContext injects per-execution routing metadata that is
	// stamped onto Approval/Ask events during Classify.
	SetExecutionContext(sessionID, chatID, platform, botUUID string)
}

type AgentType string

type ApprovalHandler interface {
	OnApproval(ctx context.Context, req PermissionRequest) (PermissionResult, error)
}

type ApprovalRequestEvent struct {
	ID        string
	AgentType AgentType
	ToolName  string
	Input     map[string]any
	Reason    string

	SessionID string
	ChatID    string
	Platform  string
	BotUUID   string
}

type ApprovalResponse struct {
	Approved     bool
	UpdatedInput map[string]any
	Reason       string
}

type AskHandler interface {
	OnAsk(ctx context.Context, req AskRequest) (AskResult, error)
}

type AskRequest struct {
	ID   string `json:"id"`
	Type string `json:"type"` // "permission", "question", "confirmation", "text_input"

	Platform  string `json:"platform"`
	ChatID    string `json:"chat_id"`
	BotUUID   string `json:"bot_uuid"`
	SessionID string `json:"session_id,omitempty"`

	AgentType AgentType              `json:"agent_type"`
	ToolName  string                 `json:"tool_name,omitempty"`
	Input     map[string]interface{} `json:"input,omitempty"`
	Message   string                 `json:"message,omitempty"`
	CallID    string                 `json:"call_id,omitempty"`
	Reason    string                 `json:"reason,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

type AskRequestEvent struct {
	ID        string
	AgentType AgentType
	Type      string
	ToolName  string
	Input     map[string]any
	CallID    string
	Message   string
	Reason    string

	SessionID string
	ChatID    string
	Platform  string
	BotUUID   string
}

type AskResponse struct {
	Approved     bool
	UpdatedInput map[string]any
	Reason       string
	Response     string
	Selection    map[string]any
}

type AskResult struct {
	ID           string                 `json:"id"`
	Approved     bool                   `json:"approved,omitempty"`
	Response     string                 `json:"response,omitempty"`
	Selection    map[string]interface{} `json:"selection,omitempty"`
	Remember     bool                   `json:"remember,omitempty"`
	Reason       string                 `json:"reason,omitempty"`
	UpdatedInput map[string]interface{} `json:"updated_input,omitempty"`
}

type AssistantMessage struct {
	BaseMessage
	Text    string                 `json:"text,omitempty"`
	Content []ContentBlock         `json:"content,omitempty"`
	Extra   map[string]interface{} `json:"extra,omitempty"`
}

type BaseMessage struct {
	Type      string    `json:"type"`
	AgentType AgentType `json:"agent_type"`
	SessionID string    `json:"session_id,omitempty"`
	Timestamp time.Time `json:"timestamp"`
}

type CompletionCallback interface {
	OnComplete(result *CompletionResult)
}

type CompletionResult struct {
	Success     bool
	DurationMS  int64
	SessionID   string
	Error       string
	ExtraFields map[string]any
}

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

type Config struct {
	DefaultAgent            AgentType     `json:"default_agent"`
	DefaultFormat           OutputFormat  `json:"default_format"`
	EnableStreamJSON        bool          `json:"enable_stream_json"`
	StreamBufferSize        int           `json:"stream_buffer_size"`
	DefaultExecutionTimeout time.Duration `json:"default_execution_timeout"`

	// Session configuration
	ClaudeProjectsDir string `json:"claude_projects_dir,omitempty"` // Path to Claude projects directory
}

type ContentBlock struct {
	Type string `json:"type"`
	Text string `json:"text,omitempty"`
	// For tool_use
	ToolID   string                 `json:"tool_id,omitempty"`
	ToolName string                 `json:"tool_name,omitempty"`
	Input    map[string]interface{} `json:"input,omitempty"`
}

type ControlResponse interface {
	// contains filtered or unexported methods
}

type ErrorEvent struct {
	Err error
}

type Event = common.Event

type EventKind int

type ExecutionHandle interface {
	Events() <-chan StreamEvent
	Respond(reqID string, resp ControlResponse) error
	Wait() (*Result, error)
	Cancel()
}

type ExecutionOptions struct {
	ProjectPath  string
	OutputFormat OutputFormat
	Timeout      time.Duration
	Env          []string
	// SessionID is the session ID to use or resume
	// If Resume is true, --resume <session_id> is used to continue an existing session
	// If Resume is false, --session-id <session_id> is used to create a new session with specific ID
	SessionID string
	// Resume indicates whether to resume an existing session (true) or create a new one (false)
	Resume bool
	// ChatID is the chat ID for permission requests (used by mock agent)
	ChatID string
	// Platform is the platform for permission requests (used by mock agent)
	Platform string
	// BotUUID is the bot UUID for permission callbacks
	BotUUID string

	// Model selection (per-execution override)
	Model         string
	FallbackModel string

	// Execution control
	MaxTurns int

	// Tool filtering (per-execution override)
	AllowedTools    []string
	DisallowedTools []string

	// MCP servers (per-execution override)
	MCPServers      map[string]interface{}
	StrictMcpConfig bool

	// System prompts (per-execution override)
	CustomSystemPrompt string
	AppendSystemPrompt string

	// Permission mode (per-execution override)
	PermissionMode string

	// Settings path (per-execution override)
	SettingsPath string

	// PermissionPromptTool specifies the tool for permission prompts (e.g., "stdio")
	// When set to "stdio", permission requests are sent via stdin/stdout for callback handling
	PermissionPromptTool string

	// Store, if set, receives session lifecycle events driven by the runner.
	// When non-nil and SessionID is non-empty the runner calls:
	//   SetRunning  — after the process starts successfully
	//   SetFailed   — if the process fails to start or Wait returns an error
	//   SetCompleted — if Wait returns without error
	Store agentsession.Store
}

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

type InitMessage struct {
	BaseMessage
	MaxIterations int `json:"max_iterations,omitempty"`
}

type LaunchSpec struct {
	// Command is the binary and arguments (e.g. ["claude", "--output-format", "stream-json", ...])
	Command []string

	// Env is the process environment. nil inherits the current process environment.
	Env []string

	// WorkDir is the working directory for the agent process. Empty means current directory.
	WorkDir string

	// InitialInput is an optional channel that feeds initial messages into the agent's stdin.
	// Close the channel to signal EOF. May be nil.
	InitialInput <-chan any
}

type MessageEvent struct {
	Raw any
}

type MessageHandler interface {
	OnMessage(msg interface{}) error
	OnError(err error)
	OnComplete(result *CompletionResult)
	OnApproval(ctx context.Context, req PermissionRequest) (PermissionResult, error)
	OnAsk(ctx context.Context, req AskRequest) (AskResult, error)
}

type MessageSink func(any)

type MessageStreamer interface {
	OnMessage(msg interface{}) error
	OnError(err error)
}

type OutputFormat string

type PermissionConfig struct {
	DefaultMode       PermissionMode `json:"default_mode"`
	Timeout           time.Duration  `json:"timeout"`
	EnableWhitelist   bool           `json:"enable_whitelist"`
	Whitelist         []string       `json:"whitelist"`
	Blacklist         []string       `json:"blacklist"`
	RememberDecisions bool           `json:"remember_decisions"`
	DecisionDuration  time.Duration  `json:"decision_duration"`
}

type PermissionMode string

type PermissionRequest struct {
	RequestID string                 `json:"request_id"`
	AgentType AgentType              `json:"agent_type"`
	ToolName  string                 `json:"tool_name"`
	Input     map[string]interface{} `json:"input"`
	Reason    string                 `json:"reason,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
	SessionID string                 `json:"session_id,omitempty"`
	BotUUID   string                 `json:"bot_uuid,omitempty"` // Bot UUID for routing permission requests
	ChatID    string                 `json:"chat_id,omitempty"`  // Chat ID for routing
	Platform  string                 `json:"platform,omitempty"` // Platform for routing
}

type PermissionRequestMessage struct {
	BaseMessage
	RequestID string                 `json:"request_id"`
	ToolName  string                 `json:"tool_name"`
	Input     map[string]interface{} `json:"input"`
	Reason    string                 `json:"reason,omitempty"`
	Step      int                    `json:"step,omitempty"`
	Total     int                    `json:"total,omitempty"`
}

type PermissionResponse struct {
	RequestID string    `json:"request_id"`
	Approved  bool      `json:"approved"`
	Reason    string    `json:"reason,omitempty"`
	Timestamp time.Time `json:"timestamp"`
}

type PermissionResult struct {
	Approved     bool                   `json:"approved"`
	Reason       string                 `json:"reason,omitempty"`
	UpdatedInput map[string]interface{} `json:"updated_input,omitempty"`
	Remember     bool                   `json:"remember,omitempty"`
}

type PermissionResultMessage struct {
	BaseMessage
	RequestID string `json:"request_id"`
	Approved  bool   `json:"approved"`
	Reason    string `json:"reason,omitempty"`
	Remember  bool   `json:"remember,omitempty"`
}

type Prompter interface {
	OnApproval(ctx context.Context, req PermissionRequest) (PermissionResult, error)
	OnAsk(ctx context.Context, req AskRequest) (AskResult, error)
}

type Result struct {
	Output   string // Agent output (text mode)
	ExitCode int    // Process exit code
	Error    string // Error message if failed
	Duration time.Duration
	Format   OutputFormat           // Output format used
	Events   []Event                // Stream events (stream-json mode)
	Metadata map[string]interface{} // Additional metadata
}

type ResultMessage struct {
	BaseMessage
	Status   string  `json:"status"` // "success", "error", "cancelled", "permission_denied"
	Message  string  `json:"message,omitempty"`
	CostUSD  float64 `json:"cost_usd,omitempty"`
	Duration int64   `json:"duration_ms,omitempty"`
	Steps    int     `json:"steps_completed,omitempty"`
	IsError  bool    `json:"is_error,omitempty"`
	ErrorMsg string  `json:"error,omitempty"`
}

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

type StreamDeltaMessage struct {
	BaseMessage
	Delta string `json:"delta"`
}

type StreamEvent interface {
	// contains filtered or unexported methods
}