sneakoscope 10.7.0 → 10.7.2

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

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

package/dist/core/codex-lb/desktop-bridge/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 {
+        }
+    }
+}

package/dist/core/codex-lb/desktop-bridge/rejection-log.js

@@ -2,6 +2,58 @@ import { PACKAGE_VERSION } from '../../version.js';
 export const DESKTOP_BRIDGE_LOG_SCHEMA = 'sks.desktop-bridge-log.v2';
 export const REJECTION_LOG_BURST = 5;
 export const REJECTION_LOG_SUMMARY_INTERVAL_MS = 60_000;
+const SHAPE_TOKEN = /^[A-Za-z0-9_.[\]-]{1,64}$/;
+const MAX_SHAPE_KEYS = 64;
+const MAX_SHAPE_INCLUDE = 16;
+const MAX_SHAPE_INPUT_TYPES = 32;
+function shapeToken(value) {
+    return typeof value === 'string' && SHAPE_TOKEN.test(value) ? value : '<other>';
+}
+export function desktopBridgeRequestShape(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return null;
+    const request = payload;
+    const inputTypes = {};
+    if (Array.isArray(request.input)) {
+        for (const item of request.input) {
+            const type = item && typeof item === 'object' && !Array.isArray(item) ? shapeToken(item.type) : '<other>';
+            if (inputTypes[type] === undefined && Object.keys(inputTypes).length >= MAX_SHAPE_INPUT_TYPES)
+                continue;
+            inputTypes[type] = (inputTypes[type] ?? 0) + 1;
+        }
+    }
+    else if (typeof request.input === 'string')
+        inputTypes['<text>'] = 1;
+    return {
+        keys: Object.keys(request).map(shapeToken).sort().slice(0, MAX_SHAPE_KEYS),
+        include: Array.isArray(request.include) ? request.include.slice(0, MAX_SHAPE_INCLUDE).map(shapeToken) : null,
+        input_types: inputTypes,
+    };
+}
+function safeRequestShape(shape) {
+    if (!shape || !Array.isArray(shape.keys))
+        return null;
+    const inputTypes = {};
+    for (const [type, count] of Object.entries(shape.input_types ?? {}).slice(0, MAX_SHAPE_INPUT_TYPES)) {
+        if (Number.isSafeInteger(count) && count > 0)
+            inputTypes[shapeToken(type)] = count;
+    }
+    return {
+        keys: shape.keys.slice(0, MAX_SHAPE_KEYS).map(shapeToken),
+        include: Array.isArray(shape.include) ? shape.include.slice(0, MAX_SHAPE_INCLUDE).map(shapeToken) : null,
+        input_types: inputTypes,
+    };
+}
+function safeUpstreamId(value) {
+    const text = String(value ?? '').trim();
+    return /^[A-Za-z0-9_.:-]{1,64}$/.test(text) ? text : null;
+}
+export function safeUpstreamParam(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.slice(0, 64);
+    return /^[A-Za-z0-9_.[\]-]+$/.test(text) ? text : null;
+}
 function safeCatalogId(value) {
     const text = String(value ?? '').replace(/[\r\n\0]/g, '').trim().slice(0, 128);
     return text.length > 0 ? text : null;
@@ -69,6 +121,10 @@ export function createDesktopBridgeRejectionLogger(options = {}) {
         const method = safeMethod(event.method);
         const providerId = safeCatalogId(event.provider_id);
         const publicModel = safeCatalogId(event.public_model);
+        const upstreamCode = safeUpstreamId(event.upstream_code);
+        const upstreamType = safeUpstreamId(event.upstream_type);
+        const upstreamParam = safeUpstreamParam(event.upstream_param);
+        const requestShape = safeRequestShape(event.request_shape);
         emit({
             event: 'sks.desktop_bridge.rejected',
             code,
@@ -81,6 +137,11 @@ export function createDesktopBridgeRejectionLogger(options = {}) {
             ...(Number.isSafeInteger(event.max_request_body_bytes) && event.max_request_body_bytes > 0 ? { max_request_body_bytes: event.max_request_body_bytes } : {}),
             ...(Number.isSafeInteger(event.request_body_bytes) && event.request_body_bytes >= 0 ? { request_body_bytes: event.request_body_bytes } : {}),
             ...(event.request_body_stage === 'encoded' || event.request_body_stage === 'decoded' ? { request_body_stage: event.request_body_stage } : {}),
+            ...(Number.isInteger(event.upstream_status) && event.upstream_status >= 100 && event.upstream_status <= 599 ? { upstream_status: event.upstream_status } : {}),
+            ...(upstreamCode ? { upstream_code: upstreamCode } : {}),
+            ...(upstreamType ? { upstream_type: upstreamType } : {}),
+            ...(upstreamParam ? { upstream_param: upstreamParam } : {}),
+            ...(requestShape ? { request_shape: requestShape } : {}),
         });
     };
 }

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

@@ -1,14 +1,18 @@
 import net from 'node:net';
 import tls from 'node:tls';
 import WebSocket, { WebSocketServer } from 'ws';
-import { BRIDGE_OFFICIAL_ROUTE_ID } from '../bridge-contracts.js';
+import { BRIDGE_OFFICIAL_ROUTE_ID, BRIDGE_REMOTE_COMPACTION } from '../bridge-contracts.js';
 import { buildOfficialPassthroughWebSocketHeaders, buildProviderWebSocketHeaders } from './header-policy.js';
-import { createDesktopBridgeRejectionLogger } from './rejection-log.js';
-import { assertDesktopBridgeRouteContext, ensureDesktopBridgeRemoteTarget, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode } from './security.js';
+import { createDesktopBridgeRejectionLogger, desktopBridgeRequestShape } from './rejection-log.js';
+import { adaptRequestForRoute, logRequestAdaptation, providerExtraInclude } from './provider-request-compat.js';
+import { assertDesktopBridgeRouteContext, ensureDesktopBridgeRemoteTarget, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, threadRouteMove } from './security.js';
+import { admitCodexLbTurnState } from './codex-lb-turn-state.js';
+import { ProviderHandoffRefusedError, assertProviderHandoffAllowed, providerHandoffRefusedEvent, stripProviderBoundItems, } from './provider-handoff.js';
 import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError } from './types.js';
-import { buildCompactionSummaryRequest, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, ResponsesContinuationChain, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
+import { buildCompactionSummaryRequest, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, ResponsesContinuationChain, safeUpstreamErrorId, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
 import { requestProviderCompactionSummary } from './http-forward.js';
 import { modelCapacityAdvisedFrame } from './capacity-retry-advice.js';
+import { desktopBridgeModelsEtag, frameWithModelsEtag } from './models-endpoint.js';
 const MAX_PENDING_MESSAGES = 256;
 const CLOSE_GRACE_MS = 1_000;
 const INITIAL_CREATE_TIMEOUT_MS = 60 * 60_000;
@@ -20,6 +24,25 @@ export function isResponsesWebSocketRequest(req) {
 function bytes(data) {
     return Buffer.isBuffer(data) ? data : Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function upstreamFailureEvent(frame) {
+    if (!frame.includes('"response.failed"') && !frame.includes('"type":"error"') && !frame.includes('"type": "error"'))
+        return null;
+    let event;
+    try {
+        event = JSON.parse(frame.toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(event) || (event.type !== 'error' && event.type !== 'response.failed'))
+        return null;
+    const error = event.type === 'error' ? event.error : isRecord(event.response) ? event.response.error : null;
+    const record = isRecord(error) ? error : {};
+    return { status: typeof event.status === 'number' ? event.status : undefined, code: record.code, type: record.type, param: record.param };
+}
 function withLineage(identity, next) {
     return {
         ...identity,
@@ -32,6 +55,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
     const upgradeIdentity = resolveCodexSessionIdentity(req.headers);
     const maxBytes = config.maxRequestBodyBytes ?? DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES;
     const server = new WebSocketServer({ noServer: true, clientTracking: false, perMessageDeflate: false, maxPayload: maxBytes });
+    const modelsEtag = config.modelsCatalog ? desktopBridgeModelsEtag(config.modelsCatalog.generation) : null;
     try {
         server.handleUpgrade(req, socket, head, (client) => {
             bridge(client);
@@ -45,10 +69,12 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
         let upstream = null;
         let upstreamSocket = null;
         let bound = null;
+        let boundByMove = false;
         let boundBaseUrl = null;
         let boundCredentialGeneration = null;
         let boundCredentialFingerprint = null;
         let routedModel = null;
+        let routedShape = null;
         let stopped = false;
         let processing = false;
         let pendingBytes = 0;
@@ -126,26 +152,51 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             }
             identity = bound ? withLineage(identity, nextIdentity) : nextIdentity;
             const request = routeRequest(model);
-            assertBinding(assertDesktopBridgeRouteContext(request, config));
-            const route = await resolveAndBindDesktopBridgeRouteContext(request, config);
+            const planned = assertDesktopBridgeRouteContext(request, config);
+            assertProviderHandoffAllowed(message.create, threadRouteMove(request, planned, config));
+            assertBinding(planned);
+            let move = null;
+            const route = await resolveAndBindDesktopBridgeRouteContext(request, config, (resolved) => {
+                move = threadRouteMove(request, resolved, config);
+                assertProviderHandoffAllowed(message.create, move);
+            });
             if (stopped || client.readyState !== WebSocket.OPEN)
                 return;
             assertBinding(route);
             routedModel = route.public_model;
             if (!bound) {
                 bound = route;
+                boundByMove = Boolean(move);
                 await connect(route);
             }
             const create = { ...message.create, model: route.upstream_model };
-            const expanded = expandBridgeCompactionItems(create);
-            if (route.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID && requestsRemoteCompaction(create)) {
+            let rewritten = expandBridgeCompactionItems(create);
+            if (route.session_pin?.handoff_from && stripProviderBoundItems(create, Boolean(move)))
+                rewritten = true;
+            const adapted = adaptRequestForRoute(create, route, providerExtraInclude(config, route));
+            if (adapted.length) {
+                rewritten = true;
+                logRequestAdaptation(config, route, adapted, 'websocket');
+            }
+            if (BRIDGE_REMOTE_COMPACTION[route.provider_id] === 'bridge_summary' && requestsRemoteCompaction(create)) {
                 message.compaction = create;
                 return;
             }
-            if (route.upstream_model !== model || expanded)
+            if (route.upstream_model !== model || rewritten) {
                 message.data = Buffer.from(JSON.stringify(create));
+                message.binary = false;
+            }
             message.routed = create;
         }
+        function refuseMove(message, error) {
+            const model = typeof message.create?.model === 'string' ? message.create.model : '';
+            logRejection({ code: error.code, transport: 'websocket', ...(req.url ? { url: req.url } : {}) });
+            relay(client, Buffer.from(JSON.stringify(providerHandoffRefusedEvent(error, newCompactionResponseId(), model))), false);
+            const index = pending.indexOf(message);
+            if (index >= 0)
+                pending.splice(index, 1);
+            pendingBytes -= message.originalBytes;
+        }
         async function answerCompaction(create) {
             const route = bound;
             const provider = config.providers[route.provider_id];
@@ -160,7 +211,9 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                 send(compactionFailedEvent(responseId, route.public_model, 'bridge_compaction_history_unavailable'));
                 return;
             }
-            const body = Buffer.from(JSON.stringify(buildCompactionSummaryRequest({ ...create, input }, route.upstream_model)));
+            const summaryRequest = buildCompactionSummaryRequest({ ...create, input }, route.upstream_model);
+            adaptRequestForRoute(summaryRequest, route, providerExtraInclude(config, route));
+            const body = Buffer.from(JSON.stringify(summaryRequest));
             let accepted = false;
             try {
                 const call = await requestProviderCompactionSummary(config, { provider, credential, clientHeaders: req.headers, requestUrl: req.url || '/' }, body, () => {
@@ -192,6 +245,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
         }
         async function connect(route) {
             const official = route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID;
+            const summarizes = BRIDGE_REMOTE_COMPACTION[route.provider_id] === 'bridge_summary';
             const provider = route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID ? null : config.providers[route.provider_id];
             const remote = official ? config.officialRemote : provider?.remote;
             if (!remote)
@@ -209,6 +263,10 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             const target = resolveDesktopBridgeTarget(req.url, remote);
             const outgoing = official ? buildOfficialPassthroughWebSocketHeaders(req.headers, target.host)
                 : buildProviderWebSocketHeaders(req.headers, { providerId: provider.provider_id, authTransport: provider.auth_transport, credential: credential }, target.host);
+            if (boundByMove)
+                delete outgoing['x-codex-turn-state'];
+            else if (provider?.provider_id === 'codex-lb')
+                admitCodexLbTurnState(outgoing, identity.thread_id, credential.fingerprint);
             const headers = {};
             for (const [name, value] of Object.entries(outgoing)) {
                 if (name.startsWith('sec-websocket-') || name === 'connection' || name === 'upgrade' || name === 'content-length')
@@ -256,7 +314,22 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                     frame = advised;
                     logRejection({ code: 'bridge_upstream_model_capacity_retry_advised', transport: 'websocket', provider_id: route.provider_id, public_model: routedModel ?? route.public_model, ...(req.url ? { url: req.url } : {}) });
                 }
-                chain.received(frame);
+                const advertised = modelsEtag && !binary ? frameWithModelsEtag(frame, modelsEtag) : null;
+                if (advertised)
+                    frame = advertised;
+                const failure = binary ? null : upstreamFailureEvent(frame);
+                if (failure) {
+                    logRejection({
+                        code: 'bridge_upstream_request_rejected', transport: 'websocket',
+                        ...(failure.status === undefined ? {} : { status: failure.status, upstream_status: failure.status }),
+                        provider_id: route.provider_id, public_model: routedModel ?? route.public_model,
+                        upstream_code: safeUpstreamErrorId(failure.code), upstream_type: safeUpstreamErrorId(failure.type),
+                        upstream_param: typeof failure.param === 'string' ? failure.param : null,
+                        request_shape: routedShape, ...(req.url ? { url: req.url } : {}),
+                    });
+                }
+                if (summarizes)
+                    chain.received(frame);
                 try {
                     relay(client, frame, binary);
                 }
@@ -289,24 +362,43 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                 return;
             processing = true;
             try {
-                if (!bound) {
+                while (!bound) {
                     const firstCreate = pending.find((message) => message.create);
                     if (!firstCreate)
                         return;
-                    await resolveCreate(firstCreate);
+                    try {
+                        await resolveCreate(firstCreate);
+                    }
+                    catch (error) {
+                        if (!(error instanceof ProviderHandoffRefusedError))
+                            throw error;
+                        refuseMove(firstCreate, error);
+                        continue;
+                    }
                     firstCreate.create = null;
                 }
                 while (!stopped && client.readyState === WebSocket.OPEN && pending.length) {
                     const message = pending[0];
-                    if (message.create)
-                        await resolveCreate(message);
+                    if (message.create) {
+                        try {
+                            await resolveCreate(message);
+                        }
+                        catch (error) {
+                            if (!(error instanceof ProviderHandoffRefusedError))
+                                throw error;
+                            refuseMove(message, error);
+                            continue;
+                        }
+                    }
                     if (stopped || client.readyState !== WebSocket.OPEN)
                         return;
                     if (message.compaction)
                         await answerCompaction(message.compaction);
                     else {
                         relay(upstream, message.data, message.binary);
-                        if (message.routed && bound?.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID)
+                        if (message.routed)
+                            routedShape = desktopBridgeRequestShape(message.routed);
+                        if (message.routed && bound && BRIDGE_REMOTE_COMPACTION[bound.provider_id] === 'bridge_summary')
                             chain.sent(message.routed, message.data);
                     }
                     pending.shift();