sneakoscope 10.7.0 → 10.7.1

package/dist/core/codex-lb/desktop-bridge/http-forward.js

@@ -2,16 +2,19 @@ import http, {} from 'node:http';
 import https from 'node:https';
 import zlib from 'node:zlib';
 import { pipeline } from 'node:stream/promises';
-import { BRIDGE_OFFICIAL_ROUTE_ID } from '../bridge-contracts.js';
+import { BRIDGE_OFFICIAL_ROUTE_ID, BRIDGE_REMOTE_COMPACTION } from '../bridge-contracts.js';
 import { buildOfficialPassthroughHeaders, buildProviderUpstreamHeaders, rewriteResponseHeaders } from './header-policy.js';
 import { createDesktopBridgeRejectionLogger } from './rejection-log.js';
-import { OPENROUTER_ONLY_REFUSAL_CODES, openRouterOnlyEnabled } from './exclusive-provider-guard.js';
-import { ensureDesktopBridgeRemoteTarget, isNoRouteUpstreamError, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, singleBridgeHeader } from './security.js';
+import { OPENROUTER_ONLY_REFUSAL_CODES } from './exclusive-provider-guard.js';
+import { ensureDesktopBridgeRemoteTarget, isNoRouteUpstreamError, isResponsesFamilyPath, isUnreachableUpstreamError, pinnedPublicModel, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, singleBridgeHeader, threadRouteMove } from './security.js';
+import { admitCodexLbTurnState, forgetCodexLbTurnStates, rememberCodexLbTurnState } from './codex-lb-turn-state.js';
+import { ProviderHandoffRefusedError, assertProviderHandoffAllowed, providerHandoffRefusalBody, stripProviderBoundItems, } from './provider-handoff.js';
 import { desktopBridgeListenOrigin } from './state.js';
 import { buildCompactionSummaryRequest, compactEndpointResult, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, safeUpstreamErrorId, sseEvent, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
-import { isAdvisableEventStream, modelCapacityAdvisingSse } from './capacity-retry-advice.js';
-import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError, DesktopBridgeRequestBodyTooLargeError } from './types.js';
+import { MODEL_CAPACITY_ERROR_CODE, MODEL_CAPACITY_RETRY_AFTER_SECONDS, isAdvisableEventStream, modelCapacityAdvisingSse } from './capacity-retry-advice.js';
+import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError, DesktopBridgeRequestBodyTooLargeError, isDesktopBridgeRoutingConflict } from './types.js';
 const MAX_UPSTREAM_ERROR_BODY_BYTES = 1024 * 1024;
+const NATIVE_COMPACTION_IDLE_FLOOR_MS = 300_000;
 function decodeBridgeRequestBody(body, encoding, maximum) {
     const options = { maxOutputLength: maximum };
     try {
@@ -61,11 +64,10 @@ async function reencodeLikeClient(plain, encoding) {
     return new Promise((resolve) => compress(plain, (error, result) => resolve(error ? null : result)));
 }
 const RESPONSES_PATHS = ['/backend-api/codex/responses', '/api/v1/responses', '/v1/responses'];
-function modelBodyKind(req, pathname, config) {
+function modelBodyKind(req, pathname) {
     if (RESPONSES_PATHS.includes(pathname))
         return req.method === 'POST' ? 'responses' : null;
-    return openRouterOnlyEnabled(config) && req.method === 'POST'
-        && RESPONSES_PATHS.some((prefix) => pathname.startsWith(`${prefix}/`)) ? 'sub-endpoint' : null;
+    return req.method === 'POST' && RESPONSES_PATHS.some((prefix) => pathname.startsWith(`${prefix}/`)) ? 'sub-endpoint' : null;
 }
 function isCompactEndpoint(req, pathname) {
     return req.method === 'POST' && RESPONSES_PATHS.some((prefix) => pathname === `${prefix}/compact`);
@@ -105,7 +107,7 @@ export async function prepareDesktopBridgeRequest(req, config) {
     let contentEncodingStripped = false;
     let encoding = '';
     let encodedBody = null;
-    const bodyKind = modelBodyKind(req, pathname, config);
+    const bodyKind = modelBodyKind(req, pathname);
     if (bodyKind) {
         const maximum = config.maxRequestBodyBytes ?? DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES;
         body = await readBoundedBody(req, maximum);
@@ -131,12 +133,19 @@ export async function prepareDesktopBridgeRequest(req, config) {
             body = decoded;
     }
     const headerModel = singleBridgeHeader(req.headers, 'x-sks-model');
-    const model = typeof payload?.model === 'string' ? payload.model : headerModel;
     const sessionIdentity = resolveCodexSessionIdentity(req.headers, payload);
-    const route = await resolveAndBindDesktopBridgeRouteContext({
+    const model = typeof payload?.model === 'string'
+        ? payload.model
+        : headerModel || (isResponsesFamilyPath(pathname) ? pinnedPublicModel(sessionIdentity.thread_id, config) : null);
+    const routeRequest = {
         public_model: String(model || ''), session_id: sessionIdentity.thread_id,
         pathname, transport: 'http', headers: req.headers, identity: sessionIdentity,
-    }, config);
+    };
+    let move = null;
+    const route = await resolveAndBindDesktopBridgeRouteContext(routeRequest, config, (resolved) => {
+        move = threadRouteMove(routeRequest, resolved, config);
+        assertProviderHandoffAllowed(payload, move);
+    });
     let rewrite = false;
     if (payload && (bodyKind === 'responses' || typeof payload.model === 'string') && payload.model !== route.upstream_model) {
         payload.model = route.upstream_model;
@@ -144,14 +153,15 @@ export async function prepareDesktopBridgeRequest(req, config) {
     }
     if (expandBridgeCompactionItems(payload))
         rewrite = true;
+    if (route.session_pin?.handoff_from && stripProviderBoundItems(payload, Boolean(move)))
+        rewrite = true;
     if (payload && rewrite)
         body = Buffer.from(JSON.stringify(payload));
     const compaction = bodyKind === 'responses' && requestsRemoteCompaction(payload)
         ? 'trigger'
         : bodyKind === 'sub-endpoint' && isCompactEndpoint(req, pathname) ? 'endpoint' : null;
     let plainBody = null;
-    const answeredByBridge = Boolean(compaction) && route.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID;
-    if (encodedBody && body && !answeredByBridge && keepsClientEncoding(route)) {
+    if (encodedBody && body && !answeredByBridge(compaction, route) && keepsClientEncoding(route)) {
         const upstreamBody = rewrite ? await reencodeLikeClient(body, encoding) : encodedBody;
         if (upstreamBody) {
             plainBody = body;
@@ -160,7 +170,10 @@ export async function prepareDesktopBridgeRequest(req, config) {
         }
     }
     const credential = route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID ? null : await resolveCredential(config, route);
-    return { body, route, credential, contentEncodingStripped, plainBody, compaction, payload };
+    return { body, route, credential, contentEncodingStripped, plainBody, compaction, payload, threadId: sessionIdentity.thread_id, move };
+}
+function answeredByBridge(compaction, route) {
+    return Boolean(compaction) && BRIDGE_REMOTE_COMPACTION[route.provider_id] === 'bridge_summary';
 }
 function connectTimeout(request, config) {
     request.once('socket', (socket) => {
@@ -191,8 +204,12 @@ function writeHttpBridgeError(res, error, req) {
         res.destroy(error instanceof Error ? error : undefined);
         return;
     }
-    res.writeHead(code.startsWith('catalog_') || code.startsWith('session_') || code.includes('route_')
-        || OPENROUTER_ONLY_REFUSAL_CODES.has(code) ? 409 : 502, {
+    if (error instanceof ProviderHandoffRefusedError) {
+        res.writeHead(400, { 'content-type': 'application/json', 'cache-control': 'no-store', connection: 'close' });
+        res.end(providerHandoffRefusalBody(error));
+        return;
+    }
+    res.writeHead(isDesktopBridgeRoutingConflict(code) || OPENROUTER_ONLY_REFUSAL_CODES.has(code) ? 409 : 502, {
         'content-type': 'application/json', 'cache-control': 'no-store', connection: 'close',
     });
     res.end(JSON.stringify({ error: { type: 'sks_bridge_error', code, message: code } }));
@@ -229,19 +246,32 @@ function redactedUpstreamClientMessage(statusCode, transient) {
 const UNREADABLE_BODY_HINT = /json|pars(?:e|ing)|decod|encod|compress|utf-?8/i;
 async function readRedactedUpstreamError(response) {
     let total = 0;
+    let complete = true;
     const chunks = [];
     for await (const raw of response) {
         const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
         total += chunk.length;
         if (total > MAX_UPSTREAM_ERROR_BODY_BYTES) {
             response.destroy();
+            complete = false;
             break;
         }
         chunks.push(chunk);
     }
     let upstreamCode = null;
     let upstreamType = null;
-    const text = Buffer.concat(chunks).toString('utf8');
+    const raw = Buffer.concat(chunks);
+    const encoding = String(response.headers['content-encoding'] || '').trim().toLowerCase();
+    let decoded = complete ? raw : null;
+    if (decoded && encoding && encoding !== 'identity') {
+        try {
+            decoded = decodeBridgeRequestBody(decoded, encoding, 4 * MAX_UPSTREAM_ERROR_BODY_BYTES);
+        }
+        catch {
+            decoded = null;
+        }
+    }
+    const text = (decoded ?? raw).toString('utf8');
     try {
         const parsed = JSON.parse(text);
         upstreamCode = safeUpstreamErrorId(parsed?.error?.code) ?? safeUpstreamErrorId(parsed?.detail);
@@ -249,7 +279,21 @@ async function readRedactedUpstreamError(response) {
     }
     catch {
     }
-    return { upstreamCode, upstreamType, unreadableBody: UNREADABLE_BODY_HINT.test(text.slice(0, 4096)) };
+    return {
+        upstreamCode,
+        upstreamType,
+        unreadableBody: UNREADABLE_BODY_HINT.test(text.slice(0, 4096)),
+        body: decoded,
+    };
+}
+function scrubUpstreamErrorBody(body, credential) {
+    let text = body.toString('utf8');
+    if (credential)
+        text = text.split(credential).join('[REDACTED]');
+    text = text
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/-]{8,}=*/gi, 'Bearer [REDACTED]')
+        .replace(/\bsk-[A-Za-z0-9_-]{16,}/g, '[REDACTED]');
+    return Buffer.from(text, 'utf8');
 }
 function buildRedactedUpstreamErrorBody(statusCode, upstreamCode, upstreamType, transient) {
     return Buffer.from(JSON.stringify({
@@ -284,6 +328,7 @@ export function destroyDesktopBridgeUpstreamAgents() {
         agent.destroy();
     upstreamAgents.clear();
     encodedBodyRefusals.clear();
+    forgetCodexLbTurnStates();
 }
 const STALE_CONNECTION_ERROR_CODES = new Set(['ECONNRESET', 'EPIPE', 'ECONNABORTED']);
 function isStalePooledSocketFailure(request, error) {
@@ -319,7 +364,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
         if (!official && !request.credential)
             throw new DesktopBridgeError('bridge_provider_credential_invalid');
         await ensureDesktopBridgeRemoteTarget(remote, config.remoteLookup);
-        if (!official && request.compaction && request.payload) {
+        if (!official && request.compaction && answeredByBridge(request.compaction, request.route) && request.payload) {
             await answerCompactionWithProviderSummary(req, res, config, {
                 kind: request.compaction,
                 payload: request.payload,
@@ -341,6 +386,12 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             : buildProviderUpstreamHeaders(req.headers, {
                 providerId: provider.provider_id, authTransport: provider.auth_transport, credential: request.credential,
             }, target.host);
+        const codexLb = provider?.provider_id === 'codex-lb';
+        const threadId = request.threadId ?? null;
+        if (request.move)
+            delete headers['x-codex-turn-state'];
+        else if (codexLb)
+            admitCodexLbTurnState(headers, threadId, request.credential.fingerprint);
         if (request.body)
             headers['content-length'] = String(request.body.length);
         else
@@ -348,6 +399,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
         if (request.contentEncodingStripped)
             delete headers['content-encoding'];
         const agent = upstreamAgent(remote.secure, `${remote.address}:${remote.port}`, config.idleTimeoutMs);
+        const idleTimeoutMs = request.compaction ? Math.max(config.idleTimeoutMs, NATIVE_COMPACTION_IDLE_FLOOR_MS) : config.idleTimeoutMs;
         const replayable = Buffer.isBuffer(request.body);
         let body = request.body;
         let plainFallbackActive = false;
@@ -371,7 +423,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                 ...(remote.tlsServername ? { servername: remote.tlsServername } : {}),
             });
             connectTimeout(upstream, config);
-            upstream.setTimeout(config.idleTimeoutMs, () => upstream.destroy(new DesktopBridgeError('bridge_upstream_idle_timeout')));
+            upstream.setTimeout(idleTimeoutMs, () => upstream.destroy(new DesktopBridgeError('bridge_upstream_idle_timeout')));
             req.once('aborted', abort);
             res.once('close', abort);
             upstream.once('error', (error) => {
@@ -390,6 +442,8 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             });
             upstream.once('response', (response) => {
                 const statusCode = response.statusCode || 502;
+                if (codexLb)
+                    rememberCodexLbTurnState(threadId, request.credential.fingerprint, response.headers);
                 if (plainFallbackActive && statusCode < 400 && !official && !encodedBodyRefusals.has(provider.provider_id)) {
                     encodedBodyRefusals.add(provider.provider_id);
                     logHttpRejection({ code: 'bridge_upstream_encoded_body_refused', transport: 'http', ...(req.method === undefined ? {} : { method: req.method }), ...(req.url === undefined ? {} : { url: req.url }), provider_id: provider.provider_id });
@@ -425,7 +479,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     return;
                 }
                 if (statusCode >= 400) {
-                    void readRedactedUpstreamError(response).then(({ upstreamCode, upstreamType, unreadableBody }) => {
+                    void readRedactedUpstreamError(response).then(({ upstreamCode, upstreamType, unreadableBody, body: upstreamBody }) => {
                         if (budget.plainFallback && (statusCode === 415
                             || (unreadableBody && !upstreamType && !upstreamCode && (statusCode === 400 || statusCode === 422)))) {
                             responseStarted = true;
@@ -440,10 +494,13 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                                 : 'bridge_upstream_transient_mislabel')));
                             return;
                         }
-                        const clientStatus = transientMislabel ? 503 : statusCode;
-                        const body = buildRedactedUpstreamErrorBody(statusCode, upstreamCode, upstreamType, transientMislabel);
+                        const verbatim = codexLb && upstreamBody !== null;
+                        const clientStatus = verbatim ? statusCode : transientMislabel ? 503 : statusCode;
+                        const body = verbatim
+                            ? scrubUpstreamErrorBody(upstreamBody, request.credential.value)
+                            : buildRedactedUpstreamErrorBody(statusCode, upstreamCode, upstreamType, transientMislabel);
                         logHttpRejection({
-                            code: transientMislabel
+                            code: transientMislabel && !verbatim
                                 ? `bridge_upstream_status_${statusCode}_translated_503`
                                 : upstreamCode ? `bridge_upstream_status_${statusCode}:${upstreamCode}` : `bridge_upstream_status_${statusCode}`,
                             transport: 'http',
@@ -457,10 +514,10 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                         const responseHeaders = rewriteResponseHeaders(response.headers, upstreamBaseUrl, authenticatedLocalBaseUrl);
                         responseHeaders['content-length'] = String(body.length);
                         delete responseHeaders['transfer-encoding'];
-                        if (transientMislabel)
-                            responseHeaders['retry-after'] = String(responseHeaders['retry-after'] || '10');
-                        if (statusCode === 429 && !responseHeaders['retry-after'])
-                            responseHeaders['retry-after'] = '10';
+                        delete responseHeaders['content-encoding'];
+                        if (verbatim && upstreamCode === MODEL_CAPACITY_ERROR_CODE && responseHeaders['retry-after'] === undefined) {
+                            responseHeaders['retry-after'] = String(MODEL_CAPACITY_RETRY_AFTER_SECONDS);
+                        }
                         res.writeHead(clientStatus, responseHeaders);
                         res.end(body, () => finish());
                     }).catch(finish);
@@ -638,6 +695,10 @@ export async function requestProviderCompactionSummary(config, input, body, onAc
         }
     }
 }
+function singleRetryAfter(value) {
+    const text = String(Array.isArray(value) ? value[0] ?? '' : value ?? '').trim();
+    return /^[A-Za-z0-9 ,:.-]{1,64}$/.test(text) ? text : null;
+}
 function upstreamErrorIds(body) {
     try {
         const parsed = JSON.parse(body.toString('utf8'));
@@ -683,9 +744,10 @@ async function answerCompactionWithProviderSummary(req, res, config, input) {
             const transient = isTransientUpstreamFailure(call.status, upstreamType, upstreamCode);
             const clientStatus = transient ? 503 : call.status;
             const errorBody = buildRedactedUpstreamErrorBody(call.status, upstreamCode, upstreamType, transient);
+            const retryAfter = singleRetryAfter(call.headers['retry-after']);
             res.writeHead(clientStatus, {
                 'content-type': 'application/json', 'cache-control': 'no-store', 'content-length': String(errorBody.length),
-                ...(transient || call.status === 429 ? { 'retry-after': String(call.headers['retry-after'] || '10') } : {}),
+                ...(retryAfter ? { 'retry-after': retryAfter } : {}),
             });
             res.end(errorBody);
             return;

package/dist/core/codex-lb/desktop-bridge/provider-handoff.js

@@ -0,0 +1,79 @@
+import { DesktopBridgeError } from './types.js';
+import { isNativeCompactionItem } from './compaction-adapter.js';
+export const PROVIDER_HANDOFF_NATIVE_COMPACTION_REFUSED = 'bridge_thread_handoff_after_native_compaction';
+const ROUTE_TARGET_NAMES = {
+    openai: 'your ChatGPT account',
+    'codex-lb': 'Codex-LB',
+    openrouter: 'OpenRouter',
+};
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function targetName(id) {
+    return ROUTE_TARGET_NAMES[id] ?? id;
+}
+export class ProviderHandoffRefusedError extends DesktopBridgeError {
+    move;
+    constructor(move) {
+        super(PROVIDER_HANDOFF_NATIVE_COMPACTION_REFUSED);
+        this.move = move;
+    }
+    userMessage() {
+        return `This thread was compacted on ${targetName(this.move.from)}, and that compaction can only be read there. `
+            + `Switch back to the model you were using, or start a new thread to continue on ${targetName(this.move.to)}.`;
+    }
+}
+export function carriesNativeCompaction(payload) {
+    return Boolean(payload && Array.isArray(payload.input) && payload.input.some(isNativeCompactionItem));
+}
+export function assertProviderHandoffAllowed(payload, move) {
+    if (!move || move.from === move.to || !carriesNativeCompaction(payload))
+        return;
+    throw new ProviderHandoffRefusedError(move);
+}
+export function providerHandoffRefusalBody(error) {
+    return JSON.stringify({
+        error: { type: 'invalid_request_error', code: 'invalid_prompt', message: error.userMessage(), param: error.code },
+    });
+}
+export function providerHandoffRefusedEvent(error, responseId, publicModel) {
+    return {
+        type: 'response.failed',
+        response: {
+            id: responseId,
+            object: 'response',
+            created_at: Math.floor(Date.now() / 1000),
+            model: publicModel,
+            status: 'failed',
+            error: { code: 'invalid_prompt', message: error.userMessage() },
+        },
+    };
+}
+export function stripProviderBoundItems(payload, moving) {
+    if (!payload)
+        return false;
+    let changed = false;
+    if (Array.isArray(payload.input)) {
+        const input = [];
+        for (const item of payload.input) {
+            if (isObject(item) && item.type === 'reasoning') {
+                changed = true;
+                continue;
+            }
+            if (isObject(item) && 'encrypted_content' in item && !isNativeCompactionItem(item)) {
+                const { encrypted_content: _foreign, ...rest } = item;
+                input.push(rest);
+                changed = true;
+                continue;
+            }
+            input.push(item);
+        }
+        if (changed)
+            payload.input = input;
+    }
+    if (moving && payload.previous_response_id !== undefined) {
+        delete payload.previous_response_id;
+        changed = true;
+    }
+    return changed;
+}

package/dist/core/codex-lb/desktop-bridge/responses-websocket.js

@@ -1,10 +1,12 @@
 import net from 'node:net';
 import tls from 'node:tls';
 import WebSocket, { WebSocketServer } from 'ws';
-import { BRIDGE_OFFICIAL_ROUTE_ID } from '../bridge-contracts.js';
+import { BRIDGE_OFFICIAL_ROUTE_ID, BRIDGE_REMOTE_COMPACTION } from '../bridge-contracts.js';
 import { buildOfficialPassthroughWebSocketHeaders, buildProviderWebSocketHeaders } from './header-policy.js';
 import { createDesktopBridgeRejectionLogger } from './rejection-log.js';
-import { assertDesktopBridgeRouteContext, ensureDesktopBridgeRemoteTarget, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode } from './security.js';
+import { assertDesktopBridgeRouteContext, ensureDesktopBridgeRemoteTarget, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, threadRouteMove } from './security.js';
+import { admitCodexLbTurnState } from './codex-lb-turn-state.js';
+import { ProviderHandoffRefusedError, assertProviderHandoffAllowed, providerHandoffRefusedEvent, stripProviderBoundItems, } from './provider-handoff.js';
 import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError } from './types.js';
 import { buildCompactionSummaryRequest, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, ResponsesContinuationChain, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
 import { requestProviderCompactionSummary } from './http-forward.js';
@@ -45,6 +47,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
         let upstream = null;
         let upstreamSocket = null;
         let bound = null;
+        let boundByMove = false;
         let boundBaseUrl = null;
         let boundCredentialGeneration = null;
         let boundCredentialFingerprint = null;
@@ -126,26 +129,44 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             }
             identity = bound ? withLineage(identity, nextIdentity) : nextIdentity;
             const request = routeRequest(model);
-            assertBinding(assertDesktopBridgeRouteContext(request, config));
-            const route = await resolveAndBindDesktopBridgeRouteContext(request, config);
+            const planned = assertDesktopBridgeRouteContext(request, config);
+            assertProviderHandoffAllowed(message.create, threadRouteMove(request, planned, config));
+            assertBinding(planned);
+            let move = null;
+            const route = await resolveAndBindDesktopBridgeRouteContext(request, config, (resolved) => {
+                move = threadRouteMove(request, resolved, config);
+                assertProviderHandoffAllowed(message.create, move);
+            });
             if (stopped || client.readyState !== WebSocket.OPEN)
                 return;
             assertBinding(route);
             routedModel = route.public_model;
             if (!bound) {
                 bound = route;
+                boundByMove = Boolean(move);
                 await connect(route);
             }
             const create = { ...message.create, model: route.upstream_model };
-            const expanded = expandBridgeCompactionItems(create);
-            if (route.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID && requestsRemoteCompaction(create)) {
+            let rewritten = expandBridgeCompactionItems(create);
+            if (route.session_pin?.handoff_from && stripProviderBoundItems(create, Boolean(move)))
+                rewritten = true;
+            if (BRIDGE_REMOTE_COMPACTION[route.provider_id] === 'bridge_summary' && requestsRemoteCompaction(create)) {
                 message.compaction = create;
                 return;
             }
-            if (route.upstream_model !== model || expanded)
+            if (route.upstream_model !== model || rewritten)
                 message.data = Buffer.from(JSON.stringify(create));
             message.routed = create;
         }
+        function refuseMove(message, error) {
+            const model = typeof message.create?.model === 'string' ? message.create.model : '';
+            logRejection({ code: error.code, transport: 'websocket', ...(req.url ? { url: req.url } : {}) });
+            relay(client, Buffer.from(JSON.stringify(providerHandoffRefusedEvent(error, newCompactionResponseId(), model))), false);
+            const index = pending.indexOf(message);
+            if (index >= 0)
+                pending.splice(index, 1);
+            pendingBytes -= message.originalBytes;
+        }
         async function answerCompaction(create) {
             const route = bound;
             const provider = config.providers[route.provider_id];
@@ -192,6 +213,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
         }
         async function connect(route) {
             const official = route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID;
+            const summarizes = BRIDGE_REMOTE_COMPACTION[route.provider_id] === 'bridge_summary';
             const provider = route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID ? null : config.providers[route.provider_id];
             const remote = official ? config.officialRemote : provider?.remote;
             if (!remote)
@@ -209,6 +231,10 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             const target = resolveDesktopBridgeTarget(req.url, remote);
             const outgoing = official ? buildOfficialPassthroughWebSocketHeaders(req.headers, target.host)
                 : buildProviderWebSocketHeaders(req.headers, { providerId: provider.provider_id, authTransport: provider.auth_transport, credential: credential }, target.host);
+            if (boundByMove)
+                delete outgoing['x-codex-turn-state'];
+            else if (provider?.provider_id === 'codex-lb')
+                admitCodexLbTurnState(outgoing, identity.thread_id, credential.fingerprint);
             const headers = {};
             for (const [name, value] of Object.entries(outgoing)) {
                 if (name.startsWith('sec-websocket-') || name === 'connection' || name === 'upgrade' || name === 'content-length')
@@ -256,7 +282,8 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                     frame = advised;
                     logRejection({ code: 'bridge_upstream_model_capacity_retry_advised', transport: 'websocket', provider_id: route.provider_id, public_model: routedModel ?? route.public_model, ...(req.url ? { url: req.url } : {}) });
                 }
-                chain.received(frame);
+                if (summarizes)
+                    chain.received(frame);
                 try {
                     relay(client, frame, binary);
                 }
@@ -289,24 +316,41 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                 return;
             processing = true;
             try {
-                if (!bound) {
+                while (!bound) {
                     const firstCreate = pending.find((message) => message.create);
                     if (!firstCreate)
                         return;
-                    await resolveCreate(firstCreate);
+                    try {
+                        await resolveCreate(firstCreate);
+                    }
+                    catch (error) {
+                        if (!(error instanceof ProviderHandoffRefusedError))
+                            throw error;
+                        refuseMove(firstCreate, error);
+                        continue;
+                    }
                     firstCreate.create = null;
                 }
                 while (!stopped && client.readyState === WebSocket.OPEN && pending.length) {
                     const message = pending[0];
-                    if (message.create)
-                        await resolveCreate(message);
+                    if (message.create) {
+                        try {
+                            await resolveCreate(message);
+                        }
+                        catch (error) {
+                            if (!(error instanceof ProviderHandoffRefusedError))
+                                throw error;
+                            refuseMove(message, error);
+                            continue;
+                        }
+                    }
                     if (stopped || client.readyState !== WebSocket.OPEN)
                         return;
                     if (message.compaction)
                         await answerCompaction(message.compaction);
                     else {
                         relay(upstream, message.data, message.binary);
-                        if (message.routed && bound?.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID)
+                        if (message.routed && bound && BRIDGE_REMOTE_COMPACTION[bound.provider_id] === 'bridge_summary')
                             chain.sent(message.routed, message.data);
                     }
                     pending.shift();