domain

type Advisor struct {
	Type  string `json:"type"`
	Model string `json:"model"`
}

type AdvisorConsultation struct {
	ThreadID        string
	UsageRequestID  string
	LifecycleIDs    []string
	Model           string
	UsageModel      string
	Usage           TokenUsage
	UsageKnown      bool
	StopReason      string
	PublicContent   []any
	AdviceDelivered bool
}

type Agent struct {
	ID          string
	Version     int
	Name        string
	Model       Model
	System      *string
	Description *string
	Tools       []any
	MCPServers  []any
	Skills      []SkillReference
	Multiagent  *Multiagent
	Metadata    map[string]any
	CreatedAt   time.Time
	UpdatedAt   time.Time
	ArchivedAt  *time.Time
}

type AgentOverrides struct {
	Model      *Model
	System     *NullableString
	Tools      *[]any
	MCPServers *[]any
	Skills     *[]SkillReference
}

type AgentPatch struct {
	Name            *string
	Model           *Model
	System          *NullableString
	Description     *NullableString
	Tools           *[]any
	MCPServers      *[]any
	Skills          *[]SkillReference
	Multiagent      *NullableMultiagent
	Metadata        map[string]any
	ExpectedVersion *int
}

type AgentReference struct {
	Type       string `json:"type"`
	ID         string `json:"id,omitempty"`
	Version    int    `json:"version,omitempty"`
	Model      string `json:"model,omitempty"`
	StringForm bool   `json:"-"`
}

type BuiltinConfig struct {
	Name    string
	Enabled *bool
	Policy  *PermissionPolicy
}

type BuiltinToolset struct {
	DefaultEnabled bool
	DefaultPolicy  PermissionPolicy
	Configs        []BuiltinConfig
}

type CacheCreationUsage struct {
	Ephemeral1hInputTokens int64
	Ephemeral5mInputTokens int64
}

type Clock interface{ Now() time.Time }

type ContentBlock struct {
	Type          string         // typed local blocks plus losslessly preserved provider-native block types
	Text          string         // text blocks; also flattened text of a tool_result
	ToolUseID     string         // tool_use: the event id
	ToolName      string         // tool_use: tool name
	Input         map[string]any // tool_use: arguments
	ToolResultFor string         // tool_result: the tool_use id it answers
	IsError       bool           // tool_result: error flag
	// ResultContent preserves rich user/custom/MCP tool-result items (text,
	// image, document, and search_result) without flattening them. Text remains
	// populated as a convenient projection for existing executors.
	ResultContent []json.RawMessage `json:"result_content,omitempty"`
	// Raw is the complete provider content block. Provider adapters populate it
	// for responses so unknown server-tool, citation, encrypted-continuation,
	// and future fields can be round-tripped without flattening. Locally created
	// blocks leave Raw empty and are encoded from the typed fields above.
	Raw json.RawMessage `json:"raw,omitempty"`
}

type ContextProjection struct {
	Compacted                bool `json:"compacted"`
	OriginalEstimatedTokens  int  `json:"original_estimated_tokens"`
	ProjectedEstimatedTokens int  `json:"projected_estimated_tokens"`
	DroppedMessages          int  `json:"dropped_messages"`
}

type ContextSnapshot struct {
	ID                        string            `json:"id"`
	SessionID                 string            `json:"session_id"`
	ThreadID                  string            `json:"thread_id"`
	TriggerEventID            string            `json:"trigger_event_id"`
	ParentSnapshotID          *string           `json:"parent_snapshot_id,omitempty"`
	TranscriptTriggerEventIDs []string          `json:"transcript_trigger_event_ids"`
	Messages                  []Message         `json:"messages"`
	Projection                ContextProjection `json:"projection"`
	ContextPolicyVersion      int               `json:"context_policy_version"`
	CreatedAt                 time.Time         `json:"created_at"`
}

type ContextUsageAnchor struct {
	Usage              ContextWindowUsage `json:"usage"`
	RequestFingerprint string             `json:"request_fingerprint"`
	PrefixFingerprint  string             `json:"prefix_fingerprint"`
	ContentBlocks      int                `json:"content_blocks"`
}

type ContextWindowUsage struct {
	CacheCreation        CacheCreationUsage
	CacheReadInputTokens int64
	InputTokens          int64
	OutputTokens         int64
}

type CredentialAuth struct {
	Type         string              `json:"type"`
	MCPServerURL string              `json:"mcp_server_url"`
	ExpiresAt    *time.Time          `json:"expires_at,omitempty"`
	Refresh      *OAuthRefreshPublic `json:"refresh,omitempty"`
}

type CustomTool struct {
	Name        string
	Description string
	InputSchema map[string]any
}

type Deployment struct {
	ID                string
	AgentID           string
	AgentVersion      int
	EnvironmentID     string
	Name              string
	Description       string
	InitialEvents     []EventDraft
	Resources         []DeploymentResource
	VaultIDs          []string
	Budget            *SessionBudget
	Metadata          map[string]string
	Schedule          *DeploymentSchedule
	Status            string
	PausedReason      *DeploymentPausedReason
	CreatedAt         time.Time
	UpdatedAt         time.Time
	ArchivedAt        *time.Time
	ScheduleClaimedAt *time.Time
}

type DeploymentPatch struct {
	AgentID       *string
	AgentVersion  *int
	EnvironmentID *string
	Name          *string
	Description   *string
	InitialEvents *[]EventDraft
	Resources     *[]DeploymentResource
	VaultIDs      *[]string
	Metadata      map[string]*string
	ScheduleSet   bool
	Schedule      *DeploymentSchedule
	BudgetSet     bool
	Budget        *SessionBudget
}

type DeploymentPausedReason struct {
	Type      string
	ErrorType string
}

type DeploymentResource struct {
	Type          string
	MemoryStoreID string
	Access        string
	Instructions  string
}

type DeploymentRun struct {
	ID           string
	DeploymentID string
	AgentID      string
	AgentVersion int
	SessionID    *string
	ErrorType    string
	ErrorMessage string
	TriggerType  string
	ScheduledAt  *time.Time
	CreatedAt    time.Time
}

type DeploymentSchedule struct {
	Expression     string
	Timezone       string
	LastRunAt      *time.Time
	UpcomingRunsAt []time.Time
}

type DomainError struct {
	Kind    ErrKind
	Code    string
	Message string
}

type Environment struct {
	ID          string
	Name        string
	Description string
	Metadata    map[string]any
	Scope       string
	ConfigType  string // "self_hosted"
	Config      map[string]any
	CreatedAt   time.Time
	UpdatedAt   time.Time
	ArchivedAt  *time.Time
}

type EnvironmentPatch struct {
	Name        *string
	Description *string
	Metadata    map[string]any
	Scope       *string
	Config      *map[string]any
}

type EnvironmentWork struct {
	ID            string
	EnvironmentID string
	SessionID     string
	Type          string
	ExpiresAt     *time.Time
	Result        *EnvironmentWorkResult
	// Secret is populated only for the worker that tentatively claimed this
	// activation. Persistence stores only its digest, and read/list surfaces
	// redact it.
	Secret            string
	State             EnvironmentWorkState
	Metadata          map[string]string
	CreatedAt         time.Time
	AcknowledgedAt    *time.Time
	StartedAt         *time.Time
	LatestHeartbeatAt *time.Time
	StopRequestedAt   *time.Time
	StoppedAt         *time.Time
	TTLSeconds        int64
}

type EnvironmentWorkHeartbeat struct {
	LastHeartbeat time.Time
	LeaseExtended bool
	State         EnvironmentWorkState
	TTLSeconds    int64
}

type EnvironmentWorkQueueStats struct {
	Depth          int64
	Pending        int64
	OldestQueuedAt *time.Time
	WorkersPolling int64
}

type EnvironmentWorkResult struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

type EnvironmentWorkState string

type ErrKind int

type Event struct {
	ID        string
	SessionID string
	// ThreadID is the ledger that owns this event. Sequence remains Session-wide
	// so aggregate ordering and cross-post causality have one durable cursor.
	ThreadID string
	Sequence int64
	Type     string
	Payload  map[string]any
	// TurnEventID is internal causal metadata. A non-nil value means this event
	// was output of that model-driving turn, not a second independent trigger.
	// HTTP projections intentionally omit it.
	TurnEventID *string `json:"-"`
	CreatedAt   time.Time
	ProcessedAt *time.Time
}

type EventDraft struct {
	ID      string
	Type    string
	Payload map[string]any
}

type File struct {
	// SessionID pins generated tool output while its owning Session exists.
	SessionID      string
	ID             string
	CreatedAt      time.Time
	UpdatedAt      time.Time
	Filename       string
	MimeType       string
	SizeBytes      int64
	BlobKey        string
	ChecksumSHA256 string
	State          FileState
}

type FileMessageContent struct {
	ContentIndex int
	FileID       string
	Filename     string
	MimeType     string
	Content      string
}

type FileState string

type FixedClock struct{ T time.Time }

type IDGenerator interface{ NewID(prefix string) string }

type MCPServer struct {
	Name string
	URL  string
}

type MCPToolset struct {
	ServerName     string
	DefaultEnabled bool
	DefaultPolicy  PermissionPolicy
	Configs        []BuiltinConfig
}

type Memory struct {
	ID              string
	MemoryStoreID   string
	MemoryVersionID string
	Path            string
	Content         string
	ContentSize     int64
	ContentSHA256   string
	CreatedAt       time.Time
	UpdatedAt       time.Time
}

type MemoryActor struct {
	Type string
	ID   string
}

type MemoryListItem struct {
	Memory *Memory
	Prefix string
}

type MemoryStore struct {
	ID          string
	Name        string
	Description string
	Metadata    map[string]string
	CreatedAt   time.Time
	UpdatedAt   time.Time
	ArchivedAt  *time.Time
}

type MemoryVersion struct {
	ID            string
	MemoryStoreID string
	MemoryID      string
	Operation     string
	Path          *string
	Content       *string
	ContentSize   *int64
	ContentSHA256 *string
	CreatedAt     time.Time
	CreatedBy     MemoryActor
	RedactedAt    *time.Time
	RedactedBy    *MemoryActor
}

type Message struct {
	Role    Role
	Content []ContentBlock
	// ContextUsage is private continuation metadata. It anchors one provider
	// response to the exact request usage the provider reported, allowing the
	// next request to measure only messages added after that response. Provider
	// adapters intentionally serialize only Role and Content.
	ContextUsage *ContextUsageAnchor `json:"context_usage,omitempty"`
}

type Model struct {
	ID     string
	Effort string
	Speed  string
	// EffortExplicit and SpeedExplicit distinguish an explicit Agent setting
	// from the Mango defaults echoed in the resolved resource. The
	// Messages adapter uses this distinction to avoid sending preview fields to
	// endpoints when the caller only accepted the platform default.
	EffortExplicit bool
	SpeedExplicit  bool
}

type Multiagent struct {
	Type   string           `json:"type"`
	Agents []AgentReference `json:"agents"`
	// contains filtered or unexported fields
}

type NullableMultiagent struct {
	Value *Multiagent
}

type NullableString struct {
	Set   bool
	Value *string
}

type OAuthRefreshPublic struct {
	ClientID          string  `json:"client_id"`
	TokenEndpoint     string  `json:"token_endpoint"`
	TokenEndpointAuth string  `json:"token_endpoint_auth_type"`
	Resource          *string `json:"resource"`
	Scope             *string `json:"scope"`
}

type OutcomeEvaluation struct {
	OutcomeID   string
	Description string
	Result      string
	Explanation string
	Iteration   int
	CompletedAt *time.Time
}

type OutcomeSpec struct {
	OutcomeID     string
	Description   string
	Rubric        map[string]any
	MaxIterations int
}

type PendingAction struct {
	ID                  string
	SessionID           string
	ThreadID            string
	ActionEventID       string
	ClientActionEventID string
	Kind                PendingActionKind
	// ApprovalEventID is the durable allow receipt for an external tool. It
	// advances the expected response to tool_result without resolving the call.
	ApprovalEventID  *string
	ResolvingEventID *string
	CreatedAt        time.Time
	ResolvedAt       *time.Time
}

type PendingActionKind string

type PermissionIntent struct {
	AgentSystem string                  `json:"agent_system"`
	Entries     []PermissionIntentEntry `json:"entries"`
	Complete    bool                    `json:"complete"`
}

type PermissionIntentEntry struct {
	EventID  string `json:"event_id"`
	ThreadID string `json:"thread_id"`
	Type     string `json:"type"`
	Text     string `json:"text"`
}

type PermissionPolicy struct{ Type string }

type PreviewFrame struct {
	ThreadID            string // empty for the primary stream; child Thread otherwise
	Kind                string // PreviewEventStart | PreviewEventDelta
	EventID             string // the id of the event being previewed (== the eventual persisted event id)
	EventType           string // event_start: the previewed event's type (e.g. "agent.message")
	ModelRequestStartID string // internal correlation fence; deliberately omitted from WireJSON
	Index               int    // event_delta: content block index
	Text                string // event_delta: incremental text
}

type ProviderToolUseMapping struct {
	PublicEventID     string `json:"public_event_id"`
	ProviderToolUseID string `json:"provider_tool_use_id"`
	ToolName          string `json:"tool_name"`
}

type ProviderTranscript struct {
	Messages        []Message                `json:"messages"`
	TriggerEventIDs []string                 `json:"trigger_event_ids"`
	ToolUseMappings []ProviderToolUseMapping `json:"tool_use_mappings"`
}

type RandomIDGen struct{}

type Role string

type RunAttempt struct {
	ID         string
	RunID      string
	AttemptNo  int
	State      RunAttemptState
	Error      *string
	CreatedAt  time.Time
	UpdatedAt  time.Time
	FinishedAt *time.Time
}

type RunAttemptState string

type RunState string

type SecretEnvelope struct {
	Version    int
	Algorithm  string
	KeyID      string
	Nonce      []byte
	Ciphertext []byte
}

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

type ServerToolUsage struct {
	WebFetchRequests  int64
	WebSearchRequests int64
}

type Session struct {
	// WorkspaceID is Mango's internal tenant boundary. It is never serialized
	// into the CMA projection or exposed on the public wire.
	WorkspaceID   string `json:"-"`
	ID            string
	AgentID       string
	AgentVersion  int
	EnvironmentID string
	// DeploymentID identifies sessions created by an autonomous Deployment.
	// It is immutable and nil for sessions created directly through /sessions.
	DeploymentID *string
	// EnvironmentType is captured with the session so tool routing remains
	// stable even if the environment resource is later archived. Empty on older
	// sessions means cloud.
	EnvironmentType string
	// EnvironmentConfig is the immutable sandbox configuration captured when
	// the Session is created. It is internal execution state and is not exposed
	// in the public Session response.
	EnvironmentConfig map[string]any
	Status            Status
	Title             string
	Metadata          map[string]any
	// AgentSnapshot is the resolved agent definition captured at session
	// creation time, after version pinning and any per-session overrides. It is
	// the immutable public projection returned as the session's `agent` field.
	// Later updates or archival of the underlying agent must never mutate it.
	AgentSnapshot Agent
	// MultiagentRoster contains the full, immutable Agent snapshots resolved for
	// the coordinator at Session creation time. Agent resources store only
	// version pins in AgentSnapshot.Multiagent; the Session contract expands
	// those pins so child Threads never need to reinterpret "latest" or observe
	// a later Agent mutation. A self entry is copied from AgentSnapshot after
	// Session overrides have been applied.
	MultiagentRoster []Agent
	Usage            TokenUsage
	// ModelListCostNanoUSD is the exact accumulated token and provider-native
	// server-tool list cost. Session runtime is priced live from ActiveSeconds.
	ModelListCostNanoUSD int64
	// ListCostKnown is false when any used model lacks a canonical Anthropic
	// public price, or when legacy usage predates per-request accounting.
	// Budgeted Sessions validate their full roster up front so it remains true.
	ListCostKnown bool
	Budget        *SessionBudget
	Outcomes      []OutcomeEvaluation
	Resources     []SessionResource
	// VaultIDs is the immutable, ordered Vault selection captured when the
	// Session is created. Runtime credential resolution preserves this order.
	VaultIDs []string
	// ActiveSeconds is the completed running time. RunningSince contributes a
	// live suffix while the Session is running. TerminatedAt freezes duration.
	ActiveSeconds float64
	RunningSince  *time.Time
	TerminatedAt  *time.Time
	CreatedAt     time.Time
	UpdatedAt     time.Time
	ArchivedAt    *time.Time
}

type SessionBudget struct {
	MaxListCostCents int64
}

type SessionBudgetUpdate struct {
	Budget *SessionBudget
}

type SessionChange struct {
	Title    bool
	Metadata bool
	Agent    bool
	Budget   bool
}

type SessionResource struct {
	ID                     string
	SessionID              string
	ResourceType           string
	MemoryStoreID          string
	MemoryAccess           string
	MemoryInstructions     string
	MemoryStoreName        string
	MemoryStoreDescription string
	MountPath              string
	CreatedAt              time.Time
	UpdatedAt              time.Time
	State                  SessionResourceState
}

type SessionResourceState string

type SessionRun struct {
	ID              string
	SessionID       string
	AdmissionSeq    int64
	TriggerEventIDs []string
	// OutputEventIDs are the exact committed event ids this run appended when it
	// closed (agent output plus the run's terminal/status events), persisted in
	// the same transaction that closes the run. Empty until completion. This is
	// internal-only durable state and is never serialized onto the public API.
	OutputEventIDs []string
	State          RunState
	Error          *string
	CreatedAt      time.Time
	UpdatedAt      time.Time
}

type SessionThread struct {
	ID             string
	SessionID      string
	ParentThreadID *string
	Agent          Agent
	// Advisor is non-nil only for a platform-spawned consultation Thread. Such a
	// Thread never executes the ordinary child Workflow or exposes Agent fields.
	Advisor              *Advisor
	Status               Status
	Usage                TokenUsage
	ModelListCostNanoUSD int64
	ListCostKnown        bool
	BudgetPaused         bool
	ActiveSeconds        float64
	RunningSince         *time.Time
	TerminatedAt         *time.Time
	StartupSeconds       float64
	CreatedAt            time.Time
	UpdatedAt            time.Time
	ArchivedAt           *time.Time
}

type SessionUpdate struct {
	// Title replaces the human-readable title when non-nil.
	Title *string
	// Metadata is a per-key patch, not a replacement: a present key with a nil
	// value deletes it and any other value upserts it. A nil map preserves the
	// whole bag. This differs from the create-time metadata bag on purpose.
	Metadata map[string]any
	// AgentTools and AgentMCPServers are session-local full replacements of the
	// resolved snapshot's lists. A non-nil pointer replaces (an empty or nil
	// slice clears); a nil pointer preserves. They never touch the underlying
	// Agent resource or its version.
	AgentTools      *[]any
	AgentMCPServers *[]any
	Budget          *SessionBudgetUpdate
}

type Skill struct {
	ID            string
	CreatedAt     time.Time
	UpdatedAt     time.Time
	DisplayTitle  string
	LatestVersion string
	Source        string
	TitleExplicit bool
	Ready         bool
}

type SkillReference struct {
	Type    string `json:"type"`
	SkillID string `json:"skill_id"`
	Version string `json:"version,omitempty"`
}

type SkillRuntime struct {
	Root     string
	Versions []SkillVersion
}

type SkillVersion struct {
	ID          string
	SkillID     string
	Version     string
	CreatedAt   time.Time
	Description string
	Directory   string
	Name        string
	BlobKey     string
	SizeBytes   int64
	// UncompressedSizeBytes is the exact byte footprint of the validated
	// canonical bundle before zip compression. Runtime admission uses it to
	// bound per-Session staging independently of compression ratio.
	UncompressedSizeBytes int64
	ChecksumSHA256        string
	State                 SkillVersionState
	Initial               bool
}

type SkillVersionState string

type Status string

type TokenUsage struct {
	CacheCreation        CacheCreationUsage
	CacheReadInputTokens int64
	InputTokens          int64
	OutputTokens         int64
	ServerToolUse        ServerToolUsage
	// Speed is the provider-reported inference mode for one model request. It is
	// intentionally not accumulated into Session usage; span events use it to
	// report the actual mode (which may differ from a requested fast fallback).
	Speed string
	// ProviderRegion is the provider-reported region for one model request. It is
	// retained only for internal list-cost accounting and is not accumulated or
	// exposed through Mango's public Agent, Session, or usage resources.
	ProviderRegion string
}

type ToolPermissionDecision struct {
	Type       string `json:"type"`
	ReasonCode string `json:"reason_code,omitempty"`
}

type ToolPermissionEvaluation struct {
	Type                string                  `json:"type"`
	EvaluatedPermission *ToolPermissionDecision `json:"evaluated_permission,omitempty"`
}

type ToolPermissionOwner struct {
	SessionID      string `json:"session_id"`
	ThreadID       string `json:"thread_id"`
	TriggerEventID string `json:"trigger_event_id"`
	AttemptID      string `json:"attempt_id"`
}

type ToolPermissionReceipt struct {
	ToolPermissionOwner
	ToolUseEventID   string                 `json:"tool_use_event_id"`
	ToolName         string                 `json:"tool_name"`
	InvocationHash   string                 `json:"invocation_hash"`
	ContextHash      string                 `json:"context_hash"`
	Decision         ToolPermissionDecision `json:"decision"`
	Model            Model                  `json:"model"`
	Usage            TokenUsage             `json:"usage"`
	StopReason       string                 `json:"stop_reason"`
	ResponseReceived bool                   `json:"response_received"`
}

type ToolSet struct {
	Builtin *BuiltinToolset
	Custom  []CustomTool
	MCP     []MCPToolset
}

type ToolStep struct {
	ID             string
	AttemptID      string
	Ordinal        int
	ToolUseEventID string
	ToolName       string
	Input          map[string]any
	State          ToolStepState
	Result         *ToolStepResult
	CreatedAt      time.Time
	UpdatedAt      time.Time
	StartedAt      *time.Time
	FinishedAt     *time.Time
}

type ToolStepResult struct {
	Content []any `json:"content"`
	// FileID references a published textual result File. FullOutput is a private
	// byte receipt retained only until publication; JSON encodes it as base64 so
	// every UTF-8 byte (including NUL) survives PostgreSQL JSONB. It never enters Workflow history.
	FileID     string `json:"file_id,omitempty"`
	FullOutput []byte `json:"full_output,omitempty"`
	IsError    bool   `json:"is_error"`
	// InjectedContent is private provider-continuation content produced by an
	// agent-runtime primitive after its ordinary tool_result. Skill activation
	// uses it to persist the rendered SKILL.md as a sibling user content block,
	// matching Claude Code's context lifecycle without exposing it as a public
	// configurable tool.
	InjectedContent []ContentBlock `json:"injected_content,omitempty"`
	// Events are server-side companion events that must commit with a durable
	// tool result and survive a lost Activity acknowledgement. They are removed
	// from the model-facing result projection.
	Events []EventDraft `json:"events,omitempty"`
	// Raw retains a bounded executor-native result for diagnostics/UI without
	// placing it in model context. Oversized native diagnostics are omitted;
	// FileID retains only the projected model-visible textual result.
	Raw     json.RawMessage `json:"raw,omitempty"`
	RawPath string          `json:"raw_path,omitempty"`
}

type ToolStepState string

type Vault struct {
	ID          string
	DisplayName string
	Metadata    map[string]string
	CreatedAt   time.Time
	UpdatedAt   time.Time
	ArchivedAt  *time.Time
}

type VaultCredential struct {
	ID             string
	VaultID        string
	DisplayName    *string
	Metadata       map[string]string
	Auth           CredentialAuth
	CredentialKey  string
	SecretEnvelope *SecretEnvelope
	Version        int64
	CreatedAt      time.Time
	UpdatedAt      time.Time
	ArchivedAt     *time.Time
}

type Webhook struct {
	ID               string
	URL              string
	EventTypes       []string
	Status           WebhookStatus
	DisabledReason   *string
	SecretEnvelope   *SecretEnvelope
	FailureStartedAt *time.Time
	LastSuccessAt    *time.Time
	CreatedAt        time.Time
	UpdatedAt        time.Time
}

type WebhookDelivery struct {
	WebhookID      string
	EventID        string
	URL            string
	SecretEnvelope SecretEnvelope
	Payload        []byte
	AttemptCount   int
	ClaimID        string
	CreatedAt      time.Time
}

type WebhookStatus string