external

type Account struct {
	SignedIn bool
	// Email is empty when the runtime does not report one.
	Email string
}

type AccountReader interface {
	Account(ctx context.Context, botID, botAgentID string) (Account, error)
}

type ApprovalCall struct {
	ToolCallID string
	ToolName   string
	Input      any
	Options    []approval.PermissionOption
}

type BotAgentAuthPurger interface {
	PurgeBotAgentAuth(ctx context.Context, botID, botAgentID string) error
}

type Caps struct {
	// Dependency is the managed workspace dependency providing the CLI, and
	// Command the executable it installs. Both are empty for a runtime whose
	// command comes from its configuration (custom ACP agents).
	Dependency string
	Command    string

	// ForkNeedsRuntime: the conversation's native session lives in its
	// runtime metadata with no owner, so a Memoh-side copy would share it. A
	// fork must then go through the runtime (ThreadForker); without one the
	// conversation cannot be forked at all.
	ForkNeedsRuntime bool
	// ForkAnchorKey names the runtime metadata key holding the only turn a
	// fork may start from. Empty: any turn can be forked.
	ForkAnchorKey string
	// ReadCommandsRequireIdle: a read command may open or replace the native
	// session, so it waits for the conversation to be idle.
	ReadCommandsRequireIdle bool
}

type Command = turn.RuntimeCommand

type CommandKind = turn.RuntimeCommandKind

type CommandProvider interface {
	Commands(context.Context, PromptInput) ([]Command, error)
	ReadCommand(context.Context, PromptInput) (CommandResult, error)
}

type CommandResult = turn.RuntimeCommandResult

type CompactionResult struct {
	RuntimeMetadata map[string]any
}

type Compactor interface {
	Compact(context.Context, PromptInput) (CompactionResult, error)
}

type ControlCapabilities = turn.RuntimeControlCapabilities

type Controls = turn.RuntimeControls

type DependencyMissingError struct {
	DependencyID string
	TaskID       string
	// OperationInProgress distinguishes an existing administrative operation
	// from a dependency that an administrator still needs to install.
	OperationInProgress bool
}

type DeviceLoginProvider interface {
	StartDeviceLogin(ctx context.Context, botID, botAgentID string) (DeviceLoginStart, error)
	// PollDeviceLogin reports the sign-in's state. On success the login is in
	// place for the Agent; ownerUserID owns it where the runtime stores one.
	PollDeviceLogin(ctx context.Context, ownerUserID, botID, botAgentID, loginID string) (DeviceLoginStatus, error)
	CancelDeviceLogin(ctx context.Context, botID, botAgentID, loginID string) error
}

type DeviceLoginStart struct {
	LoginID         string
	UserCode        string
	VerificationURL string
}

type DeviceLoginStatus struct {
	// Status is one of the DeviceLogin states.
	Status string
	Error  string
}

type Driver interface {
	// RuntimeType is the thread runtime type this driver serves (e.g. "codex").
	RuntimeType() string
	// Caps declares what the runtime supports.
	Caps() Caps
	// Prompt runs one turn. Stream events flow through input.Sink while the
	// turn runs; the returned result carries the transcript for persistence.
	// A context cancellation is an interrupt: the driver must stop the turn
	// and still return the partial transcript it has.
	Prompt(ctx context.Context, input PromptInput) (PromptResult, error)
}

type EventSink interface {
	EmitStreamEvent(event.StreamEvent)
}

type EventSinkFunc func(event.StreamEvent)

type Failure struct {
	Kind FailureKind
	Err  error
	// Message is what the agent itself said about the failure, made fit to
	// show and keep: users read it as they would in the agent's own client.
	Message string
}

type FailureKind int

type Goal = turn.RuntimeGoal

type GoalProvider interface {
	Goal(context.Context, PromptInput) (*Goal, error)
	ControlGoal(context.Context, PromptInput, string) error
}

type Image struct {
	MimeType string
	// Data is the raw image bytes (not base64, not a data URL).
	Data []byte
}

type Launcher struct {
	// Path is the absolute path the driver must execute.
	Path string
	// Version is the observed CLI version, empty when unknown.
	Version string
	Source  LauncherSource
}

type LauncherResolver interface {
	ResolveLauncher(ctx context.Context, botID, depID string) (Launcher, error)
}

type LauncherSource string

type Mode = turn.RuntimeMode

type ModeProvider interface {
	Modes(context.Context, PromptInput) (ModeState, error)
	SetMode(context.Context, PromptInput, string) (ModeState, error)
}

type ModeState = turn.RuntimeModeState

type ModelCatalog struct {
	Models                    []ModelOption `json:"models"`
	ConfiguredModelID         string        `json:"configured_model_id,omitempty"`
	ConfiguredReasoningEffort string        `json:"configured_reasoning_effort,omitempty"`
}

type ModelCatalogProvider interface {
	ModelCatalog(ctx context.Context, request ModelCatalogRequest) (ModelCatalog, error)
}

type ModelCatalogRequest struct {
	BotID       string
	BotAgentID  string
	ProjectPath string
	// ModelID selects the model whose defaults the picker is displaying.
	ModelID string
	// Preference validation needs only capabilities; resolved defaults are a
	// separate, optional observation for display.
	ResolveDefaults bool
}

type ModelOption struct {
	// ResolvedModelID preserves a runtime-advertised full model name for
	// validation without duplicating its alias in the model picker.
	ResolvedModelID        string                  `json:"resolved_model_id,omitempty"`
	ID                     string                  `json:"id"`
	Name                   string                  `json:"name"`
	Description            string                  `json:"description,omitempty"`
	Default                bool                    `json:"default,omitempty"`
	DefaultReasoningEffort string                  `json:"default_reasoning_effort,omitempty"`
	ReasoningEfforts       []ReasoningEffortOption `json:"reasoning_efforts"`
	// IDs belong to this runtime's permission menu, not a shared preset enum.
	UnavailablePermissionModes []string `json:"unavailable_permission_modes,omitempty"`
}

type PlanModeProvider interface {
	PlanMode(context.Context, PromptInput) (ModeState, error)
	SetPlanMode(context.Context, PromptInput, string) (ModeState, error)
}

type PromptInput struct {
	Steering   Steering
	BotID      string
	BotAgentID string
	ChatID     string
	ThreadID   string
	RunID      string
	RouteID    string

	// Prompt is the user's message text.
	Prompt string
	// ContextMarkdown is the assembled Memoh context document for this turn.
	ContextMarkdown string
	// Images are inline user images, raw bytes with MIME types.
	Images []Image

	// ModelID and ReasoningEffort are per-turn overrides; empty means the
	// runtime's configured default.
	ModelID         string
	ReasoningEffort string

	// SessionMode is the Memoh session mode driving this turn (chat,
	// schedule, ...); tool-gateway policy keys on it.
	SessionMode string

	// CurrentPlatform, ReplyTarget, and ConversationType describe the surface
	// the turn is answering; they flow into the trusted tool identity.
	CurrentPlatform  string
	ReplyTarget      string
	ConversationType string

	// Command is an exact agent-command selector matched at admission; a
	// runtime that advertises commands must re-validate it at dispatch.
	// Runtimes without a command vocabulary ignore it.
	Command string
	// CommandArgs is the original user input after the runtime command selector.
	CommandArgs string

	// ForceFreshRuntime asks the driver to abandon any resumable runtime
	// session and start this turn on a fresh one.
	ForceFreshRuntime bool

	// AttachmentReferences names non-image attachments already staged for the
	// runtime (paths or references it may read through its tools).
	AttachmentReferences []string
	// CanFallbackImagesToFiles permits a runtime without image input to
	// receive the images as workspace files instead of failing the turn.
	CanFallbackImagesToFiles bool
	// ToolOutputLimit bounds tool output the runtime feeds back into its
	// context through Memoh-owned tool surfaces.
	ToolOutputLimit contextlimit.ToolOutputLimit

	// RuntimeMetadata is the session's runtime metadata map. Drivers read and
	// persist their own keys through it (e.g. the codex thread id).
	RuntimeMetadata map[string]any

	// ContextURI names the Memoh-owned context document. The budget flows into
	// runtime-hosted Memoh tools.
	ContextURI             string
	ContextBudgetMaxTokens int

	// RuntimeOwnerAccountID is the account whose workspace authority the
	// runtime executes under.
	RuntimeOwnerAccountID string
	// ChannelIdentityID identifies the acting user for tool attribution.
	ChannelIdentityID string
	// SessionToken authenticates runtime-side calls back into Memoh.
	SessionToken string //nolint:gosec // session credential material, not a hardcoded secret
	// ToolHTTPURL is the Memoh tool gateway (HTTP MCP) base URL, empty when
	// the gateway is unavailable.
	ToolHTTPURL string

	// CanRequestUserInput reports whether the surface driving this turn can
	// deliver interactive decisions such as approvals and ask_user.
	CanRequestUserInput bool

	// Sink receives stream events as the turn runs. Never nil.
	Sink EventSink
}

type PromptResult struct {
	// Notices are UI-only runtime facts collected across startup and execution.
	// They are persisted with the round, independently of the model transcript.
	Notices []event.Notice
	// SteerInputIDs correspond to the user messages in Output, in arrival order.
	SteerInputIDs []string
	// Output is the transcript to persist, in provider-message form.
	Output []sdk.Message
	// Text is the final assistant message text (for surfaces that report a
	// plain-text result, e.g. schedule runs).
	Text string
	// Usage is the turn's token usage, when the runtime reported it.
	Usage *sdk.Usage
	// StopReason is the runtime's terminal stop reason, normalized to the
	// event vocabulary where possible.
	StopReason string
	// AgentTurnID is the runtime's own identifier for this turn (e.g. the
	// codex turn id); it anchors turn-level operations such as forking.
	AgentTurnID string
	// FinalTurnAnchorOnly restricts a multi-turn transcript to its final fork boundary.
	FinalTurnAnchorOnly bool
	// TurnCompleted reports whether the runtime finished the turn (as opposed
	// to an interrupt or failure part-way).
	TurnCompleted bool
	// RuntimeMetadata carries driver-owned metadata updates to merge back
	// into the session's runtime metadata (e.g. a newly created thread id).
	// Nil means no changes.
	RuntimeMetadata map[string]any
}

type Question struct {
	ToolCallID string
	// Input is the ask_user card's input.
	Input any
	// ProviderMetadata says which runtime request the answer goes back to.
	ProviderMetadata map[string]any
}

type Quota struct {
	LimitReached bool
	// Windows are the rolling usage windows, the shortest first.
	Windows []QuotaWindow
}

type QuotaReader interface {
	Quota(ctx context.Context, botID, botAgentID string) (Quota, error)
}

type QuotaWindow struct {
	UsedPercent   int
	WindowMinutes int
	ResetsAt      *time.Time
}

type ReasoningEffortOption struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
}

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

type SteerInput struct {
	ID   string
	Text string
}

type Steering interface {
	Enable(context.Context) error
	Wake() <-chan struct{}
	Next(context.Context) (SteerInput, bool, error)
	Accepted(context.Context, string, int) error
	Close(context.Context) error
}

type ThreadForker interface {
	ForkThread(ctx context.Context, botID, botAgentID string, runtimeMetadata map[string]any, lastTurnID string) (map[string]any, error)
}

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

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

type VersionObserver interface {
	ObserveLauncherVersion(ctx context.Context, botID, depID, version string)
}

type Workspaces interface {
	bridge.Provider
	bridge.WorkspaceInfoProvider
}