compute

type Approval struct {
	ID        string    `json:"id"`
	CompitaID string    `json:"compita_id"`
	Tool      string    `json:"tool"`
	Summary   string    `json:"summary"`
	At        time.Time `json:"at"`
}

type ApprovalAsk struct {
	From      string         `json:"from"`
	Tool      string         `json:"tool"`
	Arguments map[string]any `json:"arguments,omitempty"`
}

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

type Capabilities struct {
	// Docker is true when a container runtime was found.
	Docker bool `json:"docker"`
	// DockerVersion is the runtime's version when Docker is true.
	DockerVersion string `json:"docker_version,omitempty"`
	// Browser is true when the machine has a browser its Compitas can drive
	// without a container of their own (playwright-mcp), as the browser image
	// does. A Compita in a container brings its own.
	Browser bool `json:"browser,omitempty"`
}

type ChatMessage struct {
	Role  string    `json:"role"` // "user" or "compita"
	Text  string    `json:"text"`
	Error bool      `json:"error,omitempty"`
	At    time.Time `json:"at"`
}

type Compita struct {
	ID          string    `json:"id"`
	Name        string    `json:"name"`
	Description string    `json:"description,omitempty"`
	ComputeID   string    `json:"compute_id"`
	Isolation   Isolation `json:"isolation"`
	// Approvals is the approval preset; empty means careful.
	Approvals string `json:"approvals,omitempty"`
	// Browser gives the Compita a web browser it can drive and a human can
	// watch. In a container it brings its own; on the machine itself the
	// compute must have one (see Capabilities).
	Browser bool `json:"browser,omitempty"`
	// Connections are the tools and integrations made for this Compita, as MCP
	// servers it may use (a GitHub server with its token, say). Their
	// environment holds secrets, so the dashboard never gets it back.
	Connections map[string]Connection `json:"connections,omitempty"`
	CreatedAt   time.Time             `json:"created_at"`
}

type Compute struct {
	ID           string       `json:"id"`
	Name         string       `json:"name"`
	Kind         Kind         `json:"kind"`
	Mode         Mode         `json:"mode,omitempty"`
	URL          string       `json:"url,omitempty"`
	Status       Status       `json:"status"`
	Capabilities Capabilities `json:"capabilities"`
	CreatedAt    time.Time    `json:"created_at"`
	EnrolledAt   *time.Time   `json:"enrolled_at,omitempty"`
	// CredentialHash is the SHA-256 of the secret the compute presents after
	// enrolling. The secret itself is never stored.
	CredentialHash string `json:"credential_hash,omitempty"`
	// DialSecret is what Compa presents to a dial-in compute. Compa is the
	// client there, so it has to keep the secret; compute.json is mode 0600.
	DialSecret string `json:"dial_secret,omitempty"`
	// PinSHA256 pins the certificate of a dial-in compute that serves its own
	// self-signed certificate (`compute serve --tls`).
	PinSHA256 string `json:"pin_sha256,omitempty"`
}

type Connection struct {
	Command string            `json:"command"`
	Args    []string          `json:"args,omitempty"`
	Env     map[string]string `json:"env,omitempty"`
}

type DriveOptions struct {
	// Turn runs one turn of the Compita and returns its reply.
	Turn func(ctx context.Context, prompt string) (string, error)
	// Say records a Compita line in its chat; Log is optional.
	Say func(text string, isError bool)
	// Pause is the gap between turns; Backoff computes retry waits.
	Pause   time.Duration
	Backoff func(failures int) time.Duration
	// MaxFailures is how many turns in a row may fail before the objective
	// is marked blocked. Waiting for an offline compute does not count.
	MaxFailures int
	// MaxStalls is how many identical replies in a row mean no progress.
	MaxStalls int
	// Colleagues names the other Compitas, listed in each prompt. Optional.
	Colleagues func() []string
}

type EnrollRequest struct {
	Token        string       `json:"token"`
	Capabilities Capabilities `json:"capabilities"`
}

type EnrollResponse struct {
	ComputeID  string `json:"compute_id"`
	Credential string `json:"credential"`
}

type Enrollment struct {
	ComputeID string    `json:"compute_id"`
	TokenHash string    `json:"token_hash"`
	ExpiresAt time.Time `json:"expires_at"`
}

type EventsReport struct {
	JobID  string        `json:"job_id"`
	Events []StreamEvent `json:"events"`
}

type HostAsker struct {
	URL, ComputeID, Token, Self string
	Client                      *http.Client
}

type Identity struct {
	CompaURL   string `json:"compa_url"`
	ComputeID  string `json:"compute_id"`
	Credential string `json:"credential"`
}

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

type Isolation string

type Job struct {
	ID        string    `json:"id"`
	CompitaID string    `json:"compita_id"`
	Isolation Isolation `json:"isolation"`
	Session   string    `json:"session"`
	Message   string    `json:"message"`
	Depth     int       `json:"depth,omitempty"`
	Approvals string    `json:"approvals,omitempty"`
	Browser   bool      `json:"browser,omitempty"`
	// Connections are the Compita's own MCP servers.
	Connections map[string]Connection `json:"connections,omitempty"`
	// Events asks the compute to report the turn as it runs.
	Events bool `json:"events,omitempty"`
	// Tunnel, when set, makes this a control job rather than a turn: open a
	// tunnel to the host for this session (see Tunnel in tunnel.go).
	Tunnel string `json:"tunnel,omitempty"`
}

type Kind string

type Mode string

type Objective struct {
	Goal       string          `json:"goal"`
	Status     ObjectiveStatus `json:"status"`
	Turns      int             `json:"turns"`
	MaxTurns   int             `json:"max_turns"`
	MaxMinutes int             `json:"max_minutes"`
	StartedAt  time.Time       `json:"started_at"`
	UpdatedAt  time.Time       `json:"updated_at"`
	// Spent is the active working time so far, so a budget survives restarts.
	SpentSeconds int `json:"spent_seconds"`
	// Note is the Compita's latest progress note; Summary or Reason end it.
	Note    string `json:"note,omitempty"`
	Summary string `json:"summary,omitempty"`
	Reason  string `json:"reason,omitempty"`
	// Claimed is the Compita's own report that it is done, kept while a check
	// turn confirms it. A Compita that says "done" is not trusted until then.
	Claimed string `json:"claimed,omitempty"`
	// Sig and Stalls spot a Compita that keeps repeating itself.
	Sig    string `json:"sig,omitempty"`
	Stalls int    `json:"stalls,omitempty"`
	// BaseURL is how the Compita reaches Compa to message its peers.
	BaseURL string `json:"base_url,omitempty"`
}

type ObjectiveStatus string

type Peer struct {
	URL        string
	ComputeID  string
	Credential string
}

type Result struct {
	JobID string `json:"job_id"`
	Reply string `json:"reply"`
	Error string `json:"error,omitempty"`
}

type Runner struct {
	// Home is this machine's Compa home; its config.json seeds each Compita.
	Home string
	// Kernel is the compa-kernel binary used outside containers.
	Kernel string
	// Image is the container image for container isolation.
	Image string
	// BrowserImage is the image for Compitas with a browser.
	BrowserImage string
	// Peer lets the Compita message its peers. Optional.
	Peer *Peer
}

type Schedule struct {
	ID           string    `json:"id"`
	Goal         string    `json:"goal"`
	EveryMinutes int       `json:"every_minutes"`
	Enabled      bool      `json:"enabled"`
	LastRun      time.Time `json:"last_run,omitempty"`
	NextRun      time.Time `json:"next_run"`
}

type State struct {
	Enabled     bool         `json:"enabled"`
	Computes    []Compute    `json:"computes"`
	Compitas    []Compita    `json:"compitas"`
	Enrollments []Enrollment `json:"enrollments,omitempty"`
}

type Status string

type Store struct {
	Home string
	// Detect reports what this computer offers Compitas: a container runtime
	// and a browser. Tests replace it.
	Detect func() Capabilities
	// contains filtered or unexported fields
}

type StreamEvent struct {
	Type   string `json:"type"`
	Text   string `json:"text,omitempty"`
	Tool   string `json:"tool,omitempty"`
	State  string `json:"state,omitempty"`
	Detail string `json:"detail,omitempty"`
}

type Triggers struct {
	Schedules []Schedule `json:"schedules"`
	// Token authenticates events (as a bearer token, or as the secret of a
	// GitHub-style HMAC signature). It is kept in the clear, like a webhook
	// secret has to be, in a file only the owner reads.
	Token string `json:"token,omitempty"`
	// Instruction says what to do with each event.
	Instruction string `json:"instruction,omitempty"`
	// Pending holds events that arrived while the Compita was busy.
	Pending []string `json:"pending,omitempty"`
	// BaseURL is how the Compita reaches Compa for objectives these start.
	BaseURL string `json:"base_url,omitempty"`
}

type Turn struct {
	CompitaID string
	Isolation Isolation
	Session   string
	Message   string
	// Depth counts hops of Compita-to-Compita messages, to stop loops.
	Depth int
	// Peer* let a dial-in compute's Compitas reach back to the Compa host.
	PeerURL, PeerCompute, PeerToken string
	// Approvals is the Compita's approval preset (see ApprovalsCareful).
	Approvals string
	// Browser runs the turn in the browser image, with a browser to drive.
	Browser bool
	// Connections are the Compita's own MCP servers.
	Connections map[string]Connection
	// Events asks the kernel to report the turn as it runs (`agent --events`).
	// RunStream sets it; callers of Run leave it off.
	Events bool
}