import { type WebSocketConstructor, type WebSocketLike } from "./bun-websocket.js";
import { type ConnectPermit, type TransportProvider } from "./coordinator.js";
import type { TransportContext } from "./headers.js";
type PendingMetadata = {
    responseId?: string;
    activeResponseId?: string;
};
export interface StreamSink {
    enqueue(chunk: Uint8Array): void;
    close(): void;
    error(error: Error): void;
}
export interface PendingRequest {
    body: Record<string, unknown>;
    sink: StreamSink;
    onFinalize?: () => void;
    onError?: (error: Error, pending: PendingRequest) => boolean;
    done: boolean;
    sent: boolean;
    writeCommitted: boolean;
    framesReceived: boolean;
    finalMessageOutputReceived: boolean;
    processedAckSent: boolean;
    idleTimer: ReturnType<typeof setTimeout> | null;
    metadata: PendingMetadata;
    streamKey: string;
}
export interface PooledConnection {
    id: string;
    ws: WebSocketLike | null;
    wsUrl: string;
    headers: Record<string, string>;
    scopeKey: string;
    scopeHash: string;
    contextKey: string;
    endpointKey: string;
    accountFp: string;
    provider: TransportProvider;
    origin: string;
    authGeneration: number;
    busy: boolean;
    warm: boolean;
    staleAuth: boolean;
    pending: PendingRequest | null;
    activeSessionID?: string;
    lastSessionID?: string;
    activeAgent?: string;
    lastAgent?: string;
    lastModelID?: string;
    lastStablePrefixHash?: string;
    lastResponseID?: string;
    lastResponseIDGeneration?: number;
    continuationPrefix?: string[];
    continuationPrefixGeneration?: number;
    turnState?: string;
    serverModel?: string;
    modelsEtag?: string;
    serverReasoningIncluded?: boolean;
    generation: number;
    reconnectAttempts: number;
    createdAt: number;
    expiresAt: number;
    lastActivityAt: number;
    lastCloseCode?: number;
    lastCloseReason?: string;
    lastErrorMessage?: string;
    retryAfterMs?: number;
    frameCarryover: string;
    idleTimer: ReturnType<typeof setTimeout> | null;
    connectTimer: ReturnType<typeof setTimeout> | null;
    retryTimer: ReturnType<typeof setTimeout> | null;
    detach: (() => void) | null;
    socketReserved: boolean;
    socketReleased: boolean;
    sessionCounted: boolean;
    connectPermit: ConnectPermit | null;
    connectFinished: boolean;
    turnCount: number;
    intent: "demand" | "prewarm";
    breakerDomain: string;
    contextEpoch: number;
    sawConnectTimeout: boolean;
    sawConnectNonTimeout: boolean;
}
export declare const connectionPool: PooledConnection[];
export declare const readyState: {
    readonly CONNECTING: 0;
    readonly OPEN: 1;
    readonly CLOSING: 2;
    readonly CLOSED: 3;
};
export declare function closeConnection(conn: PooledConnection, reason?: string, graceful?: boolean): void;
export declare function sendPending(conn: PooledConnection): boolean;
export declare function invalidateStaleAuthConnections(wsUrl: string, headers: Record<string, string>): void;
export declare function acquireConnection(wsUrl: string, headers: Record<string, string>, context: TransportContext, _signal?: AbortSignal): PooledConnection;
export declare function ensureWarmConnection(wsUrl: string, headers: Record<string, string>, context?: TransportContext): PooledConnection | undefined;
export declare function clearTransportContextState(wsUrl: string, headers: Record<string, string>, context: TransportContext): void;
export declare function clearSessionTransportState(sessionID: string): void;
export declare function clearAllTransportState(): void;
export declare function closeConnections(predicate?: (conn: PooledConnection) => boolean, message?: string): void;
export declare function nextStreamKeyForTesting(): string;
export declare function allocateStreamKey(): string;
export declare function syncCoordinatorFromTransportConfig(): void;
export declare function getTransportSnapshotForTesting(): {
    contextEntries: number;
    physicalSockets: number;
    connecting: number;
    prewarming: number;
    sessions: number;
    accountEntries: number;
    rateEntries: number;
    queuedInboundBytes: number;
    queuedInboundMessages: number;
    queueOverflows: number;
    providerQueues: {
        codex: {
            bytes: number;
            messages: number;
        };
        openai: {
            bytes: number;
            messages: number;
        };
    };
    counters: {
        admissionMissesByReason: {
            provider_breaker: number;
            session_busy: number;
            session_cooldown: number;
            provider_cap: number;
            process_cap: number;
            account_cap: number;
            connect_cap: number;
            handshake_rate: number;
            memory_guard: number;
            connect_failure: number;
            handshake_timeout: number;
            stale_auth: number;
            other: number;
        };
        httpByReason: {
            provider_breaker: number;
            session_busy: number;
            session_cooldown: number;
            provider_cap: number;
            process_cap: number;
            account_cap: number;
            connect_cap: number;
            handshake_rate: number;
            memory_guard: number;
            connect_failure: number;
            handshake_timeout: number;
            stale_auth: number;
            provider_connection_limit: number;
            previous_response_not_found: number;
            other: number;
        };
        leaseAttempts: number;
        leaseAdmissions: number;
        connectAttempts: number;
        connectSuccesses: number;
        connectFailures: number;
        connectTimeouts: number;
        prewarmAttempts: number;
        prewarmDeferred: number;
        prewarmFailures: number;
        authStaleRejects: number;
        sessionCooldowns: number;
        fallbacks: number;
        maxAgeRetires: number;
    };
    distributions: {
        handshakeLatencyMs: {
            bounds: number[];
            counts: number[];
        };
        socketLifetimeMs: {
            bounds: number[];
            counts: number[];
        };
        turnsPerConnection: {
            bounds: number[];
            counts: number[];
        };
        inboundQueueHighWaterBytes: {
            bounds: number[];
            counts: number[];
        };
        inboundQueueHighWaterMessages: {
            bounds: number[];
            counts: number[];
        };
    };
    breaker: import("./breaker.js").TransportBreakerSnapshot;
};
export declare function resetPoolForTesting(): void;
export declare function setWebSocketConstructorForTesting(ctor: WebSocketConstructor): void;
export declare function resetWebSocketConstructorForTesting(): void;
export {};
//# sourceMappingURL=pool.d.ts.map