execbackend

type Backend struct {
	Caps lipapi.BackendCaps
	// ResolveCaps, when set, supplies model/candidate-aware capabilities; otherwise Caps is used.
	ResolveCaps func(ctx context.Context, call lipapi.Call, cand routing.AttemptCandidate) lipapi.BackendCaps
	// ResolveWireCaps, when set, supplies candidate/model-aware capabilities for wire fast-path evaluation without requiring a synthesized lipapi.Call.
	ResolveWireCaps func(ctx context.Context, cand routing.AttemptCandidate) lipapi.BackendCaps
	TransportCaps   lipapi.BackendTransportCaps
	// ResolveTransportCaps, when set, supplies model/candidate-aware transport capabilities; otherwise TransportCaps is used.
	ResolveTransportCaps func(ctx context.Context, call lipapi.Call, cand routing.AttemptCandidate) lipapi.BackendTransportCaps
	Open                 func(ctx context.Context, call lipapi.Call, cand routing.AttemptCandidate) (lipapi.ManagedEventStream, error)
	ModelInventory       modelinventory.Provider
	// BackendPrefixes names this connector kind for model-inventory discovery. Prefixes may be
	// shared by instances of the same backend kind, but different backend kinds must not claim the
	// same prefix. Canonical model IDs must not use the qualifier form "<prefix>:<canonical-id>".
	BackendPrefixes []string
	// ReplaySupport is the static historical-reasoning dialect profile for this backend.
	// Prefer ResolveReplaySupport when support depends on candidate/model.
	ReplaySupport lipapi.ReasoningReplaySupport
	// ResolveReplaySupport, when set, supplies candidate/model-aware replay support; otherwise ReplaySupport is used.
	ResolveReplaySupport func(ctx context.Context, call lipapi.Call, cand routing.AttemptCandidate) lipapi.ReasoningReplaySupport

	// DialectSupport declares exact item/reasoning/compaction/extension dialects this backend satisfies.
	DialectSupport lipapi.DialectSupport
	// ResolveDialectSupport, when set, supplies candidate/model-aware dialect support; otherwise DialectSupport is used.
	ResolveDialectSupport func(ctx context.Context, call lipapi.Call, cand routing.AttemptCandidate) lipapi.DialectSupport

	// ResolvePromptCacheProfile supplies model/candidate-aware provider-neutral
	// residency capability. nil means observation/control unsupported.
	ResolvePromptCacheProfile func(context.Context, lipapi.Call, routing.AttemptCandidate) promptcache.Profile
	// RenewPromptCache and ReleasePromptCache are direct operations on an
	// already-issued backend-owned handle. They never receive a selector and
	// must not invoke ordinary route selection or inference.
	RenewPromptCache   func(context.Context, promptcache.RenewRequest) (promptcache.RenewResponse, error)
	ReleasePromptCache func(context.Context, promptcache.ReleaseRequest) error

	BillingFinalizationSupported bool
	FinalizeBilling              func(ctx context.Context, in BillingFinalizationInput) (lipapi.Event, error)
	// FinalizeBillingV2 preserves host-only economic observations returned by
	// an executable connector. FinalizeBilling remains the compatibility
	// projection consumed by legacy authority paths.
	FinalizeBillingV2 func(ctx context.Context, in BillingFinalizationInput) (BillingFinalizationResult, error)

	// EnforcesMaxOutputTokens reports whether this backend serializes a
	// non-nil/positive MaxOutputTokens onto the provider wire so an authority
	// spend-cap clamp actually binds. Zero value (false) is fail-closed: the
	// executor excludes candidates that cannot represent the clamp rather than
	// opening with an unenforced limit. Backends that drop or omit the option
	// (Codex, ACP family, OpenCode, local-stub) must leave this false.
	EnforcesMaxOutputTokens bool
	// IgnoresAuthorityMaxOutputTokensClamp, when set, reports call-specific reasons
	// the backend drops MaxOutputTokens despite EnforcesMaxOutputTokens.
	IgnoresAuthorityMaxOutputTokensClamp func(call lipapi.Call) bool

	ProviderCounter accountingapp.ProviderCounter
	// LocalCounter, when set, supplies instance-local tokenizer counting for
	// compatible modes configured with an explicit tokenizer override.
	LocalCounter accountingapp.LocalCounter
	// TokenizerID is the bounded configured local tokenizer identifier exposed
	// for diagnostics and accounting when LocalCounter is attached.
	TokenizerID string

	// Close, when non-nil, releases backend-owned persistent runtime resources
	// (for example a companion process). nil means the backend owns no such
	// resources or cleans them through individual streams. Callers treat a
	// non-nil callback as idempotent; it is not a request-cancellation API.
	Close func() error

	// Optional generation-local lifecycle / transport seams. nil means unsupported.
	// Composition roots adapt these into candidate prepare/rollback ownership;
	// legacy backends that only set Close remain fully compatible.
	Start                 func(context.Context) error
	Stop                  func(context.Context) error
	CleanupIdleTransports func(context.Context) error
	// PreflightCapability, when set, is an explicit non-billable readiness probe.
	// It is never invoked automatically as a publication gate.
	PreflightCapability func(context.Context) (CapabilityPreflight, error)

	// ResolveWireRequest, when set, supplies candidate-aware pure exact wire
	// capability proof for one candidate (design section 9, Requirements 8, 9).
	// nil means wire execution unsupported (canonical fallback).
	ResolveWireRequest func(ctx context.Context, facts largebody.WireRequestFacts, cand routing.AttemptCandidate) largebody.WireRequestSupport

	// ResolveWireDomain, when set, supplies pure late-route domain wire
	// capability proof (Requirement 7, design section 9).
	// nil means wire execution unsupported (canonical fallback).
	ResolveWireDomain func(ctx context.Context, facts largebody.WireDomainFacts) largebody.WireDomainSupport

	// WireBackend, when non-nil, provides the optional wire capability interface.
	WireBackend largebody.WireBackend

	// OpenWire, when set, opens a backend attempt directly from a wire request
	// without constructing a lipapi.Call (design section 9, Requirement 8).
	OpenWire func(ctx context.Context, req largebody.WireOpenRequest) (lipapi.ManagedEventStream, error)
}

type BillingFinalizationInput struct {
	TraceID string
	ALegID  string
	BLegID  string
	Backend string
	Model   string
	Reason  string
}

type BillingFinalizationResult struct {
	Usage            lipapi.Event
	EconomicEvidence []EconomicEvidence
}

type CapabilityPreflight struct {
	Ready       bool
	Billable    bool
	Description string
}

type EconomicEvidence struct {
	Observation    metering.Observation
	Coverage       string
	CoverageReason string
}

type EconomicEvidenceSource interface {
	DrainEconomicEvidenceRecords() []EconomicEvidence
}

type WireBackend = largebody.WireBackend

type WireOpener = largebody.WireOpener