sneakoscope 10.7.1 → 10.7.3

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.3**, 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.3"
 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.3"
 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-app.js

@@ -36,13 +36,13 @@ export async function run(_command, args = []) {
                 process.exitCode = 1;
             return;
         }
-        console.log(`Codex 1M Context: ${result.enabled ? 'enabled' : 'disabled'}`);
+        console.log(`Codex 1M Context: ${result.enabled === null ? 'unavailable' : result.enabled ? 'enabled' : 'disabled'}`);
         console.log(`Config: ${result.config_path}`);
         const window = result.model_window;
-        console.log(`Model: ${result.model || 'not set'}${window.effective_window ? ` · window ${window.effective_window} (default ${window.default_window ?? 'unknown'}, max ${window.max_window ?? 'uncapped'})` : ' · window unknown'}`);
+        console.log(`Model: ${result.enabled === null ? 'unavailable' : result.model || 'not set'}${window.effective_window ? ` · window ${window.effective_window} (default ${window.default_window ?? 'unknown'}, max ${window.max_window ?? 'uncapped'})` : ' · window unknown'}`);
         if (result.larger_window_models.length)
             console.log(`Models with a larger window: ${result.larger_window_models.join(', ')}`);
-        for (const [key, target] of Object.entries(result.target)) {
+        for (const [key, target] of result.keys ? Object.entries(result.target) : []) {
             const state = result.keys[key];
             const detail = state?.present ? `${state.value ?? 'unparsed'}${state.managed ? ' (SKS-managed)' : ''}` : 'not set';
             console.log(`${key}: ${detail} · target ${target}`);

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.3",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/codex-app/codex-context-window.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { exists, readText } from '../fsx.js';
+import { readText } from '../fsx.js';
 import { escapeRegExp } from '../text/regex.js';
 import { safeWriteCodexConfigToml } from '../codex-runtime/codex-desktop-config-policy.js';
 import { codexHomePath, codexUserConfigPath, readTopLevelTomlString } from './codex-model-catalog.js';
@@ -177,15 +177,28 @@ export async function codexContext1mCommand(args = [], opts = {}) {
     const action = normalizeCodexContext1mAction(args[0]);
     const noRestart = args.includes('--no-restart');
     const configPath = codexUserConfigPath({ env, ...(opts.home ? { home: opts.home } : {}) });
-    const before = String(await readText(configPath, ''));
-    const fileExists = await exists(configPath);
     const blockers = [];
     const warnings = [];
+    let before = '';
+    let fileExists = true;
+    let configReadable = true;
+    try {
+        before = await readText(configPath);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            fileExists = false;
+        }
+        else {
+            configReadable = false;
+            blockers.push('codex_context_config_unreadable');
+        }
+    }
     let write = null;
     let changed = false;
     let afterText = before;
     let mutation = null;
-    if (action === 'on' || action === 'off') {
+    if (configReadable && (action === 'on' || action === 'off')) {
         mutation = action === 'on' ? enableCodexContext1m(before) : disableCodexContext1m(before);
         blockers.push(...mutation.blockers);
         warnings.push(...mutation.warnings);
@@ -205,9 +218,11 @@ export async function codexContext1mCommand(args = [], opts = {}) {
     }
     const inspection = inspectCodexContext1m(afterText);
     warnings.push(...inspection.warnings);
-    const windowRows = await readCodexModelWindows({ env, ...(opts.home ? { home: opts.home } : {}) });
+    const windowRows = configReadable
+        ? await readCodexModelWindows({ env, ...(opts.home ? { home: opts.home } : {}) })
+        : [];
     const modelWindow = codexContextModelWindow(windowRows, inspection.model);
-    if (action === 'on' || inspection.enabled) {
+    if (configReadable && (action === 'on' || inspection.enabled)) {
         if (!inspection.model)
             warnings.push('codex_context_model_line_missing');
         else if (modelWindow.source === 'unknown')
@@ -235,7 +250,7 @@ export async function codexContext1mCommand(args = [], opts = {}) {
         schema: CODEX_CONTEXT_1M_SCHEMA,
         ok: blockers.length === 0,
         action,
-        enabled: inspection.enabled,
+        enabled: configReadable ? inspection.enabled : null,
         config_path: configPath,
         model: inspection.model,
         model_window: modelWindow,
@@ -243,7 +258,7 @@ export async function codexContext1mCommand(args = [], opts = {}) {
             .filter((row) => row.listed && row.max_window !== null && row.default_window !== null && row.max_window > row.default_window)
             .map((row) => row.slug),
         target: { ...CODEX_CONTEXT_1M_TARGETS },
-        keys: inspection.keys,
+        keys: configReadable ? inspection.keys : null,
         previous: mutation && action === 'on' ? mutation.previous : null,
         restored: mutation && action === 'off' ? mutation.restored : null,
         changed,

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-control/model-call-concurrency.js

@@ -83,15 +83,16 @@ class ModelCallSemaphoreImpl {
         }
         this.queued += 1;
         await new Promise((resolve) => this.waiters.push(resolve));
-        this.queued = Math.max(0, this.queued - 1);
-        this.active += 1;
-        this.maxObserved = Math.max(this.maxObserved, this.active);
     }
     release() {
-        this.active = Math.max(0, this.active - 1);
         const next = this.waiters.shift();
-        if (next)
+        if (next) {
+            this.queued -= 1;
             next();
+        }
+        else {
+            this.active = Math.max(0, this.active - 1);
+        }
     }
 }
 function envInt(name, fallback) {

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/capacity-retry-advice.js

@@ -67,23 +67,47 @@ function adviseSseEvents(events, onAdvised) {
     return Buffer.from(parts.join(''));
 }
 export function modelCapacityAdvisingSse(onAdvised) {
+    const maxEventBytes = 1024 * 1024;
     let carry = Buffer.alloc(0);
-    return new Transform({
+    let passthrough = false;
+    let endingBytes = 0;
+    const stream = new Transform({
         transform(chunk, _encoding, done) {
-            const data = carry.length ? Buffer.concat([carry, chunk]) : chunk;
-            const lf = data.lastIndexOf('\n\n');
-            const crlf = data.lastIndexOf('\r\n\r\n');
-            const end = Math.max(lf === -1 ? -1 : lf + 2, crlf === -1 ? -1 : crlf + 4);
-            if (end === -1) {
-                carry = data;
-                done();
-                return;
+            let advised = false;
+            let start = 0;
+            for (let index = 0; index < chunk.length; index += 1) {
+                endingBytes = ((endingBytes << 8) | chunk[index]) >>> 0;
+                if ((endingBytes & 0xffff) !== 0x0a0a && endingBytes !== 0x0d0a0d0a)
+                    continue;
+                append(chunk.subarray(start, index + 1));
+                if (!passthrough)
+                    this.push(adviseSseEvents(carry, () => { advised = true; }));
+                carry = Buffer.alloc(0);
+                passthrough = false;
+                endingBytes = 0;
+                start = index + 1;
             }
-            carry = data.subarray(end);
-            done(null, adviseSseEvents(data.subarray(0, end), onAdvised));
+            if (start < chunk.length)
+                append(chunk.subarray(start));
+            if (advised)
+                onAdvised();
+            done();
         },
         flush(done) {
             done(null, carry.length ? adviseSseEvents(carry, onAdvised) : null);
         },
     });
+    function append(part) {
+        if (passthrough || carry.length + part.length > maxEventBytes) {
+            if (carry.length)
+                stream.push(carry);
+            carry = Buffer.alloc(0);
+            passthrough = true;
+            stream.push(part);
+        }
+        else {
+            carry = carry.length ? Buffer.concat([carry, part]) : Buffer.from(part);
+        }
+    }
+    return stream;
 }

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