sneakoscope 10.7.0 → 10.7.2

package/dist/core/codex-lb/combined-catalog/builder.js

@@ -1,6 +1,6 @@
 import { buildBridgeRouteIndex, sha256Stable } from '../route-index.js';
 import { COMBINED_BRIDGE_CATALOG_SCHEMA } from './contracts.js';
-import { normalizeProviderCatalog, providerCatalogStatus, routeProviderState } from './normalize.js';
+import { OPENROUTER_PRIORITY_BASE, normalizeProviderCatalog, providerCatalogStatus, routeProviderState } from './normalize.js';
 import { pinCatalogToLatestGenerations } from './latest-generation.js';
 import { compareModels, unique } from './shared.js';
 import { applyBridgeModelSelection, availableModelRows, emptyBridgeModelSelection } from './model-selection.js';
@@ -11,7 +11,9 @@ export function buildCombinedBridgeCatalog(registry, options) {
         openrouter: normalizeProviderCatalog(options.catalogs.openrouter)
     };
     const selection = options.selection || emptyBridgeModelSelection(createdAt);
-    const allModels = pinCatalogToLatestGenerations([...normalized['codex-lb'].models, ...normalized.openrouter.models].sort(compareModels));
+    let openRouterIndex = 0;
+    const allModels = pinCatalogToLatestGenerations([...normalized['codex-lb'].models, ...normalized.openrouter.models].sort(compareModels)).map((model) => model.provider_id === 'openrouter' ? { ...model, priority: OPENROUTER_PRIORITY_BASE + openRouterIndex++ } : model)
+        .sort((left, right) => left.priority - right.priority || left.slug.localeCompare(right.slug) || compareModels(left, right));
     const availableOpenRouterModels = availableModelRows(allModels, selection);
     const models = options.selection ? applyBridgeModelSelection(allModels, selection) : allModels;
     const routeBuild = buildBridgeRouteIndex({

package/dist/core/codex-lb/combined-catalog/latest-generation.js

@@ -3,13 +3,6 @@ function isListed(model) {
     const visibility = String(model.visibility || 'list').toLowerCase();
     return visibility !== 'hide' && visibility !== 'hidden';
 }
-function escapeRegExp(text) {
-    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function displayNamePattern(displayName) {
-    const body = escapeRegExp(displayName.trim()).replace(/\\?-|\s+/g, '[-\\s]');
-    return new RegExp(`(?<![\\w-])${body}(?![\\w-])`, 'gi');
-}
 export function pinCatalogToLatestGenerations(models) {
     const newest = new Map();
     for (const model of models) {
@@ -20,34 +13,14 @@ export function pinCatalogToLatestGenerations(models) {
         if (!best || compareModelVersions(id.version, parseGptModelId(best.public_id).version) > 0)
             newest.set(id.family, model);
     }
-    const byId = new Map(models.map((model) => [model.public_id, model]));
     return models.map((model) => {
         const id = parseGptModelId(model.public_id);
-        let next = model;
-        if (id && isListed(model)) {
-            const best = newest.get(id.family);
-            if (best && compareModelVersions(parseGptModelId(best.public_id).version, id.version) > 0)
-                next = { ...next, visibility: 'hide' };
-        }
-        const upgrade = model.upgrade;
-        const target = upgrade && typeof upgrade === 'object' ? String(upgrade.model || '') : '';
-        const targetId = parseGptModelId(target);
-        const replacement = targetId ? newest.get(targetId.family) : undefined;
-        if (targetId && replacement && replacement.public_id !== target
-            && compareModelVersions(parseGptModelId(replacement.public_id).version, targetId.version) > 0) {
-            const old = byId.get(target);
-            const markdown = upgrade.migration_markdown;
-            next = {
-                ...next,
-                upgrade: {
-                    ...upgrade,
-                    model: replacement.public_id,
-                    ...(typeof markdown === 'string' && old?.display_name
-                        ? { migration_markdown: markdown.replace(displayNamePattern(old.display_name), () => replacement.display_name) }
-                        : {})
-                }
-            };
-        }
-        return next;
+        if (!id || !isListed(model))
+            return model;
+        const best = newest.get(id.family);
+        if (!best || compareModelVersions(parseGptModelId(best.public_id).version, id.version) <= 0)
+            return model;
+        const { upgrade: _retired, ...rest } = model;
+        return { ...rest, visibility: 'hide' };
     });
 }

package/dist/core/codex-lb/combined-catalog/normalize.js

@@ -130,7 +130,7 @@ function normalizeCodexLbBridgeCatalogModels(payload, sourceCatalogGeneration) {
                 ...codexModelInfoFields(publicId, row, {
                     tools: row.supports_tools === true || row.supports_tool_choice === true
                 }),
-                ...(typeof row.priority === 'number' ? {} : { priority: 100 })
+                ...(typeof row.priority === 'number' ? {} : { priority: CODEX_LB_DEFAULT_PRIORITY })
             });
         }
         catch (error) {
@@ -164,6 +164,8 @@ export const OPENROUTER_REASONING_LEVELS = [
     { effort: 'xhigh', description: 'Extra high reasoning depth for complex problems' }
 ];
 export const OPENROUTER_DEFAULT_REASONING_LEVEL = 'medium';
+export const CODEX_LB_DEFAULT_PRIORITY = 500;
+export const OPENROUTER_PRIORITY_BASE = 1000;
 function openRouterReasoningLevels() {
     return OPENROUTER_REASONING_LEVELS.map((level) => ({ ...level }));
 }

package/dist/core/codex-lb/combined-catalog/persistence.js

@@ -43,6 +43,10 @@ export async function stageCombinedBridgeCatalog(input) {
                 || existing.route_index.generation !== input.build.route_index.generation) {
                 throw new Error('combined_catalog_generation_bundle_mismatch');
             }
+            if (JSON.stringify(existing.catalog.provider_statuses) !== JSON.stringify(input.build.catalog.provider_statuses)) {
+                await fs.rename(tempCatalog, layout.catalogPath);
+                await fsyncDirectory(layout.bundleDirectory);
+            }
         }
         else {
             await fs.rename(tempBundle, layout.bundleDirectory);

package/dist/core/codex-lb/combined-catalog/storage.js

@@ -139,7 +139,10 @@ export function emptyRouteIndex() {
     }).route_index;
 }
 export function catalogObservationGeneration(catalog) {
-    return sha256Stable(catalog.provider_statuses);
+    return sha256Stable(Object.fromEntries(Object.entries(catalog.provider_statuses).map(([providerId, row]) => {
+        const { checked_at: _checkedAt, expires_at: _expiresAt, ...observed } = row;
+        return [providerId, observed];
+    })));
 }
 function validProviderStatuses(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

package/dist/core/codex-lb/desktop-bridge/codex-lb-turn-state.js

@@ -0,0 +1,35 @@
+const MAX_THREADS = 4_096;
+const MAX_VALUES_PER_THREAD = 8;
+const issued = new Map();
+function scope(threadId, keyFingerprint) {
+    return `${keyFingerprint}\u0000${threadId}`;
+}
+function headerValues(value) {
+    const values = Array.isArray(value) ? value : value === undefined ? [] : [String(value)];
+    return values.map((entry) => entry.trim()).filter(Boolean);
+}
+export function rememberCodexLbTurnState(threadId, keyFingerprint, headers) {
+    const values = headerValues(headers['x-codex-turn-state']);
+    if (!threadId || !values.length)
+        return;
+    const key = scope(threadId, keyFingerprint);
+    const kept = (issued.get(key) ?? []).filter((value) => !values.includes(value));
+    issued.delete(key);
+    issued.set(key, [...kept, ...values].slice(-MAX_VALUES_PER_THREAD));
+    while (issued.size > MAX_THREADS)
+        issued.delete(issued.keys().next().value);
+}
+export function admitCodexLbTurnState(headers, threadId, keyFingerprint) {
+    const values = headerValues(headers['x-codex-turn-state']);
+    if (!values.length) {
+        delete headers['x-codex-turn-state'];
+        return;
+    }
+    const known = threadId ? issued.get(scope(threadId, keyFingerprint)) : undefined;
+    if (values.length === 1 && known?.includes(values[0]))
+        return;
+    delete headers['x-codex-turn-state'];
+}
+export function forgetCodexLbTurnStates() {
+    issued.clear();
+}

package/dist/core/codex-lb/desktop-bridge/compaction-adapter.js

@@ -43,6 +43,9 @@ export function decodeBridgeCompaction(encrypted) {
         return null;
     }
 }
+export function isNativeCompactionItem(item) {
+    return isObject(item) && COMPACTION_ITEM_TYPES.has(String(item.type)) && decodeBridgeCompaction(item.encrypted_content) === null;
+}
 function summaryMessage(summary) {
     return { type: 'message', role: 'user', content: [{ type: 'input_text', text: `${CODEX_SUMMARY_PREFIX}\n${summary}` }] };
 }

package/dist/core/codex-lb/desktop-bridge/header-policy.js

@@ -7,9 +7,10 @@ const REQUEST_HEADER_ALLOWLIST = new Set([
 ]);
 const CODEX_LOCAL_HEADERS = new Set([
     'thread-id', 'thread_id', 'session-id', 'session_id', 'x-client-request-id',
-    'x-codex-installation-id', 'x-codex-turn-metadata', 'x-codex-window-id',
+    'x-codex-installation-id', 'x-codex-turn-metadata', 'x-codex-window-id', 'x-codex-turn-state',
     'originator', 'openai-beta',
 ]);
+const CLIENT_IDENTITY_HEADERS = new Set(['authorization', 'cookie', 'chatgpt-account-id']);
 const NEVER_FORWARD_FROM_CLIENT = new Set([
     'authorization', 'cookie', 'forwarded', 'proxy-authorization', 'x-api-key', 'x-codex-lb-api-key',
     'x-forwarded-for', 'x-forwarded-host', 'x-forwarded-port', 'x-forwarded-proto', 'x-real-ip',
@@ -39,14 +40,19 @@ function injectCredential(result, providerId, transport, credential) {
         result.authorization = `Bearer ${credential.value}`;
 }
 export function buildProviderUpstreamHeaders(inbound, context, upstreamHost) {
+    if (context.providerId === 'codex-lb') {
+        const result = buildOfficialPassthroughHeaders(inbound, upstreamHost);
+        for (const name of CLIENT_IDENTITY_HEADERS)
+            delete result[name];
+        injectCredential(result, context.providerId, context.authTransport, context.credential);
+        return result;
+    }
     const result = {};
     for (const [rawName, rawValue] of Object.entries(inbound)) {
         if (rawValue === undefined)
             continue;
         const name = rawName.toLowerCase();
-        const providerAllowed = (context.providerId === 'openrouter' && OPENROUTER_CLIENT_HEADERS.has(name))
-            || (context.providerId === 'codex-lb' && CODEX_LOCAL_HEADERS.has(name));
-        if (!REQUEST_HEADER_ALLOWLIST.has(name) && !providerAllowed)
+        if (!REQUEST_HEADER_ALLOWLIST.has(name) && !(context.providerId === 'openrouter' && OPENROUTER_CLIENT_HEADERS.has(name)))
             continue;
         result[name] = rawValue;
     }

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

@@ -2,16 +2,21 @@ 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 { createDesktopBridgeRejectionLogger, desktopBridgeRequestShape, safeUpstreamParam } from './rejection-log.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 { adaptRequestForRoute, logRequestAdaptation, providerExtraInclude } from './provider-request-compat.js';
+import { desktopBridgeModelsEtag } from './models-endpoint.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 +66,16 @@ 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 advertisedModelsEtag(req, config) {
+    if (!config.modelsCatalog)
+        return null;
+    const pathname = new URL(String(req.url || '/'), 'http://bridge.invalid').pathname;
+    return modelBodyKind(req, pathname) === 'responses' ? desktopBridgeModelsEtag(config.modelsCatalog.generation) : null;
 }
 function isCompactEndpoint(req, pathname) {
     return req.method === 'POST' && RESPONSES_PATHS.some((prefix) => pathname === `${prefix}/compact`);
@@ -105,7 +115,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 +141,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 +161,20 @@ export async function prepareDesktopBridgeRequest(req, config) {
     }
     if (expandBridgeCompactionItems(payload))
         rewrite = true;
+    if (route.session_pin?.handoff_from && stripProviderBoundItems(payload, Boolean(move)))
+        rewrite = true;
+    const adapted = adaptRequestForRoute(payload, route, providerExtraInclude(config, route));
+    if (adapted.length) {
+        rewrite = true;
+        logRequestAdaptation(config, route, adapted, 'http');
+    }
     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 +183,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 +217,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,27 +259,57 @@ 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');
+    let upstreamParam = null;
+    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);
         upstreamType = safeUpstreamErrorId(parsed?.error?.type);
+        upstreamParam = safeUpstreamParam(parsed?.error?.param);
     }
     catch {
     }
-    return { upstreamCode, upstreamType, unreadableBody: UNREADABLE_BODY_HINT.test(text.slice(0, 4096)) };
+    return {
+        upstreamCode,
+        upstreamType,
+        upstreamParam,
+        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 +344,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 +380,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 +402,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 +415,8 @@ 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 modelsEtag = advertisedModelsEtag(req, config);
         const replayable = Buffer.isBuffer(request.body);
         let body = request.body;
         let plainFallbackActive = false;
@@ -371,7 +440,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 +459,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 });
@@ -414,7 +485,10 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     }
                     responseStarted = true;
                     try {
-                        res.writeHead(statusCode, rewriteResponseHeaders(response.headers, upstreamBaseUrl, authenticatedLocalBaseUrl));
+                        const responseHeaders = rewriteResponseHeaders(response.headers, upstreamBaseUrl, authenticatedLocalBaseUrl);
+                        if (modelsEtag)
+                            responseHeaders['x-models-etag'] = modelsEtag;
+                        res.writeHead(statusCode, responseHeaders);
                     }
                     catch (error) {
                         response.destroy(error instanceof Error ? error : undefined);
@@ -425,7 +499,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, upstreamParam, unreadableBody, body: upstreamBody }) => {
                         if (budget.plainFallback && (statusCode === 415
                             || (unreadableBody && !upstreamType && !upstreamCode && (statusCode === 400 || statusCode === 422)))) {
                             responseStarted = true;
@@ -440,27 +514,42 @@ 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);
+                        const rejected = statusCode >= 400 && statusCode <= 499;
                         logHttpRejection({
-                            code: transientMislabel
-                                ? `bridge_upstream_status_${statusCode}_translated_503`
-                                : upstreamCode ? `bridge_upstream_status_${statusCode}:${upstreamCode}` : `bridge_upstream_status_${statusCode}`,
+                            code: rejected
+                                ? 'bridge_upstream_request_rejected'
+                                : transientMislabel && !verbatim
+                                    ? `bridge_upstream_status_${statusCode}_translated_503`
+                                    : upstreamCode ? `bridge_upstream_status_${statusCode}:${upstreamCode}` : `bridge_upstream_status_${statusCode}`,
                             transport: 'http',
                             ...(req.method === undefined ? {} : { method: req.method }),
                             ...(req.url === undefined ? {} : { url: req.url }),
                             status: clientStatus,
                             provider_id: provider.provider_id,
                             public_model: request.route.public_model,
+                            ...(rejected ? {
+                                upstream_status: statusCode,
+                                upstream_code: upstreamCode,
+                                upstream_type: upstreamType,
+                                upstream_param: upstreamParam,
+                                request_shape: desktopBridgeRequestShape(request.payload),
+                            } : {}),
                         });
                         responseStarted = true;
                         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);
+                        }
+                        if (modelsEtag)
+                            responseHeaders['x-models-etag'] = modelsEtag;
                         res.writeHead(clientStatus, responseHeaders);
                         res.end(body, () => finish());
                     }).catch(finish);
@@ -479,6 +568,8 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     const responseHeaders = rewriteResponseHeaders(response.headers, upstreamBaseUrl, authenticatedLocalBaseUrl);
                     if (advising)
                         delete responseHeaders['content-length'];
+                    if (modelsEtag)
+                        responseHeaders['x-models-etag'] = modelsEtag;
                     res.writeHead(statusCode, responseHeaders);
                 }
                 catch (error) {
@@ -638,6 +729,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'));
@@ -654,12 +749,18 @@ async function answerCompactionWithProviderSummary(req, res, config, input) {
     const streaming = input.kind === 'trigger';
     const responseId = newCompactionResponseId();
     const publicModel = input.route.public_model;
-    const body = Buffer.from(JSON.stringify(buildCompactionSummaryRequest(input.payload, input.route.upstream_model)));
+    const summaryRequest = buildCompactionSummaryRequest(input.payload, input.route.upstream_model);
+    adaptRequestForRoute(summaryRequest, input.route, providerExtraInclude(config, input.route));
+    const body = Buffer.from(JSON.stringify(summaryRequest));
     let keepalive = null;
     const startStream = () => {
         if (!streaming || res.headersSent)
             return;
-        res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
+        const modelsEtag = advertisedModelsEtag(req, config);
+        res.writeHead(200, {
+            'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive',
+            ...(modelsEtag ? { 'x-models-etag': modelsEtag } : {}),
+        });
         res.write(sseEvent(compactionCreatedEvent(responseId, publicModel)));
         keepalive = setInterval(() => { if (!res.writableEnded)
             res.write(': keepalive\n\n'); }, COMPACTION_KEEPALIVE_MS);
@@ -683,9 +784,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/models-endpoint.js

@@ -0,0 +1,62 @@
+export const DESKTOP_BRIDGE_MODELS_PATHS = ['/backend-api/codex/models', '/api/v1/models', '/v1/models'];
+export function desktopBridgeModelsEtag(generation) {
+    return `sksb-${generation.slice(0, 16)}`;
+}
+export function isDesktopBridgeModelsRequest(req, pathname) {
+    return (req.method === 'GET' || req.method === 'HEAD') && DESKTOP_BRIDGE_MODELS_PATHS.includes(pathname);
+}
+function versionParts(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(String(value ?? '').trim());
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+function newerThan(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] > right[index];
+    }
+    return false;
+}
+export function modelsForClient(catalog, clientVersion) {
+    const client = versionParts(clientVersion);
+    if (!client)
+        return [...catalog.models];
+    return catalog.models.filter((row) => {
+        const minimum = versionParts(row.minimal_client_version);
+        return !minimum || !newerThan(minimum, client);
+    });
+}
+export function answerDesktopBridgeModels(req, res, catalog) {
+    const etag = desktopBridgeModelsEtag(catalog.generation);
+    const headers = { etag, 'cache-control': 'no-store', 'content-type': 'application/json' };
+    const ifNoneMatch = String(req.headers['if-none-match'] || '').split(',').map((value) => value.trim());
+    if (ifNoneMatch.includes(etag)) {
+        res.writeHead(304, headers);
+        res.end();
+        return;
+    }
+    const clientVersion = new URL(String(req.url || '/'), 'http://bridge.invalid').searchParams.get('client_version');
+    const body = Buffer.from(JSON.stringify({ models: modelsForClient(catalog, clientVersion) }));
+    res.writeHead(200, { ...headers, 'content-length': String(body.length) });
+    res.end(req.method === 'HEAD' ? undefined : body);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function frameWithModelsEtag(frame, etag) {
+    if (!frame.includes('"codex.response.metadata"'))
+        return null;
+    let event;
+    try {
+        event = JSON.parse(frame.toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(event) || event.type !== 'codex.response.metadata')
+        return null;
+    const headers = isRecord(event.headers) ? event.headers : {};
+    const others = Object.entries(headers).filter(([name]) => name.toLowerCase() !== 'x-models-etag');
+    if (headers['x-models-etag'] === etag && others.length === Object.keys(headers).length - 1)
+        return null;
+    return Buffer.from(JSON.stringify({ ...event, headers: { ...Object.fromEntries(others), 'x-models-etag': etag } }));
+}