web

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

type EngineConfig struct {
	TaskID         string
	Pwd            string
	Mode           string
	ProviderName   string
	ModelName      string
	Agent          *adk.ChatModelAgent
	Env            *tools.Env
	TodoStore      *tools.TodoStore
	Recorder       *session.Recorder
	TokenUsage     *model.TokenUsage
	ApprovalState  *runner.ApprovalState
	Handler        *handler.WebHandler
	EventHandler   handler.AgentEventHandler
	BreakdownFn    func() usage.ContextBreakdown
	CreateAgent    func(providerName, modelName string) (*adk.ChatModelAgent, error)
	RebuildForMode func(planMode bool) (*adk.ChatModelAgent, error)
}

type Server struct {
	// Engine is the bootstrap/active task's run state. Its fields (agent, history,
	// recorder, pwd, env, tokenUsage, approvalState, handler, …) are PROMOTED onto
	// Server, so existing s.<field> accesses resolve to s.Engine.<field> while
	// there is a single active task. Per-task routing (Server.tasks) supersedes
	// this promotion in a later increment. Always non-nil after NewServer.
	*Engine
	// contains filtered or unexported fields
}

type ServerConfig struct {
	Port                int
	Host                string
	OpenBrowser         bool
	Pwd                 string
	Version             string
	Agent               *adk.ChatModelAgent
	CreateAgent         func(providerName, modelName string) (*adk.ChatModelAgent, error)
	RebuildForMode      func(planMode bool) (*adk.ChatModelAgent, error)
	NewEngine           func(taskID, pwd, mode string) (*EngineConfig, error)                                             // factory for new concurrent task engines (local)
	NewRemoteEngine     func(taskID string, executor tools.RemoteExecutor, remotePwd, mode string) (*EngineConfig, error) // remote sibling of NewEngine (SSH or Docker)
	NewAutomationEngine func(taskID, pwd, mode string) (*EngineConfig, error)                                             // headless sibling of NewEngine for automation runs (drops interactive tools)
	InitialMode         string                                                                                            // unified startup mode string ("approval"/"plan"/"full_access")
	TodoStore           *tools.TodoStore
	Recorder            *session.Recorder
	Tracer              *telemetry.LangfuseTracer
	Env                 *tools.Env
	ProviderName        string
	ModelName           string
	Config              *config.Config
	Registry            *model.ModelRegistry
	ApprovalState       *runner.ApprovalState
	SkillLoader         *skills.Loader
	ReloadMCP           func(servers map[string]*config.MCPServer) ([]tools.MCPStatus, error) // optional: hot-reload MCP tools
	InitialMCPStatuses  []tools.MCPStatus                                                     // statuses from the startup MCP load
	WechatClient        channel.Channel                                                       // optional WeChat channel
	WebHandler          *handler.WebHandler                                                   // optional: pre-created handler for sharing with tools
	EventHandler        handler.AgentEventHandler                                             // optional: handler for runner (e.g. NotifyingHandler)
	NeedsSetup          bool                                                                  // true when no providers are configured (setup mode)
	TokenUsage          *model.TokenUsage                                                     // optional: shared token tracker (created when nil)
	ContextBreakdownFn  func() usage.ContextBreakdown                                         // optional: live per-task context breakdown
	Automations         *automation.Store                                                     // optional: automation store (nil in setup mode)
}

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

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

type WSEvent struct {
	Type string `json:"type"`
	// TaskID tags the event with the task (engine) it came from so the client can
	// route it to the right task view, and so the broker can deliver it only to
	// clients subscribed to that task. Empty for global/server-wide events
	// (mcp_changed, model_changed, pong, …), which every client receives.
	TaskID string `json:"task_id,omitempty"`
	Data   any    `json:"data,omitempty"`
}

type WSIncoming struct {
	Type string          `json:"type"`
	Data json.RawMessage `json:"data,omitempty"`
}