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 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 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
}

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()
}