binding

type AdmissionSettings = rollout.Admission

type ApprovalDecision struct {
	Label                  string
	Response               map[string]any
	Approve, Session, Deny bool
	Outcome                string
}

type ApprovalRequest struct {
	Kind           string `json:"kind"`
	ThreadID       string `json:"threadId"`
	TurnID         string `json:"turnId"`
	ItemID         string `json:"itemId"`
	Reason         string `json:"reason"`
	Command        string `json:"command"`
	Cwd            string `json:"cwd"`
	GrantRoot      string `json:"grantRoot"`
	NetworkContext *struct {
		Host string `json:"host"`
	} `json:"networkApprovalContext"`
	Additional         jsontext.Value   `json:"additionalPermissions"`
	Amendment          []string         `json:"proposedExecpolicyAmendment"`
	Permissions        jsontext.Value   `json:"permissions"`
	AvailableDecisions []jsontext.Value `json:"availableDecisions"`
}

type ApprovalReview struct {
	Thread, Turn, Item, Status string
}

type Binder interface {
	Registrar
	Capability(capability.Mechanism) capability.Result
}

type Bindings[S any] struct {
	Requires        []capability.Requirement
	Observation     func(S) Observation
	Frontends       bool // Exposes the descriptor's command contributions.
	Rollout         func(S, RolloutSource) error
	InputProjection func(S) InputProjection
	Guidance        func(S) Guidance
	SessionNaming   func(S) SessionNaming
	ShellApproval   func(S) ShellApproval
	MCP             func(S) MCPServer
}

type CommandAction struct {
	Type    string `json:"type"`
	Command string `json:"command"`
	Path    string `json:"path"`
	Query   string `json:"query"`
}

type CommandGrants interface {
	Allows(approval.Command) bool
	Allow(approval.Command)
}

type CommandObservation struct {
	Key            [3]string // Thread, turn, item.
	Command, Delta string
	Output         *string
	Exit           *int
}

type ContextUsage struct {
	Session, Thread             string
	Tokens, Window, Compactions uint64
	FreshInput                  func() json.RawMessage
	Notify                      func(string)
}

type DispatchError struct {
	Outcome DispatchOutcome
	Method  string
	Cause   error
}

type DispatchOutcome string

type EnvironmentContext struct {
	Session, Thread, Workspace string
	Revision                   uint64
}

type ExecutionCall struct {
	CodeMode      bool
	Native        bool
	NativePayload bool
	CellID        string
	ResumeHandle  string
}

type ExecutionContinuation struct {
	Handle   map[string]any     `json:"handle"`
	NextCall *ExecutionNextCall `json:"next_call"`
	Reason   string             `json:"reason,omitempty"`
}

type ExecutionNextCall struct {
	Tool  string `json:"tool"`
	Input any    `json:"input"`
}

type ExecutionResult struct {
	Terminal     bool
	Succeeded    bool
	ExitCode     *int
	Text         string
	ResumeHandle string
}

type FileChange struct {
	Path string `json:"path"`
	Diff string `json:"diff"`
	Kind struct {
		Type      string `json:"type"`
		MovePath  string `json:"move_path"`
		MovePath2 string `json:"movePath"`
	} `json:"kind"`
}

type ForkBoundary = rollout.PrefixBoundary

type ForkResolver = rollout.PrefixResolver

type ForkSource = rollout.PrefixSource

type FrontendGuidance struct {
	Descriptions string `json:"descriptions"`
	Workflow     string `json:"workflow"`
	Shell        string `json:"shell,omitempty"` // Native-shell descriptions and shared workflow, without Codex execution framing.
}

type Guidance struct {
	ContextUsage      func(InstructionInput, ContextUsage) (InstructionUpdate, error)
	Environment       func(context.Context, InstructionInput, EnvironmentContext) (InstructionUpdate, error)
	Threads           func(InstructionInput, []guidance.Replacement) (InstructionUpdate, error)
	BeforePreparation func(InstructionInput) (InstructionUpdate, error)
	ForExecution      func(InstructionInput) (InstructionUpdate, error)
	AfterAttachments  func(InstructionInput, bool) (InstructionUpdate, error)
	Frontends         func([]command.Spec) (FrontendGuidance, error)
	ToolDescription   func(description, guide string, remove bool) (string, error)
	BaseInstructions  func(instructions json.RawMessage, workflow string, remove bool) (json.RawMessage, error)
}

type HistoryTurn struct {
	ID          string       `json:"id"`
	Status      string       `json:"status"`
	Items       []ThreadItem `json:"items"`
	StartedAt   int64        `json:"startedAt"`
	CompletedAt int64        `json:"completedAt"`
	Error       *struct {
		Message string `json:"message"`
	} `json:"error"`
}

type InputByteRange struct {
	Start int `json:"start"`
	End   int `json:"end"`
}

type InputProjection struct {
	Name    string
	Prepare func([]byte) PreparedInputProjection
}

type InputTextElement struct {
	ByteRange   InputByteRange `json:"byteRange"`
	Placeholder string         `json:"placeholder"`
}

type InstructionInput struct {
	Instructions json.RawMessage
	Input        json.RawMessage
}

type InstructionUpdate struct {
	InstructionInput
	InstructionsChanged bool
	InputChanged        bool
}

type MCPIdentity struct {
	Thread  string
	Session string
	Turn    string
	Call    string
	Item    string
	Window  string
	Version string
	Model   string
	Effort  string
}

type MCPServer struct {
	Name   string
	Server *mcp.Server
	Tools  []string
}

type Notification struct {
	Command *CommandObservation `json:"-"`
	Status  struct {
		Type string `json:"type"`
	} `json:"status"`
	ThreadID   string             `json:"threadId"`
	TurnID     string             `json:"turnId"`
	ItemID     string             `json:"itemId"`
	Delta      string             `json:"delta"`
	ProcessID  string             `json:"processId"`
	Stdin      string             `json:"stdin"`
	Item       ThreadItem         `json:"item"`
	Run        *appserver.HookRun `json:"run,omitempty"`
	Thread     ThreadInfo         `json:"thread"`
	TokenUsage struct {
		Total              TokenUsage  `json:"total"`
		Last               *TokenUsage `json:"last"`
		ModelContextWindow uint64      `json:"modelContextWindow"`
	} `json:"tokenUsage"`
	Turn Turn `json:"turn"`
}

type Observation struct {
	NewTranscript func(*scope.Store) observation.Transcript
}

type PreparedInputProjection func([]byte) ProjectionResult

type ProjectionReceipt struct {
	SavedTokens         int64
	TokensMeasured      bool
	OutputRepetitions   uint64
	RepeatedCalls       map[string]string
	RepeatedAttachments map[string]string
}

type ProjectionResult struct {
	Input   []byte
	Receipt *ProjectionReceipt
}

type Question struct {
	ID       string         `json:"id"`
	Header   string         `json:"header"`
	Question string         `json:"question"`
	Title    string         `json:"title"`
	IsSecret bool           `json:"isSecret"`
	Options  jsontext.Value `json:"options"`
}

type QuestionAnswer struct {
	ID      string
	Answers []string
	Other   bool
}

type QuestionOption struct {
	Label       string `json:"label"`
	Description string `json:"description"`
}

type QuestionReply struct {
	Answer         string `json:"answer"`
	Question       string `json:"question"`
	QuestionItemID string `json:"questionItemId"`
}

type QuestionRequest struct {
	ThreadID  string     `json:"threadId"`
	TurnID    string     `json:"turnId"`
	ItemID    string     `json:"itemId"`
	Questions []Question `json:"questions"`
}

type Registrar interface {
	MCP(MCPServer) error
	Observation(Observation) error
	Rollout(func(RolloutSource) error) error
	Frontend(command.Spec) error
	InputProjection(InputProjection) error
	Guidance(Guidance) error
	SessionNaming(SessionNaming) error
	ShellApproval(ShellApproval) error
}

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

type ResolvedRequest struct {
	ThreadID  string         `json:"threadId"`
	RequestID jsontext.Value `json:"requestId"`
}

type RetainedExecution struct {
	CarrierKind string
	ToolName    string
	Script      string
}

type Rollout = rollout.Inspection

type RolloutCall = rollout.Call

type RolloutEvent = rollout.InspectionEvent

type RolloutItem = rollout.ToolItem

type RolloutReader func(context.Context, string, func(RolloutEvent) error) (Rollout, error)

type RolloutSource struct {
	Inspect  RolloutReader
	Replay   func(context.Context, string, map[string]bool) (observation.Source, error)
	Identity func(string) (string, error)
}

type RuntimeContext = rollout.Runtime

type SessionNaming struct {
	NewThread func(name string, hasTurns bool) ThreadNaming
}

type ShellApproval struct {
	Kind       ShellGuardKind
	NewSession func() CommandGrants
}

type ShellGuardKind string

type ThreadAdmissionPolicy struct{}

type ThreadInfo struct {
	SessionID      string        `json:"sessionId"`
	ThreadSource   string        `json:"threadSource"`
	Name           string        `json:"name"`
	ID             string        `json:"id"`
	ParentThreadID string        `json:"parentThreadId"`
	AgentNickname  string        `json:"agentNickname"`
	AgentRole      string        `json:"agentRole"`
	Cwd            string        `json:"cwd"`
	Path           string        `json:"path"`
	CreatedAt      int64         `json:"createdAt"`
	UpdatedAt      int64         `json:"updatedAt"`
	Turns          []HistoryTurn `json:"turns"`
}

type ThreadItem struct {
	DurationMS       *int64           `json:"durationMs"`
	Delivery         string           `json:"delivery"`
	Questions        []Question       `json:"questions"`
	ID               string           `json:"id"`
	ClientID         string           `json:"clientId"` // userMessage: the submission's clientUserMessageId.
	Type             string           `json:"type"`
	Text             string           `json:"text"`
	Summary          []string         `json:"summary"`
	Command          string           `json:"command"`
	Cwd              string           `json:"cwd"` // commandExecution: the directory the host ran it in.
	Source           string           `json:"source"`
	ProcessID        string           `json:"processId"`
	Path             string           `json:"path"`
	SavedPath        string           `json:"savedPath"`
	Status           string           `json:"status"`
	AggregatedOutput *string          `json:"aggregatedOutput"`
	Query            string           `json:"query"`
	Action           *WebSearchAction `json:"action"`
	Results          []jsontext.Value `json:"results"`
	// Content is variant-specific: user input blocks or raw reasoning strings.
	// Decode only userMessage content; reasoning presentation uses Summary.
	Content        jsontext.Value  `json:"content"`
	Phase          string          `json:"phase"`
	ExitCode       *int            `json:"exitCode"`
	CommandActions []CommandAction `json:"commandActions"`
	Changes        []FileChange    `json:"changes"`
	Tool           string          `json:"tool"`
	Server         string          `json:"server"`
	Arguments      jsontext.Value  `json:"arguments"`
	Result         jsontext.Value  `json:"result"`
	Error          jsontext.Value  `json:"error"`
}

type ThreadNaming interface {
	ObserveMetadata(name string, hasTurns bool)
	NameChanged(string)
	ObserveInput([]byte)
	Admit() func(context.Context, inference.Complete) (string, error)
	AcceptCandidate() bool
}

type TokenUsage struct {
	TotalTokens           uint64 `json:"totalTokens"`
	InputTokens           uint64 `json:"inputTokens"`
	OutputTokens          uint64 `json:"outputTokens"`
	CachedInputTokens     uint64 `json:"cachedInputTokens"`
	ReasoningOutputTokens uint64 `json:"reasoningOutputTokens"`
}

type ToolResult struct {
	CallID   string
	Tool     string
	Status   string
	ExitCode *int `json:",omitempty"`
}

type TranscriptItem struct {
	ID, Type, Text, Status, Delivery, Phase string
	Summary                                 []string
	Questions                               []Question
}

type Turn struct {
	ID     string     `json:"id"`
	Status string     `json:"status"`
	Error  *TurnError `json:"error"`
}

type TurnError struct {
	Message        string         `json:"message"`
	CodexErrorInfo jsontext.Value `json:"codexErrorInfo"`
}

type WebSearchAction struct {
	Type    string   `json:"type"`
	Query   string   `json:"query"`
	Queries []string `json:"queries"`
	URL     string   `json:"url"`
	Pattern string   `json:"pattern"`
}