openresponses

type Authorizer interface {
	Authenticate(ctx context.Context, meta sdkauth.InboundCallMeta) (sdkauth.Decision, error)
}

type CompactOperation struct {
	Call         *lipapi.Call
	Requirements lipapi.ProtocolRequirements
}

type CompactResourceIDSource interface {
	NewCompactResourceID() string
}

type Config struct {
	Profile                  string             `yaml:"profile"`
	BasePath                 string             `yaml:"base_path"`
	Continuation             ContinuationConfig `yaml:"continuation"`
	WebSocket                WebSocketConfig    `yaml:"websocket"`
	ExposeLipUsageExtensions bool               `yaml:"expose_lip_usage_extensions"`
	// contains filtered or unexported fields
}

type ContinuationConfig struct {
	PersistentStore      string `yaml:"persistent_store"`
	TTL                  string `yaml:"ttl"`
	MaxChainDepth        int    `yaml:"max_chain_depth"`
	MaxMaterializedBytes int64  `yaml:"max_materialized_bytes"`
}

type ContinuationRecorderFactory interface {
	NewRecorder(store lipcont.Store, record lipcont.ContinuationRecord) lipcont.StreamObserver
}

type ContinuationResolver interface {
	ResolveParent(ctx context.Context, scope lipcont.Scope, parentID string, baseCall lipapi.Call) (lipapi.Call, lipcont.ContinuationRecord, error)
}

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

type DecodeCompactOptions struct {
	DefaultRouteSelector string
	RoutePrefixes        []string
	RouteSelector        string
	Headers              http.Header
	Auth                 Authorizer
	MaxBodyBytes         int64
	Limits               proto.Limits
	Method               string
	Path                 string
	RemoteAddr           string
	HTTPHeaders          lipsdk.HTTPHeaders
}

type DecodeCreateOptions struct {
	DefaultRouteSelector string
	RoutePrefixes        []string
	RouteSelector        string
	Headers              http.Header
	Auth                 Authorizer
	MaxBodyBytes         int64
	Limits               proto.Limits
	Method               string
	Path                 string
	RemoteAddr           string
	HTTPHeaders          lipsdk.HTTPHeaders
}

type DecodedCompact struct {
	Call          *lipapi.Call
	Requirements  lipapi.ProtocolRequirements
	RouteSelector string
	Model         string
	AuthDecision  sdkauth.Decision
}

type DecodedCreate struct {
	Call               *lipapi.Call
	Requirements       lipapi.ProtocolRequirements
	Stream             bool
	RouteSelector      string
	Model              string
	PreviousResponseID string
	Store              bool
	ExplicitStore      *bool
	AuthDecision       sdkauth.Decision
}

type Diagnostics struct {
	Profile                  string                    `json:"profile"`
	BasePath                 string                    `json:"base_path"`
	WebSocketEnabled         bool                      `json:"websocket_enabled"`
	WebSocketMaxQueuedTurns  int                       `json:"websocket_max_queued_turns"`
	WebSocketMaxQueuedBytes  int64                     `json:"websocket_max_queued_bytes"`
	WebSocketDevelopmentMode bool                      `json:"websocket_development_mode"`
	WebSocketAllowAnyOrigin  bool                      `json:"websocket_allow_any_origin"`
	AllowedOrigins           []string                  `json:"allowed_origins"`
	ContinuationStore        string                    `json:"continuation_store"`
	ContinuationTTL          string                    `json:"continuation_ttl"`
	RouteClaims              []httpcontract.RouteClaim `json:"route_claims"`
}

type ExecutorView interface {
	Execute(ctx context.Context, call *lipapi.Call) (lipapi.EventStream, error)
}

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

type HandlerConfig struct {
	Authorizer            Authorizer
	RequireAuthentication bool
	AllowUnauthenticated  bool
	Executor              ExecutorView
	// ContinuationResolver is the narrow injected seam for resolving parent continuation state.
	ContinuationResolver ContinuationResolver
	// ContinuationStore is the injected protocol-neutral store port for continuation
	// state. When nil, continuation features degrade gracefully.
	ContinuationStore       lipcont.Store
	DefaultRouteSelector    string
	RoutePrefixes           []string
	MaxRequestBodyBytes     int64
	ProtocolLimits          proto.Limits
	DecodeAdmission         lipsdk.DecodeAdmission
	TrafficPorts            traffic.PortBundle
	PreRequestKeepalive     lipsdk.FrontendKeepaliveConfig
	Config                  Config
	HTTPHeaders             lipsdk.HTTPHeaders
	StreamKeepaliveInterval time.Duration
	ResponseIDSource        ResponseIDSource
	CompactResourceIDSource CompactResourceIDSource
	ResponseClock           ResponseClock
	// RecorderFactory is the narrow seam for incremental terminal recording.
	// A nil factory uses the standard core recorder.
	RecorderFactory ContinuationRecorderFactory
	// Profile optionally enables large-payload fast-path candidate evaluation (Task 17).
	Profile frontendpipe.FrontendProfile
	// LargePayload configures the large-payload fast-path candidate limits (Task 17).
	LargePayload frontendpipe.LargePayloadConfig
}

type Profile struct{}

type ResponseClock interface {
	Now() time.Time
}

type ResponseIDSource interface {
	NewResponseID() string
}

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

type SessionRunnerConfig struct {
	// Executor is the canonical event-stream executor shared with the HTTP
	// frontend. A nil executor makes every accepted turn fail with a classified
	// operation_not_implemented error without killing the connection.
	Executor ExecutorView
	// DefaultRouteSelector and RoutePrefixes mirror the HTTP decode options so a
	// WebSocket turn resolves its canonical route the same way a POST does.
	DefaultRouteSelector string
	RoutePrefixes        []string
	// MaxMessageBytes bounds one turn envelope during decode. Zero uses the
	// protocol request limit, which also bounds the transport read.
	MaxMessageBytes int64
	// ProtocolLimits bounds the shared OpenResponses request codec.
	ProtocolLimits proto.Limits
	// ResponseIDSource and ResponseClock are proxy-owned envelope metadata shared
	// with the non-streaming/SSE handlers.
	ResponseIDSource ResponseIDSource
	ResponseClock    ResponseClock
	// MaterializeBounds bound parent-chain reconstruction for a continued turn.
	// Zero uses the contract defaults.
	MaterializeBounds lipcont.Bounds
	// RecorderFactory is the narrow seam for incremental terminal recording into
	// the connection-local store. A nil factory uses the standard core recorder.
	RecorderFactory ContinuationRecorderFactory
}

type WSCounterSnapshot struct {
	SessionsOpened    int64
	SessionsClosed    int64
	AuthRejected      int64
	OriginRejected    int64
	HandshakeRejected int64
	MethodRejected    int64
	AgeExpired        int64
	IdleClosed        int64
}

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

type WSLocalContinuationConfig struct {
	Enabled bool
	// Limits bound one connection's retained terminal records.
	Limits lipcont.StorageLimits
	// MaterializeBounds bound parent-chain reconstruction for a continued turn.
	MaterializeBounds lipcont.Bounds
	// StoreFactory builds the per-connection store. A nil factory uses the
	// bounded in-memory connection-local store; tests inject tracking wrappers.
	StoreFactory func(scope lipcont.Scope) lipcont.Store
}

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

type WSSessionRunner interface {
	HandleMessage(ctx context.Context, s *WSSession, data []byte) error
}

type WebSocketConfig struct {
	Enabled          bool     `yaml:"enabled"`
	MaxConnectionAge string   `yaml:"max_connection_age"`
	IdleTimeout      string   `yaml:"idle_timeout"`
	MaxQueuedTurns   int      `yaml:"max_queued_turns"`
	MaxQueuedBytes   int64    `yaml:"max_queued_bytes"`
	AllowedOrigins   []string `yaml:"allowed_origins"`
	DevelopmentMode  bool     `yaml:"development_mode"`
	AllowAnyOrigin   bool     `yaml:"allow_any_origin"`
}

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

type WebSocketHandlerConfig struct {
	// Authorizer is evaluated before the upgrade and before any session state is
	// allocated. When nil, the handler requires an authenticated transport context
	// unless AllowUnauthenticated is explicitly set.
	Authorizer            Authorizer
	RequireAuthentication bool
	AllowUnauthenticated  bool
	// Config is the validated frontend configuration supplying the WebSocket policy.
	Config Config
	// Runner processes established sessions (Task 6.2). A nil runner keeps the
	// bounded keepalive shell alive without turn execution.
	Runner WSSessionRunner
	// ShutdownCtx, when non-nil, is a runtime-owned context that cancels when the
	// frontend begins shutdown. Every session observes it and closes exactly once.
	ShutdownCtx context.Context
	// MaxMessageBytes overrides the default per-message bound; zero uses the default.
	MaxMessageBytes int64
	// LocalContinuation configures connection-local store:false continuation.
	// A nil value enables the profile defaults derived from Config.
	LocalContinuation *WSLocalContinuationConfig
	// WriteTextWrapper, when non-nil, wraps the socket data-frame writer for every
	// session this handler establishes. next writes one text frame to the socket.
	// A wrapper may count frames and return an error on the Nth write to force a
	// deterministic writer failure; production leaves it nil.
	WriteTextWrapper func(next func(data []byte) error) func(data []byte) error
}

type WireErrors struct{}