sneakoscope 10.7.1 → 10.7.2

package/README.md

@@ -17,7 +17,7 @@
 Sneakoscope Codex (`sks`) is an open-source local tool for the Codex CLI and Codex desktop app. It adds a macOS control center, bounded agent workflows, repository context, and evidence checks for SKS releases.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-Current package: **SKS 10.7.1**, prepared for npm publication.
+Current package: **SKS 10.7.2**, prepared for npm publication.
 [Latest release notes](https://github.com/mandarange/Sneakoscope-Codex/releases/latest)
 · [npm package](https://www.npmjs.com/package/sneakoscope)
 · [Changelog](CHANGELOG.md). Install the latest stable release from npm.

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "10.7.1"
+version = "10.7.2"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "10.7.1"
+version = "10.7.2"
 edition = "2021"
 
 [dependencies]

package/dist/cli/command-manifest-lite.js

@@ -273,7 +273,7 @@ const COMMAND_HELP_LITE = {
     },
     doctor: {
         usage: 'sks doctor [--fix] [--local-only] [--json] [--install-scope global|project]',
-        description: 'Check and repair SKS generated files, while blocking setup if another Codex harness is detected.'
+        description: 'Check and repair SKS generated files, while blocking setup if another Codex harness is detected. Every run refreshes the Desktop Bridge model list; without --fix it writes only SKS\'s own catalog files, never ~/.codex/config.toml.'
     },
     git: {
         usage: 'sks git policy|install|status|doctor|precommit|publish-plan|summary [--json]',

package/dist/cli/install-helpers-codex-lb-config.js

@@ -1,6 +1,38 @@
 import path from 'node:path';
 import { ensureTrailingNewline, upsertTopLevelTomlString } from '../core/codex-runtime/codex-desktop-config-policy.js';
 import { escapeRegExp } from '../core/text/regex.js';
+export function codexReadsBridgeModels(text) {
+    const source = String(text || '');
+    return topLevelHasLine(source, DESKTOP_BRIDGE_MANAGED_BASE_URL_MARKER)
+        && Boolean(topLevelTomlString(source, 'openai_base_url'))
+        && !topLevelTomlString(source, 'model_catalog_json');
+}
+export function hasUserOwnedModelCatalog(text) {
+    const source = String(text || '');
+    return Boolean(topLevelTomlString(source, 'model_catalog_json'))
+        && !topLevelHasLine(source, DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER);
+}
+export function setDesktopBridgeManagedModelCatalog(text, combinedCatalogPath) {
+    const source = String(text || '');
+    if (!topLevelHasLine(source, DESKTOP_BRIDGE_MANAGED_BASE_URL_MARKER) || hasUserOwnedModelCatalog(source))
+        return source;
+    if (combinedCatalogPath === null) {
+        if (!topLevelTomlString(source, 'model_catalog_json'))
+            return source;
+        return ensureTrailingNewline(removeTopLevelLine(removeTopLevelTomlKey(source, 'model_catalog_json'), DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER));
+    }
+    assertCombinedCatalogPath(combinedCatalogPath);
+    if (topLevelTomlString(source, 'model_catalog_json') === combinedCatalogPath)
+        return source;
+    const next = upsertTopLevelTomlString(source, 'model_catalog_json', combinedCatalogPath);
+    return ensureTrailingNewline(addTopLevelMarkerBeforeKey(next, 'model_catalog_json', DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER));
+}
+function assertCombinedCatalogPath(combinedCatalogPath) {
+    if (!combinedCatalogPath || !path.isAbsolute(combinedCatalogPath)
+        || path.basename(combinedCatalogPath) !== 'sks-bridge-catalog.json') {
+        throw new Error('desktop_bridge_combined_catalog_path_invalid');
+    }
+}
 export const DESKTOP_BRIDGE_MANAGED_MARKER = '# sks-desktop-bridge-managed';
 export const DESKTOP_BRIDGE_MANAGED_BASE_URL_MARKER = '# sks-desktop-bridge-managed-base-url';
 export const DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER = '# sks-desktop-bridge-managed-model-catalog';
@@ -18,12 +50,8 @@ export function hasCodexLbProviderTable(text) {
 export function upsertDesktopBridgeManagedConfig(text, input) {
     const bridgeBaseUrl = normalizeManagedBridgeBaseUrl(input.bridgeBaseUrl);
     const combinedCatalogPath = String(input.combinedCatalogPath || '').trim();
-    if (!combinedCatalogPath || !path.isAbsolute(combinedCatalogPath)) {
-        throw new Error('desktop_bridge_combined_catalog_path_invalid');
-    }
-    if (path.basename(combinedCatalogPath) !== 'sks-bridge-catalog.json') {
-        throw new Error('desktop_bridge_combined_catalog_path_invalid');
-    }
+    assertCombinedCatalogPath(combinedCatalogPath);
+    const bindModelCatalog = input.bindModelCatalog !== false;
     const orphanCleanup = removeDesktopBridgeOrphanManagedMarkers(String(text || ''));
     let next = orphanCleanup.text;
     const selectedProvider = topLevelTomlString(next, 'model_provider');
@@ -39,17 +67,20 @@ export function upsertDesktopBridgeManagedConfig(text, input) {
     }
     const existingCatalog = topLevelTomlString(next, 'model_catalog_json');
     const catalogOwned = topLevelHasLine(next, DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER);
-    if (existingCatalog && !catalogOwned) {
+    if (existingCatalog && !catalogOwned && bindModelCatalog) {
         throw new Error('historical_user_owned_config_conflict:model_catalog_json');
     }
+    const userCatalog = existingCatalog && !catalogOwned ? existingCatalog : null;
     const keepCodexLb = selectedProvider === 'codex-lb' && hasCodexLbProviderTable(next);
-    next = removeManagedBridgeTopLevelBindings(next);
+    next = removeManagedBridgeTopLevelBindings(next, { keepModelCatalog: userCatalog !== null });
     next = upsertTopLevelTomlString(next, 'model_provider', keepCodexLb ? 'codex-lb' : 'openai');
     next = addTopLevelMarkerBeforeKey(next, 'model_provider', DESKTOP_BRIDGE_MANAGED_MARKER);
     next = upsertTopLevelTomlString(next, 'openai_base_url', bridgeBaseUrl);
     next = addTopLevelMarkerBeforeKey(next, 'openai_base_url', DESKTOP_BRIDGE_MANAGED_BASE_URL_MARKER);
-    next = upsertTopLevelTomlString(next, 'model_catalog_json', combinedCatalogPath);
-    next = addTopLevelMarkerBeforeKey(next, 'model_catalog_json', DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER);
+    if (bindModelCatalog) {
+        next = upsertTopLevelTomlString(next, 'model_catalog_json', combinedCatalogPath);
+        next = addTopLevelMarkerBeforeKey(next, 'model_catalog_json', DESKTOP_BRIDGE_MANAGED_MODEL_CATALOG_MARKER);
+    }
     return ensureTrailingNewline(next);
 }
 export function removeDesktopBridgeManagedConfig(text) {
@@ -135,11 +166,12 @@ function removeTopLevelTomlKey(text, key) {
         .replace(/^\n+/, '')
         .replace(/\n{3,}/g, '\n\n');
 }
-function removeManagedBridgeTopLevelBindings(text) {
+function removeManagedBridgeTopLevelBindings(text, options = {}) {
     let next = String(text || '');
     next = removeTopLevelTomlKey(next, 'model_provider');
     next = removeTopLevelTomlKey(next, 'openai_base_url');
-    next = removeTopLevelTomlKey(next, 'model_catalog_json');
+    if (!options.keepModelCatalog)
+        next = removeTopLevelTomlKey(next, 'model_catalog_json');
     for (const marker of [
         DESKTOP_BRIDGE_MANAGED_MARKER,
         DESKTOP_BRIDGE_MANAGED_BASE_URL_MARKER,

package/dist/commands/bridge.js

@@ -31,6 +31,7 @@ export function usage(command = 'bridge') {
         `       sks ${command} catalog sync|status [--json]`,
         `       sks ${command} models list [--json]`,
         `       sks ${command} models select --set <public-id,...> [--json]`,
+        `       sks ${command} models refresh [--json]`,
         `       sks ${command} route list [--json]`,
         `       sks ${command} route set-default <codex-lb|openrouter> [--json]`,
         `       sks ${command} route official-models <passthrough|gateway|auto> [--json]`,
@@ -86,7 +87,7 @@ export async function executeBridgeCommand(args = [], options = {}) {
             : await (options.facade || await loadBridgeCommandFacade()).execute(parsed.request);
         const output = parsed.request.operation === 'verify'
             ? verificationOutput(raw, parsed.request.level, parsed.strict)
-            : ordinaryOutput(raw, parsed.label);
+            : ordinaryOutput(raw, parsed.request.operation === 'models.refresh' ? modelRefreshLine(raw) ?? parsed.label : parsed.label);
         const sanitized = sanitizeBridgeValue(output, parsed.secrets);
         const decorated = mergeMetadata(sanitized, options.metadata);
         return {
@@ -104,6 +105,10 @@ export async function executeBridgeCommand(args = [], options = {}) {
         };
     }
 }
+function modelRefreshLine(raw) {
+    const result = raw?.result;
+    return typeof result?.model_refresh?.line === 'string' ? result.model_refresh.line : null;
+}
 export async function loadBridgeCommandFacade() {
     const controller = await import('../core/codex-lb/desktop-controller.js');
     const execute = controller[CONTROLLER_FACADE_EXPORT];
@@ -260,6 +265,14 @@ async function parseInvocation(args, io) {
             allowOnly(parsed, ['--json'], []);
             return { ...base, request: { operation: 'models.list' }, label: 'Selectable bridge models' };
         }
+        if (action === 'refresh' && target === undefined) {
+            allowOnly(parsed, ['--json'], []);
+            return {
+                ...base,
+                request: { operation: 'models.refresh', reason: 'cli', force: true, allow_config_writes: true },
+                label: 'Model list refresh'
+            };
+        }
         if (action === 'select') {
             allowOnly(parsed, ['--json'], ['--set']);
             const raw = parsed.values.get('--set') || '';

package/dist/commands/codex.js

@@ -45,7 +45,9 @@ export async function run(_command, args = []) {
         return;
     }
     if (action === 'update' || action === 'update-now') {
-        const result = await updateCodexCliNow();
+        const updated = await updateCodexCliNow();
+        const modelRefresh = await (await import('../core/codex-lb/model-refresh-after.js')).refreshModelListAfter('codex-update');
+        const result = modelRefresh ? { ...updated, model_refresh: modelRefresh } : updated;
         if (flag(args, '--json')) {
             printJson(result);
             if (!result.ok)
@@ -54,6 +56,8 @@ export async function run(_command, args = []) {
         }
         for (const line of codexCliUpdateConsoleLines(result))
             console.log(line);
+        if (typeof modelRefresh?.line === 'string')
+            console.log(modelRefresh.line);
         if (!result.ok)
             process.exitCode = 1;
         return;

package/dist/commands/doctor-console.js

@@ -238,6 +238,8 @@ export function renderDoctorConsoleReport(result, extras) {
     if (codexCurrentAppDoctor.fixed?.length)
         line(`  doctor --fix repaired: ${codexCurrentAppDoctor.fixed.join(', ')}`);
     line(`Desktop Bridge: ${desktopBridge.ok ? 'ready' : 'blocked'} (${desktopBridge.status?.readiness?.state || 'unavailable'})`);
+    if (desktopBridge.model_refresh?.line)
+        line(`  ${desktopBridge.model_refresh.line}`);
     for (const providerId of ['codex-lb', 'openrouter']) {
         const provider = desktopBridge.providers?.[providerId];
         if (!provider)

package/dist/commands/doctor.js

@@ -376,6 +376,8 @@ async function runDoctorGlobalOnlyFix(args = [], root, deps = {}) {
                 ? 'repaired'
                 : bridgeRepair?.ok === false ? 'failed' : 'nothing_to_repair'}`);
         console.log(`Desktop Bridge: ${result.desktop_bridge.ok ? 'ready' : 'blocked'} (${result.desktop_bridge.status?.readiness?.state || 'unavailable'})`);
+        if (result.desktop_bridge_repair?.model_refresh?.line)
+            console.log(result.desktop_bridge_repair.model_refresh.line);
         if (result.migration_receipt) {
             console.log(`Migration receipt: ${result.migration_receipt.status} (${result.home})`);
         }
@@ -737,9 +739,8 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
     const codexApp = deepDiagnostics
         ? await codexAppIntegrationStatus({ codex }).catch((err) => ({ ok: false, error: err.message }))
         : { ok: false, skipped: true, warnings: ['codex_app_optional_diagnostic_skipped'] };
-    const desktopBridgeBeforeFix = await inspectDoctorDesktopBridgeStatus({
-        processEnv: process.env
-    }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl });
+    let desktopBridgeModelRefresh = doctorFix ? null : (await (deps.desktopBridgeRepairImpl || repairDoctorDesktopBridgeCatalog)({ fix: false, reason: 'doctor' }).catch(() => null))?.model_refresh ?? null;
+    const desktopBridgeBeforeFix = await inspectDoctorDesktopBridgeStatus({ processEnv: process.env }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl });
     const providerContext = deepDiagnostics
         ? await resolveProviderContext({ root, route: '$Doctor', serviceTier: process.env.SKS_SERVICE_TIER || 'fast' }).catch((err) => ({
             schema: 'sks.provider-context.v2',
@@ -1091,7 +1092,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
                 {
                     id: 'desktop_bridge_catalog_repair',
                     required_for_ready: false,
-                    run: async () => repairDoctorDesktopBridgeCatalog({ fix: doctorFix })
+                    run: async () => { const repair = await repairDoctorDesktopBridgeCatalog({ fix: doctorFix }); desktopBridgeModelRefresh = repair.model_refresh ?? null; return repair; }
                 }
             ].filter((phase) => doctorPhaseIds.includes(phase.id))
         }).catch((err) => ({
@@ -1118,11 +1119,9 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         }))
         : null;
     const doctorFixPostcheck = doctorFix ? (await import('../core/doctor/doctor-repair-postcheck.js')).doctorRepairPostcheck(doctorFixTransaction) : null;
-    const desktopBridge = doctorFixTransaction
-        ? await inspectDoctorDesktopBridgeStatus({
-            processEnv: process.env
-        }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl })
-        : desktopBridgeBeforeFix;
+    const desktopBridge = { ...(doctorFixTransaction
+            ? await inspectDoctorDesktopBridgeStatus({ processEnv: process.env }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl })
+            : desktopBridgeBeforeFix), model_refresh: desktopBridgeModelRefresh };
     const startupRoleRepair = startupConfigRepair?.role_repair;
     const agentRoleConfigRepair = doctorFix && startupRoleRepair
         ? startupRoleRepair

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.7.1",
+  "package_version": "10.7.2",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/codex-app/menubar/constants.js

@@ -33,7 +33,6 @@ export const NATIVE_SOURCE_FILES = [
     'ProvidersOpenRouterOnly.swift',
     'SubagentModelsModels.swift',
     'SubagentModelsViewController.swift',
-    'RemoteCodingViewController.swift',
     'DiagnosticsViewController.swift',
     'SettingsViewController.swift',
     'LocalDecisionModels.swift',

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/http-forward.js

@@ -4,12 +4,14 @@ import zlib from 'node:zlib';
 import { pipeline } from 'node:stream/promises';
 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 { 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 { 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';
@@ -69,6 +71,12 @@ function modelBodyKind(req, pathname) {
         return req.method === 'POST' ? 'responses' : 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`);
 }
@@ -155,6 +163,11 @@ export async function prepareDesktopBridgeRequest(req, config) {
         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)
@@ -260,6 +273,7 @@ async function readRedactedUpstreamError(response) {
     }
     let upstreamCode = null;
     let upstreamType = null;
+    let upstreamParam = null;
     const raw = Buffer.concat(chunks);
     const encoding = String(response.headers['content-encoding'] || '').trim().toLowerCase();
     let decoded = complete ? raw : null;
@@ -276,12 +290,14 @@ async function readRedactedUpstreamError(response) {
         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,
+        upstreamParam,
         unreadableBody: UNREADABLE_BODY_HINT.test(text.slice(0, 4096)),
         body: decoded,
     };
@@ -400,6 +416,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             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;
@@ -468,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);
@@ -479,7 +499,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     return;
                 }
                 if (statusCode >= 400) {
-                    void readRedactedUpstreamError(response).then(({ upstreamCode, upstreamType, unreadableBody, body: upstreamBody }) => {
+                    void readRedactedUpstreamError(response).then(({ upstreamCode, upstreamType, upstreamParam, unreadableBody, body: upstreamBody }) => {
                         if (budget.plainFallback && (statusCode === 415
                             || (unreadableBody && !upstreamType && !upstreamCode && (statusCode === 400 || statusCode === 422)))) {
                             responseStarted = true;
@@ -499,16 +519,26 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                         const body = verbatim
                             ? scrubUpstreamErrorBody(upstreamBody, request.credential.value)
                             : buildRedactedUpstreamErrorBody(statusCode, upstreamCode, upstreamType, transientMislabel);
+                        const rejected = statusCode >= 400 && statusCode <= 499;
                         logHttpRejection({
-                            code: transientMislabel && !verbatim
-                                ? `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);
@@ -518,6 +548,8 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                         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);
@@ -536,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) {
@@ -715,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);

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 } }));
+}

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

@@ -60,10 +60,19 @@ export function stripProviderBoundItems(payload, moving) {
                 changed = true;
                 continue;
             }
-            if (isObject(item) && 'encrypted_content' in item && !isNativeCompactionItem(item)) {
-                const { encrypted_content: _foreign, ...rest } = item;
-                input.push(rest);
-                changed = true;
+            if (isObject(item)) {
+                let next = item;
+                if ('encrypted_content' in next && !isNativeCompactionItem(next)) {
+                    const { encrypted_content: _foreign, ...rest } = next;
+                    next = rest;
+                    changed = true;
+                }
+                if (next.type === 'function_call' && 'encrypted_function_args' in next) {
+                    const { encrypted_function_args: _foreign, ...rest } = next;
+                    next = rest;
+                    changed = true;
+                }
+                input.push(next);
                 continue;
             }
             input.push(item);

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

@@ -0,0 +1,89 @@
+import { BRIDGE_OFFICIAL_ROUTE_ID } from '../bridge-contracts.js';
+import { PACKAGE_VERSION } from '../../version.js';
+import { DESKTOP_BRIDGE_LOG_SCHEMA, REJECTION_LOG_SUMMARY_INTERVAL_MS } from './rejection-log.js';
+export const PROVIDER_INCLUDE_ALLOWLIST = {
+    [BRIDGE_OFFICIAL_ROUTE_ID]: null,
+    'codex-lb': [
+        'code_interpreter_call.outputs',
+        'computer_call_output.output.image_url',
+        'file_search_call.results',
+        'message.input_image.image_url',
+        'message.output_text.logprobs',
+        'reasoning.encrypted_content',
+        'web_search_call.action.sources',
+    ],
+    openrouter: [
+        'code_interpreter_call.outputs',
+        'computer_call_output.output.image_url',
+        'file_search_call.results',
+        'message.input_image.image_url',
+        'reasoning.encrypted_content',
+    ],
+};
+export const REQUEST_COMPAT_INCLUDE_VALUE = /^[a-z_.]{1,64}$/;
+export const REQUEST_COMPAT_MAX_EXTRA_INCLUDE = 8;
+export function adaptRequestForRoute(payload, route, extraInclude = []) {
+    if (!payload || route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID)
+        return [];
+    const changes = [];
+    const allowlist = PROVIDER_INCLUDE_ALLOWLIST[route.provider_id];
+    if (allowlist && Array.isArray(payload.include)) {
+        const allowed = new Set([...allowlist, ...extraInclude]);
+        const kept = [];
+        for (const value of payload.include) {
+            if (typeof value === 'string' && allowed.has(value))
+                kept.push(value);
+            else
+                changes.push({ field: 'include', value: String(value) });
+        }
+        if (kept.length !== payload.include.length)
+            payload.include = kept;
+    }
+    return changes;
+}
+export function providerExtraInclude(config, route) {
+    if (route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID)
+        return [];
+    const values = config.providers[route.provider_id]?.request_compat?.extra_include;
+    return Array.isArray(values) ? values.filter((value) => REQUEST_COMPAT_INCLUDE_VALUE.test(value)) : [];
+}
+const adaptationCounts = new WeakMap();
+function loggedValue(value) {
+    return /^[A-Za-z0-9_.:-]{1,64}$/.test(value) ? value : '<other>';
+}
+export function logRequestAdaptation(config, route, changes, transport, options = {}) {
+    const write = options.write ?? ((line) => process.stdout.write(line));
+    const now = options.now?.() ?? Date.now();
+    let counts = adaptationCounts.get(config);
+    if (!counts) {
+        counts = new Map();
+        adaptationCounts.set(config, counts);
+    }
+    for (const change of changes) {
+        const value = loggedValue(change.value);
+        const key = `${route.provider_id}\0${change.field}\0${value}`;
+        const entry = counts.get(key) ?? { count: 0, loggedAtMs: Number.NEGATIVE_INFINITY };
+        entry.count += 1;
+        counts.set(key, entry);
+        if (entry.count > 1 && now - entry.loggedAtMs < REJECTION_LOG_SUMMARY_INTERVAL_MS)
+            continue;
+        entry.loggedAtMs = now;
+        try {
+            write(`${JSON.stringify({
+                schema: DESKTOP_BRIDGE_LOG_SCHEMA,
+                sks_version: PACKAGE_VERSION,
+                at: new Date(now).toISOString(),
+                secret_fields_redacted: true,
+                event: 'sks.desktop_bridge.request_adapted',
+                code: 'bridge_request_include_dropped',
+                transport,
+                provider_id: route.provider_id,
+                field: change.field,
+                value,
+                count: entry.count,
+            })}\n`);
+        }
+        catch {
+        }
+    }
+}