external

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

type BotAgentResetter interface {
	ResetBotAgent(botID, botAgentID string)
}

type BotResetter interface {
	ResetBot(botID string)
}

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 DependencyRequirement struct {
	DependencyID string
}

type DependencyRequirer interface {
	RequiredDependency() (depID string)
}

type Driver interface {
	// RuntimeType is the thread runtime type this driver serves (e.g. "codex").
	RuntimeType() string
	// 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 Drivers []Driver

type EventSink interface {
	EmitStreamEvent(event.StreamEvent)
}

type EventSinkFunc func(event.StreamEvent)

type Failure struct {
	Kind FailureKind
	Err  error
}

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 and tool
	// exchange policy flow into runtime-hosted Memoh tools.
	ContextURI                string
	ContextBudgetMaxTokens    int
	ContextToolExchangePolicy *contextfrag.ToolExchangePolicy

	// 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
	// PublishHead asks the application to publish a completed round's run ID
	// with its messages so warm runtimes can detect another process's progress.
	PublishHead bool
	// RoundMetadata carries driver-owned keys merged into the round's
	// assistant-message metadata (provenance such as the ACP agent id).
	RoundMetadata map[string]any
	// 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 ReasoningEffortOption struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
}

type RoundRollbackHandler interface {
	OnRoundRolledBack(ctx context.Context, botID, threadID string)
}

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 VersionObserver interface {
	ObserveLauncherVersion(ctx context.Context, botID, depID, version string)
}