lipapi

type ALegCancelRequest struct {
	ALegID      string
	SessionID   string
	ResumeToken string
	FrontendID  string
	Reason      string
}

type AnnotationPart struct {
	Type string          `json:"type,omitempty"`
	Data json.RawMessage `json:"data,omitempty"`
}

type AssistantPhase string

type AttemptOutcome string

type AttemptRecord struct {
	BLegID         string
	ALegID         string
	Seq            int
	BackendID      string
	EffectiveModel string
	StartedAt      time.Time
	FinishedAt     time.Time
	Outcome        AttemptOutcome
	Reason         string
}

type BackendCaps map[Capability]struct{}

type BackendTransportCaps map[Operation]TransportModeSet

type Call struct {
	ID           string
	Session      SessionRef
	Route        RouteIntent
	Instructions []Message
	Messages     []Message
	Items        []Item
	// PreviousResponseID identifies a proxy-owned continuation parent. It allows
	// an item-authoritative continuation request to carry an intentionally empty
	// input item slice; the continuation resolver supplies the materialized items.
	PreviousResponseID string
	// PromptCacheKey is a proxy-carried prompt-caching hint for the remote
	// OpenResponses endpoint. It is protocol-neutral metadata (never a canonical
	// trajectory control); the OpenResponses backend forwards it on compact
	// requests so a schema-permitted client hint is never silently dropped.
	PromptCacheKey string
	// SemanticExtensions carries bounded residual semantics whose identity and
	// presence participate in admission. PromptCacheKey is a source-compatible
	// alias; when both forms are present they must agree.
	SemanticExtensions []SemanticExtension
	Tools              []ToolDef
	ToolChoice         ToolChoice
	Options            GenerationOptions
	Extensions         map[string]json.RawMessage
	Invocation         Invocation `json:"-"`

	// MaxPendingWireEvents caps backend adapter-internal pending event queues per stream (0 = unlimited).
	// Not client API; the core executor sets this from server config when non-zero.
	MaxPendingWireEvents int `json:"-"`
}

type CancelCause struct {
	Kind   CancelKind
	Detail string
}

type CancelKind string

type CancelMode string

type CancelResult struct {
	Mode CancelMode
	Err  error
}

type CandidateAdmissionInput struct {
	Call              Call
	Invocation        Invocation
	BackendCaps       BackendCaps
	TransportCaps     BackendTransportCaps
	TransportPolicy   TransportFallbackPolicy
	ReplaySupport     ReasoningReplaySupport
	DialectSupport    DialectSupport
	ProjectionTarget  LegacyProjectionTarget
	RequireProjection bool
	// FrozenRequirements, when set, is the immutable baseline requirement set every
	// candidate must satisfy; transforms must not weaken it during failover.
	FrozenRequirements *ProtocolRequirements
}

type CandidateAdmissionResult struct {
	Kind            NegotiationKind
	Capability      NegotiationResult
	Transport       TransportNegotiationResult
	Requirements    RequirementsMatchResult
	ProjectionError error
}

type Capability string

type CapabilitySet struct {
	Provides []Capability
}

type CloseOnlyManagedStream struct {
	Stream EventStream
}

type CollectLimits struct {
	MaxTextBytes             int
	MaxReasoningBytes        int
	MaxToolArgsTotalBytes    int
	MaxWarnings              int
	MaxAssistantMediaParts   int // assistant_image_ref / assistant_file_ref events aggregated into Collected.AssistantMedia; 0 = unlimited
	MaxAggregatePayloadBytes int // aggregate retained bytes across Text + Reasoning (delta + exact ReasoningPart payload) + ToolArgs; 0 = unlimited (backward-compatible). Overflow-safe.
}

type Collected struct {
	Text      strings.Builder
	Reasoning strings.Builder
	ToolArgs  map[string]*strings.Builder // keyed by tool_call_id
	// ToolNames maps tool_call_id to the function name from EventToolCallStarted.
	ToolNames map[string]string
	// ToolCallOrder is the order tool_call_ids first appear (started or first args delta).
	ToolCallOrder    []string
	Warnings         []string
	InputTokens      int
	OutputTokens     int
	CacheReadTokens  int
	CacheWriteTokens int
	ReasoningTokens  int
	TotalTokens      int
	CostNanoUnits    int64
	Currency         string
	CostSource       string
	TerminalError    *Event
	FinishReceived   bool

	// FinishReason is copied from the terminal EventResponseFinished when set.
	FinishReason string
	// AssistantMedia collects EventAssistantImageRef / EventAssistantFileRef in order.
	AssistantMedia []Part
	// ReasoningParts collects EventReasoningPart payloads in stream emission order.
	// It does not encode placement among text/tool parts; feature observers own
	// cross-part positioning for restore. Distinct from Reasoning, which aggregates
	// progressive EventReasoningDelta text only.
	ReasoningParts []ReasoningPart
}

type CompactionItem struct {
	EncapsulatedID string `json:"encapsulated_id,omitempty"`
	Dialect        string `json:"dialect,omitempty"`
	Implementor    string `json:"implementor,omitempty"`
	// EncryptedContent carries the provider compaction blob (pinned profile
	// encrypted_content). It is protocol-neutral opaque data that the
	// OpenResponses wire encoder renders verbatim on response.compaction output.
	EncryptedContent string          `json:"encrypted_content,omitempty"`
	Opaque           json.RawMessage `json:"opaque,omitempty"`
}

type ContentPart struct {
	Kind ContentPartKind `json:"kind"`

	Text string `json:"text,omitempty"`

	ImageRef  string `json:"image_ref,omitempty"`
	ImageMIME string `json:"image_mime,omitempty"`

	FileRef  string `json:"file_ref,omitempty"`
	FileData string `json:"file_data,omitempty"`
	FileMIME string `json:"file_mime,omitempty"`
	FileName string `json:"file_name,omitempty"`

	VideoRef  string `json:"video_ref,omitempty"`
	VideoMIME string `json:"video_mime,omitempty"`

	Refusal string `json:"refusal,omitempty"`

	Reasoning *ReasoningPart `json:"reasoning,omitempty"`

	Summary string `json:"summary,omitempty"`

	Annotation *AnnotationPart `json:"annotation,omitempty"`

	AssistantRef string `json:"assistant_ref,omitempty"`

	// Extension carries a vendor-prefixed custom content part preserved
	// opaquely when Kind is ContentPartExtension.
	Extension *ExtensionContentPart `json:"extension,omitempty"`
}

type ContentPartKind string

type DeliveryMode string

type DialectRequirement struct {
	Kind        string // "item", "reasoning", "compaction"
	Dialect     string
	Implementor string
}

type DialectSupport struct {
	ItemDialects       []DialectRequirement
	ReasoningDialects  []DialectRequirement
	CompactionDialects []DialectRequirement
	ExtensionTypes     []ExtensionRequirement
}

type Event struct {
	Kind EventKind

	MessageIndex int
	Delta        string
	// Signature carries the Anthropic thinking-block signature on
	// EventReasoningSignatureDelta; it is empty for other kinds.
	Signature string
	// Opaque carries provider opaque reasoning bytes on EventReasoningOpaqueDelta
	// (Anthropic redacted_thinking JSON envelope). Empty for other kinds.
	Opaque []byte
	// Reasoning carries one complete dialect-tagged reasoning part on
	// EventReasoningPart. Nil for other kinds. Callers must not mutate Opaque
	// bytes after the event is handed to streams/collectors; receivers deep-copy.
	Reasoning *ReasoningPart
	// Item carries one complete canonical Item on EventItem (for example a
	// compaction item preserved in a compacted ordered window). Nil for other
	// kinds; EventItem events must not carry content-class fields. Receivers
	// deep-copy before retaining.
	Item       *Item
	ToolCallID string
	ToolName   string

	// Usage fields apply to EventUsageDelta. InputTokens and OutputTokens are
	// retained as the compatibility totals used by existing frontends.
	InputTokens  int
	OutputTokens int
	// CacheReadTokens are submitted/input tokens served from a provider cache.
	CacheReadTokens int
	// CacheWriteTokens are submitted/input tokens written to a provider cache.
	CacheWriteTokens int
	// ReasoningTokens are response/output tokens used for hidden reasoning or
	// thinking when the provider reports them separately.
	ReasoningTokens int
	// TotalTokens is the provider-reported total when available.
	TotalTokens int
	// UsagePresence distinguishes explicitly reported zero counters from
	// counters omitted by a partial provider response.
	UsagePresence UsagePresence
	// CostNanoUnits is a high-precision per-response cost amount in Currency.
	// One whole currency unit is 1e9 nano-units.
	CostNanoUnits int64
	Currency      string
	CostSource    string
	// CostPresent distinguishes an explicitly reported monetary value (including
	// authoritative zero) from a usage event that omits cost. CostSource alone
	// is provenance metadata and must not imply a present monetary value.
	CostPresent bool
	// RawUsageJSON stores bounded provider usage metadata for audit/backfill.
	RawUsageJSON string
	// Accounting annotates the compatibility usage totals on EventUsageDelta.
	Accounting UsageAccountingMetadata
	// UsageScopes carries per-plane usage entries for EventUsageDelta.
	UsageScopes []ScopedUsageDelta

	WarningCode    string
	WarningMessage string

	ErrorCode    string
	ErrorMessage string

	// FinishReason is optional metadata on EventResponseFinished (vendor stop/finish taxonomy).
	FinishReason string

	// ResponseStatus is explicit terminal status on EventResponseFinished
	// ("completed" or "incomplete"). It is authoritative when set: producers that
	// know the upstream response status (for example an OpenResponses backend
	// mapping an upstream resource whose status is "incomplete") set it so
	// downstream state machines never have to infer incompleteness solely from
	// FinishReason, which is ambiguous (a completed response may legitimately
	// carry finish_reason "content_filter"). Empty means the producer left the
	// terminal semantics to the frontend's legacy inference.
	ResponseStatus string

	// AssistantRef / AssistantMIME / AssistantName apply to EventAssistantImageRef and
	// EventAssistantFileRef (same meaning as Part.ImageRef / Part.FileRef fields).
	AssistantRef  string
	AssistantMIME string
	AssistantName string
}

type EventKind string

type EventStream interface {
	Recv(ctx context.Context) (Event, error) // io.EOF means normal completion after terminal event
	Close() error
}

type ExtensionContentPart struct {
	Namespace   string          `json:"namespace,omitempty"`
	Type        string          `json:"type"`
	Implementor string          `json:"implementor,omitempty"`
	Data        json.RawMessage `json:"data,omitempty"`
}

type ExtensionRequirement struct {
	Namespace   string
	Type        string
	Implementor string
}

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

type GenerationOptions struct {
	Temperature       *float64
	MaxOutputTokens   *int
	TopP              *float64
	ReasoningEffort   string
	Verbosity         VerbosityLevel
	ResponseMIMEType  string
	ParallelToolCalls *bool
}

type HookMutationError struct {
	HookID  string
	Details string
	Cause   error
}

type Invocation struct {
	Operation     Operation
	DeliveryMode  DeliveryMode
	TransportMode TransportMode
	// ClientUserAgent is the trimmed inbound HTTP User-Agent captured by frontends.
	// It is protocol-neutral invocation metadata and must not be serialized as provider JSON.
	ClientUserAgent string `json:"-"`
}

type Item struct {
	Kind       ItemKind         `json:"kind"`
	ID         string           `json:"id,omitempty"`
	Status     ItemStatus       `json:"status,omitempty"`
	Role       Role             `json:"role,omitempty"`
	Phase      AssistantPhase   `json:"phase,omitempty"`
	Content    []ContentPart    `json:"content,omitempty"`
	Reference  *ItemReference   `json:"reference,omitempty"`
	ToolCall   *ToolCallItem    `json:"tool_call,omitempty"`
	ToolResult *ToolResultItem  `json:"tool_result,omitempty"`
	Reasoning  *ReasoningItem   `json:"reasoning,omitempty"`
	Compaction *CompactionItem  `json:"compaction,omitempty"`
	Extension  *OpaqueExtension `json:"extension,omitempty"`
}

type ItemKind string

type ItemReference struct {
	ID string `json:"id"`
}

type ItemStatus string

type LegacyProjectionResult struct {
	Instructions []Message
	Messages     []Message
	Requirements ProtocolRequirements
}

type LegacyProjectionTarget struct {
	Caps                     BackendCaps
	ReplaySupport            ReasoningReplaySupport
	SupportsPhase            bool
	SupportsItemReferences   bool
	SupportsCompaction       bool
	SupportsVideoInput       bool
	SupportsOpaqueExtensions bool
	SupportsAnnotations      bool
	SupportsAssistantRefs    bool
	SupportsSummaries        bool
	SupportedExtensions      []ExtensionRequirement
}

type ManagedEventStream interface {
	EventStream
	Cancel(ctx context.Context, cause CancelCause) CancelResult
}

type Message struct {
	Role  Role
	Parts []Part
	// Metadata carries proxy-owned message-level traceability (for example
	// interleaved-thinking injection markers). It is never serialized to wire
	// payloads and never treated as client input.
	Metadata map[string]string `json:"-"`
}

type NegotiationKind string

type NegotiationResult struct {
	Kind       NegotiationKind
	Missing    []Capability // hard rejects only
	Downgraded []Capability // capabilities that will be stripped or softened
}

type OpaqueExtension struct {
	Namespace   string          `json:"namespace"`
	Type        string          `json:"type"`
	Implementor string          `json:"implementor,omitempty"`
	Direction   string          `json:"direction,omitempty"`
	Data        json.RawMessage `json:"data,omitempty"`
}

type Operation string

type OperationTransportSupport struct {
	Operation Operation
	Modes     []TransportMode
}

type OrderedItemProjectionTarget struct {
	SupportsCallExtensions bool
	SupportedExtensions    []ExtensionRequirement
}

type OutputPhase string

type Part struct {
	Kind PartKind

	Text string

	ImageRef  string
	ImageMIME string

	FileRef  string
	FileMIME string
	FileName string

	ToolCallID string
	ToolName   string
	Content    json.RawMessage

	// Reasoning carries historical assistant reasoning when Kind is PartReasoning.
	Reasoning *ReasoningPart
}

type PartKind string

type PolicyDecisionError struct {
	Kind           PolicyDecisionErrorKind
	Stage          string
	ProviderID     string
	ReasonCode     string
	ClientCategory string
	ClientMessage  string
	Cause          error
}

type PolicyDecisionErrorKind string

type ProjectionError struct {
	Reason ProjectionReason
	Field  string
	Detail string
}

type ProjectionReason string

type ProtocolRequirements struct {
	Capabilities       []Capability
	ItemDialects       []DialectRequirement
	ReasoningDialects  []DialectRequirement
	CompactionDialects []DialectRequirement
	ExtensionTypes     []ExtensionRequirement
}

type ReasoningDialect string

type ReasoningItem struct {
	Reasoning *ReasoningPart `json:"reasoning,omitempty"`
}

type ReasoningPart struct {
	Dialect   ReasoningDialect
	Text      string
	Signature string
	Opaque    json.RawMessage

	// Summary and Content preserve the official OpenResponses reasoning-item
	// arrays when the canonical adapter can carry them without flattening.
	// They remain raw JSON because their element vocabulary is protocol-owned.
	Summary        json.RawMessage
	SummaryPresent bool
	Content        json.RawMessage
	ContentPresent bool
	// EncryptedContent preserves the official encrypted_content value,
	// including JSON null. EncryptedContentPresent distinguishes an omitted
	// field from an explicitly present null value.
	EncryptedContent        json.RawMessage
	EncryptedContentPresent bool
}

type ReasoningReplaySupport struct {
	Dialects []ReasoningDialect
}

type RejectError struct {
	Missing []Capability
	Reason  string
}

type RequirementsMatchResult struct {
	Kind              NegotiationKind
	MissingCaps       []Capability
	MissingDialects   []DialectRequirement
	MissingExtensions []ExtensionRequirement
}

type RequirementsRejectError struct {
	MissingCaps       []Capability
	MissingDialects   []DialectRequirement
	MissingExtensions []ExtensionRequirement
}

type Role string

type RouteIntent struct {
	Selector string
}

type ScopedUsageDelta struct {
	InputTokens      int
	OutputTokens     int
	CacheReadTokens  int
	CacheWriteTokens int
	ReasoningTokens  int
	TotalTokens      int
	UsagePresence    UsagePresence
	Accounting       UsageAccountingMetadata
}

type SemanticExtension struct {
	Namespace   string
	Type        string
	Implementor string
	Direction   string
	Presence    SemanticExtensionPresence
	Data        json.RawMessage
}

type SemanticExtensionPresence string

type SessionDenialCode string

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

type SessionRef struct {
	ClientSessionID        string
	ContinuityKey          string
	ALegID                 string
	AuthoritativeSessionID string `json:"SessionID,omitempty"`
	ResumeToken            string
	// Metadata carries validated client session metadata. It is never treated as
	// proxy authority unless a separate trusted carrier establishes that field.
	Metadata map[string]string `json:"-"`
}

type StreamError struct {
	Code    string
	Message string
}

type TokenizerRef struct {
	Type      string
	ID        string
	Version   string
	Source    string
	ModelUsed string
}

type ToolCallItem struct {
	CallID    string          `json:"call_id"`
	Name      string          `json:"name"`
	Arguments json.RawMessage `json:"arguments,omitempty"`
}

type ToolCallSummary struct {
	ID        string
	Name      string
	Arguments string
}

type ToolCategory string

type ToolChoice struct {
	Mode ToolChoiceMode
	// Name is used when Mode requires a specific tool.
	Name string
	// AllowedTools is the OpenResponses allowed_tools subset: when non-empty,
	// only tools named here may be invoked, while the full Tools list stays
	// visible to the model (cache-preserving control surface). Mode still
	// governs whether tools may/should/must be called (auto/none/any).
	// Empty means no subset restriction.
	AllowedTools []string
}

type ToolChoiceMode string

type ToolDef struct {
	Name        string
	Description string
	Parameters  json.RawMessage
}

type ToolEvent struct {
	Kind ToolEventKind

	ToolCallID string
	ToolName   string

	// Category is the coarse category derived from ToolName (or from lifecycle
	// correlation when a later fragment omits ToolName). It is informational
	// metadata, never an allow/deny decision by itself.
	Category ToolCategory
	// MayMutateLocalFS is a conservative potential-capability hint: true when the
	// named tool family can mutate the local filesystem. It is not evidence that
	// a specific invocation mutated anything.
	//
	// The zero value is false and is not a classified result. Unknown names
	// classify as true; project via ToolEventFromEvent or ClassifyToolName
	// rather than inspecting an unprojected ToolEvent literal.
	MayMutateLocalFS bool

	// ArgsDelta carries incremental JSON/tool arguments fragments for ToolEventArgsDelta.
	ArgsDelta string
}

type ToolEventKind string

type ToolResultItem struct {
	CallID string        `json:"call_id"`
	Name   string        `json:"name"`
	Output string        `json:"output,omitempty"`
	Parts  []ContentPart `json:"parts,omitempty"`
}

type TransportFallbackPolicy string

type TransportMode string

type TransportModeSet map[TransportMode]struct{}

type TransportNegotiationResult struct {
	Kind      NegotiationKind
	Selected  TransportMode
	Operation Operation
	Mode      TransportMode
}

type TransportRejectError struct {
	Operation Operation
	Mode      TransportMode
}

type UpstreamFailureError struct {
	Phase        OutputPhase
	Recoverable  bool
	Reason       string
	CandidateKey string
}

type UsageAccountingMetadata struct {
	Plane     UsagePlane
	Source    UsageSource
	Authority UsageAuthority
	Tokenizer TokenizerRef
	// Provider identifiers are opaque, bounded correlation values captured by
	// an adapter. They are never credentials and do not grant runtime
	// attribution authority; the host still supplies the trusted B-leg/store.
	ProviderAccountKey string
	ProviderRequestID  string
	ProviderChargeID   string
	// ServiceContext is an optional provider-returned context lexeme (for
	// example a service tier or endpoint class). It is retained for host-side
	// evidence diagnostics and is never interpreted as a tariff.
	ServiceContext string
	// DedupeKey is an internal accounting correlation key. It is never encoded
	// by frontend adapters and is used only to apply provider evidence once.
	DedupeKey string
}

type UsageAuthority string

type UsageEvidenceSource interface {
	DrainUsageEvidence() []Event
}

type UsagePlane string

type UsagePresence struct {
	InputTokens      bool
	OutputTokens     bool
	CacheReadTokens  bool
	CacheWriteTokens bool
	ReasoningTokens  bool
	TotalTokens      bool
}

type UsageSource string

type ValidationError struct {
	Field   string
	Message string
}

type VerbosityLevel string