@qodo/sdk 0.13.4 → 2.0.0-next.1

package/dist/api/websocket.js

@@ -1,1166 +0,0 @@
-import WebSocket from "ws";
-import { EventEmitter } from "events";
-import { v4 as uuid } from "uuid";
-import { getAuthConfig } from "../auth/index.js";
-import { ServerData } from "../session/index.js";
-import { getCurrentEnvironment } from "../session/index.js";
-// WebSocket-specific configuration
-const WS_CONFIG = {
-    IDLE_TIMEOUT: 600000,
-    HEARTBEAT_INTERVAL: 30000,
-    HEARTBEAT_TIMEOUT: 60000,
-    CONNECTION_TIMEOUT: 15000,
-    INITIAL_RECONNECT_DELAY: 1000,
-    MAX_RECONNECT_DELAY: 30000,
-    RECONNECT_BACKOFF_FACTOR: 1.5,
-    MESSAGE_QUEUE_MAX_SIZE: 1000,
-    READY_TIMEOUT: 300000,
-};
-export var ConnectionState;
-(function (ConnectionState) {
-    ConnectionState["DISCONNECTED"] = "DISCONNECTED";
-    ConnectionState["CONNECTING"] = "CONNECTING";
-    ConnectionState["CONNECTED"] = "CONNECTED";
-    ConnectionState["RECONNECTING"] = "RECONNECTING";
-    ConnectionState["DISCONNECTING"] = "DISCONNECTING";
-    ConnectionState["FAILED"] = "FAILED";
-})(ConnectionState || (ConnectionState = {}));
-export var ReadyState;
-(function (ReadyState) {
-    ReadyState["IDLE"] = "IDLE";
-    /**
-     * Post-connect, waiting for ResumeAck from the server before sending any
-     * turn. Replaces the old WAITING_INITIAL_READY — the server's authoritative
-     * view is now the precondition for proceeding, not a bare "Ready" signal.
-     */
-    ReadyState["AWAITING_RESUME_ACK"] = "AWAITING_RESUME_ACK";
-    ReadyState["WAITING_INITIAL_READY"] = "WAITING_INITIAL_READY";
-    ReadyState["READY"] = "READY";
-    ReadyState["MESSAGE_SENT"] = "MESSAGE_SENT";
-    ReadyState["WAITING_READY"] = "WAITING_READY";
-    ReadyState["CHECKPOINT_RECOVERY"] = "CHECKPOINT_RECOVERY";
-})(ReadyState || (ReadyState = {}));
-export class WebSocketClient extends EventEmitter {
-    ws;
-    shouldDebugLog() {
-        const env = getCurrentEnvironment();
-        // In SDK mode, default is silent unless sdkDebug=true or QODO_DEBUG=true.
-        if (env?.sdkMode) {
-            return !!env.sdkDebug || process.env.QODO_DEBUG === 'true';
-        }
-        return process.env.QODO_DEBUG === 'true';
-    }
-    debug(...args) {
-        if (this.shouldDebugLog()) {
-            // eslint-disable-next-line no-console
-            console.debug(...args);
-        }
-    }
-    state = ConnectionState.DISCONNECTED;
-    sessionId;
-    requestId;
-    connectionId;
-    // Idle management
-    idleTimer;
-    autoDisconnected = false;
-    // Heartbeat management
-    heartbeatInterval;
-    lastPongReceived = Date.now();
-    lastPingSent = 0;
-    // Reconnection management
-    reconnectAttempts = 0;
-    reconnectTimer;
-    isReconnecting = false;
-    // Message queue for handling during disconnection
-    messageQueue = [];
-    isProcessingQueue = false;
-    // Ready protocol state management
-    readyState = ReadyState.IDLE;
-    latestCheckpointId;
-    lastSentMessage;
-    readyTimer;
-    receivedResponsesSinceMessage = false; // Track if any responses received after sending message
-    /**
-     * Protocol-v2 counters. Public read-only via `getMetrics()` — wired into
-     * SDK telemetry so observability dashboards can alert on e.g. rising
-     * `reconcile_failures_total` without digging through debug logs.
-     */
-    metrics = {
-        reconnects_total: 0,
-        turns_sent_total: 0,
-        turns_acked_total: 0,
-        turns_replayed_total: 0,
-        resume_acks_total: 0,
-        reconcile_failures_total: 0,
-        stalls_detected_total: 0,
-        idempotent_replays_total: 0,
-    };
-    /** Last time the socket transitioned from CONNECTED to not-CONNECTED; used for downtime metrics. */
-    lastDisconnectAt;
-    getMetrics() {
-        return { ...this.metrics };
-    }
-    /**
-     * Outbox of turns the client has sent (or is about to send) but has not
-     * received a TurnAck for. Keyed by turn_id so idempotent replay across
-     * reconnect is an O(1) lookup. Only pruned on TurnAck or ResumeAck.
-     */
-    outbox = new Map();
-    /**
-     * FIFO order of turn_ids in the outbox. We send one turn at a time — the
-     * Ready/MESSAGE_SENT ping-pong enforces this — but the order matters for
-     * replay after reconcile, so we track it explicitly rather than relying on
-     * Map iteration order across Node versions.
-     */
-    outboxOrder = [];
-    /** SLA timer: Resume must be ack'd within this window or the socket is dead. */
-    resumeAckTimer;
-    /** SLA timer: post-ResumeAck, the server must produce forward progress or we surface a stall. */
-    postResumeProgressTimer;
-    /**
-     * Short grace period after a bare Ready arrives while we're awaiting a
-     * ResumeAck. If no ResumeAck shows up in that window, we assume the
-     * backend is a pre-v2 deployment that only emits Ready and fall back —
-     * instead of hanging for 15s until the ResumeAck SLA closes the socket.
-     */
-    legacyFallbackTimer;
-    /**
-     * Flips true on the first transition to READY and stays true for the life
-     * of the instance. Represents "initial handshake has completed at least
-     * once." Used by ``handleClose`` to distinguish startup failures (fail
-     * fast with a real error) from mid-session drops (enter reconnect loop).
-     * Decoupling this from specific ReadyState values means new handshake
-     * states can be added without silently changing close behavior.
-     */
-    hasCompletedHandshake = false;
-    /** Expose current ready state so callers can detect post-await state changes. */
-    getReadyState() {
-        return this.readyState;
-    }
-    hasReceivedResponsesSinceLastMessage() {
-        return this.receivedResponsesSinceMessage;
-    }
-    // Connection-timeout timer (ensure we clear/unref to avoid keeping event loop alive)
-    connectionTimeoutTimer;
-    constructor() {
-        super();
-    }
-    setState(newState) {
-        if (this.state !== newState) {
-            const oldState = this.state;
-            this.state = newState;
-            this.debug(`[WebSocketClient] Connection state transition: ${oldState} → ${newState} | ` +
-                `ReadyState: ${this.readyState} | ` +
-                `Session: ${this.sessionId?.substring(0, 8)}...`);
-            this.emit('stateChanged', newState);
-        }
-    }
-    setReadyState(newState, context) {
-        if (this.readyState !== newState) {
-            const oldState = this.readyState;
-            this.readyState = newState;
-            // First entry into READY marks the handshake as complete. Any close
-            // before this point is a startup failure; any close after is a
-            // mid-session drop that should trigger the reconnect loop.
-            if (newState === ReadyState.READY && !this.hasCompletedHandshake) {
-                this.hasCompletedHandshake = true;
-            }
-            // Leaving AWAITING_RESUME_ACK — either we got what we wanted
-            // (ResumeAck) or we gave up. Either way the legacy-fallback grace
-            // timer is no longer relevant.
-            if (oldState === ReadyState.AWAITING_RESUME_ACK) {
-                this.clearLegacyFallbackTimer();
-            }
-            this.debug(`[WebSocketClient] Ready state transition: ${oldState} → ${newState}` +
-                (context ? ` | Context: ${context}` : '') +
-                ` | Session: ${this.sessionId?.substring(0, 8)}...` +
-                ` | Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'}`);
-            this.emit('readyStateChanged', { oldState, newState, context });
-        }
-    }
-    /**
-     * SLA for the Resume→ResumeAck round trip. Tuned to cover a cold graph load
-     * from postgres with some headroom, but tight enough that a silently dead
-     * socket reveals itself before the outer timeout layer even notices.
-     */
-    static RESUME_ACK_TIMEOUT_MS = 15000;
-    /**
-     * SLA for "something must happen after ResumeAck." If the server says it's
-     * awaiting nothing and we also have nothing to send, we stay in READY (not
-     * a stall). Otherwise a quiet socket for this long is a stall.
-     */
-    static POST_RESUME_PROGRESS_TIMEOUT_MS = 30000;
-    /**
-     * Grace period after a bare Ready arrives in AWAITING_RESUME_ACK. Long
-     * enough to cover the backend's ResumeAck round-trip latency, short
-     * enough that a true legacy server doesn't hang the SDK startup.
-     */
-    static LEGACY_READY_FALLBACK_MS = 2000;
-    addToOutbox(turn) {
-        if (this.outbox.has(turn.turn_id))
-            return;
-        this.outbox.set(turn.turn_id, turn);
-        this.outboxOrder.push(turn.turn_id);
-        this.metrics.turns_sent_total++;
-    }
-    removeFromOutbox(turnId) {
-        if (!this.outbox.delete(turnId))
-            return false;
-        const idx = this.outboxOrder.indexOf(turnId);
-        if (idx >= 0)
-            this.outboxOrder.splice(idx, 1);
-        return true;
-    }
-    outboxSnapshot() {
-        return this.outboxOrder
-            .map(id => this.outbox.get(id))
-            .filter((t) => t !== undefined);
-    }
-    /** Build the client half of a PendingTurn for the Resume envelope. */
-    pendingTurnDescriptor(turn) {
-        if (turn.type === 'UserQuery') {
-            return { turn_id: turn.turn_id, type: 'prompt' };
-        }
-        return {
-            turn_id: turn.turn_id,
-            type: 'tool_result',
-            ...(turn.tool_call_id ? { tool_call_id: turn.tool_call_id } : {}),
-        };
-    }
-    clearResumeAckTimer() {
-        if (this.resumeAckTimer) {
-            clearTimeout(this.resumeAckTimer);
-            this.resumeAckTimer = undefined;
-        }
-    }
-    clearPostResumeProgressTimer() {
-        if (this.postResumeProgressTimer) {
-            clearTimeout(this.postResumeProgressTimer);
-            this.postResumeProgressTimer = undefined;
-        }
-    }
-    startResumeAckTimer() {
-        this.clearResumeAckTimer();
-        this.resumeAckTimer = setTimeout(() => {
-            this.debug(`[WebSocketClient] ResumeAck timeout expired | ` +
-                `State: ${this.readyState} | ` +
-                `Session: ${this.sessionId?.substring(0, 8)}...`);
-            // The server didn't reply to Resume — treat the socket as dead and cycle it.
-            try {
-                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                    this.ws.close(4001, 'ResumeAck timeout');
-                }
-            }
-            catch { /* cleanup: forcing close on an already-closing socket is expected to no-op */ }
-            this.emit('resumeAckTimeout');
-        }, WebSocketClient.RESUME_ACK_TIMEOUT_MS);
-        this.resumeAckTimer.unref?.();
-    }
-    clearLegacyFallbackTimer() {
-        if (this.legacyFallbackTimer) {
-            clearTimeout(this.legacyFallbackTimer);
-            this.legacyFallbackTimer = undefined;
-        }
-    }
-    /**
-     * Start the legacy-server fallback grace period.
-     *
-     * Called when we receive a bare ``Ready`` while still in
-     * ``AWAITING_RESUME_ACK``. In the normal v2 flow the server sends Ready
-     * first and ResumeAck right after — we want to wait for ResumeAck. But if
-     * the server is a pre-v2 deployment that never emits ResumeAck, waiting
-     * for the 15s SLA would stall every startup. Instead, we wait a short
-     * grace period; if no ResumeAck arrives, we treat the Ready we already
-     * saw as a legacy-protocol signal and transition to READY.
-     */
-    startLegacyFallbackTimer() {
-        // Idempotent — multiple Ready messages shouldn't pile up timers.
-        if (this.legacyFallbackTimer)
-            return;
-        this.legacyFallbackTimer = setTimeout(() => {
-            this.legacyFallbackTimer = undefined;
-            if (this.readyState !== ReadyState.AWAITING_RESUME_ACK)
-                return;
-            this.debug(`[WebSocketClient] Legacy fallback: Ready seen without ResumeAck, ` +
-                `assuming pre-v2 backend | outbox: ${this.outbox.size}`);
-            // Cancel the longer ResumeAck SLA — we've decided the server doesn't speak it.
-            this.clearResumeAckTimer();
-            this.setReadyState(ReadyState.READY, 'Legacy fallback after Ready without ResumeAck');
-            // Drain anything queued. Legacy flow has no TurnAck, so outbox
-            // entries will linger; a later reconnect (against a v2 backend)
-            // would reconcile them, but that's out of scope for this path.
-            void this.processOutbox();
-        }, WebSocketClient.LEGACY_READY_FALLBACK_MS);
-        this.legacyFallbackTimer.unref?.();
-    }
-    startPostResumeProgressTimer() {
-        this.clearPostResumeProgressTimer();
-        this.postResumeProgressTimer = setTimeout(() => {
-            this.debug(`[WebSocketClient] Post-ResumeAck stall | ` +
-                `State: ${this.readyState} | ` +
-                `Outbox size: ${this.outbox.size} | ` +
-                `Session: ${this.sessionId?.substring(0, 8)}...`);
-            this.metrics.stalls_detected_total++;
-            this.emit('stallDetected', {
-                stage: 'post_resume',
-                outboxSize: this.outbox.size,
-            });
-        }, WebSocketClient.POST_RESUME_PROGRESS_TIMEOUT_MS);
-        this.postResumeProgressTimer.unref?.();
-    }
-    /**
-     * Send the protocol-v2 Resume envelope. Called on every (re)connect before
-     * any turn can flow. Gives the backend enough state to reply with an
-     * authoritative ResumeAck.
-     */
-    sendResume() {
-        if (!this.ws || this.state !== ConnectionState.CONNECTED) {
-            this.debug('[WebSocketClient] sendResume: socket not connected, skipping');
-            return;
-        }
-        const payload = {
-            last_seen_checkpoint: this.latestCheckpointId ?? null,
-            pending_turns: this.outboxSnapshot().map(t => this.pendingTurnDescriptor(t)),
-        };
-        const formatted = `Resume ${JSON.stringify(payload)}\n`;
-        try {
-            this.ws.send(formatted);
-            this.debug(`[WebSocketClient] Sent Resume | ` +
-                `pending_turns: ${payload.pending_turns.length} | ` +
-                `last_seen_checkpoint: ${(this.latestCheckpointId ?? 'none').toString().substring(0, 8)}`);
-            this.setReadyState(ReadyState.AWAITING_RESUME_ACK, 'Resume sent');
-            this.startResumeAckTimer();
-        }
-        catch (err) {
-            this.debug('[WebSocketClient] Error sending Resume:', err);
-        }
-    }
-    /**
-     * Apply the server's authoritative view. This is the anti-deadlock primitive:
-     * every reconnect path runs through here and produces an explicit decision
-     * instead of both sides waiting on each other.
-     *
-     * Reconcile only runs on the FIRST ResumeAck of a (re)connect — the one we
-     * were explicitly waiting for. Any subsequent ResumeAcks (e.g. the server
-     * re-emits one as a loop-top heartbeat, or replies to our Resume probe) are
-     * informational; acting on them would double-send turns we've already
-     * replayed.
-     */
-    async handleResumeAck(message) {
-        const args = message?.data?.tool_args ?? {};
-        const currentCheckpoint = args.current_checkpoint;
-        const lastConsumedTurnId = args.last_consumed_turn_id;
-        const awaiting = args.awaiting ?? { type: 'none' };
-        const awaitingType = awaiting.type ?? 'none';
-        const awaitingToolCallId = awaiting.tool_call_id;
-        this.clearResumeAckTimer();
-        if (currentCheckpoint && currentCheckpoint !== this.latestCheckpointId) {
-            this.latestCheckpointId = currentCheckpoint;
-        }
-        const isReconcilePhase = this.readyState === ReadyState.AWAITING_RESUME_ACK;
-        this.metrics.resume_acks_total++;
-        this.emit('resumeAck', {
-            current_checkpoint: currentCheckpoint,
-            last_consumed_turn_id: lastConsumedTurnId,
-            awaiting: { type: awaitingType, tool_call_id: awaitingToolCallId },
-            outbox_size: this.outbox.size,
-        });
-        if (!isReconcilePhase) {
-            this.debug(`[WebSocketClient] Informational ResumeAck (already reconciled) | ` +
-                `State: ${this.readyState}`);
-            return;
-        }
-        // 1) Drop turns the server has already consumed (implicit ack via Resume).
-        if (lastConsumedTurnId && this.outbox.has(lastConsumedTurnId)) {
-            this.removeFromOutbox(lastConsumedTurnId);
-            this.debug(`[WebSocketClient] ResumeAck dropped acked turn from outbox | ` +
-                `turn_id: ${lastConsumedTurnId}`);
-        }
-        // 2) Reconcile what the server is waiting for against what we hold.
-        let reconcileFailedReason;
-        let resumeToSend;
-        if (awaitingType === 'tool_result') {
-            // Drop any tool_results whose tool_call_id does NOT match what the
-            // server is now awaiting. The server only advances to "awaiting the
-            // next tool" after it has ingested the previous tool_result into its
-            // graph state — so a pending outbox entry for any OTHER tool_call_id
-            // is already consumed; we just missed the TurnAck across the drop.
-            //
-            // This is the production case behind the Apr 19 Slack-bot hang: the
-            // socket closed between the server's graph advance (which added the
-            // next ToolRequested to state) and `_commit_turn_consumed`, so the
-            // client's last_consumed_turn_id guard didn't match. Treating the
-            // mismatch as a hard failure froze the session until the outer
-            // 10-min max timer fired. Dropping-as-stale keeps forward progress.
-            for (const turn of this.outboxSnapshot()) {
-                if (turn.type === 'IDERetrievalAnswer' && turn.tool_call_id !== awaitingToolCallId) {
-                    this.debug(`[WebSocketClient] ResumeAck dropped stale tool_result | ` +
-                        `turn_id: ${turn.turn_id} | stale tool_call: ${turn.tool_call_id} | ` +
-                        `server awaits: ${awaitingToolCallId ?? 'unspecified'}`);
-                    this.removeFromOutbox(turn.turn_id);
-                }
-            }
-            // If the matching tool_result is still present (real replay), send it.
-            const candidate = this.outboxSnapshot().find(t => t.type === 'IDERetrievalAnswer' && t.tool_call_id === awaitingToolCallId);
-            if (candidate)
-                resumeToSend = candidate;
-            // Otherwise: outbox is empty. The tool the server wants is either
-            // executing in the MCP layer now (normal in-flight) or truly lost
-            // (the outer inactivity timer catches that case).
-        }
-        else if (awaitingType === 'prompt' || awaitingType === 'none') {
-            // Server is idle — any leftover outbox turns are stale consumed or never-delivered
-            // probes. We keep prompt-style outbox entries (they will flow via normal send),
-            // but drop any stale tool_results since the graph is no longer at that step.
-            for (const turn of this.outboxSnapshot()) {
-                if (turn.type === 'IDERetrievalAnswer') {
-                    this.removeFromOutbox(turn.turn_id);
-                    this.debug(`[WebSocketClient] ResumeAck dropped stale tool_result from outbox | ` +
-                        `turn_id: ${turn.turn_id}`);
-                }
-            }
-            // If we still have a UserQuery queued (client sent a prompt but never saw TurnAck)
-            // we should replay it.
-            const promptCandidate = this.outboxSnapshot().find(t => t.type === 'UserQuery');
-            if (promptCandidate)
-                resumeToSend = promptCandidate;
-        }
-        if (reconcileFailedReason) {
-            this.debug(`[WebSocketClient] Reconcile failed | ${reconcileFailedReason} | ` +
-                `outbox: ${this.outbox.size}`);
-            this.metrics.reconcile_failures_total++;
-            this.emit('reconcileFailed', { reason: reconcileFailedReason, awaiting });
-            // Don't lock up — transition to READY so the consumer's own error handling
-            // can decide what to do. The consumer can still send a new prompt.
-            this.setReadyState(ReadyState.READY, 'Reconcile failed');
-            return;
-        }
-        // 3) Happy path: transition to READY and replay anything still pending.
-        this.setReadyState(ReadyState.READY, 'ResumeAck reconciled');
-        if (resumeToSend) {
-            this.startPostResumeProgressTimer();
-            this.metrics.turns_replayed_total++;
-            await this.sendImmediately({
-                type: resumeToSend.type,
-                data: resumeToSend.data,
-                timestamp: resumeToSend.timestamp,
-            });
-            this.receivedResponsesSinceMessage = false;
-            this.setReadyState(ReadyState.MESSAGE_SENT, `Replayed ${resumeToSend.type} after reconcile`);
-            this.startReadyTimer();
-        }
-        else if (this.outbox.size > 0) {
-            // No specific replay target, but we have queued work — drain it.
-            await this.processOutbox();
-        }
-    }
-    handleTurnAck(message) {
-        const args = message?.data?.tool_args ?? {};
-        const turnId = args.turn_id;
-        const checkpointId = args.checkpoint_id;
-        if (!turnId) {
-            this.debug('[WebSocketClient] TurnAck received without turn_id, ignoring');
-            return;
-        }
-        const removed = this.removeFromOutbox(turnId);
-        if (checkpointId)
-            this.latestCheckpointId = checkpointId;
-        this.clearPostResumeProgressTimer();
-        // TurnAck is the v2 completion signal — the in-flight turn is consumed,
-        // so the TurnAck/Ready SLA started on send is no longer needed.
-        this.clearReadyTimer();
-        // Transition out of MESSAGE_SENT so the next queued turn can drain and
-        // a subsequent legacy-Ready (informational) no longer looks mid-send.
-        if (this.readyState === ReadyState.MESSAGE_SENT) {
-            this.setReadyState(ReadyState.READY, 'TurnAck received — turn durably consumed');
-            // If more turns piled up while we were waiting, drain one now.
-            void this.processOutbox();
-        }
-        this.metrics.turns_acked_total++;
-        // A TurnAck for a turn we no longer have in the outbox means the server
-        // re-ACK'd an already-dropped turn (idempotent replay confirmation).
-        if (!removed)
-            this.metrics.idempotent_replays_total++;
-        this.debug(`[WebSocketClient] TurnAck received | ` +
-            `turn_id: ${turnId} | ` +
-            `checkpoint: ${checkpointId?.substring(0, 8) || 'none'} | ` +
-            `outbox_removed: ${removed} | ` +
-            `outbox_remaining: ${this.outbox.size}`);
-        this.emit('turnAck', { turn_id: turnId, checkpoint_id: checkpointId });
-    }
-    async handleReadyMessage(message) {
-        const checkpointId = message.data?.tool_args?.checkpoint_id;
-        const previousCheckpoint = this.latestCheckpointId;
-        const previousReadyState = this.readyState;
-        this.debug(`[WebSocketClient] Ready message received | ` +
-            `State: ${this.readyState} | ` +
-            `Checkpoint: ${checkpointId?.substring(0, 8) || 'none'} | ` +
-            `Previous: ${previousCheckpoint?.substring(0, 8) || 'none'}`);
-        // Update checkpoint if provided and changed
-        if (checkpointId && checkpointId !== previousCheckpoint) {
-            this.latestCheckpointId = checkpointId;
-            this.debug(`[WebSocketClient] Checkpoint ID updated: ${previousCheckpoint?.substring(0, 8) || 'none'} → ` +
-                `${checkpointId.substring(0, 8)}`);
-        }
-        // Handle based on current state
-        switch (this.readyState) {
-            case ReadyState.AWAITING_RESUME_ACK:
-                // In the normal v2 flow the server sends Ready then ResumeAck;
-                // Ready here is informational and we stay put until ResumeAck.
-                // Start a short legacy-fallback grace period so that a pre-v2
-                // backend (Ready only, no ResumeAck) doesn't stall the whole
-                // 15s ResumeAck SLA before we make progress.
-                this.debug('[WebSocketClient] Ready received while awaiting ResumeAck — starting legacy fallback grace');
-                this.startLegacyFallbackTimer();
-                break;
-            case ReadyState.WAITING_INITIAL_READY:
-                this.clearReadyTimer();
-                this.setReadyState(ReadyState.READY, 'Initial Ready received after connection');
-                await this.processOutbox();
-                break;
-            case ReadyState.WAITING_READY:
-                this.clearReadyTimer();
-                this.setReadyState(ReadyState.READY, 'Ready received after responses completed');
-                await this.processOutbox();
-                break;
-            case ReadyState.MESSAGE_SENT:
-                // Under protocol-v2, ``TurnAck`` is the authoritative signal that our
-                // message was consumed — not ``Ready``. The backend sends Ready at
-                // the top of every loop iteration (including between turns and after
-                // handling a Resume probe), so Ready can legitimately arrive while
-                // we're still waiting on TurnAck — sometimes even before the graph's
-                // own output lands, purely due to network ordering. Acting on it
-                // (the old "server failed to process" path that force-reconnected)
-                // created a tight infinite loop where every UserQuery triggered a
-                // spurious reconnect.
-                //
-                // Treat Ready here as informational. The timer started in
-                // ``sendMessage`` / ``processOutbox`` still bounds how long we wait
-                // for TurnAck, and ``handleTurnAck`` is the real state transition.
-                this.debug('[WebSocketClient] Ready received in MESSAGE_SENT — ignoring (v2 relies on TurnAck)');
-                break;
-            case ReadyState.READY:
-                this.debug('[WebSocketClient] Ready received while already in READY state (duplicate)');
-                break;
-            case ReadyState.IDLE:
-                this.debug('[WebSocketClient] Ready received while IDLE - transitioning to READY');
-                this.setReadyState(ReadyState.READY, 'Ready received while idle');
-                break;
-            case ReadyState.CHECKPOINT_RECOVERY:
-                this.debug('[WebSocketClient] Ready received during recovery - resuming normal flow');
-                this.clearReadyTimer();
-                this.setReadyState(ReadyState.READY, 'Recovery completed, Ready received');
-                await this.processOutbox();
-                break;
-        }
-        // Emit event for monitoring.
-        // Include previous ready state so listeners can distinguish initial Ready
-        // from completion Ready after MESSAGE_SENT.
-        this.emit('readyReceived', checkpointId, previousReadyState);
-    }
-    async connect(sessionId, requestId) {
-        // Update session info if provided
-        if (sessionId)
-            this.sessionId = sessionId;
-        if (requestId)
-            this.requestId = requestId;
-        if (this.state === ConnectionState.CONNECTED) {
-            this.resetIdleTimer();
-            return;
-        }
-        // If we auto-disconnected due to idle, reconnect
-        if (this.autoDisconnected || this.state === ConnectionState.DISCONNECTED) {
-            this.autoDisconnected = false;
-            await this.establishConnection();
-        }
-    }
-    async sendMessage(type, data) {
-        // Reset idle timer on any outgoing message
-        this.resetIdleTimer();
-        // Ensure every turn carries a turn_id — the backend idempotency key.
-        // Accepts a caller-supplied id (rare; only tests need that) and otherwise
-        // mints one here so existing call sites don't need updates.
-        const turn_id = (data && typeof data === 'object' && typeof data.turn_id === 'string' && data.turn_id)
-            ? data.turn_id
-            : uuid();
-        const dataWithTurnId = (data && typeof data === 'object')
-            ? { ...data, turn_id }
-            : { turn_id, payload: data };
-        const tool_call_id = type === 'IDERetrievalAnswer'
-            ? (dataWithTurnId.tool_id ?? dataWithTurnId.tool_call_id)
-            : undefined;
-        const turn = {
-            turn_id,
-            type,
-            data: dataWithTurnId,
-            tool_call_id,
-            timestamp: Date.now(),
-        };
-        this.addToOutbox(turn);
-        this.debug(`[WebSocketClient] sendMessage called | ` +
-            `Type: ${type} | ` +
-            `turn_id: ${turn_id} | ` +
-            `ReadyState: ${this.readyState} | ` +
-            `ConnectionState: ${this.state} | ` +
-            `outbox_size: ${this.outbox.size}`);
-        // Save as last sent message for potential recovery (legacy path)
-        this.lastSentMessage = { type, data: dataWithTurnId, timestamp: turn.timestamp };
-        if (this.readyState === ReadyState.READY && this.ws && this.state === ConnectionState.CONNECTED) {
-            this.receivedResponsesSinceMessage = false;
-            await this.sendImmediately({ type, data: dataWithTurnId, timestamp: turn.timestamp });
-            this.setReadyState(ReadyState.MESSAGE_SENT, `Sent ${type} message`);
-            this.startReadyTimer();
-        }
-        else {
-            this.debug(`[WebSocketClient] Turn parked in outbox | ` +
-                `Type: ${type} | ` +
-                `turn_id: ${turn_id} | ` +
-                `outbox_size: ${this.outbox.size} | ` +
-                `Reason: ReadyState=${this.readyState}, Connected=${this.state === ConnectionState.CONNECTED}`);
-            if (this.state === ConnectionState.DISCONNECTED) {
-                this.debug('[WebSocketClient] Initiating connection due to queued turn');
-                await this.connect();
-            }
-        }
-    }
-    async sendImmediately(msg) {
-        const formatted = this.formatMessage(msg.type, msg.data);
-        this.ws.send(formatted);
-        this.debug(`[WebSocketClient] Message sent immediately | ` +
-            `Type: ${msg.type} | ` +
-            `Size: ${formatted.length} bytes`);
-    }
-    /**
-     * Drain the outbox into the socket. Only one turn is in-flight at a time
-     * (MESSAGE_SENT gate enforces this). Called on ResumeAck (after reconcile)
-     * and on transitions back to READY.
-     */
-    async processOutbox() {
-        this.debug(`[WebSocketClient] Processing outbox | ` +
-            `outbox_size: ${this.outbox.size} | ` +
-            `ReadyState: ${this.readyState}`);
-        if (this.outbox.size === 0) {
-            this.debug('[WebSocketClient] Outbox is empty, no messages to process');
-            return;
-        }
-        if (this.readyState !== ReadyState.READY) {
-            this.debug(`[WebSocketClient] Cannot process outbox | ` +
-                `ReadyState: ${this.readyState} (expected READY)`);
-            return;
-        }
-        const nextId = this.outboxOrder[0];
-        const turn = nextId ? this.outbox.get(nextId) : undefined;
-        if (!turn)
-            return;
-        this.debug(`[WebSocketClient] Sending queued turn | ` +
-            `Type: ${turn.type} | ` +
-            `turn_id: ${turn.turn_id} | ` +
-            `Queued at: ${turn.timestamp} | ` +
-            `Wait: ${Date.now() - turn.timestamp}ms | ` +
-            `outbox_remaining: ${this.outbox.size}`);
-        this.receivedResponsesSinceMessage = false;
-        await this.sendImmediately({ type: turn.type, data: turn.data, timestamp: turn.timestamp });
-        this.setReadyState(ReadyState.MESSAGE_SENT, `Sent queued ${turn.type} message`);
-        this.startReadyTimer();
-    }
-    startReadyTimer() {
-        this.clearReadyTimer();
-        this.readyTimer = setTimeout(async () => {
-            this.debug(`[WebSocketClient] Ready timeout expired | ` +
-                `State: ${this.readyState} | ` +
-                `Last message: ${this.lastSentMessage?.type} | ` +
-                `Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'}`);
-            await this.initiateCheckpointRecovery('Ready timeout');
-        }, WS_CONFIG.READY_TIMEOUT);
-        // Do not keep the event loop alive solely because of this timer
-        this.readyTimer.unref?.();
-    }
-    clearReadyTimer() {
-        if (this.readyTimer) {
-            clearTimeout(this.readyTimer);
-            this.readyTimer = undefined;
-        }
-    }
-    /**
-     * Legacy recovery entry point.
-     *
-     * Under protocol v2 the outbox holds every un-ACK'd turn by turn_id and the
-     * Resume/ResumeAck handshake replays it authoritatively. All we need to do
-     * here is cycle the socket — the open handler will send Resume, the server
-     * will reply with ResumeAck, and reconciliation will happen automatically.
-     */
-    async initiateCheckpointRecovery(reason) {
-        this.debug(`[WebSocketClient] Forcing reconnect for recovery | ` +
-            `Reason: ${reason} | ` +
-            `Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'} | ` +
-            `outbox_size: ${this.outbox.size} | ` +
-            `State: ${this.readyState}`);
-        this.emit('checkpointRecovery', { reason, checkpoint: this.latestCheckpointId });
-        try {
-            // Close the socket hard. handleClose will schedule reconnection via
-            // attemptReconnection, and the open handler will send a fresh Resume.
-            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                this.ws.close(4002, `Recovery: ${reason}`);
-            }
-        }
-        catch (error) {
-            this.debug(`[WebSocketClient] Recovery reconnect failed | ` +
-                `Error: ${error instanceof Error ? error.message : error}`);
-        }
-    }
-    disconnect() {
-        // Hold a reference to the current socket to close it safely
-        const wsRef = this.ws;
-        // Stop all timers and reconnection attempts
-        this.clearTimers();
-        this.autoDisconnected = false;
-        this.isReconnecting = false;
-        // Invalidate the current connection so any late events from wsRef are ignored
-        // Event handlers compare this.connectionId to their captured id
-        this.connectionId = uuid();
-        if (wsRef) {
-            try {
-                // Attempt a graceful close when open; otherwise force terminate to avoid races
-                if (wsRef.readyState === WebSocket.OPEN) {
-                    this.setState(ConnectionState.DISCONNECTING);
-                    wsRef.close(1000, 'Normal closure');
-                }
-                else if (wsRef.readyState === WebSocket.CONNECTING || wsRef.readyState === WebSocket.CLOSING) {
-                    // Avoid an "open" event racing in after manual disconnect
-                    try {
-                        wsRef.terminate?.();
-                    }
-                    catch { /* cleanup: terminate may fail if already closed */ }
-                }
-            }
-            catch { /* cleanup: WS close/terminate during disconnect must not throw */ }
-        }
-        // Explicitly mark as disconnected and reset internal refs
-        this.setState(ConnectionState.DISCONNECTED);
-        this.ws = undefined;
-        this.setReadyState(ReadyState.IDLE, 'Manual disconnect');
-        this.lastPingSent = 0;
-    }
-    getState() {
-        return this.state;
-    }
-    keepAlive() {
-        if (this.state === ConnectionState.CONNECTED) {
-            this.resetIdleTimer();
-        }
-    }
-    // === Private Methods ===
-    async establishConnection() {
-        if (this.state === ConnectionState.CONNECTING) {
-            await this.waitForConnection();
-            return;
-        }
-        return new Promise((resolve, reject) => {
-            try {
-                this.setState(ConnectionState.CONNECTING);
-                this.connectionId = uuid();
-                const currentConnectionId = this.connectionId;
-                const wsUrl = this.buildWebSocketUrl();
-                const env = getCurrentEnvironment();
-                const { token } = env.authProvider
-                    ? env.authProvider.getAuthConfig()
-                    : getAuthConfig();
-                this.debug(`Connecting to WebSocket: ${wsUrl}`);
-                const ws = new WebSocket(wsUrl, {
-                    headers: {
-                        'Authorization': `Bearer ${token}`,
-                    },
-                    handshakeTimeout: WS_CONFIG.CONNECTION_TIMEOUT,
-                });
-                this.ws = ws;
-                // Set up event handlers
-                ws.on('open', () => {
-                    if (this.connectionId !== currentConnectionId) {
-                        ws.close();
-                        return;
-                    }
-                    // Clear pending connection timeout timer if any
-                    if (this.connectionTimeoutTimer) {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        this.connectionTimeoutTimer = undefined;
-                    }
-                    this.setState(ConnectionState.CONNECTED);
-                    this.reconnectAttempts = 0;
-                    this.emit('connected');
-                    this.debug(`[WebSocketClient] WebSocket connected | ` +
-                        `Session: ${this.sessionId?.substring(0, 8)}... | ` +
-                        `Checkpoint: ${this.latestCheckpointId?.substring(0, 8) || 'none'} | ` +
-                        `outbox: ${this.outbox.size}`);
-                    // Start idle timer and heartbeat immediately so dead sockets surface.
-                    this.startIdleTimer();
-                    this.startHeartbeat();
-                    // Protocol v2: every (re)connect opens with a Resume envelope. The
-                    // server's ResumeAck is the authoritative signal — the old "wait for
-                    // Ready" handshake is left as a fallback for servers that don't yet
-                    // understand Resume (they emit Ready first, which we treat as info).
-                    this.setReadyState(ReadyState.AWAITING_RESUME_ACK, 'Connection opened, sending Resume');
-                    this.sendResume();
-                    this.debug('[WebSocketClient] Connection established, waiting for ResumeAck');
-                    resolve();
-                });
-                ws.on('message', (data) => {
-                    if (this.connectionId !== currentConnectionId)
-                        return;
-                    this.resetIdleTimer();
-                    this.lastPongReceived = Date.now(); // any message is also a ping
-                    const message = data.toString();
-                    // Intercept protocol-v2 control messages (ResumeAck, TurnAck, Ready)
-                    // before forwarding to the consumer. These are transport concerns.
-                    try {
-                        const parsed = JSON.parse(message);
-                        const tool = parsed?.data?.tool;
-                        if (tool === 'Ready') {
-                            this.handleReadyMessage(parsed);
-                            return;
-                        }
-                        if (tool === 'ResumeAck') {
-                            this.handleResumeAck(parsed);
-                            return;
-                        }
-                        if (tool === 'TurnAck') {
-                            this.handleTurnAck(parsed);
-                            return;
-                        }
-                    }
-                    catch (e) {
-                        // Not JSON or not a control message — fall through to consumer.
-                    }
-                    // Track that we received a non-Ready message (response)
-                    if (this.readyState === ReadyState.MESSAGE_SENT) {
-                        this.receivedResponsesSinceMessage = true;
-                    }
-                    // A domain event after ResumeAck counts as forward progress — clear the stall timer.
-                    this.clearPostResumeProgressTimer();
-                    // Emit non-Ready messages to AgentAPI
-                    this.emit('message', message);
-                });
-                ws.on('close', (code, reason) => {
-                    if (this.connectionId !== currentConnectionId)
-                        return;
-                    // Clear pending connection-timeout timer
-                    if (this.connectionTimeoutTimer) {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        this.connectionTimeoutTimer = undefined;
-                    }
-                    this.handleClose(code, reason.toString());
-                    if (this.state === ConnectionState.CONNECTING) {
-                        reject(new Error(`Connection closed during setup: ${code} ${reason}`));
-                    }
-                });
-                ws.on('error', (error) => {
-                    if (this.connectionId !== currentConnectionId)
-                        return;
-                    // Clear pending connection-timeout timer
-                    if (this.connectionTimeoutTimer) {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        this.connectionTimeoutTimer = undefined;
-                    }
-                    this.debug('WebSocket error:', error);
-                    this.emit('error', error);
-                    if (this.state === ConnectionState.CONNECTING) {
-                        reject(error);
-                    }
-                });
-                ws.on('pong', () => {
-                    if (this.connectionId === currentConnectionId) {
-                        this.lastPongReceived = Date.now();
-                        this.debug('Pong received, heartbeat OK');
-                    }
-                });
-                // Connection timeout
-                this.connectionTimeoutTimer = setTimeout(() => {
-                    if (this.connectionId === currentConnectionId && this.state === ConnectionState.CONNECTING) {
-                        ws.close();
-                        reject(new Error('Connection timeout'));
-                    }
-                }, WS_CONFIG.CONNECTION_TIMEOUT);
-                this.connectionTimeoutTimer.unref?.();
-            }
-            catch (error) {
-                this.setState(ConnectionState.FAILED);
-                reject(error);
-            }
-        });
-    }
-    async waitForConnection(timeout = WS_CONFIG.CONNECTION_TIMEOUT) {
-        const startTime = Date.now();
-        while (this.state === ConnectionState.CONNECTING || this.state === ConnectionState.RECONNECTING) {
-            if (Date.now() - startTime > timeout) {
-                throw new Error('Connection timeout while waiting');
-            }
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        if (this.state !== ConnectionState.CONNECTED) {
-            throw new Error('Failed to establish connection');
-        }
-    }
-    buildWebSocketUrl() {
-        const baseUrl = ServerData.getInstance().getBaseUrl();
-        const wsUrl = baseUrl.replace(/^http/, 'ws');
-        const trimmedBase = wsUrl.replace(/\/+$/, '');
-        const url = new URL(`${trimmedBase}/v2/agentic/ws/connect`);
-        // Use current session ID, or generate one if not set
-        const currentSessionId = this.sessionId || uuid();
-        url.searchParams.set('session_id', currentSessionId);
-        if (this.requestId) {
-            url.searchParams.set('request_id', this.requestId);
-        }
-        // Include checkpoint_id if available for recovery
-        if (this.latestCheckpointId && this.readyState === ReadyState.CHECKPOINT_RECOVERY) {
-            url.searchParams.set('checkpoint_id', this.latestCheckpointId);
-            this.debug(`[WebSocketClient] Building URL with checkpoint | ` +
-                `Checkpoint: ${this.latestCheckpointId.substring(0, 8)}...`);
-        }
-        else {
-            this.debug('[WebSocketClient] Building URL without checkpoint (fresh connection)');
-        }
-        // SDK always uses agent_type=sdk
-        url.searchParams.set('agent_type', 'sdk');
-        return url.toString();
-    }
-    formatMessage(type, data) {
-        return `${type} ${JSON.stringify(data)}\n`;
-    }
-    handleClose(code, reason) {
-        this.clearTimers();
-        if (this.autoDisconnected) {
-            this.debug('WebSocket closed due to idle timeout');
-            this.setState(ConnectionState.DISCONNECTED);
-            this.emit('disconnected', { reason: 'idle', code });
-            return;
-        }
-        this.debug(`WebSocket closed: ${code} ${reason}`);
-        // Determine if we should reconnect
-        if (code === 1000 || code === 1001) {
-            // Normal closure
-            this.setState(ConnectionState.DISCONNECTED);
-            this.emit('disconnected', { reason: 'normal', code });
-        }
-        else if (code === 1008) {
-            // Authentication failure - don't reconnect
-            this.setState(ConnectionState.FAILED);
-            this.emit('error', new Error('Authentication failed'));
-        }
-        else if (!this.hasCompletedHandshake) {
-            // No successful handshake has completed on this instance. Treat any
-            // close here as a startup failure — auth issues, wrong URL, server
-            // rejecting the protocol, etc. should surface as a real error rather
-            // than enter an indefinite reconnect loop that hides the root cause.
-            this.setState(ConnectionState.FAILED);
-            const errorMessage = this.buildConnectionErrorMessage(code, reason);
-            this.emit('error', new Error(errorMessage));
-        }
-        else {
-            // Unexpected closure mid-session - attempt reconnect
-            this.setState(ConnectionState.FAILED);
-            this.attemptReconnection().catch((error) => {
-                this.debug('Reconnection attempt failed:', error instanceof Error ? error.message : error);
-            });
-        }
-    }
-    buildConnectionErrorMessage(code, reason) {
-        const baseUrl = ServerData.getInstance().getBaseUrl();
-        const codeDescriptions = {
-            1002: 'Protocol error',
-            1003: 'Unsupported data type',
-            1006: 'Connection closed abnormally (server may have crashed or rejected the connection)',
-            1007: 'Invalid message data',
-            1008: 'Policy violation',
-            1009: 'Message too large',
-            1010: 'Extension negotiation failed',
-            1011: 'Unexpected server condition',
-            1012: 'Service restart',
-            1013: 'Try again later',
-            1014: 'Bad gateway',
-            1015: 'TLS handshake failed',
-        };
-        const codeDescription = codeDescriptions[code] || `Unexpected close code ${code}`;
-        const reasonPart = reason ? `: ${reason}` : '';
-        return `Failed to connect to Qodo backend at ${baseUrl}. ${codeDescription}${reasonPart}. If this issue persists, please contact Qodo support.`;
-    }
-    async attemptReconnection() {
-        if (this.isReconnecting)
-            return;
-        this.isReconnecting = true;
-        this.setState(ConnectionState.RECONNECTING);
-        this.reconnectAttempts++;
-        this.metrics.reconnects_total++;
-        // Stamp the disconnect time on the first reconnect attempt of a cycle so
-        // the eventual `reconnected` event can carry an accurate downtime_ms.
-        if (this.reconnectAttempts === 1 && !this.lastDisconnectAt) {
-            this.lastDisconnectAt = Date.now();
-        }
-        this.emit('reconnecting', { attempt: this.reconnectAttempts });
-        const delay = this.calculateBackoffDelay(this.reconnectAttempts);
-        this.debug(`Attempting reconnection ${this.reconnectAttempts} in ${delay}ms`);
-        this.reconnectTimer = setTimeout(async () => {
-            try {
-                await this.establishConnection();
-                this.isReconnecting = false;
-                const downtime_ms = this.lastDisconnectAt ? Date.now() - this.lastDisconnectAt : undefined;
-                this.lastDisconnectAt = undefined;
-                this.emit('reconnected', { downtime_ms });
-            }
-            catch (error) {
-                this.debug('Reconnection failed:', error instanceof Error ? error.message : error);
-                this.isReconnecting = false;
-                // Infinite retry - always attempt again
-                setTimeout(() => this.attemptReconnection(), 1000);
-            }
-        }, delay);
-        this.reconnectTimer.unref?.();
-    }
-    calculateBackoffDelay(attempt) {
-        const delay = WS_CONFIG.INITIAL_RECONNECT_DELAY *
-            Math.pow(WS_CONFIG.RECONNECT_BACKOFF_FACTOR, attempt - 1);
-        const jitter = delay * 0.25 * (Math.random() - 0.5);
-        return Math.min(delay + jitter, WS_CONFIG.MAX_RECONNECT_DELAY);
-    }
-    // === Idle Timer Management ===
-    startIdleTimer() {
-        this.clearIdleTimer();
-        this.idleTimer = setTimeout(() => {
-            this.debug('Connection idle for 10 minutes, disconnecting...');
-            this.autoDisconnected = true;
-            // Clean disconnect - ready for next request
-            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                this.ws.close(1000, 'Idle timeout');
-            }
-            this.setState(ConnectionState.DISCONNECTED);
-            this.emit('disconnected', { reason: 'idle' });
-        }, WS_CONFIG.IDLE_TIMEOUT);
-        // Let process exit if this is the only pending timer
-        this.idleTimer.unref?.();
-    }
-    clearIdleTimer() {
-        if (this.idleTimer) {
-            clearTimeout(this.idleTimer);
-            this.idleTimer = undefined;
-        }
-    }
-    resetIdleTimer() {
-        this.startIdleTimer();
-    }
-    // === Heartbeat Management ===
-    startHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-        }
-        this.heartbeatInterval = setInterval(() => {
-            if (this.state === ConnectionState.CONNECTED && this.ws) {
-                const now = Date.now();
-                const timeSinceLastPong = now - this.lastPongReceived;
-                // If we haven't sent a ping recently, or if it's time to send another one
-                if (this.lastPingSent === 0 || (now - this.lastPingSent) >= WS_CONFIG.HEARTBEAT_INTERVAL) {
-                    try {
-                        this.ws.ping();
-                        this.lastPingSent = now;
-                        this.debug('Ping sent, waiting for pong...');
-                    }
-                    catch (error) {
-                        this.debug('Error sending ping:', error);
-                    }
-                }
-                // If we sent a ping and enough time has passed without a pong, timeout
-                else if (this.lastPingSent > 0 && timeSinceLastPong > WS_CONFIG.HEARTBEAT_TIMEOUT) {
-                    this.debug('Heartbeat timeout, closing connection');
-                    this.ws.close();
-                    return;
-                }
-            }
-        }, WS_CONFIG.HEARTBEAT_INTERVAL);
-        // Allow process to exit if heartbeat is the last thing running
-        this.heartbeatInterval.unref?.();
-    }
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = undefined;
-        }
-    }
-    async processQueuedMessages() {
-        if (this.isProcessingQueue || this.messageQueue.length === 0)
-            return;
-        this.isProcessingQueue = true;
-        this.debug(`Processing ${this.messageQueue.length} queued messages`);
-        try {
-            while (this.messageQueue.length > 0 && this.state === ConnectionState.CONNECTED) {
-                const queuedMessage = this.messageQueue.shift();
-                try {
-                    const message = this.formatMessage(queuedMessage.type, queuedMessage.data);
-                    this.ws.send(message);
-                    this.debug(`Sent queued ${queuedMessage.type} message`);
-                }
-                catch (error) {
-                    console.error('Error processing queued message:', error);
-                    if (queuedMessage.retryCount < 3) {
-                        queuedMessage.retryCount++;
-                        this.messageQueue.unshift(queuedMessage);
-                        break;
-                    }
-                }
-            }
-        }
-        finally {
-            this.isProcessingQueue = false;
-        }
-    }
-    // === Cleanup ===
-    clearTimers() {
-        this.clearIdleTimer();
-        this.stopHeartbeat();
-        this.clearReadyTimer();
-        this.clearResumeAckTimer();
-        this.clearPostResumeProgressTimer();
-        this.clearLegacyFallbackTimer();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = undefined;
-        }
-        if (this.connectionTimeoutTimer) {
-            clearTimeout(this.connectionTimeoutTimer);
-            this.connectionTimeoutTimer = undefined;
-        }
-    }
-    cleanup() {
-        this.debug(`[WebSocketClient] Cleanup called | ` +
-            `State: ${this.state} | ` +
-            `ReadyState: ${this.readyState} | ` +
-            `Queued messages: ${this.messageQueue.length} | ` +
-            `Outbox: ${this.outbox.size}`);
-        this.clearTimers();
-        this.disconnect();
-        this.messageQueue = [];
-        this.outbox.clear();
-        this.outboxOrder.length = 0;
-        this.isReconnecting = false;
-        this.latestCheckpointId = undefined;
-        this.lastSentMessage = undefined;
-        this.hasCompletedHandshake = false;
-        this.setReadyState(ReadyState.IDLE, 'Cleanup performed');
-        this.removeAllListeners();
-        this.debug('[WebSocketClient] Cleanup completed');
-    }
-    // --- Test hooks -----------------------------------------------------------
-    // These are intentionally tiny, read-only accessors so the chaos harness
-    // can assert on internal state without resorting to `any` casts. They are
-    // not part of the public SDK API.
-    /** @internal */
-    __getOutboxIds() {
-        return [...this.outboxOrder];
-    }
-    /** @internal */
-    __getOutboxSize() {
-        return this.outbox.size;
-    }
-    /** @internal */
-    __getLatestCheckpointId() {
-        return this.latestCheckpointId;
-    }
-}
-//# sourceMappingURL=websocket.js.map