extension

type AIContext = any

type API interface {

	// OnProjectTrust registers a handler for "project_trust".
	// upstream: types.ts:1125 (on("project_trust", ...))
	OnProjectTrust(handler func(ctx context.Context, evt ProjectTrustEvent) (ProjectTrustEventResult, error))

	// OnResourcesDiscover registers a handler for "resources_discover".
	// upstream: types.ts:1071
	OnResourcesDiscover(handler func(ctx context.Context, evt ResourcesDiscoverEvent) (ResourcesDiscoverResult, error))

	// OnSessionStart registers a handler for "session_start".
	// upstream: types.ts:1143
	OnSessionStart(handler func(ctx context.Context, evt SessionStartEvent) error)

	// OnSessionInfoChanged registers a handler for "session_info_changed"
	// (upstream types.ts SessionInfoChangedEvent; adopted upstream in 0.80.3).
	OnSessionInfoChanged(handler func(ctx context.Context, evt SessionInfoChangedEvent) error)

	// OnMcpServersChange registers a handler for "mcp_servers_change", fired when
	// an extension registers or unregisters an MCP server after the extensions
	// are bound. Handling it marks an extension as the one that connects
	// registered servers.
	// upstream: types.ts:1562 (on("mcp_servers_change", ...))
	OnMcpServersChange(handler func(ctx context.Context, evt McpServersChangeEvent) error)

	// OnSessionBeforeSwitch registers a handler for "session_before_switch".
	// upstream: types.ts:1145
	OnSessionBeforeSwitch(handler func(ctx context.Context, evt SessionBeforeSwitchEvent) (SessionBeforeSwitchResult, error))

	// OnSessionBeforeFork registers a handler for "session_before_fork".
	// upstream: types.ts:1077
	OnSessionBeforeFork(handler func(ctx context.Context, evt SessionBeforeForkEvent) (SessionBeforeForkResult, error))

	// OnSessionBeforeCompact registers a handler for "session_before_compact".
	// upstream: types.ts:1078
	OnSessionBeforeCompact(handler func(ctx context.Context, evt SessionBeforeCompactEvent) (SessionBeforeCompactResult, error))

	// OnSessionCompact registers a handler for "session_compact".
	// upstream: types.ts:1082
	OnSessionCompact(handler func(ctx context.Context, evt SessionCompactEvent) error)

	// OnSessionCompactFailed registers a handler for "session_compact_failed",
	// fired after manual or automatic compaction fails or is aborted.
	// upstream: types.ts:1374
	OnSessionCompactFailed(handler func(ctx context.Context, evt SessionCompactFailedEvent) error)

	// OnSessionShutdown registers a handler for "session_shutdown".
	// upstream: types.ts:1083
	OnSessionShutdown(handler func(ctx context.Context, evt SessionShutdownEvent) error)

	// OnSessionBeforeTree registers a handler for "session_before_tree".
	// upstream: types.ts:1084
	OnSessionBeforeTree(handler func(ctx context.Context, evt SessionBeforeTreeEvent) (SessionBeforeTreeResult, error))

	// OnSessionTree registers a handler for "session_tree".
	// upstream: types.ts:1085
	OnSessionTree(handler func(ctx context.Context, evt SessionTreeEvent) error)

	// OnContext registers a handler for "context".
	// upstream: types.ts:1086
	OnContext(handler func(ctx context.Context, evt ContextEvent) (ContextEventResult, error))

	// OnContextWithSystem registers a handler for "context_with_system".
	// upstream: types.ts ExtensionAPI.on("context_with_system")
	OnContextWithSystem(handler func(ctx context.Context, evt ContextWithSystemEvent) (ContextEventResult, error))

	// OnBeforeProviderRequest registers a handler for "before_provider_request".
	// upstream: types.ts:1087
	OnBeforeProviderRequest(handler func(ctx context.Context, evt BeforeProviderRequestEvent) (BeforeProviderRequestEventResult, error))

	// OnAfterProviderResponse registers a handler for "after_provider_response".
	// upstream: types.ts:1091
	OnAfterProviderResponse(handler func(ctx context.Context, evt AfterProviderResponseEvent) error)

	// OnBeforeProviderHeaders registers a handler for "before_provider_headers".
	// Handlers mutate evt.Headers in place before the request is sent.
	// upstream: types.ts:1199
	OnBeforeProviderHeaders(handler func(ctx context.Context, evt BeforeProviderHeadersEvent) error)

	// OnProviderStreamEvent registers a handler for "provider_stream_event",
	// fired for a parsed provider stream event before it is normalized.
	// upstream: types.ts:1580 (on("provider_stream_event", ...))
	OnProviderStreamEvent(handler func(ctx context.Context, evt ProviderStreamEvent) error)

	// OnBeforeAgentStart registers a handler for "before_agent_start".
	// upstream: types.ts:1092
	OnBeforeAgentStart(handler func(ctx context.Context, evt BeforeAgentStartEvent) (BeforeAgentStartEventResult, error))

	// OnAgentStart registers a handler for "agent_start".
	// upstream: types.ts:1093
	OnAgentStart(handler func(ctx context.Context, evt AgentStartEvent) error)

	// OnAgentEnd registers a handler for "agent_end".
	// upstream: types.ts:1399
	OnAgentEnd(handler func(ctx context.Context, evt AgentEndEvent) error)

	// OnAgentBeforeSettle registers an awaited final-settlement boundary handler.
	// Handlers may propose durable entries and request one runnable continuation.
	// upstream: types.ts:1401
	OnAgentBeforeSettle(handler func(ctx context.Context, evt *AgentBeforeSettleEvent) (AgentBeforeSettleEventResult, error))

	// OnAgentSettled registers a handler for "agent_settled", fired after an
	// agent run has fully settled (no retry, compaction, or queued continuation).
	// upstream: types.ts:1204
	OnAgentSettled(handler func(ctx context.Context, evt AgentSettledEvent) error)

	// OnUiPromptStart registers a handler for "ui_prompt_start", fired
	// without awaiting handlers when the outermost blocking ctx.ui prompt
	// (select, confirm, input, editor, custom) begins.
	// upstream: types.ts:1404
	OnUiPromptStart(handler func(ctx context.Context, evt UIPromptStartEvent) error)

	// OnUiPromptEnd registers a handler for "ui_prompt_end", fired without
	// awaiting handlers when the outermost blocking ctx.ui prompt settles.
	// upstream: types.ts:1405
	OnUiPromptEnd(handler func(ctx context.Context, evt UIPromptEndEvent) error)

	// OnTurnStart registers a handler for "turn_start".
	// upstream: types.ts:1095
	OnTurnStart(handler func(ctx context.Context, evt TurnStartEvent) error)

	// OnTurnEnd registers a handler for "turn_end".
	// upstream: types.ts:1096
	OnTurnEnd(handler func(ctx context.Context, evt TurnEndEvent) error)

	// OnMessageStart registers a handler for "message_start".
	// upstream: types.ts:1097
	OnMessageStart(handler func(ctx context.Context, evt MessageStartEvent) error)

	// OnMessageUpdate registers a handler for "message_update".
	// upstream: types.ts:1098
	OnMessageUpdate(handler func(ctx context.Context, evt MessageUpdateEvent) error)

	// OnMessageEnd registers a handler for "message_end".
	// upstream: types.ts:1099
	OnMessageEnd(handler func(ctx context.Context, evt MessageEndEvent) (MessageEndEventResult, error))

	// OnToolExecutionStart registers a handler for "tool_execution_start".
	// upstream: types.ts:1100
	OnToolExecutionStart(handler func(ctx context.Context, evt ToolExecutionStartEvent) error)

	// OnToolExecutionUpdate registers a handler for "tool_execution_update".
	// upstream: types.ts:1101
	OnToolExecutionUpdate(handler func(ctx context.Context, evt ToolExecutionUpdateEvent) error)

	// OnToolExecutionEnd registers a handler for "tool_execution_end".
	// upstream: types.ts:1102
	OnToolExecutionEnd(handler func(ctx context.Context, evt ToolExecutionEndEvent) error)

	// OnModelSelect registers a handler for "model_select".
	// upstream: types.ts:1103
	OnModelSelect(handler func(ctx context.Context, evt ModelSelectEvent) error)

	// OnThinkingLevelSelect registers a handler for "thinking_level_select".
	// upstream: types.ts:1122 (added in v0.71.0).
	OnThinkingLevelSelect(handler func(ctx context.Context, evt ThinkingLevelSelectEvent) error)

	// OnToolCall registers a handler for "tool_call". The event is the union
	// [ToolCallEvent]. Type-switch on its concrete variant.
	// upstream: types.ts:1104
	OnToolCall(handler func(ctx context.Context, evt ToolCallEvent) (ToolCallEventResult, error))

	// OnToolResult registers a handler for "tool_result". The event is the
	// union [ToolResultEvent].
	// upstream: types.ts:1105
	OnToolResult(handler func(ctx context.Context, evt ToolResultEvent) (ToolResultEventResult, error))

	// OnUserBash registers a handler for "user_bash".
	// upstream: types.ts:1106
	OnUserBash(handler func(ctx context.Context, evt UserBashEvent) (UserBashEventResult, error))

	// OnInput registers a handler for "input".
	// upstream: types.ts:1107
	OnInput(handler func(ctx context.Context, evt InputEvent) (InputEventResult, error))

	// RegisterTool registers a tool that the LLM can call.
	// upstream: types.ts:1114 (registerTool)
	RegisterTool(tool ToolDefinition)

	// RegisterCommand registers a custom command. Mirrors upstream's
	// `registerCommand(name, options: Omit<RegisteredCommand, "name" | "sourceInfo">)`.
	// upstream: types.ts:1123
	RegisterCommand(name string, options CommandOptions)

	// RegisterShortcut registers a keyboard shortcut.
	// upstream: types.ts:1126
	RegisterShortcut(shortcut KeyID, options ShortcutOptions)

	// RegisterFlag registers a CLI flag.
	// upstream: types.ts:1135
	RegisterFlag(name string, options FlagOptions)

	// GetFlag returns the value of a registered CLI flag. Upstream returns
	// `boolean | string | undefined`; Go returns `any` (nil when unset).
	// upstream: types.ts:1145
	GetFlag(name string) any

	// RegisterMessageRenderer registers a custom renderer for a CustomMessageEntry.
	// upstream: types.ts:1152
	RegisterMessageRenderer(customType string, renderer MessageRenderer)

	// RegisterEntryRenderer registers a custom renderer for a CustomEntry. Custom
	// entries do not participate in LLM context.
	// upstream: types.ts:1266
	RegisterEntryRenderer(customType string, renderer EntryRenderer)

	// RegisterToolRenderer chooses how tool calls are drawn. Resolvers run in
	// extension load order.
	// upstream: types.ts registerToolRenderer
	RegisterToolRenderer(resolver ToolRendererResolver)

	// RegisterMarkdownTransformer registers a display-only Markdown transform.
	// upstream: types.ts:1287
	RegisterMarkdownTransformer(transformer MarkdownTransformer)

	// SendMessage sends a custom message to the session. Pass nil options for defaults.
	// upstream: types.ts:1159
	SendMessage(message SendMessagePayload, options *SendMessageOptions)

	// SendUserMessage sends a user message to the agent. Always triggers a turn.
	// content is `string` or `[]any` carrying TextContent / ImageContent values
	// (matches upstream's `string | (TextContent | ImageContent)[]`).
	// upstream: types.ts:1168
	SendUserMessage(content any, options *SendUserMessageOptions)

	// AppendEntry appends a custom entry to the session for state persistence
	// (not sent to LLM).
	// upstream: types.ts:1174
	AppendEntry(customType string, data any)

	// SetSessionName sets the session display name (shown in session selector).
	// upstream: types.ts:1181
	SetSessionName(name string)

	// GetSessionName returns the current session name. Upstream returns
	// `string | undefined`; Go returns the empty string when unset.
	// upstream: types.ts:1184
	GetSessionName() string

	// SetLabel sets or clears a label on an entry. Pass empty string to clear.
	// upstream: types.ts:1187
	SetLabel(entryID string, label string)

	// Exec executes a shell command. Pass nil options for defaults. Upstream
	// returns `Promise<ExecResult>`; Go returns `(ExecResult, error)`.
	// Cancellation flows through `options.Signal` (which is a context.Context
	// after the D3 migration; see docs/parity/DIVERGENCES.md).
	// upstream: types.ts:1190
	Exec(command string, args []string, options *ExecOptions) (ExecResult, error)

	// GetActiveTools returns the names of the active tools, which are the tools
	// declared to the model.
	// upstream: types.ts:1193
	GetActiveTools() []string

	// GetAllTools returns all configured tools with parameter schema, prompt
	// guidelines, exposure, and source metadata.
	// upstream: types.ts:1196
	GetAllTools() []ToolInfo

	// GetSettings returns a copy of the effective settings (global and project
	// settings merged, with overrides).
	// upstream: types.ts:1708 (getSettings)
	GetSettings() Settings

	// SetActiveTools sets the active tools by name. Unknown and `hidden` tools
	// are ignored. Tools with `codemode` or `deferred` exposure stay callable
	// from codemode scripts whether active or not.
	// upstream: types.ts:1199
	SetActiveTools(toolNames []string)

	// GetCommands returns the available slash commands in the current session.
	// upstream: types.ts:1202
	GetCommands() []SlashCommandInfo

	// SetModel sets the current model. Upstream returns
	// `Promise<boolean>` (false when no API key available); Go returns
	// `(bool, error)`: error is non-nil only on host-side failures.
	// upstream: types.ts:1209
	SetModel(model Model) (bool, error)

	// GetThinkingLevel returns the current thinking level.
	// upstream: types.ts:1212
	GetThinkingLevel() ThinkingLevel

	// SetThinkingLevel sets the thinking level (clamped to model capabilities).
	// upstream: types.ts:1215
	SetThinkingLevel(level ThinkingLevel)

	// RegisterProvider registers or overrides a model provider. See [ProviderConfig]
	// for the field-level semantics (upstream JSDoc preserved).
	// upstream: types.ts:1264
	RegisterProvider(name string, config ProviderConfig)

	// UnregisterProvider unregisters a previously registered provider. Has
	// no effect if the provider is not currently registered.
	// upstream: types.ts:1280
	UnregisterProvider(name string)

	// RegisterMcpServer registers an MCP server for this session, with the same
	// config as an `mcpServers` entry in `mcp.json`. The server connects next to
	// the configured servers: on session_start when registered during extension
	// load, right away when registered later. Registering a name again replaces
	// the extension's earlier registration.
	//
	// The registration is not saved; register again on every load. A server of
	// the same name in `mcp.json` takes precedence. It returns an error for
	// invalid configs and for names another extension registered (upstream
	// throws). When no loaded extension handles MCP servers (for example because
	// another MCP extension replaced the built-in one), the registration is
	// reported as an extension error.
	// upstream: types.ts:1833 (registerMcpServer)
	RegisterMcpServer(name string, config McpServerConfig) error

	// UnregisterMcpServer removes an MCP server this extension registered and
	// closes its connection.
	// upstream: types.ts:1836 (unregisterMcpServer)
	UnregisterMcpServer(name string)

	// GetMcpServers returns every MCP server registered by extensions, for
	// extensions that connect MCP servers.
	// upstream: types.ts:1839 (getMcpServers)
	GetMcpServers() []RegisteredMcpServer

	// RegisterVirtualModel registers a virtual model: a selectable catalog entry
	// that routes each request to a physical model. The selection (`ctx.model`,
	// `model_change` entries) names the virtual model; assistant messages record
	// the physical model and thinking level the router picked.
	//
	// The provider may be any provider id, including one with physical models,
	// and may list several virtual models. Registering the same provider and id
	// again replaces the virtual model. See docs/virtual-models.md.
	// upstream: types.ts:1852 (registerVirtualModel)
	RegisterVirtualModel(model ExtensionVirtualModel)

	// UnregisterVirtualModel removes a virtual model registered with
	// [API.RegisterVirtualModel].
	// upstream: types.ts:1855 (unregisterVirtualModel)
	UnregisterVirtualModel(provider, id string)

	// Events returns the shared event bus for extension communication.
	//
	// pig translation rule (interface property → method): upstream exposes
	// this as the property `events: EventBus`. Go interfaces cannot have
	// fields, so the API surfaces a method that returns the host's single
	// shared instance. See docs/parity/DIVERGENCES.md "TS→Go translation rituals".
	// upstream: types.ts:1283
	Events() EventBus
}

type AfterProviderResponseEvent struct {
	Type    string            `json:"type"`
	Status  int               `json:"status"`
	Headers map[string]string `json:"headers"`
}

type AgentActivityOutcome string

type AgentBeforeSettleEvent struct {
	Type string `json:"type"`
	BoundaryState
}

type AgentBeforeSettleEventResult = BoundaryResult

type AgentEndEvent struct {
	Type     string         `json:"type"`
	Messages []AgentMessage `json:"messages"`
}

type AgentMessage = any

type AgentSettledEvent struct {
	Type string `json:"type"`
}

type AgentStartEvent struct {
	Type string `json:"type"`
}

type AgentTool struct {
	Name                string            `json:"name"`
	Label               string            `json:"label"`
	Description         string            `json:"description"`
	Parameters          json.RawMessage   `json:"parameters"`
	OutputSchema        json.RawMessage   `json:"outputSchema,omitempty"`
	ConstrainedSampling json.RawMessage   `json:"constrainedSampling,omitempty"`
	ExecutionMode       ToolExecutionMode `json:"executionMode,omitempty"`
}

type AgentToolCall = ai.ToolCall

type AgentToolCallOutcome struct {
	ToolCall AgentToolCall   `json:"toolCall"`
	Result   AgentToolResult `json:"result"`
	IsError  bool            `json:"isError"`
}

type AgentToolResult = any

type AgentToolUpdateCallback = any

type ArgumentCompletionsFunc = func(argumentPrefix string) ([]AutocompleteItem, error)

type AssistantMessageEvent = any

type AssistantMessageEventStream = any

type AttributedResourcePath struct {
	Path          string `json:"path"`
	ExtensionPath string `json:"extensionPath"`
}

type AutocompleteCompletion struct {
	Lines      []string `json:"lines"`
	CursorLine int      `json:"cursorLine"`
	CursorCol  int      `json:"cursorCol"`
}

type AutocompleteItem struct {
	Value       string `json:"value"`
	Label       string `json:"label,omitempty"`
	Description string `json:"description,omitempty"`
}

type AutocompleteProvider struct {
	TriggerCharacters           []string
	GetSuggestions              func(context.Context, []string, int, int, bool) (*AutocompleteSuggestions, error)
	ApplyCompletion             func(context.Context, []string, int, int, AutocompleteItem, string) (AutocompleteCompletion, error)
	ShouldTriggerFileCompletion func(context.Context, []string, int, int) (bool, error)
}

type AutocompleteProviderFactory func(context.Context, *AutocompleteProvider) (*AutocompleteProvider, error)

type AutocompleteSuggestions struct {
	Items  []AutocompleteItem `json:"items"`
	Prefix string             `json:"prefix"`
}

type BashOperations interface {
	Exec(ctx context.Context, command, cwd string, options BashOperationsExecOptions) (BashOperationsResult, error)
}

type BashOperationsExecOptions struct {
	// OnData receives raw output bytes (stdout and stderr) as they arrive,
	// from one goroutine at a time. The callee may keep the slice.
	OnData func(data []byte)
	// Timeout is the requested timeout in seconds; nil means none.
	Timeout *float64
	// Env replaces the inherited environment when non-nil.
	Env []string
}

type BashOperationsResult struct {
	ExitCode *int
}

type BashResult = any

type BashToolCallEvent struct {
	ToolCallEventBase
	ToolName string        `json:"toolName"` // "bash"
	Input    BashToolInput `json:"input"`
}

type BashToolDetails struct {
	Truncation     *ToolTruncation `json:"truncation,omitempty"`
	FullOutputPath string          `json:"fullOutputPath,omitempty"`
}

type BashToolInput = any

type BashToolResultEvent struct {
	ToolResultEventBase
	ToolName string           `json:"toolName"` // "bash"
	Details  *BashToolDetails `json:"details,omitempty"`
}

type BeforeAgentStartCombinedResult struct {
	// Messages is the slice of custom messages collected from every
	// handler that returned `result.message`. Empty when no handler
	// pushed a message.
	Messages []CustomMessageRef `json:"messages,omitempty"`

	// SystemPrompt is the final mutated system prompt, non-nil only if at
	// least one handler set `result.systemPrompt` (an empty prompt included).
	SystemPrompt *string `json:"systemPrompt,omitempty"`

	// SystemPromptOptions is the per-run options object the handlers shared. It is set when the incoming options or a handler supplied sections, or a handler edited selectedTools. It does not alias the caller's base options.
	SystemPromptOptions *BuildSystemPromptOptions `json:"systemPromptOptions,omitempty"`

	// SelectedToolsEdited retains an explicit edit even when filtering non-string registry misses produces the original list.
	SelectedToolsEdited bool `json:"-"`
}

type BeforeAgentStartEvent struct {
	Type         string         `json:"type"`
	Prompt       string         `json:"prompt"`
	Images       []ImageContent `json:"images,omitempty"`
	SystemPrompt string         `json:"systemPrompt"`
	// SystemPromptOptions is the per-handler value view of the run's options. Use BeforeAgentStartOptions with the dispatch context to replace collections on the shared per-run object.
	SystemPromptOptions BuildSystemPromptOptions `json:"systemPromptOptions"`
}

type BeforeAgentStartEventResult struct {
	Message *CustomMessageRef `json:"message,omitempty"`
	// SystemPrompt replaces the run's system prompt when set, including when
	// it is empty; nil leaves it unchanged (upstream `systemPrompt?: string`).
	SystemPrompt *string `json:"systemPrompt,omitempty"`
}

type BeforeProviderHeadersEvent struct {
	Type    string          `json:"type"`
	Headers ProviderHeaders `json:"headers"`
}

type BeforeProviderRequestEvent struct {
	Type    string `json:"type"`
	Payload any    `json:"payload"`
}

type BeforeProviderRequestEventResult = any

type BoundaryBaseEvent interface {
	// contains filtered or unexported methods
}

type BoundaryContextPreview struct {
	ContextEntries  []ProjectedSessionEntry `json:"contextEntries"`
	ContextMessages []AgentMessage          `json:"contextMessages"`
	LLMMessages     []any                   `json:"llmMessages"`
	PendingMessages []AgentMessage          `json:"pendingMessages"`
	CanContinue     bool                    `json:"canContinue"`
}

type BoundaryResult struct {
	Entries  *[]SessionBoundaryDraft `json:"entries,omitempty"`
	Continue *bool                   `json:"continue,omitempty"`
}

type BoundaryState struct {
	Entries  []SessionBoundaryDraft `json:"entries"`
	Continue bool                   `json:"continue"`
	Context  BoundaryContextPreview `json:"context"`
	Outcome  AgentActivityOutcome   `json:"outcome"`
}

type BranchSummaryEntry = any

type BuildSystemPromptOptions struct {
	// CustomPrompt is the user-supplied prompt that replaces the default
	// (from --system-prompt, SYSTEM.md, or custom templates).
	CustomPrompt string `json:"customPrompt,omitempty"`
	// CustomPromptSet preserves a present empty customPrompt without changing the existing string field. A nonempty CustomPrompt is always present.
	CustomPromptSet bool `json:"-"`
	// ForceSystemPrompt is the exact full prompt a before_agent_start handler returned as systemPrompt; later handlers observe it (runner.ts:1346-1348). Nil is Pi's undefined; an empty string is a forced empty prompt.
	ForceSystemPrompt *string `json:"forceSystemPrompt,omitempty"`
	// SelectedTools is the list of tool names included in the prompt.
	// Defaults upstream to [read, bash, edit, write].
	SelectedTools []string `json:"selectedTools,omitzero"`
	// ToolSnippets maps tool name → one-line description used in the
	// "Available tools" section.
	ToolSnippets map[string]string `json:"toolSnippets,omitzero"`
	// ToolGuidelines contributes rules only while its tool is active.
	ToolGuidelines map[string][]string `json:"toolGuidelines,omitzero"`
	// PromptGuidelines holds bullet lines appended to the default
	// guidelines section.
	PromptGuidelines []string `json:"promptGuidelines,omitzero"`
	// AppendSystemPrompt is the joined text appended after the main
	// prompt body (from --append-system-prompt flags / settings).
	AppendSystemPrompt string `json:"appendSystemPrompt"`
	// Sections holds additional XML-wrapped sections in authored order. Event handlers mutate the per-run collection, not the Session's base options.
	Sections *ai.OrderedSections `json:"sections,omitempty"`
	// Cwd is the working directory shown to the LLM.
	Cwd string `json:"cwd"`
	// ContextFiles are pre-loaded AGENTS.md / CLAUDE.md files in the
	// order they appear in the prompt.
	ContextFiles []SystemPromptContextFile `json:"contextFiles,omitzero"`
	// Skills lists skills surfaced in the prompt's skills section.
	Skills []SystemPromptSkill `json:"skills,omitzero"`
}

type CacheWarmingAction string

type CacheWarmingDecisionEvent struct {
	Type                    string             `json:"type"`
	WarmCost                float64            `json:"warmCost"`
	MissCost                float64            `json:"missCost"`
	ContinuationProbability float64            `json:"continuationProbability"`
	Action                  CacheWarmingAction `json:"action"`
}

type CacheWarmingDecisionEventResult struct {
	Action *CacheWarmingAction `json:"action,omitempty"`
}

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

type CallOrder struct {
	Wait    func()
	Release func()
}

type CancelledResult struct {
	Cancelled bool `json:"cancelled"`
}

type Capability = string

type CommandActions struct {
	// WaitForIdle blocks until the agent finishes streaming.
	WaitForIdle        func() error
	WaitForIdleContext func(context.Context) error

	// NewSession starts a new session.
	NewSession        func(opts *NewSessionOptions) (CancelledResult, error)
	NewSessionContext func(context.Context, *NewSessionOptions) (CancelledResult, error)

	// Fork creates a new branch from entryId.
	Fork        func(entryID string, opts *ForkOptions) (CancelledResult, error)
	ForkContext func(context.Context, string, *ForkOptions) (CancelledResult, error)

	// NavigateTree moves to a different point in the session tree.
	NavigateTree        func(targetID string, opts *NavigateTreeOptions) (CancelledResult, error)
	NavigateTreeContext func(context.Context, string, *NavigateTreeOptions) (CancelledResult, error)

	// SwitchSession switches to a different session file.
	SwitchSession        func(sessionPath string, opts *SwitchSessionOptions) (CancelledResult, error)
	SwitchSessionContext func(context.Context, string, *SwitchSessionOptions) (CancelledResult, error)

	// Reload reloads extensions, skills, prompts, themes.
	Reload        func() error
	ReloadContext func(context.Context) error
}

type CommandContext struct {
	*Context
	// contains filtered or unexported fields
}

type CommandHandler = func(ctx context.Context, args string) error

type CommandOptions struct {
	Description            string                  `json:"description,omitempty"`
	GetArgumentCompletions ArgumentCompletionsFunc `json:"-"`
	Handler                CommandHandler          `json:"-"`
}

type CompactOptions struct {
	CustomInstructions string                        `json:"customInstructions,omitempty"`
	OnComplete         func(result CompactionResult) `json:"-"`
	OnError            func(err error)               `json:"-"`
}

type CompactionEntry = any

type CompactionPreparation = any

type CompactionResult = any

type Component = any

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

type ContextActions struct {
	// SessionManager backs Context.SessionManager().
	// upstream: types.ts:301 (read-only)
	SessionManager SessionManager

	// ModelRegistry backs Context.ModelRegistry().
	// upstream: types.ts:303
	ModelRegistry ModelRegistry

	// GetModel backs Context.Model(). Returns nil if no model is
	// currently selected.
	// upstream: types.ts:305 (Model<any> | undefined)
	GetModel func() Model

	// GetScopedModels returns the current read-only model scope. Context creation captures this callback, not its result.
	// upstream: packages/coding-agent/src/core/extensions/runner.ts:createContext
	GetScopedModels func() []ScopedModel

	// IsIdle backs Context.IsIdle().
	// upstream: types.ts:307
	IsIdle func() bool

	// IsProjectTrusted backs Context.IsProjectTrusted().
	// upstream: types.ts:332
	IsProjectTrusted func() bool

	// GetSignal backs Context.Signal(). It returns the active run's cancellation, or nil while no run is active.
	// upstream: types.ts:2158, runner.ts:917-920
	GetSignal func() context.Context

	// HasPendingMessages backs Context.HasPendingMessages().
	// upstream: types.ts:313
	HasPendingMessages func() bool

	// SendUserMessage backs Context.SendUserMessage(). Injects a user
	// message into the agent loop. Populated by the runner from
	// ExtensionActions, which is where a host supplies it.
	// upstream: types.ts:1306 (ExtensionAPI.sendUserMessage)
	SendUserMessage SendUserMessageHandler

	// Abort backs Context.Abort(). Cancels the current agent action.
	// upstream: types.ts:311
	Abort func()

	// Shutdown backs Context.Shutdown(). Triggers graceful agent
	// shutdown.
	// upstream: types.ts:315
	Shutdown func()

	// GetContextUsage backs Context.GetContextUsage().
	// upstream: types.ts:317
	GetContextUsage func() *ContextUsage

	// Compact backs Context.Compact(opts).
	// upstream: types.ts:319
	Compact func(opts *CompactOptions)

	// GetSystemPrompt backs Context.GetSystemPrompt(). The host callback
	// returns the latest prompt, including changes made by earlier
	// before_agent_start handlers.
	// upstream: types.ts:321
	GetSystemPrompt func() string

	// GetSystemPromptOptions backs CommandContext.GetSystemPromptOptions().
	// Returns the base inputs pi currently uses to build the system
	// prompt (custom prompt, tools, snippets, guidelines, append text,
	// cwd, context files, skills). nil → method returns zero-value
	// options, matching upstream's
	// `getSystemPromptOptions ?? (() => ({ cwd: this.cwd }))` default.
	// upstream: types.ts:1512, runner.ts:303,653
	GetSystemPromptOptions func() *BuildSystemPromptOptions

	// GetMode reads the current runner mode. Nil means print.
	// upstream: runner.ts:createContext
	GetMode func() ExtensionMode

	// GetUIContext reads the current runner UI binding. Nil uses the constructor's UI binding.
	// upstream: runner.ts:createContext
	GetUIContext func() UIContext

	// GetAllTools returns metadata about all registered tools.
	// Used by piglet scoping to enumerate available tools.
	GetAllTools func() []ToolInfo

	// GetActiveTools returns the names of currently active tools.
	GetActiveTools func() []string

	// SetActiveTools sets the active tool list by name.
	// Tools not in the list are hidden from the agent.
	SetActiveTools func(names []string)

	// RefreshTools rebuilds the session's tool registry from the tools extensions hold, so a tool registered after load
	// reaches the model. It returns the error that admitting a registered tool reports.
	// upstream: types.ts:1598 (RefreshToolsHandler), loader.ts:273-284 (registerTool calls runtime.refreshTools)
	RefreshTools func() error

	// GetMcpServers returns the MCP servers extensions registered, in registration order.
	// upstream: loader.ts:475-478 (getMcpServers)
	GetMcpServers func() []RegisteredMcpServer

	// GetFlagValue returns the value of an extension-registered flag.
	GetFlagValue func(name string) any

	// ToolActions back the [ToolContext] of a tool call: executeTool and
	// getCallableTools of upstream's ExtensionContextActions.
	// upstream: types.ts:2161-2169
	ToolActions
}

type ContextEvent struct {
	Type     string         `json:"type"`
	Messages []AgentMessage `json:"messages"`
}

type ContextEventResult struct {
	Messages []AgentMessage `json:"messages,omitempty"`
}

type ContextUsage struct {
	Tokens        *int     `json:"tokens"`
	ContextWindow int      `json:"contextWindow"`
	Percent       *float64 `json:"percent"`
}

type ContextWithSystemEvent struct {
	Type     string         `json:"type"`
	Messages []AgentMessage `json:"messages"`
}

type CustomEntry = any

type CustomFactory func(host CustomHost, theme Theme, keybindings KeybindingsManager, done func(result any)) (Component, error)

type CustomHost interface {
	// RequestRender asks the terminal to draw again. It is safe from any goroutine.
	RequestRender()
}

type CustomMessage = any

type CustomMessageRef struct {
	CustomType string `json:"customType"`
	Content    any    `json:"content"`
	Display    any    `json:"display,omitempty"`
	Details    any    `json:"details,omitempty"`
}

type CustomOptions struct {
	// Overlay shows the component over the screen instead of in the editor slot.
	Overlay bool
	// Layout positions an overlay.
	Layout *OverlayLayout
}

type CustomToolCallEvent struct {
	ToolCallEventBase
	ToolName string         `json:"toolName"`
	Input    map[string]any `json:"input"`
}

type CustomToolResultEvent struct {
	ToolResultEventBase
	ToolName string `json:"toolName"`
	Details  any    `json:"details,omitempty"`
}

type DeliverAs string

type DialogInitiationReporter interface {
	ReportsDialogInitiation() bool
}

type EditToolCallEvent struct {
	ToolCallEventBase
	ToolName string        `json:"toolName"` // "edit"
	Input    EditToolInput `json:"input"`
}

type EditToolDetails struct {
	Diff             string `json:"diff"`
	Patch            string `json:"patch"`
	FirstChangedLine int    `json:"firstChangedLine,omitempty"`
}

type EditToolInput = any

type EditToolResultEvent struct {
	ToolResultEventBase
	ToolName string           `json:"toolName"` // "edit"
	Details  *EditToolDetails `json:"details,omitempty"`
}

type EditorComponent = any

type EditorTheme = any

type EntryRenderOptions struct {
	Expanded bool `json:"expanded"`
}

type EntryRenderer = func(
	entry CustomEntry,
	options EntryRenderOptions,
	theme Theme,
) Component

type ErrorListener = func(*ExtensionError)

type EventBus interface {
	// Emit broadcasts data on channel to every current listener. Synchronous:
	// handlers run before Emit returns. A handler's failure does not reach the
	// emitter or the other listeners; the host reports it as
	// `Event handler error (<channel>):` (event-bus.ts:19-23).
	Emit(channel string, data any)

	// On registers handler for channel and returns an idempotent function that
	// removes it. Handlers are dispatched in registration order.
	On(channel string, handler func(data any)) (unsubscribe func())
}

type ExecOptions struct {
	// Timeout in milliseconds. Pi's timeout is a JavaScript number: a positive value starts a timer and anything else starts none.
	Timeout float64 `json:"timeout,omitempty"`
	// CWD overrides the working directory. Empty uses the extension's CWD.
	CWD string `json:"cwd,omitempty"`
}

type ExecResult struct {
	Stdout string `json:"stdout"`
	Stderr string `json:"stderr"`
	Code   int    `json:"code"`
	Killed bool   `json:"killed"`
}

type ExecuteToolOptions struct {
	// Signal cancels the nested call. Defaults to the calling tool's context. Go mechanic (not a divergence): upstream's AbortSignal is a context.Context, as in [ExecOptions].
	Signal context.Context `json:"-"`
	// OnUpdate receives partial results of the nested tool, in addition to `tool_execution_update` events.
	OnUpdate AgentToolUpdateCallback `json:"-"`
}

type Extension struct {
	// Name is the human-readable name of the extension, typically derived
	// from the manifest or directory name. Used for display in the UI.
	Name string

	// Path is the original (unresolved) path the extension was loaded from.
	// This is typically the path the user passed via --extension or that the
	// loader discovered. May be relative.
	Path string

	// ResolvedPath is the absolute, canonical path used for diagnostics,
	// telemetry, and "Using <path>" UI strings.
	ResolvedPath string

	// Replaceable leaves the extension out when another extension registers a
	// tool, command, or flag with a name it registers during loading, instead of
	// reporting a conflict. The CLI's built-in MCP, codemode, and tool search
	// extensions use it. upstream: types.ts:2209 (Extension.replaceable)
	Replaceable bool

	// SourceInfo describes the extension's origin and ownership metadata. The
	// current public contract carries this value opaquely.
	SourceInfo SourceInfo

	// Handlers is the legacy construction shape. NewRunner imports it into the
	// concurrency-safe handler registry before dispatch.
	Handlers map[string][]HandlerFn

	// Tools is the startup construction shape, keyed by name. Runtime readers use RegisteredTools or RegisteredTool to include synchronized late registrations.
	Tools map[string]RegisteredTool

	// ToolOrder records tool registration order. Go maps do not retain
	// insertion order; loaders populate this alongside Tools so tool lists
	// keep upstream's registration order (a Map in extension.tools).
	ToolOrder []string

	// MessageRenderers is keyed by the custom message type the renderer handles.
	MessageRenderers map[string]MessageRenderer

	// EntryRenderers is keyed by the custom entry type the renderer handles.
	// Custom entries (appended via AppendEntry) do not participate in LLM context.
	EntryRenderers map[string]EntryRenderer

	// ToolRenderers are the extension's tool renderer resolvers, in registration order.
	// upstream: types.ts Extension.toolRenderers
	ToolRenderers []ToolRendererResolver

	// MarkdownTransformer is the extension's display-only Markdown transform,
	// if it registered one; a later registration replaces an earlier one.
	// upstream: types.ts Extension.markdownTransformer
	MarkdownTransformer MarkdownTransformer

	// Commands is keyed by the command name (without leading slash).
	Commands map[string]RegisteredCommand

	// CommandOrder records command registration order. Go maps do not retain
	// insertion order; loaders populate this alongside Commands so resolved
	// invocation names match upstream extension and registration order.
	CommandOrder []string

	// Flags is keyed by the flag name.
	Flags map[string]ExtensionFlag

	// FlagOrder records the first registration of each flag name. Loaders populate it alongside Flags, so --help lists flags in upstream registration order.
	FlagOrder []string

	// Shortcuts is keyed by the canonical KeyID (e.g. "ctrl+shift+r").
	Shortcuts map[KeyID]ExtensionShortcut

	// Hidden omits the extension from the startup Extensions list.
	// upstream: .upstream/v0.99.1/packages/coding-agent/src/core/extensions/types.ts:2208 (Extension.hidden)
	Hidden bool
	// contains filtered or unexported fields
}

type ExtensionActions struct {
	// upstream: types.ts:1590: SendMessageHandler
	SendMessage any
	// upstream: types.ts:1591: SendUserMessageHandler
	SendUserMessage SendUserMessageHandler
	// upstream: types.ts:1591: AppendEntryHandler
	AppendEntry any
	// upstream: types.ts:1592: SetSessionNameHandler
	SetSessionName any
	// upstream: types.ts:1593: GetSessionNameHandler
	GetSessionName any
	// upstream: types.ts:1594: SetLabelHandler
	SetLabel any
	// upstream: types.ts:1595: GetActiveToolsHandler
	GetActiveTools any
	// upstream: types.ts:1596: GetAllToolsHandler
	GetAllTools any
	// upstream: types.ts:2135: GetSettingsHandler
	GetSettings func() Settings
	// upstream: types.ts:1597: SetActiveToolsHandler
	SetActiveTools any
	// upstream: types.ts:1598: RefreshToolsHandler
	RefreshTools any
	// upstream: types.ts:1599: GetCommandsHandler
	GetCommands any
	// upstream: types.ts:1600: SetModelHandler
	SetModel any
	// upstream: types.ts:1601: GetThinkingLevelHandler
	GetThinkingLevel any
	// upstream: types.ts:1602: SetThinkingLevelHandler
	SetThinkingLevel any
}

type ExtensionError struct {
	// ExtensionPath is the resolved filesystem path of the extension
	// whose handler failed. Mirrors upstream `extensionPath`.
	ExtensionPath string `json:"extensionPath"`

	// Event is the event-type string the handler was registered for
	// (e.g. "tool_call", "session_start"). Mirrors upstream `event`.
	Event string `json:"event"`

	// Error is the human-readable message. In Go this is `err.Error()`;
	// upstream is `err.message`. Mirrors upstream `error`.
	Error string `json:"error"`

	// Stack is the optional stack of the failure itself, as upstream's
	// `err.stack`: the thrown error's stack for a subprocess extension, or
	// the panicking goroutine's stack for an in-process handler. It is empty
	// for a plain returned error, which carries no stack. See [ErrorStack].
	Stack string `json:"stack,omitempty"`
}

type ExtensionFlag struct {
	Name          string   `json:"name"`
	Description   string   `json:"description,omitempty"`
	Type          FlagType `json:"type"`
	Default       any      `json:"default,omitempty"`
	ExtensionPath string   `json:"extensionPath"`
}

type ExtensionMode string

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

type ExtensionShortcut struct {
	Shortcut      KeyID           `json:"shortcut"`
	Description   string          `json:"description,omitempty"`
	Handler       ShortcutHandler `json:"-"`
	ExtensionPath string          `json:"extensionPath"`
}

type ExtensionUIDialogOptions = any

type ExtensionVirtualModel = VirtualModelDefinition

type ExtensionWidgetOptions = any

type FindToolCallEvent struct {
	ToolCallEventBase
	ToolName string        `json:"toolName"` // "find"
	Input    FindToolInput `json:"input"`
}

type FindToolDetails struct {
	Truncation         *ToolTruncation `json:"truncation,omitempty"`
	ResultLimitReached *float64        `json:"resultLimitReached,omitempty"`
}

type FindToolInput = any

type FindToolResultEvent struct {
	ToolResultEventBase
	ToolName string           `json:"toolName"` // "find"
	Details  *FindToolDetails `json:"details,omitempty"`
}

type FlagOptions struct {
	Description string   `json:"description,omitempty"`
	Type        FlagType `json:"type"`
	// Default is bool when Type == FlagBoolean and string when
	// Type == FlagString. Nil when no default.
	Default any `json:"default,omitempty"`
}

type FlagType string

type ForkOptions struct {
	Position    string                              `json:"position,omitempty"` // "before" | "at"
	WithSession func(*ReplacedSessionContext) error `json:"-"`
}

type GrepToolCallEvent struct {
	ToolCallEventBase
	ToolName string        `json:"toolName"` // "grep"
	Input    GrepToolInput `json:"input"`
}

type GrepToolDetails struct {
	Truncation        *ToolTruncation `json:"truncation,omitempty"`
	MatchLimitReached float64         `json:"matchLimitReached,omitempty"`
	LinesTruncated    bool            `json:"linesTruncated,omitempty"`
}

type GrepToolInput = any

type GrepToolResultEvent struct {
	ToolResultEventBase
	ToolName string           `json:"toolName"` // "grep"
	Details  *GrepToolDetails `json:"details,omitempty"`
}

type HandlerFn = func(args ...any) (any, error)

type ImageContent = any

type InputEvent struct {
	Type   string         `json:"type"`
	Text   string         `json:"text"`
	Images []ImageContent `json:"images,omitempty"`
	Source InputSource    `json:"source"`
	// StreamingBehavior indicates context when input arrives during streaming.
	// "steer" = mid-stream steer, "followUp" = queued follow-up.
	// Empty when the agent is idle. Mirrors upstream v0.77.0.
	StreamingBehavior string `json:"streamingBehavior,omitempty"`
}

type InputEventResult interface {
	// contains filtered or unexported methods
}

type InputEventResultContinue struct{}

type InputEventResultHandled struct{}

type InputEventResultTransform struct {
	Text   string         `json:"text"`
	Images []ImageContent `json:"images,omitempty"`
}

type InputSource = string

type KeyID = string

type KeybindingsManager = any

type LoginDefinition struct {
	Brand       []string          `json:"brand"`
	Hero        []string          `json:"hero"`
	Mascot      []string          `json:"mascot"`
	Palette     map[string]string `json:"palette"`
	Name        string            `json:"name"`
	Description string            `json:"description"`
	Tagline     string            `json:"tagline"`
}

type LoginDefinitionError struct {
	Field   string
	Message string
}

type LsToolCallEvent struct {
	ToolCallEventBase
	ToolName string      `json:"toolName"` // "ls"
	Input    LsToolInput `json:"input"`
}

type LsToolDetails struct {
	Truncation        *ToolTruncation `json:"truncation,omitempty"`
	EntryLimitReached float64         `json:"entryLimitReached,omitempty"`
}

type LsToolInput = any

type LsToolResultEvent struct {
	ToolResultEventBase
	ToolName string         `json:"toolName"` // "ls"
	Details  *LsToolDetails `json:"details,omitempty"`
}

type MarkdownMessageType string

type MarkdownTransformContext struct {
	// Context owns the off-loop host generation; it is not part of Pi's wire context.
	Context        context.Context     `json:"-"`
	MessageType    MarkdownMessageType `json:"messageType"`
	IsStreaming    bool                `json:"isStreaming"`
	AvailableWidth int                 `json:"availableWidth"`
}

type MarkdownTransformer func(markdown string, context MarkdownTransformContext) string

type McpAuthConfig struct {
	Provider string `json:"provider"`
}

type McpExposure string

type McpOAuthConfig struct {
	// ClientID is a pre-registered client id. Without it, a client is registered
	// with the authorization server.
	ClientID string `json:"clientId,omitempty"`
	// ClientSecret may reference environment variables (`${NAME}`) or commands (`!cmd`).
	ClientSecret string `json:"clientSecret,omitempty"`
	// CallbackPort is the port of the loopback callback server, for clients
	// registered with a fixed redirect URI. Without CallbackURL, the redirect URI
	// is `http://127.0.0.1:<port>/callback`.
	CallbackPort *int `json:"callbackPort,omitempty"`
	// CallbackURL is the redirect URI registered for ClientID, for example
	// `http://localhost:8080/oauth/callback`. It must be an `http` URI on
	// `localhost`, `127.0.0.1`, or `[::1]`. Without a port, the callback server
	// listens on CallbackPort or a free port, which is added to the URI (RFC 8252).
	CallbackURL string `json:"callbackUrl,omitempty"`
	// Scope lists the scopes to request, separated by spaces. Default: the
	// scopes the server advertises.
	Scope string `json:"scope,omitempty"`
	// ClientName is the `client_name` sent with dynamic client registration,
	// for servers that only accept known clients. Default: the app name.
	ClientName string `json:"clientName,omitempty"`
	// ClientRegistration is how pi identifies itself without ClientID. `dcr`
	// (default): dynamic client registration. `cimd`: pi's Client ID Metadata
	// Document on pi.dev, for authorization servers that allow pi by that URL.
	// The server must support it for public clients, and the callback must use
	// the default path `/callback`.
	ClientRegistration string `json:"clientRegistration,omitempty"`
	// AuthServerMetadataURL is an authorization server metadata document
	// (RFC 8414 or OpenID Connect discovery) to use instead of discovery
	// through the server, for servers that advertise a wrong authorization
	// server or none. The document is trusted as configured. It must use
	// https, except on loopback hosts.
	AuthServerMetadataURL string `json:"authServerMetadataUrl,omitempty"`
}

type McpServerConfig struct {
	// Type is "stdio" or "http"; "streamable-http" is accepted for HTTP servers.
	Type string `json:"type,omitempty"`
	// Exposure defaults to codemode.
	Exposure McpExposure `json:"exposure,omitempty"`
	// Description is what the server offers, in a sentence. The `mcp_servers`
	// system prompt section lists the server with it, tool search ranks the
	// server's tools by it, and codemode's `describeNamespace()` returns it.
	Description string `json:"description,omitempty"`
	// ToolExposure overrides Exposure for single tools. Keys are tool names as
	// the server offers them, or patterns where `*` matches any characters. An
	// exact name wins over patterns; among patterns the first match in the
	// object wins. hidden removes tools, so `"exposure": "hidden"` with overrides
	// for a few tools exposes only those.
	ToolExposure *OrderedExposures `json:"toolExposure,omitempty"`
	// Enabled set to false keeps the entry without connecting. Default: true.
	Enabled *bool `json:"enabled,omitempty"`
	// Timeout is the per-request timeout in seconds. Progress notifications from
	// the server reset it. Default: 60.
	Timeout *float64 `json:"timeout,omitempty"`

	// Stdio servers.
	Command string   `json:"command,omitempty"`
	Args    []string `json:"args,omitempty"`
	// Env values may reference environment variables (`${NAME}`) or commands (`!cmd`).
	Env *OrderedStrings `json:"env,omitempty"`
	// Cwd is relative to the session working directory.
	Cwd string `json:"cwd,omitempty"`

	// HTTP servers.
	URL string `json:"url,omitempty"`
	// Headers values may reference environment variables (`${NAME}`) or commands (`!cmd`).
	Headers *OrderedStrings `json:"headers,omitempty"`
	OAuth   *McpOAuthConfig `json:"oauth,omitempty"`
	// Auth sends the token of a pi provider instead of using OAuth. Not allowed
	// in project `mcp.json` files, and requires https except on loopback hosts.
	Auth *McpAuthConfig `json:"auth,omitempty"`
}

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

type McpServersChangeEvent struct {
	Type string `json:"type"`
	// Servers is every registered server after the change.
	Servers []RegisteredMcpServer `json:"servers"`
}

type MessageEndEvent struct {
	Type    string       `json:"type"`
	Message AgentMessage `json:"message"`
}

type MessageEndEventResult struct {
	// Message replaces the finalized message. Replacement must preserve role.
	Message *AgentMessage `json:"message,omitempty"`
}

type MessageRenderOptions struct {
	Expanded bool `json:"expanded"`
	// OutputPad is the horizontal padding configured by the outputPad setting.
	OutputPad int `json:"outputPad"`
}

type MessageRenderer = func(
	message CustomMessage,
	options MessageRenderOptions,
	theme Theme,
) Component

type MessageStartEvent struct {
	Type    string       `json:"type"`
	Message AgentMessage `json:"message"`
}

type MessageUpdateEvent struct {
	Type                  string                `json:"type"`
	Message               AgentMessage          `json:"message"`
	AssistantMessageEvent AssistantMessageEvent `json:"assistantMessageEvent"`
}

type Model = any

type ModelRegistry = any

type ModelRoute struct {
	Model         *ai.Model
	ThinkingLevel ai.ModelThinkingLevel
	// State is the new router state, stored on the session branch unless it is the request's own state. Return the request's state or nil to keep the current state. Must be JSON. Ignored for `direct` requests.
	State json.RawMessage
}

type ModelRouteFailed struct {
	Model         *ai.Model
	ThinkingLevel ai.ModelThinkingLevel
	Message       ai.AssistantMessage
}

type ModelRouteFunc = func(ctx context.Context, request ModelRouteRequest) (ModelRoute, error)

type ModelRoutePrevious struct {
	Model         *ai.Model
	ThinkingLevel ai.ModelThinkingLevel
}

type ModelRouteReason string

type ModelRouteRequest struct {
	// Model is the selected virtual model.
	Model *ai.Model
	// ThinkingLevel is the selected thinking level. Its meaning is up to the router.
	ThinkingLevel ai.ModelThinkingLevel
	Reason        ModelRouteReason
	// Previous is the physical model and thinking level of the latest successful response in Messages.
	Previous *ModelRoutePrevious
	// Failed is the failed request of a retry. Absent when the router itself failed.
	Failed *ModelRouteFailed
	// State is the router state last returned on this session branch. Absent before the first state and for `direct` requests.
	State json.RawMessage
	// Messages is the conversation for this request, including system messages.
	Messages []ai.Message
}

type ModelSelectEvent struct {
	Type          string            `json:"type"`
	Model         Model             `json:"model"`
	PreviousModel Model             `json:"previousModel,omitempty"`
	Source        ModelSelectSource `json:"source"`
}

type ModelSelectSource = string

type ModelStreamRequest struct {
	API              bool
	Fetch            *http.Client
	OnPayload        func(any, *ai.Model) (any, error)
	OnResponse       func(context.Context, ai.ProviderResponse, *ai.Model) error
	TransformHeaders func(context.Context, ai.ProviderHeaders) (ai.ProviderHeaders, error)
}

type NativeProvider struct {
	// IsCurrent guards publication when host registrations overlap across connections.
	IsCurrent                func() bool
	ID                       string
	Name                     string
	BaseURL                  string
	Models                   []ProviderModelConfig
	CheckAuth                func(context.Context, *ai.Credential) (*ai.AuthCheck, error)
	FilterModels             func(context.Context, []ProviderModelConfig, *ai.Credential) ([]ProviderModelConfig, error)
	ResolveAuth              func(context.Context, *ai.Credential, ai.AuthResolutionOverrides) (*ai.AuthResult, *ai.Credential, error)
	ResolveRefreshCredential func(context.Context, *ai.Credential) (*ai.Credential, *ai.Credential, error)
	RefreshModels            func(context.Context, *ai.Credential, *ai.ModelsStoreEntry, bool, *bool, func(NativeProviderPublication) error) ([]ProviderModelConfig, error)
	Stream                   func(context.Context, *ai.Model, ai.TranscriptContext, ai.StreamOptions, bool) (*ai.AssistantMessageEventStream, error)
	// GenerateImages and Classify are the provider object's image and classifier operations; nil when it has none.
	// upstream: pi-ai Provider.generateImages, Provider.classify
	GenerateImages func(context.Context, *ai.ImageModel, ai.ImagesContext, ai.ImagesOptions) (ai.AssistantImages, error)
	Classify       func(context.Context, *ai.ClassifierModel, ai.ClassifierContext, ai.ClassifierOptions) (ai.ClassifierResult, error)
}

type NativeProviderPublication struct {
	Persist json.RawMessage        `json:"persist,omitempty"`
	Models  *[]ProviderModelConfig `json:"models,omitempty"`
}

type NavigateTreeOptions struct {
	Summarize           bool   `json:"summarize,omitempty"`
	CustomInstructions  string `json:"customInstructions,omitempty"`
	ReplaceInstructions bool   `json:"replaceInstructions,omitempty"`
	Label               string `json:"label,omitempty"`
}

type NewSessionOptions struct {
	ParentSession string                              `json:"parentSession,omitempty"`
	Setup         func(SessionManager) error          `json:"-"`
	WithSession   func(*ReplacedSessionContext) error `json:"-"`
}

type OAuthCredentials = any

type OAuthLoginCallbacks = any

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

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

type OverlayHandle = any

type OverlayLayout struct {
	Width        *OverlaySizeValue   `json:"width,omitempty"`
	MinWidth     *int                `json:"minWidth,omitempty"`
	MaxHeight    *OverlaySizeValue   `json:"maxHeight,omitempty"`
	Anchor       string              `json:"anchor,omitempty"`
	OffsetX      int                 `json:"offsetX,omitempty"`
	OffsetY      int                 `json:"offsetY,omitempty"`
	Row          *OverlaySizeValue   `json:"row,omitempty"`
	Col          *OverlaySizeValue   `json:"col,omitempty"`
	Margin       *OverlayMarginValue `json:"margin,omitempty"`
	NonCapturing bool                `json:"nonCapturing,omitempty"`
}

type OverlayMarginValue struct {
	All                      *int
	Top, Right, Bottom, Left int
}

type OverlayOptions = any

type OverlaySizeValue struct {
	Value   float64
	Percent bool
	Invalid bool
}

type PendingProviderRegistration struct {
	Name          string
	Config        ProviderConfig
	ExtensionPath string
}

type PendingVirtualModelRegistration struct {
	Definition    VirtualModelDefinition
	ExtensionPath string
}

type PowerShellToolCallEvent struct {
	ToolCallEventBase
	ToolName string              `json:"toolName"` // "powershell"
	Input    PowerShellToolInput `json:"input"`
}

type PowerShellToolDetails = BashToolDetails

type PowerShellToolInput = BashToolInput

type PowerShellToolResultEvent struct {
	ToolResultEventBase
	ToolName string                 `json:"toolName"` // "powershell"
	Details  *PowerShellToolDetails `json:"details,omitempty"`
}

type ProjectTrustEvent struct {
	Type string `json:"type"` // "project_trust"
	Cwd  string `json:"cwd"`
}

type ProjectTrustEventDecision string

type ProjectTrustEventResult struct {
	Trusted  ProjectTrustEventDecision `json:"trusted"`
	Remember *bool                     `json:"remember,omitempty"`
}

type ProjectedSessionEntry struct {
	SourceEntry any            `json:"sourceEntry"`
	Messages    []AgentMessage `json:"messages"`
}

type ProviderActions struct {
	RegisterProvider   func(name string, config ProviderConfig) error
	UnregisterProvider func(name string)
	// RegisterVirtualModel and UnregisterVirtualModel apply virtual-model registrations; the model registry's own ones apply when unset.
	// upstream: runner.ts:413-417 (providerActions.registerVirtualModel, unregisterVirtualModel)
	RegisterVirtualModel   func(definition VirtualModelDefinition) error
	UnregisterVirtualModel func(provider, id string)
}

type ProviderConfig struct {
	Name         string               `json:"name,omitempty"`
	BaseURL      string               `json:"baseUrl,omitempty"`
	APIKey       string               `json:"apiKey,omitempty"`
	API          ai.API               `json:"api,omitempty"`
	StreamSimple ProviderStreamSimple `json:"-"`
	// Images are the image-generation implementations keyed by image API.
	// upstream: types.ts:1896 (ProviderConfig.images)
	Images map[ai.ImageAPI]*ai.ProviderImages `json:"-"`
	// Classifiers are the classifier implementations keyed by classifier API.
	// upstream: types.ts:1898 (ProviderConfig.classifiers)
	Classifiers map[ai.ClassifierAPI]*ai.ProviderClassifier `json:"-"`
	Headers     map[string]string                           `json:"headers,omitempty"`

	AuthHeader bool                  `json:"authHeader,omitempty"`
	Models     []ProviderModelConfig `json:"models,omitempty"`
	OAuth      *ProviderOAuth        `json:"oauth,omitempty"`
	// Insecure skips TLS certificate verification for this provider's
	// endpoint. Opt-in only, for self-signed/internal-CA on-prem gateways.
	// pig additive (D36): additive optional field; no upstream per-provider TLS-skip.
	Insecure bool `json:"insecure,omitempty"`
	// contains filtered or unexported fields
}

type ProviderHeaders = map[string]*string

type ProviderModelConfig struct {
	ID   string `json:"id"`
	Name string `json:"name"`
	// Type is "chat", "image" or "classifier". Empty is "chat".
	// upstream: types.ts:1953-1976 (type)
	Type ai.ModelType `json:"type,omitempty"`
	// API is a chat API, or for an image or classifier entry the image or classifier API id.
	API ai.API `json:"api,omitempty"`
	// Output is the output types of an image entry: it always includes "image"; "text" means the model can also return text blocks.
	// upstream: types.ts:1969 (ProviderImageModelConfig.output)
	Output           []string            `json:"output,omitempty"`
	BaseURL          string              `json:"baseUrl,omitempty"`
	Reasoning        bool                `json:"reasoning"`
	ThinkingLevelMap ai.ThinkingLevelMap `json:"thinkingLevelMap,omitempty"`
	Input            []string            `json:"input"`
	// InputLimits is upstream's provider input limits and cache-safe image
	// preprocessing metadata.
	InputLimits *ai.ModelInputLimits `json:"inputLimits,omitempty"`
	Cost        ProviderModelCost    `json:"cost"`
	// PromptCache is upstream's best-effort prompt cache lifetime in seconds
	// per retention tier.
	PromptCache    ai.ModelPromptCache `json:"promptCache,omitempty"`
	SamplingParams map[string]any      `json:"samplingParams,omitempty"`
	// SamplingParamsByThinkingLevel overrides SamplingParams for the effective Pi thinking level of a chat entry.
	// upstream: packages/coding-agent/src/core/provider-composer.ts:72 (ProviderChatModelConfig.samplingParamsByThinkingLevel), carried by extensionModelFromDefinition's spread.
	SamplingParamsByThinkingLevel ai.SamplingParamsByThinkingLevel `json:"samplingParamsByThinkingLevel,omitempty"`
	ContextWindow                 int                              `json:"contextWindow"`
	MaxTokens                     int                              `json:"maxTokens"`
	Headers                       map[string]string                `json:"headers,omitempty"`

	Compat any `json:"compat,omitempty"`
	// contains filtered or unexported fields
}

type ProviderModelCost struct {
	Input      float64       `json:"input"`
	Output     float64       `json:"output"`
	CacheRead  float64       `json:"cacheRead"`
	CacheWrite float64       `json:"cacheWrite"`
	Tiers      []ai.CostTier `json:"tiers,omitzero"`
}

type ProviderOAuth struct {
	Name string `json:"name"`
	// IsSubscription marks access through this OAuth method as subscription-backed.
	IsSubscription bool                                                          `json:"isSubscription,omitempty"`
	Login          func(callbacks OAuthLoginCallbacks) (OAuthCredentials, error) `json:"-"`
	RefreshToken   func(creds OAuthCredentials) (OAuthCredentials, error)        `json:"-"`
	GetAPIKey      func(creds OAuthCredentials) string                           `json:"-"`
	ModifyModels   func(models []Model, creds OAuthCredentials) []Model          `json:"-"`
}

type ProviderStreamEvent struct {
	Type     string `json:"type"`
	Provider string `json:"provider"`
	API      string `json:"api"`
	Model    string `json:"model"`
	Data     any    `json:"data"`
}

type ProviderStreamSimple = func(model Model, ctx AIContext, opts SimpleStreamOptions) AssistantMessageEventStream

type ReadToolCallEvent struct {
	ToolCallEventBase
	ToolName string        `json:"toolName"` // "read"
	Input    ReadToolInput `json:"input"`
}

type ReadToolDetails struct {
	Truncation *ToolTruncation `json:"truncation,omitempty"`
}

type ReadToolInput = any

type ReadToolResultEvent struct {
	ToolResultEventBase
	ToolName string           `json:"toolName"` // "read"
	Details  *ReadToolDetails `json:"details,omitempty"`
}

type ReadonlyFooterDataProvider = any

type ReadonlySessionManager = any

type RegisteredCommand struct {
	Name                   string                  `json:"name"`
	SourceInfo             SourceInfo              `json:"sourceInfo"`
	Description            string                  `json:"description,omitempty"`
	GetArgumentCompletions ArgumentCompletionsFunc `json:"-"`
	Handler                CommandHandler          `json:"-"`
}

type RegisteredMcpServer struct {
	Name   string          `json:"name"`
	Config McpServerConfig `json:"config"`
	// Declared is the config as the extension wrote it with its exposure aliases resolved, JSON.stringify(JSON.parse(text)): every member, known or not, in the order written, the way a JavaScript object holds them. Extensions read it back through getMcpServers, so the wire carries it in place of Config, which holds the members the host uses. Empty for a server registered with a typed Config alone.
	// upstream: mcp-servers.ts:151-166,192-222 (validateMcpServerConfig returns the alias-resolved copy of the object it was given), 283 (list copies it with structuredClone)
	Declared json.RawMessage `json:"-"`
	// ExtensionPath is the path of the extension that registered the server.
	ExtensionPath string `json:"extensionPath"`
}

type RegisteredTool struct {
	Definition ToolDefinition `json:"definition"`
	SourceInfo SourceInfo     `json:"sourceInfo"`
}

type RemoteEditor interface {
	// Input delivers one keystroke to the editor's handleInput.
	Input(data string)
	// SetText, InsertTextAtCursor and AddToHistory call the editor's
	// methods of the same name, as Pi's host calls them on this.editor.
	SetText(text string)
	InsertTextAtCursor(text string)
	AddToHistory(text string)
	// Mouse delivers a left click on the editor rows to the editor's
	// handleMouse, as Pi's fullscreen renderer does.
	Mouse(event RemoteEditorMouseEvent)
	// Configure applies host editor state to the editor: Pi copies the
	// default editor's text, padding and autocomplete size when it installs
	// the editor, and the TUI sets its focus.
	Configure(config RemoteEditorConfig)
	// EmbedWorkingStatus reports whether this editor wants status in its border.
	EmbedWorkingStatus() bool
	// Bind attaches the host that receives the editor's frames and
	// callbacks. Events that arrive before Bind are delivered on binding.
	Bind(host RemoteEditorHost)
	// Close detaches the editor from the host.
	Close()
}

type RemoteEditorAction struct {
	Action   string `json:"action"`
	Text     string `json:"text"`
	Expanded string `json:"expanded"`
	Local    bool   `json:"local"`
}

type RemoteEditorConfig struct {
	PaddingX               int  `json:"paddingX"`
	AutocompleteMaxVisible int  `json:"autocompleteMaxVisible"`
	Focused                bool `json:"focused"`
	// ThinkingLevel is the session's thinking level, whose border color Pi
	// gives the editor outside bash mode.
	ThinkingLevel string `json:"thinkingLevel"`
	// ShowHardwareCursor is the TUI's hardware-cursor setting, which the
	// editor's tui.getShowHardwareCursor() reports.
	ShowHardwareCursor bool `json:"showHardwareCursor"`
	// Shortcuts are the key ids of the extension shortcuts Pi's
	// onExtensionShortcut runs from inside the editor.
	Shortcuts        []string `json:"shortcuts"`
	Streaming        bool     `json:"streaming"`
	Compacting       bool     `json:"compacting"`
	BashRunning      bool     `json:"bashRunning"`
	InterruptHandled bool     `json:"interruptHandled"`
	// WorkingStatus is the current border status; nil clears it.
	WorkingStatus *RemoteEditorStatus `json:"workingStatus"`
}

type RemoteEditorHost interface {
	// EditorFrame is the editor's render(width) output for the terminal
	// width. WantsKeyRelease is the editor's wantsKeyRelease flag.
	EditorFrame(lines []string, width int, wantsKeyRelease bool)
	// EditorChanged is the editor's onChange: its text and, for the host's
	// getEditorText, the text with paste markers expanded.
	EditorChanged(text, expanded string)
	// EditorSubmit is the editor's onSubmit. done runs once the host has
	// handled the submission, which settles the promise onSubmit returns.
	EditorSubmit(text string, done func())
	// EditorAction runs Pi's handler for an app action the editor
	// dispatched: app.interrupt (onEscape), app.exit (onCtrlD),
	// app.clipboard.pasteImage (onPasteImage), or an actionHandlers entry.
	EditorAction(action RemoteEditorAction)
	// EditorInputDone releases input backpressure after the key's callbacks have reached the host.
	EditorInputDone()
	// EditorShortcut runs the extension shortcut the editor's
	// onExtensionShortcut matched for data.
	EditorShortcut(data string)
	// TerminalWrite writes raw output to the terminal (tui.terminal.write).
	TerminalWrite(data string)
	// SetShowHardwareCursor is tui.setShowHardwareCursor.
	SetShowHardwareCursor(enabled bool)
	// EditorClosed reports that the extension's editor is gone (its process
	// ended); the host restores its own editor.
	EditorClosed()
}

type RemoteEditorMouseEvent struct {
	Type       string `json:"type"`
	Button     string `json:"button"`
	X          int    `json:"x"`
	Y          int    `json:"y"`
	ScreenX    int    `json:"screenX"`
	ScreenY    int    `json:"screenY"`
	Width      int    `json:"width"`
	Height     int    `json:"height"`
	Shift      bool   `json:"shift"`
	Alt        bool   `json:"alt"`
	Ctrl       bool   `json:"ctrl"`
	ClickCount int    `json:"clickCount,omitempty"`
}

type RemoteEditorStatus struct {
	Kind              string   `json:"kind"`
	Message           string   `json:"message"`
	Frames            []string `json:"frames"`
	Frame             int      `json:"frame"`
	SpinnerColor      string   `json:"spinnerColor"`
	MessageColor      string   `json:"messageColor"`
	IndicatorVerbatim bool     `json:"indicatorVerbatim"`
}

type RemoteOverlayBounds struct {
	Row    int `json:"row"`
	Col    int `json:"col"`
	Width  int `json:"width"`
	Height int `json:"height"`
}

type RemoteOverlayFocusTarget struct {
	Overlay any
	Editor  bool
}

type RemoteOverlayHandle interface {
	// UpdateLines replaces the overlay's cached lines and triggers
	// a TUI render. Safe to call from any goroutine.
	UpdateLines(lines []string)
	// Close signals that the overlay is finished and unblocks the
	// originating [UIContext.RunRemoteOverlay] call with the given
	// result value. Safe to call from any goroutine.
	Close(result any)
}

type RemoteOverlayHost interface {
	// OnInput is invoked for every input chunk (a single key event
	// after [tui.ReadInput] segmentation) while the overlay is
	// open. Called from the input-reading goroutine.
	OnInput(data string)
}

type RemoteOverlayOptions struct {
	// Title is the overlay's titlebar text. Empty hides the bar.
	Title string `json:"title,omitempty"`
	// WidthFraction is the fraction of terminal width the overlay
	// should occupy. Zero falls back to the overlay default.
	WidthFraction float64 `json:"widthFraction,omitempty"`
	// HeightFraction is the fraction of terminal height the
	// overlay should occupy. Zero falls back to the overlay default.
	HeightFraction float64 `json:"heightFraction,omitempty"`
	// Overlay opens a floating viewport overlay over the whole screen
	// instead of replacing the inline editor slot. Mirrors upstream
	// ui.custom()'s `overlay: true`. When false the component replaces
	// the editor slot.
	Overlay bool `json:"overlay,omitempty"`
	// Layout carries upstream ui.custom()'s overlayOptions (the pi-tui
	// OverlayOptions fields that can cross a process boundary). When set, or
	// when no legacy Title/fractions are given, an overlay is mounted
	// component-framed with exactly upstream's showOverlay geometry.
	Layout *OverlayLayout `json:"overlayOptions,omitempty"`
}

type RemoteOverlayState struct {
	Hidden  bool                 `json:"hidden"`
	Focused bool                 `json:"focused"`
	Visible bool                 `json:"visible"`
	Bounds  *RemoteOverlayBounds `json:"bounds,omitempty"`
}

type RemoteTerminalInputHandler = func(ctx context.Context, data string) TerminalInputResult

type ReplacedSessionContext struct {
	*CommandContext
	// contains filtered or unexported fields
}

type ReplacedSessionSendUserMessageOptions = SendUserMessageOptions

type ResolvedCommand struct {
	RegisteredCommand
	InvocationName string `json:"invocationName"`
}

type ResourceCollision struct {
	ResourceType string `json:"resourceType"`
	Name         string `json:"name"`
	WinnerPath   string `json:"winnerPath"`
	LoserPath    string `json:"loserPath"`
	WinnerSource string `json:"winnerSource,omitempty"`
	LoserSource  string `json:"loserSource,omitempty"`
}

type ResourceDiagnostic struct {
	// Type is one of "warning", "error", "collision". Mirrors the
	// upstream literal union. Not enforced by the Go type system -
	// callers are expected to use the constants below.
	Type string `json:"type"`

	// Message is the human-readable diagnostic text. Format matches
	// upstream verbatim where the diagnostic is user-visible (e.g.
	// shortcut/command collision strings) so no fidelity drift in
	// diagnostic UIs.
	Message string `json:"message"`

	// Path is the extension's resolvedPath for attribution. Optional;
	// upstream uses `path?: string`.
	Path string `json:"path,omitempty"`

	// Collision carries structured details when Type == "collision".
	// upstream: ResourceCollision in core/diagnostics.ts.
	Collision *ResourceCollision `json:"collision,omitempty"`
}

type ResourcesDiscoverAggregateResult struct {
	SkillPaths  []AttributedResourcePath `json:"skillPaths"`
	PromptPaths []AttributedResourcePath `json:"promptPaths"`
	ThemePaths  []AttributedResourcePath `json:"themePaths"`
}

type ResourcesDiscoverEvent struct {
	Type   string `json:"type"`
	Cwd    string `json:"cwd"`
	Reason string `json:"reason"` // "startup" | "reload"
}

type ResourcesDiscoverResult struct {
	SkillPaths  []string `json:"skillPaths,omitempty"`
	PromptPaths []string `json:"promptPaths,omitempty"`
	ThemePaths  []string `json:"themePaths,omitempty"`
}

type ScopedModel struct {
	Model         *ai.Model
	ThinkingLevel ai.ThinkingLevel
}

type SendMessageOptions struct {
	TriggerTurn *bool     `json:"triggerTurn,omitempty"`
	DeliverAs   DeliverAs `json:"deliverAs,omitempty"`
}

type SendMessagePayload struct {
	CustomType string `json:"customType"`
	// Content preserves upstream CustomMessage content across the dynamic
	// extension boundary.
	Content any `json:"content,omitempty"`
	Display any `json:"display,omitempty"`
	Details any `json:"details,omitempty"`
}

type SendUserMessageHandler func(content any, options *SendUserMessageOptions) error

type SendUserMessageOptions struct {
	DeliverAs             DeliverAs `json:"deliverAs,omitempty"`
	ExpandPromptTemplates *bool     `json:"expandPromptTemplates,omitempty"`
}

type SessionBeforeCompactEvent struct {
	Type               string                `json:"type"`
	Preparation        CompactionPreparation `json:"preparation"`
	BranchEntries      []SessionEntry        `json:"branchEntries"`
	CustomInstructions string                `json:"customInstructions,omitempty"`
	// reason/willRetry adopted upstream in 0.80.3.
	Reason    string          `json:"reason"`
	WillRetry bool            `json:"willRetry"`
	Signal    context.Context `json:"-"`
}

type SessionBeforeCompactResult struct {
	Cancel     bool             `json:"cancel,omitempty"`
	Compaction CompactionResult `json:"compaction,omitempty"`
}

type SessionBeforeForkEvent struct {
	Type     string `json:"type"`
	EntryID  string `json:"entryId"`
	Position string `json:"position"` // "before" | "at"
}

type SessionBeforeForkResult struct {
	Cancel                  bool `json:"cancel,omitempty"`
	SkipConversationRestore bool `json:"skipConversationRestore,omitempty"`
}

type SessionBeforeSwitchEvent struct {
	Type              string `json:"type"`
	Reason            string `json:"reason"` // "new" | "resume"
	TargetSessionFile string `json:"targetSessionFile,omitempty"`
}

type SessionBeforeSwitchResult struct {
	Cancel bool `json:"cancel,omitempty"`
}

type SessionBeforeTreeEvent struct {
	Type        string          `json:"type"`
	Preparation TreePreparation `json:"preparation"`
	Signal      context.Context `json:"-"`
}

type SessionBeforeTreeResult struct {
	Cancel              bool                            `json:"cancel,omitempty"`
	Summary             *SessionBeforeTreeResultSummary `json:"summary,omitempty"`
	CustomInstructions  string                          `json:"customInstructions,omitempty"`
	ReplaceInstructions bool                            `json:"replaceInstructions,omitempty"`
	Label               string                          `json:"label,omitempty"`
}

type SessionBeforeTreeResultSummary struct {
	Summary string `json:"summary"`
	Details any    `json:"details,omitempty"`
	// Usage is the pi-ai Usage of the extension's summarization call.
	Usage any `json:"usage,omitempty"`
}

type SessionBoundaryDraft struct {
	Type             string          `json:"type"`
	CustomType       string          `json:"customType,omitempty"`
	Data             any             `json:"data,omitempty"`
	Content          any             `json:"content,omitempty"`
	Display          bool            `json:"display,omitempty"`
	Details          any             `json:"details,omitempty"`
	TargetID         string          `json:"targetId,omitempty"`
	Replacement      json.RawMessage `json:"replacement,omitempty"`
	Summary          string          `json:"summary,omitempty"`
	FirstKeptEntryID *string         `json:"firstKeptEntryId,omitempty"`
	Usage            *ai.Usage       `json:"usage,omitempty"`
}

type SessionCompactEvent struct {
	Type            string          `json:"type"`
	CompactionEntry CompactionEntry `json:"compactionEntry"`
	FromExtension   bool            `json:"fromExtension"`
	// reason/willRetry adopted upstream in 0.80.3.
	Reason    string `json:"reason"`
	WillRetry bool   `json:"willRetry"`
}

type SessionCompactFailedEvent struct {
	Type string `json:"type"`
	// Reason is what triggered the compaction: "manual" (/compact),
	// "threshold" (the context threshold), or "overflow" (context overflow
	// recovery).
	Reason string `json:"reason"`
	// ErrorMessage is the error text when compaction failed for a
	// non-abort reason.
	ErrorMessage string `json:"errorMessage,omitempty"`
	// Aborted is true when compaction was cancelled or aborted.
	Aborted bool `json:"aborted"`
	// WillRetry is true when the aborted turn would have been retried after
	// this compaction (overflow recovery).
	WillRetry bool `json:"willRetry"`
	// FromExtension is true when the failing compaction content came from a
	// session_before_compact handler.
	FromExtension bool `json:"fromExtension"`
}

type SessionEntry = any

type SessionInfoChangedEvent struct {
	Type string `json:"type"`
	Name string `json:"name,omitempty"`
}

type SessionManager = any

type SessionShutdownEvent struct {
	Type              string `json:"type"`
	Reason            string `json:"reason"` // "quit" | "reload" | "new" | "resume" | "fork"
	TargetSessionFile string `json:"targetSessionFile,omitempty"`
}

type SessionStartEvent struct {
	Type                string `json:"type"`
	Reason              string `json:"reason"` // "startup" | "reload" | "new" | "resume" | "fork"
	PreviousSessionFile string `json:"previousSessionFile,omitempty"`
}

type SessionTreeEvent struct {
	Type          string             `json:"type"`
	NewLeafID     *string            `json:"newLeafId"`
	OldLeafID     *string            `json:"oldLeafId"`
	SummaryEntry  BranchSummaryEntry `json:"summaryEntry,omitempty"`
	FromExtension bool               `json:"fromExtension,omitempty"`
}

type SetThemeResult struct {
	Success bool   `json:"success"`
	Error   string `json:"error,omitempty"`
}

type Settings = map[string]any

type ShortcutHandler = func(ctx context.Context) error

type ShortcutOptions struct {
	Description string          `json:"description,omitempty"`
	Handler     ShortcutHandler `json:"-"`
}

type SimpleStreamOptions = any