channels

type AgentEventReceiver interface {
	OnAgentEvent(sessionID string, ev event.AgentEvent)
}

type ApprovalReceiver interface {
	OnApprovalRequest(sessionID string, req gate.ApprovalRequest)
	OnApprovalResolved(sessionID, requestID, decision string)
}

type ApproveFn func(sessionID, requestID, decision, matchKey string) error

type ApproveFnSetter interface{ SetApproveFn(ApproveFn) }

type Channel interface {
	Name() string
	Start(ctx context.Context) error
	Stop()
	IsConfigured() bool
}

type ChannelEnsurer interface {
	EnsureChannel(channelType string) error
}

type ConfigSource interface {
	Hash() string
	Reload(ctx context.Context) error
}

type DBStore struct {
	Configs *configs.Service
	// contains filtered or unexported fields
}

type HTTPHandlerProvider interface {
	HTTPPath() string
	HTTPHandler() http.Handler
}

type HealthCheck struct {
	Name   string `json:"name"`
	OK     bool   `json:"ok"`
	Error  string `json:"error,omitempty"`
	Detail string `json:"detail,omitempty"`
}

type HealthChecker interface {
	HealthCheck() []HealthCheck
}

type IncomingMessage struct {
	SessionKey string   // routing key
	UserID     string   // sender identifier
	GroupIDs   []string // user groups (Slack only — access control)
	Text       string
	Source     string // "slack" | "ui" | "api"
	Raw        any    // original payload from the channel
}

type LookupItem struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

type LookupProvider interface {
	Lookup(source, query string) ([]LookupItem, error)
}

type MetaResult struct {
	// IsMeta is true when the text is a wick meta-command and should NOT
	// be forwarded to the agent subprocess.
	IsMeta bool
	// Cmd is the canonical command name (e.g. "dashboard", "reset").
	Cmd string
	// Arg is the optional argument following the command (e.g. agent name
	// after "agent <name>").
	Arg string
}

type MultiHTTPHandlerProvider interface {
	HTTPHandlers() map[string]http.Handler
}

type OutgoingMessage struct {
	SessionKey string
	Text       string
	// State carries the reaction lifecycle marker for Slack:
	// "queued" | "running" | "done" | "blocked" | "error"
	State string
}

type ProviderSwitchResult struct {
	Tag    string // provider type parsed from #tag, empty if no tag
	Rest   string // message text after the tag (may be empty)
	HasTag bool
}

type PublicURLSetter interface{ SetPublicURL(string) }

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

type RegistryApproveFn func(channelName, sessionID, requestID, decision, matchKey string) error

type RestConfigStore interface {
	LoadRest() (cfg agentconfig.RestChannelConfig, err error)
}

type SendFunc func(ctx context.Context, sessionID, agentName, source, role, text string) error

type SendFuncSetter interface{ SetSendFunc(SendFunc) }

type SessionChecker interface {
	SessionExists(sessionID string) bool
}

type SessionCheckerSetter interface{ SetSessionChecker(SessionChecker) }

type SessionStartHook func(sessionID, source, ctxText string)

type SessionStartHookSetter interface{ SetSessionStartHook(SessionStartHook) }

type SlackConfigStore interface {
	LoadSlack() (cfg agentconfig.SlackChannelConfig, pubURL string, err error)
}

type SwitchPool interface {
	Kill(sessionID, agentName string) error
	Send(ctx context.Context, sessionID, agentName, source, role, text string) error
}

type TelegramConfigStore interface {
	LoadTelegram() (cfg agentconfig.TelegramChannelConfig, err error)
}

type WorkflowActionProvider interface {
	WorkflowActionSpecs() []WorkflowActionSpec
	WorkflowSend(ctx context.Context, op string, args map[string]any) (any, error)
}

type WorkflowActionSpec struct {
	ID           string         `json:"id"`
	Description  string         `json:"description"`
	Destructive  bool           `json:"destructive,omitempty"`
	InputSchema  map[string]any `json:"input_schema"`
	OutputSchema map[string]any `json:"output_schema,omitempty"`
}

type WorkflowSessionOriginator interface {
	SupportsSession() bool
}

type WorkflowTriggerProvider interface {
	WorkflowTriggerSpecs() []WorkflowTriggerSpec
}

type WorkflowTriggerSpec struct {
	Type          string         `json:"type"` // always "channel"
	Events        []string       `json:"events"`
	Description   string         `json:"description"`
	MatchSchema   map[string]any `json:"match_schema,omitempty"`
	PayloadSchema map[string]any `json:"payload_schema,omitempty"`
}