runtime

type AcpEventDone struct {
	StopReason string // Reason for completion
}

type AcpEventError struct {
	Message   string // Error message
	Code      string // Error code
	Retryable bool   // Whether the error is retryable
}

type AcpEventStatus struct {
	Text string // Status message
}

type AcpEventTextDelta struct {
	Text   string // Generated text content
	Stream string // "output" or "thought"
}

type AcpEventToolCall struct {
	ID        string                 // Tool call ID
	Name      string                 // Tool name/function name
	Arguments map[string]interface{} // Tool arguments
	Text      string                 // Tool call description (legacy)
	Status    string                 // Tool status: "pending", "in_progress", "completed", "failed"
}

type AcpRuntime interface {
	// EnsureSession creates or retrieves an ACP session.
	// Returns a handle that identifies the session for subsequent operations.
	EnsureSession(ctx context.Context, input AcpRuntimeEnsureInput) (AcpRuntimeHandle, error)

	// RunTurn executes a single turn in an ACP session.
	// Returns a channel of events that will be closed when the turn completes.
	RunTurn(ctx context.Context, input AcpRuntimeTurnInput) (<-chan AcpRuntimeEvent, error)

	// GetCapabilities returns the capabilities of the runtime.
	// If the runtime doesn't support capability queries, it may return static capabilities.
	GetCapabilities(ctx context.Context, handle *AcpRuntimeHandle) (AcpRuntimeCapabilities, error)

	// GetStatus returns the current status of an ACP session.
	// Optional - runtimes that don't support status queries may return nil.
	GetStatus(ctx context.Context, handle AcpRuntimeHandle) (*AcpRuntimeStatus, error)

	// SetMode changes the runtime mode for an ACP session.
	// Optional - runtimes that don't support mode changes may return an error.
	SetMode(ctx context.Context, handle AcpRuntimeHandle, mode string) error

	// SetConfigOption sets a configuration option on an ACP session.
	// Optional - runtimes that don't support config options may return an error.
	SetConfigOption(ctx context.Context, handle AcpRuntimeHandle, key, value string) error

	// Doctor performs a health check on the runtime backend.
	// Optional - runtimes without health checks may return a static report.
	Doctor(ctx context.Context) (AcpRuntimeDoctorReport, error)

	// Cancel cancels an active turn in an ACP session.
	Cancel(ctx context.Context, handle AcpRuntimeHandle, reason string) error

	// Close closes an ACP session and releases resources.
	Close(ctx context.Context, handle AcpRuntimeHandle, reason string) error
}

type AcpRuntimeBackend struct {
	// ID is the unique identifier for this backend
	ID string

	// Runtime is the ACP runtime implementation
	Runtime AcpRuntime

	// Healthy is an optional function to check if the backend is healthy.
	// If nil, the backend is always considered healthy.
	Healthy func() bool
}

type AcpRuntimeBackendStats struct {
	Total      int // Total number of registered backends
	Healthy    int // Number of healthy backends
	Unhealthy  int // Number of unhealthy backends
	BackendIDs []string
}

type AcpRuntimeCapabilities struct {
	// Controls lists the control operations supported by this runtime
	Controls []AcpRuntimeControl

	// ConfigOptionKeys are optional backend-advertised config keys for session/set_config_option.
	// Empty/nil means backend accepts keys but did not advertise a strict list.
	ConfigOptionKeys []string
}

type AcpRuntimeControl string

type AcpRuntimeDoctorReport struct {
	// Ok indicates if the runtime is healthy
	Ok bool

	// Code is an error code if Ok is false
	Code string

	// Message describes the health status
	Message string

	// InstallCommand is a suggested installation command if the runtime is missing
	InstallCommand string

	// Details contains additional diagnostic information
	Details []string
}

type AcpRuntimeEnsureInput struct {
	// SessionKey is the goclaw session key
	SessionKey string

	// Agent is the agent ID to use for this session
	Agent string

	// Mode is the session lifecycle mode
	Mode AcpRuntimeSessionMode

	// Cwd is the working directory for the session
	Cwd string

	// Env contains environment variables to pass to the runtime
	Env map[string]string
}

type AcpRuntimeError struct {
	Code    string // Machine-readable error code
	Message string // Human-readable error message
	Err     error  // Underlying error, if any
}

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

type AcpRuntimeHandle struct {
	// SessionKey is the goclaw session key for this ACP session
	SessionKey string

	// Backend is the identifier of the runtime backend (e.g., "acpx", "acp-go-sdk")
	Backend string

	// RuntimeSessionName is the session name assigned by the runtime
	RuntimeSessionName string

	// Cwd is the effective working directory for this ACP session
	Cwd string

	// AcpxRecordId is the backend-local record identifier (for acpx backend)
	AcpxRecordId string

	// BackendSessionId is the backend-level ACP session identifier
	BackendSessionId string

	// AgentSessionId is the upstream harness/agent session identifier
	AgentSessionId string
}

type AcpRuntimePromptMode string

type AcpRuntimeSessionMode string

type AcpRuntimeStatus struct {
	// Summary is a human-readable status summary
	Summary string

	// AcpxRecordId is the backend-local record identifier
	AcpxRecordId string

	// BackendSessionId is the backend-level ACP session identifier
	BackendSessionId string

	// AgentSessionId is the upstream harness session identifier
	AgentSessionId string

	// Details contains additional backend-specific status details
	Details map[string]any
}

type AcpRuntimeTurnInput struct {
	// Handle identifies the ACP session
	Handle AcpRuntimeHandle

	// Text is the prompt text to send
	Text string

	// Mode is the prompt delivery mode
	Mode AcpRuntimePromptMode

	// RequestID uniquely identifies this turn request
	RequestID string

	// Signal allows canceling the turn
	Signal context.CancelFunc
}