mcp

type AdmissionStatuser interface {
	AdmissionStatus() (atCapacity bool, current int, max int)
}

type AvailabilityError struct {
	Category FailureCategory
	Err      error
}

type CircuitBreakerConfig struct {
	FailureThreshold int
	RecoveryTimeout  time.Duration
}

type CircuitOpenError struct {
	Server  string
	RetryIn time.Duration
}

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

type FailureCategory string

type FallbackSuggestion struct {
	ServerName   string
	Capabilities []string
	Installed    bool
	Source       string
	Reason       string
}

type FallbackSuggestionProvider interface {
	SuggestAlternatives(ctx context.Context, failedServer, failedTool string) []FallbackSuggestion
}

type HardeningConfig struct {
	// MaxBodyBytes caps the request body size. 0 uses DefaultMaxBodyBytes.
	MaxBodyBytes int64

	// ReadTimeout for http.Server. 0 uses DefaultReadTimeout.
	ReadTimeout time.Duration

	// ReadHeaderTimeout for http.Server. 0 uses DefaultReadHeaderTimeout.
	ReadHeaderTimeout time.Duration

	// WriteTimeout for http.Server. Negative disables (0 = SSE-safe default = no timeout).
	WriteTimeout time.Duration

	// IdleTimeout for http.Server. 0 uses DefaultIdleTimeout.
	IdleTimeout time.Duration

	// RateBurst is the token bucket burst size. 0 uses DefaultRateBurst.
	// Set to -1 to disable rate limiting.
	RateBurst int

	// RateInterval is the token refill interval. 0 uses DefaultRateInterval.
	RateInterval time.Duration
}

type LeaseClock interface {
	Now() time.Time
}

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

type LeaseSnapshot struct {
	CapacityUsed  int
	CapacityMax   int
	Rows          []LeaseSnapshotRow
	Omitted       int
	Closed        []LeaseSnapshotRow
	ClosedOmitted int
}

type LeaseSnapshotRow struct {
	SafeID          string
	State           LeaseState
	Age             time.Duration
	Idle            time.Duration
	InFlight        int
	SSEConnections  int
	LifecycleReason string
}

type LeaseState string

type ManagedBackendGate interface {
	BeginRequest() (func(), error)
	Ready() bool
}

type ManagedGatewayMetrics interface {
	IncActiveSessions()
	DecActiveSessions()
	IncAdmissionDenied()
	IncReaped(reason string)
}

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

type ManagedHTTPGatewayConfig struct {
	Target             *url.URL
	MaxSessions        int
	IdleTimeout        time.Duration
	Clock              LeaseClock
	Transport          http.RoundTripper
	Backend            ManagedBackendGate
	OnAmbiguousFailure func(error)
	Metrics            ManagedGatewayMetrics
	Logger             *slog.Logger
}

type ManagerSelector interface {
	SessionCloser
	AdmissionStatuser
	SelectForNewSession(ctx context.Context, upstreamSessionID string) (*session.Manager, error)
	Rebind(oldKey, newKey string)
	ReportSpawnResult(sessionKey string, err error)
	SetOnSessionRemoved(fn func(sessionID string))
	Release(upstreamSessionID string)
}

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

type PortManagerError struct {
	Message string
}

type ProxyConfig struct {
	// ServerName is the name of the MCP server being proxied.
	ServerName string

	// SessionManager manages downstream subprocess lifecycle.
	SessionManager *session.Manager

	// Selector chooses which session manager should own a new upstream session.
	// Used by slot groups for transparent routing. When nil, SessionManager is
	// used directly.
	Selector ManagerSelector

	// SharedManager manages a single downstream subprocess shared across all
	// upstream sessions for stateless MCP servers. When set, SessionManager and
	// Selector must both be nil.
	SharedManager *session.SharedSessionManager

	// Logger for proxy operations.
	Logger *slog.Logger

	// SuggestionProvider supplies alternative tool suggestions when downstream
	// availability failures are returned to the upstream client as tool results.
	SuggestionProvider FallbackSuggestionProvider

	// HealthCheckInterval is how often to probe idle downstream sessions.
	// 0 means no proactive health checking (reactive respawn only).
	HealthCheckInterval time.Duration

	// RequestTimeout is the default downstream tool-call deadline when the
	// upstream request has no earlier deadline.
	RequestTimeout time.Duration

	// RetryConfig controls retry behavior for retryable downstream failures.
	RetryConfig RetryConfig

	// CircuitBreakerConfig controls fast-fail behavior after repeated failures.
	CircuitBreakerConfig CircuitBreakerConfig

	// SharedReadOnlyTools lists tool names that are safe to coalesce/cache across
	// concurrent sessions for this server.
	SharedReadOnlyTools []string

	// SharedResultCacheTTL controls how long successful shared read-only results
	// stay cached. 0 disables caching while still allowing in-flight coalescing.
	SharedResultCacheTTL time.Duration

	// SharedResultCacheSize caps cached shared read-only results per server.
	// 0 uses the default size.
	SharedResultCacheSize int

	// MaxInFlightRequests caps concurrent downstream tool calls per server.
	// 0 means unlimited.
	MaxInFlightRequests int

	// DisconnectGracePeriod is the time to wait after the last HTTP connection
	// closes before removing a shared-mode upstream session. 0 disables disconnect
	// detection. Set from ServerConfig.ResolvedDisconnectGracePeriod().
	DisconnectGracePeriod time.Duration

	// Metrics tracks per-server session lifecycle counters. Optional; nil = no metrics.
	Metrics metrics.ServerMetricsReporter
}

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

type RetryConfig struct {
	MaxAttempts     int
	InitialDelay    time.Duration
	MaxDelay        time.Duration
	RetryableErrors []string
}

type SecurityConfig struct {
	// BearerToken is the expected bearer token for Authorization header validation.
	// When empty, authentication is not enforced (open access).
	BearerToken string

	// AllowedOrigins is the list of permitted Origin header values.
	// When empty, origin checking is not enforced.
	// Wildcard ("*") entries are explicitly rejected and treated as if origin is disallowed.
	AllowedOrigins []string

	// Logger for security events. When nil, security events are not logged.
	Logger *slog.Logger
}

type ServerListener struct {
	Name           string
	Port           int
	MCPHandler     http.Handler  // Streamable HTTP handler
	SessionManager SessionCloser // Session manager for cleanup (nil if not applicable)
	Server         *http.Server
}

type SessionCloser interface {
	CloseAll()
}