harnesses

type AccountHarness interface {
	Harness

	// AccountStatus returns the harness's current account/auth state.
	// Cheap; reads cached evidence only. Absence of evidence is
	// reported via AccountSnapshot fields on a valid snapshot; the
	// error return is reserved for call failure.
	AccountStatus(ctx context.Context, now time.Time) (AccountSnapshot, error)

	// RefreshAccount drives the harness's account probe and persists
	// the result. Single-flight per harness instance; concurrent
	// callers block. Probe failure is reported via AccountSnapshot
	// fields, not as an error.
	RefreshAccount(ctx context.Context) (AccountSnapshot, error)

	// AccountFreshness returns the harness's account freshness window
	// (e.g. 7 days for gemini). Constant for the harness; cheap.
	AccountFreshness() time.Duration
}

type AccountInfo struct {
	Email    string `json:"email,omitempty"`
	PlanType string `json:"plan_type,omitempty"`
	OrgName  string `json:"org_name,omitempty"`
}

type AccountSnapshot struct {
	Authenticated   bool
	Unauthenticated bool
	Email           string
	PlanType        string
	OrgName         string
	Source          string // file path, env var name, "cache", "cli"
	CapturedAt      time.Time
	Fresh           bool
	Detail          string // free-form diagnostic detail
}

type ContextCapacityData struct {
	Action                 string `json:"action"`
	CallKind               string `json:"call_kind"`
	TurnIndex              int    `json:"turn_index"`
	AttemptIndex           int    `json:"attempt_index"`
	ContextWindow          int    `json:"context_window"`
	EffectiveContextWindow int    `json:"effective_context_window"`
	EstimatedInputTokens   int    `json:"estimated_input_tokens"`
	RequestedMaxTokens     int    `json:"requested_max_tokens"`
	EffectiveMaxTokens     int    `json:"effective_max_tokens"`
	AvailableOutputTokens  int    `json:"available_output_tokens"`
}

type ContextModelDiscoveryHarness interface {
	ModelDiscoveryHarness

	// DefaultModelSnapshotWithContext returns live discovery evidence while
	// honoring ctx. Implementations must not replace ctx with a background
	// context, and must finish process cleanup before returning cancellation.
	DefaultModelSnapshotWithContext(ctx context.Context) (ModelDiscoverySnapshot, error)
}

type ContinuationHarness interface {
	Harness

	PrepareContinuation(context.Context, ContinuationRequest) (PreparedContinuation, error)
}

type ContinuationRequest struct {
	ParentSessionID string
	Request         ExecuteRequest
}

type CostSource string

type Event struct {
	Type     EventType         `json:"type"`
	Sequence int64             `json:"sequence"`
	Time     time.Time         `json:"time"`
	Metadata map[string]string `json:"metadata,omitempty"`
	Data     json.RawMessage   `json:"data"`
}

type EventType string

type ExecuteRequest struct {
	// Prompt is the resolved user prompt sent to the model.
	Prompt string

	// SystemPrompt is the resolved system prompt; empty means harness default.
	SystemPrompt string

	// Provider is the resolved provider identifier when applicable. May be
	// empty for harnesses that have no provider concept (e.g. claude CLI).
	Provider string

	// Model is the resolved model identifier; empty means harness default.
	Model string

	// WorkDir is the working directory for tool operations. Required when
	// the chosen harness uses tools.
	WorkDir string

	// Permissions is "safe" | "supervised" | "unrestricted". Empty defaults to "safe".
	Permissions string

	// Temperature is the model sampling temperature requested by the caller.
	// Harness adapters may ignore it when their CLI has no equivalent control.
	Temperature float32

	// Seed is the requested sampling seed. Zero means unset/provider chooses.
	// Harness adapters may ignore it when their CLI has no equivalent control.
	Seed int64

	// Reasoning is the normalized public reasoning scalar. Empty/off means no
	// adapter flag should be emitted.
	Reasoning string

	// Timeout is the wall-clock cap for the entire request. 0 disables.
	Timeout time.Duration

	// IdleTimeout is the streaming-quiet cap. 0 uses harness default.
	IdleTimeout time.Duration

	// SessionLogDir overrides the per-run session-log directory; harness
	// uses this to direct progress traces into a per-bundle evidence dir.
	SessionLogDir string

	// SessionID is a stable identifier for the run, used in progress log
	// filenames and event metadata. Empty means the harness generates one.
	SessionID string

	// LifecycleStateDir is the service-selected directory for durable process
	// ownership records. It is separate from the human-readable session log.
	LifecycleStateDir string

	// CleanupTimeout is the service-owned deadline for stopping and proving the
	// per-invocation containment boundary empty.
	CleanupTimeout time.Duration

	// Metadata is echoed back into Event.Metadata (e.g. bead_id, attempt_id).
	Metadata map[string]string
}

type FinalData struct {
	Status          string               `json:"status"` // success|iteration_limit|failed|stalled|timed_out|cancelled
	Outcome         SessionOutcome       `json:"outcome"`
	Cause           TerminalCause        `json:"cause"`
	Stage           SessionStage         `json:"stage"`
	PrimaryOutcome  SessionOutcome       `json:"primary_outcome,omitempty"`
	PrimaryCause    TerminalCause        `json:"primary_cause,omitempty"`
	PrimaryStage    SessionStage         `json:"primary_stage,omitempty"`
	ExitCode        int                  `json:"exit_code"`
	Error           string               `json:"error,omitempty"`
	ContextCapacity *ContextCapacityData `json:"context_capacity,omitempty"`
	FinalText       string               `json:"final_text,omitempty"`
	DurationMS      int64                `json:"duration_ms"`
	Usage           *FinalUsage          `json:"usage,omitempty"`
	Warnings        []FinalWarning       `json:"warnings,omitempty"`
	FinalCostUSD    *float64             `json:"cost_usd,omitempty"`
	FinalCostSource CostSource           `json:"cost_source"`
	// CostUSD is a temporary compatibility bridge for in-memory consumers.
	// Deprecated: use FinalCostUSD and FinalCostSource.
	CostUSD        float64           `json:"-"`
	SessionLogPath string            `json:"session_log_path,omitempty"`
	RoutingActual  *RoutingActual    `json:"routing_actual,omitempty"`
	Reasoning      *ReasoningActual  `json:"reasoning,omitempty"`
	Extra          map[string]string `json:"-"`
}

type FinalUsage struct {
	InputTokens      *int                  `json:"input_tokens,omitempty"`
	OutputTokens     *int                  `json:"output_tokens,omitempty"`
	CacheReadTokens  *int                  `json:"cache_read_tokens,omitempty"`
	CacheWriteTokens *int                  `json:"cache_write_tokens,omitempty"`
	CacheTokens      *int                  `json:"cache_tokens,omitempty"`
	ReasoningTokens  *int                  `json:"reasoning_tokens,omitempty"`
	TotalTokens      *int                  `json:"total_tokens,omitempty"`
	Source           string                `json:"source,omitempty"`
	Fresh            *bool                 `json:"fresh,omitempty"`
	CapturedAt       string                `json:"captured_at,omitempty"`
	Sources          []UsageSourceEvidence `json:"sources,omitempty"`
}

type FinalWarning struct {
	Code    string                `json:"code"`
	Message string                `json:"message,omitempty"`
	Sources []UsageSourceEvidence `json:"sources,omitempty"`
}

type Harness interface {
	// Info returns identity + capability metadata for this harness.
	Info() HarnessInfo

	// HealthCheck triggers a fresh probe (binary present, auth ok, etc.)
	// and returns nil if the harness is ready to execute.
	HealthCheck(ctx context.Context) error

	// Execute runs one resolved request. Events stream on the returned
	// channel; a single final event closes the stream. The first error
	// return is reserved for setup failures (binary missing, etc.) — once
	// the channel is returned, all per-run failures are reported via a
	// final event with Status != "success".
	Execute(ctx context.Context, req ExecuteRequest) (<-chan Event, error)
}

type HarnessConfig struct {
	Name                string              // e.g. "codex", "claude", "gemini"
	Binary              string              // binary name to exec
	BaseArgs            []string            // args always included regardless of permission level
	PermissionArgs      map[string][]string // extra args keyed by permission level: "safe", "supervised", "unrestricted"
	PromptMode          string              // "arg" (final arg), "stdin" (pipe)
	DefaultModel        string              // built-in model choice when no config override exists
	ReasoningLevels     []string            // supported reasoning levels in preference order
	MaxReasoningTokens  int                 // numeric reasoning budget max; 0 = unsupported/unknown
	ModelFlag           string              // flag for model override (e.g. "-m", "--model"), empty if unsupported
	WorkDirFlag         string              // flag for working directory (e.g. "-C", "--cwd"), empty if unsupported
	ReasoningFlag       string              // adapter flag for reasoning control, empty if unsupported
	ReasoningFormat     string              // format string for adapter reasoning value, empty = use value directly
	TokenPattern        string              // regex to extract token count from output, must have one capture group
	Surface             string              // catalog surface identifier: "codex", "claude", "embedded-openai", "embedded-anthropic"
	CostClass           string              // local, cheap, medium, expensive
	IsLocal             bool                // true for embedded/local harnesses (no cloud cost)
	ExactPinSupport     bool                // true if harness can accept an exact concrete model pin
	QuotaCommand        string              // CLI args for non-interactive quota introspection; empty = skip probe
	TUIQuotaCommand     string              // Slash command to send as a prompt when native quota signal is unavailable
	IsHTTPProvider      bool                // true for API-only providers (openrouter, lmstudio) that have no CLI binary
	IsSubscription      bool                // true for fixed-subscription harnesses (codex, claude)
	AutoRoutingEligible bool                // true when this harness has full coverage and may be selected by unattended profile routing
	TestOnly            bool                // true for sentinel/test harnesses that must never be selected by production tier routing
}

type HarnessInfo struct {
	Name                 string
	Type                 string // "native" | "subprocess"
	Available            bool
	Path                 string
	Error                string
	IsLocal              bool
	IsSubscription       bool
	AutoRoutingEligible  bool
	ExactPinSupport      bool
	DefaultModel         string
	SupportedPermissions []string
	SupportedReasoning   []string
	CostClass            string
}

type HarnessOutputPipes struct {
	Stdout *os.File
	Stderr *os.File
	// contains filtered or unexported fields
}

type HarnessSessionRecord = processlifecycle.LegacyHarnessSessionRecord

type HarnessState struct {
	Installed       bool       `json:"installed"`
	Reachable       bool       `json:"reachable"`
	Authenticated   bool       `json:"authenticated"`
	QuotaOK         bool       `json:"quota_ok"`
	QuotaState      string     `json:"quota_state,omitempty"` // ok, blocked, unknown
	Degraded        bool       `json:"degraded"`
	PolicyOK        bool       `json:"policy_ok"`
	LastCheckedUnix int64      `json:"last_checked_unix,omitempty"`
	Error           string     `json:"error,omitempty"`
	Quota           *QuotaInfo `json:"quota,omitempty"`
}

type HarnessStatus struct {
	Name      string `json:"name"`
	Available bool   `json:"available"`
	Binary    string `json:"binary"`
	Path      string `json:"path,omitempty"` // resolved binary path
	Error     string `json:"error,omitempty"`
}

type LookPathFunc func(file string) (string, error)

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

type ModelDiscoveryHarness interface {
	Harness

	// DefaultModelSnapshot returns the harness's seed/fallback
	// discovery snapshot. Used to bootstrap the catalog before the
	// first live refresh lands. Per the no-static-fallback principle,
	// returns ErrModelDiscoveryEvidenceMissing when live evidence cannot
	// be obtained; never returns a cached or literal fallback.
	DefaultModelSnapshot() (ModelDiscoverySnapshot, error)

	// ResolveModelAlias maps a family-style requested model to a
	// concrete model ID using the provided discovery snapshot.
	// Returns ErrAliasNotResolvable if the family is not recognized
	// or the snapshot has no matching concrete model.
	ResolveModelAlias(family string, snapshot ModelDiscoverySnapshot) (string, error)

	// SupportedAliases returns the harness's stable set of family
	// aliases ResolveModelAlias recognizes. Constant for the harness;
	// the conformance suite uses this value to verify
	// ResolveModelAlias covers each documented family (positive path)
	// and rejects out-of-set families with ErrAliasNotResolvable
	// (negative path). Empty slice is allowed for harnesses that
	// recognize no family aliases.
	SupportedAliases() []string
}

type ModelDiscoveryLoader func(harnessName, source string) (ModelDiscoverySnapshot, error)

type ModelDiscoverySnapshot struct {
	CapturedAt      time.Time `json:"captured_at"`
	Models          []string  `json:"models,omitempty"`
	ReasoningLevels []string  `json:"reasoning_levels,omitempty"`
	Source          string    `json:"source"`
	FreshnessWindow string    `json:"freshness_window,omitempty"`
	Detail          string    `json:"detail,omitempty"`
}

type PTYSessionStarter func(
	ctx context.Context,
	command string,
	args []string,
	workdir string,
	env []string,
	size session.Size,
	opts ...session.Option,
) (*session.Session, error)

type PortableRuntimeAsset struct {
	Kind          PortableRuntimeAssetKind
	PathKind      PortableRuntimePathKind
	Source        string
	Target        string
	ContentSHA256 string
	Executable    bool
}

type PortableRuntimeAssetKind string

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

type PortableRuntimeClosureClass string

type PortableRuntimeContribution struct {
	ClosureClass         PortableRuntimeClosureClass
	Launch               PortableRuntimeLaunch
	Assets               []PortableRuntimeAsset
	Environment          []PortableRuntimeEnvironment
	ExecutionConstraints PortableRuntimeExecutionConstraints
	StateProjections     []PortableRuntimeStateProjection
}

type PortableRuntimeDynamicClosureRequest struct {
	EntrypointSource string
	EntrypointTarget string
	LoaderTarget     string
	LibraryRoots     []PortableRuntimeSourceTree
	// ExactLibraryRoots emit only the recursive DT_NEEDED files selected from
	// unique candidates. Exactly one of LibraryRoots and ExactLibraryRoots must
	// be set.
	ExactLibraryRoots []PortableRuntimeLibrarySearchRoot
	RuntimeLookup     PortableRuntimeLookupPolicy
	RuntimeTrees      []PortableRuntimeSourceTree
}

type PortableRuntimeEnvironment struct {
	Name string
}

type PortableRuntimeEnvironmentConstraint struct {
	Name      string
	Kind      PortableRuntimeEnvironmentConstraintKind
	GuestPath PortableRuntimeGuestPath
}

type PortableRuntimeEnvironmentConstraintKind string

type PortableRuntimeExecutionConstraints struct {
	Environment         []PortableRuntimeEnvironmentConstraint
	ReadOnlyPaths       []PortableRuntimeGuestPath
	RequiredAbsentPaths []PortableRuntimeGuestPath
	FixedArguments      []string
	FixedOptionValues   []PortableRuntimeFixedOptionValue
}

type PortableRuntimeFileIdentity struct {
	Size          int64
	ContentSHA256 string
}

type PortableRuntimeFixedOptionValue struct {
	Option string
	Value  string
}

type PortableRuntimeGuestPath struct {
	Scope  PortableRuntimeGuestPathScope
	Target string
}

type PortableRuntimeGuestPathScope string

type PortableRuntimeHarness interface {
	Harness

	PortableRuntimeAssets(context.Context, PortableRuntimeTarget) (PortableRuntimeContribution, error)
}

type PortableRuntimeInclusion string

type PortableRuntimeInterpretedClosureRequest struct {
	EntrypointSource string
	EntrypointTarget string
	// EntrypointPackageTreeTarget opts into a package-tree-owned entrypoint.
	// The analyzer proves that EntrypointSource resolves to a direct regular
	// member of this exact PackageTrees target and that EntrypointTarget names
	// the same relative member. The tree then owns the emitted entrypoint; no
	// overlapping duplicate file asset is produced.
	EntrypointPackageTreeTarget string
	InterpreterSource           string
	InterpreterIdentity         PortableRuntimeFileIdentity
	InterpreterTarget           string
	LoaderTarget                string
	LibraryRoots                []PortableRuntimeSourceTree
	ExactLibraryRoots           []PortableRuntimeLibrarySearchRoot
	PackageTrees                []PortableRuntimeSourceTree
	NativeAddons                []PortableRuntimeNativeAddon
	RuntimeArgs                 []string
	RuntimeLookup               PortableRuntimeLookupPolicy
	RuntimeTrees                []PortableRuntimeSourceTree
}

type PortableRuntimeLaunch struct {
	EntrypointTarget string
	// EntrypointTreeMember binds an interpreted entrypoint to one exact regular
	// member of the unique install-tree asset that owns EntrypointTarget.
	EntrypointTreeMember string
	InterpreterTarget    string
	LoaderTarget         string
	RuntimeArgs          []string
	LibraryRootTargets   []string
}

type PortableRuntimeLibrarySearchRoot struct {
	Source string
	Target string
}

type PortableRuntimeLookupPolicy string

type PortableRuntimeNamespaceRecipe interface {
	PortableRuntimeNamespaceRecipe()
}

type PortableRuntimeNativeAddon struct {
	PackageTreeTarget string
	RelativePath      string
	Identity          PortableRuntimeFileIdentity
}

type PortableRuntimePathKind string

type PortableRuntimeRunnerBinder interface {
	BindPortableRuntime(PortableRuntimeRunnerBinding) error
	PortableRuntimeBinding() (PortableRuntimeRunnerBinding, bool)
}

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

type PortableRuntimeRunnerBindingInput struct {
	Structure         PortableRuntimeStructure
	GuestRoot         string
	ClosureClass      PortableRuntimeClosureClass
	Launch            PortableRuntimeLaunch
	FixedArguments    []string
	FixedOptionValues []PortableRuntimeFixedOptionValue
	Environment       map[string]string
	NamespaceRecipe   PortableRuntimeNamespaceRecipe
}

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

type PortableRuntimeSourceTree struct {
	Source string
	Target string
}

type PortableRuntimeStateProjection struct {
	Directory PortableRuntimeGuestPath
	Entries   []PortableRuntimeStateProjectionEntry
}

type PortableRuntimeStateProjectionEntry struct {
	AssetTarget string
	Target      string
}

type PortableRuntimeStaticClosureRequest struct {
	EntrypointSource string
	EntrypointTarget string
	RuntimeLookup    PortableRuntimeLookupPolicy
	RuntimeTrees     []PortableRuntimeSourceTree
}

type PortableRuntimeStructuralHarness interface {
	PortableRuntimeStructure() PortableRuntimeStructure
}

type PortableRuntimeStructuralMode string

type PortableRuntimeStructure struct {
	Name      string
	Transport PortableRuntimeTransport
	Mode      PortableRuntimeStructuralMode
}

type PortableRuntimeSurface struct {
	Name      string
	Transport PortableRuntimeTransport
	Inclusion PortableRuntimeInclusion
	Instance  Harness
}

type PortableRuntimeTarget struct {
	GOOS   string
	GOARCH string
}

type PortableRuntimeTransport string

type PreparedContinuation interface {
	Start(context.Context) (<-chan Event, error)
}

type QuotaHarness interface {
	Harness

	// QuotaStatus returns the current quota state from the harness's
	// owned cache, with Fresh/Age computed against now. MUST be cheap
	// (no live probe) and safe to call on every routing decision.
	// Absence of evidence is reported via State=QuotaUnavailable on a
	// valid QuotaStatus value; the error return is reserved for call
	// failure (ctx cancelled, IO failure, lock acquisition failure).
	QuotaStatus(ctx context.Context, now time.Time) (QuotaStatus, error)

	// RefreshQuota drives the harness's live probe, persists the
	// result through the harness's owned cache, and returns the
	// resulting status. Single-flight per harness instance via the
	// harness's cache lock; concurrent callers block. Probe failure
	// is reported as a QuotaStatus with State=QuotaUnavailable (or
	// QuotaUnauthenticated for auth-related failures), not as an
	// error. The error return is reserved for call failure.
	RefreshQuota(ctx context.Context) (QuotaStatus, error)

	// QuotaFreshness returns the harness's freshness window (e.g. 15m).
	// Constant for the harness; cheap to call.
	QuotaFreshness() time.Duration

	// SupportedLimitIDs returns the harness's stable set of emitted
	// Windows[].LimitID values. Constant for the harness; the
	// conformance suite reads this value to verify that emitted
	// Windows[].LimitID strings are a subset of this set. Empty
	// slice is allowed for harnesses that emit no windows.
	SupportedLimitIDs() []string
}

type QuotaInfo struct {
	PercentUsed int    `json:"percent_used"`
	LimitWindow string `json:"limit_window,omitempty"` // e.g. "5h", "7 day"
	ResetDate   string `json:"reset_date,omitempty"`   // e.g. "April 12"
}

type QuotaStateValue string

type QuotaStatus struct {
	// Source identifies how the underlying evidence was captured:
	// "pty", "cache", "session-token-count", "cli", "api".
	Source string

	// CapturedAt is when the underlying evidence was observed (not when
	// this status struct was assembled).
	CapturedAt time.Time

	// Fresh reports whether CapturedAt is within QuotaFreshness() at the
	// time of the call.
	Fresh bool

	// Age is now - CapturedAt at the time of the call.
	Age time.Duration

	// State is the normalized state. Only QuotaOK and QuotaStale carry
	// routing-usable signal.
	State QuotaStateValue

	// Windows captures per-window evidence (5h, weekly, tier-specific).
	// Authoritative for any structured fact the routing layer or
	// operator surfaces consume — including tier breakdowns.
	Windows []QuotaWindow

	// Account is the account/plan/auth evidence captured alongside
	// quota. Nil when the harness has no concept of account or when
	// account evidence is delivered through AccountHarness only.
	Account *AccountSnapshot

	// RoutingPreference indicates whether the routing layer should
	// prefer this harness given the current evidence.
	RoutingPreference RoutingPreference

	// Reason is a short human-readable explanation of State and
	// RoutingPreference — surfaced in operator views and routing logs.
	Reason string

	// Detail is harness-specific opaque metadata for diagnostic display
	// only. Service code MAY surface it verbatim in operator views;
	// service code MUST NOT branch on its keys or values for routing
	// decisions.
	Detail map[string]string
}

type QuotaWindow struct {
	Name          string  `json:"name"`               // e.g. "5h", "7d", "spark"
	LimitID       string  `json:"limit_id,omitempty"` // provider limit_id
	LimitName     string  `json:"limit_name,omitempty"`
	WindowMinutes int     `json:"window_minutes"`
	UsedPercent   float64 `json:"used_percent"`
	ResetsAt      string  `json:"resets_at,omitempty"`      // human-readable
	ResetsAtUnix  int64   `json:"resets_at_unix,omitempty"` // unix timestamp
	State         string  `json:"state"`
}

type ReasoningActual struct {
	Harness            string   `json:"harness,omitempty"`
	RequestedReasoning string   `json:"requested_reasoning,omitempty"`
	ResolvedReasoning  string   `json:"resolved_reasoning,omitempty"`
	Source             string   `json:"source,omitempty"`
	DiscoverySource    string   `json:"discovery_source,omitempty"`
	Reason             string   `json:"reason,omitempty"`
	Warning            string   `json:"warning,omitempty"`
	SupportedReasoning []string `json:"supported_reasoning,omitempty"`
}

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

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

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

type RouteRunnerFactory func(RouteRunnerKey, Harness) (Harness, error)

type RouteRunnerKey struct {
	Harness        string
	Provider       string
	Endpoint       string
	ServerInstance string
	Model          string
}

type RoutingActual struct {
	Harness            string   `json:"harness"`
	Provider           string   `json:"provider,omitempty"`
	ServerInstance     string   `json:"server_instance,omitempty"`
	Model              string   `json:"model"`
	FallbackChainFired []string `json:"fallback_chain_fired,omitempty"`
	FailureClass       string   `json:"failure_class,omitempty"`
	// Power is the catalog-projected power of the actually-dispatched
	// Model. 0 means unknown/exact-pin-only/no catalog entry.
	Power int `json:"power,omitempty"`
}

type RoutingPreference int

type RunnerModelResolution struct {
	HarnessName       string `json:"harness_name"`
	RequestedModel    string `json:"requested_model,omitempty"`
	ResolvedModel     string `json:"resolved_model"`
	PriorDefaultModel string `json:"prior_default_model,omitempty"`
	Source            string `json:"source"`
	Surface           string `json:"surface"`
	Warning           string `json:"warning,omitempty"`
	Reason            string `json:"reason,omitempty"`
	ExplicitPin       bool   `json:"explicit_pin,omitempty"`
}

type SessionOutcome string

type SessionStage string

type TerminalCause string

type TextDeltaData struct {
	Text string `json:"text"`
}

type ToolCallData struct {
	ID    string          `json:"id"`
	Name  string          `json:"name"`
	Input json.RawMessage `json:"input,omitempty"`
}

type ToolResultData struct {
	ID         string `json:"id"`
	Output     string `json:"output,omitempty"`
	Error      string `json:"error,omitempty"`
	DurationMS int64  `json:"duration_ms,omitempty"`
}

type UsageCandidate struct {
	Source     string
	Fresh      *bool
	CapturedAt string
	Counts     UsageTokenCounts
	Warning    string
}

type UsageSourceEvidence struct {
	Source     string            `json:"source"`
	Fresh      *bool             `json:"fresh,omitempty"`
	CapturedAt string            `json:"captured_at,omitempty"`
	Usage      *UsageTokenCounts `json:"usage,omitempty"`
	Warning    string            `json:"warning,omitempty"`
}

type UsageTokenCounts struct {
	InputTokens      *int `json:"input_tokens,omitempty"`
	OutputTokens     *int `json:"output_tokens,omitempty"`
	CacheReadTokens  *int `json:"cache_read_tokens,omitempty"`
	CacheWriteTokens *int `json:"cache_write_tokens,omitempty"`
	CacheTokens      *int `json:"cache_tokens,omitempty"`
	ReasoningTokens  *int `json:"reasoning_tokens,omitempty"`
	TotalTokens      *int `json:"total_tokens,omitempty"`
}