Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(pi): preserve subscription auth failure handling

xuzini-xzn70e2bba63eaa
diff --cc apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.e2e.test.ts
index c4390e592b,0000000000..89388422ef
mode 100644,000000..100644
--- a/apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.e2e.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.e2e.test.ts
@@@ -1,214 -1,0 +1,242 @@@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { once } from 'node:events';
+import { existsSync } from 'node:fs';
+import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
+import { WebSocketServer } from 'ws';
+import sharp from 'sharp';
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+import { createAnthropicCompatProxy } from '@cindy/anthropic-compat-proxy';
+import { PI_NATIVE_PROVIDER_ADAPTER_SOURCE } from '../../../../../../packages/maker-core/src/agents/pi/native-provider-adapter-source.js';
+import { CINDY_BRIDGE_EXTENSION_SOURCE } from '../../../../../../packages/maker-core/src/agents/pi/cindy-bridge-source.js';
+
+vi.mock('../../appSessionState.js', () => ({ activeOwnerScopeKey: () => 'fixture-owner', isAppSessionBoundaryPending: () => false }));
+vi.mock('../codex-account-auth.js', () => ({ isOpenAiSubscriptionProviderId: (id: string) => id === 'openai' || id === 'account-b' }));
+vi.mock('../session-provider-store.js', () => ({ getSessionProvider: () => null, hasHostedSessionModelAccess: () => false }));
+vi.mock('../guest-provider-route-store.js', () => ({ guestProviderRouteForSession: () => null }));
- vi.mock('../anthropic-responses-bridge-host.js', () => ({ getChatgptBridgeAuthForDispatch: vi.fn() }));
++vi.mock('../anthropic-responses-bridge-host.js', () => ({ getChatgptBridgeAuthForDispatch: vi.fn(), invalidateChatgptBridgeAuth: vi.fn(async () => false) }));
+const fastPolicy = vi.hoisted(() => ({ allowed: true }));
+vi.mock('../subscription-fast-request-policy.js', () => ({ subscriptionRequestAllowsFast: () => fastPolicy.allowed }));
+import { createPiWebSocketRequestPreparer, resolvePiWebSocketUpstream, piWebSocketTransforms } from '../pi-subscription-websocket.js';
+import { registerPiProxySession } from '../pi-proxy-session-auth.js';
+
+const binary = process.env.CINDY_TEST_PI_BINARY ?? resolve('../../apps/pi-bin', `${process.platform}-${process.arch}`, process.platform === 'win32' ? 'pi.exe' : 'pi');
+const fastHookStart = CINDY_BRIDGE_EXTENSION_SOURCE.indexOf('async function nativeFastPayload(');
+const fastHookEnd = CINDY_BRIDGE_EXTENSION_SOURCE.indexOf('type CindyAdapterAlias', fastHookStart);
+if (fastHookStart < 0 || fastHookEnd <= fastHookStart) throw new Error('Production Fast hook fixture is unavailable');
+const fastHookSource = CINDY_BRIDGE_EXTENSION_SOURCE.slice(fastHookStart, fastHookEnd);
+let image: string;
+
+function responseEvents(index: number, tool: boolean) {
+ const item = tool
+ ? { type: 'function_call', id: `fc_${index}`, call_id: `call_${index}`, name: 'fixture_probe', arguments: '{}', status: 'completed' }
+ : { type: 'message', id: `msg_${index}`, role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: 'fixture-complete', annotations: [], logprobs: [] }] };
+ const response = { id: `resp_${index}`, status: 'completed', output: [item], model: 'gpt-6-astra',
+ usage: { input_tokens: 100, input_tokens_details: { cached_tokens: index ? 90 : 0 }, output_tokens: 5, output_tokens_details: { reasoning_tokens: 0 }, total_tokens: 105 } };
+ return [
+ { type: 'response.created', response: { ...response, status: 'in_progress', output: [], usage: null } },
+ { type: 'response.output_item.added', output_index: 0, item: { ...item, ...(tool ? { arguments: '' } : { content: [] }) } },
+ ...(tool
+ ? [{ type: 'response.function_call_arguments.delta', output_index: 0, delta: '{}' }, { type: 'response.function_call_arguments.done', output_index: 0, arguments: '{}' }]
+ : [{ type: 'response.content_part.added', output_index: 0, content_index: 0, part: { type: 'output_text', text: '', annotations: [] } },
+ { type: 'response.output_text.delta', output_index: 0, content_index: 0, delta: 'fixture-complete' },
+ { type: 'response.output_text.done', output_index: 0, content_index: 0, text: 'fixture-complete' }]),
+ { type: 'response.output_item.done', output_index: 0, item },
+ { type: 'response.completed', response },
+ ];
+}
+
+describe.skipIf(!existsSync(binary))('actual Pi subscription incremental transport', () => {
+ beforeAll(async () => {
+ image = (await sharp(randomBytes(512 * 512 * 3), { raw: { width: 512, height: 512, channels: 3 } }).png().toBuffer()).toString('base64');
+ });
+ it.each([
+ { label: 'standard', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: false },
+ { label: 'fast and context profile', source: 'openai', provider: 'openai-codex', fast: true, fallback: false, reconnect: false },
+ { label: 'independent account', source: 'account-b', provider: 'openai-codex-account', fast: false, fallback: false, reconnect: false },
+ { label: 'reconnect', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: true },
+ { label: 'native SSE fallback', source: 'openai', provider: 'openai-codex', fast: false, fallback: true, reconnect: false },
++ // Regression #7427: exercise the native 1009 fallback on the first request,
++ // a reused connection and reconnect, without rewriting or discarding history.
++ { label: 'oversized first history', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: false, oversized: 'initial' },
++ { label: 'oversized reused socket', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: false, oversized: 'tool' },
++ { label: 'oversized reconnect history', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: true, oversized: 'reconnect' },
+ { label: 'original SSE baseline', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: false, baseline: true },
+ { label: 'live Fast change', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: false, toggleFast: true },
+ { label: 'Fast restriction between tool steps', source: 'openai', provider: 'openai-codex', fast: true, fallback: false, reconnect: false, restrictFast: true },
+ { label: 'missing continuation', source: 'openai', provider: 'openai-codex', fast: false, fallback: false, reconnect: false, missingContinuation: true },
+ ])('preserves tool/image history and native recovery: $label', async scenario => {
+ fastPolicy.allowed = true;
+ const directory = await mkdtemp(join(tmpdir(), 'cindy-pi-ws-'));
+ const requests: Array<Record<string, any>> = [];
+ const handshakes: Array<Record<string, any>> = [];
- const ws = new WebSocketServer({ noServer: true });
++ const uploads: Array<{ transport: string; bytes: number }> = [];
++ const ws = new WebSocketServer({ noServer: true, maxPayload: 16 * 1024 * 1024 });
+ let acknowledgeDisconnect!: () => void;
+ const disconnected = new Promise<void>(resolve => { acknowledgeDisconnect = resolve; });
+ const upstream = createServer((_req, res) => { void disconnected.then(() => res.end('closed')); });
+ let connections = 0;
+ let continuationRejected = false;
+ upstream.on('upgrade', (req, socket, head) => {
+ handshakes.push({ ...req.headers });
+ if (scenario.fallback) { socket.end('HTTP/1.1 426 Upgrade Required\r\nConnection: close\r\n\r\n'); return; }
+ connections++;
+ ws.handleUpgrade(req, socket, head, client => {
+ client.once('close', acknowledgeDisconnect);
++ // A real upstream rejects oversized messages with close 1009.
++ client.on('error', () => {});
+ client.on('message', async raw => {
++ uploads.push({ transport: 'websocket', bytes: Buffer.byteLength(raw.toString()) });
+ const body = JSON.parse(raw.toString());
+ const index = requests.length - (continuationRejected ? 1 : 0);
+ requests.push(body);
+ if (scenario.missingContinuation && index === 2 && !continuationRejected) {
+ continuationRejected = true;
+ client.send(JSON.stringify({ type: 'error', code: 'previous_response_not_found', message: 'Fixture continuation expired' }));
+ return;
+ }
+ if (scenario.toggleFast && index === 0) await writeFile(join(directory, 'options.json'), JSON.stringify({ fast: true }));
+ if (scenario.restrictFast && index === 0) fastPolicy.allowed = false;
+ for (const event of responseEvents(index, index < 3)) client.send(JSON.stringify(event));
+ if (scenario.reconnect && index === 1) client.close();
+ });
+ });
+ });
+ await new Promise<void>(resolve => upstream.listen(0, '127.0.0.1', resolve));
+ const upstreamUrl = `http://127.0.0.1:${(upstream.address() as import('node:net').AddressInfo).port}`;
+ const closeAuth = registerPiProxySession('fixture-session', 'fixture-token', () => scenario.source);
+ const prepare = createPiWebSocketRequestPreparer(async () => ({ accessToken: 'fixture-upstream-token', accountId: 'fixture-upstream-account', canDispatch: () => true }));
+ const proxy = await createAnthropicCompatProxy({
+ upstream: upstreamUrl, transformRequest: [],
+ resolveWebSocketUpstream: ctx => resolvePiWebSocketUpstream(ctx) ? upstreamUrl : null,
+ prepareWebSocketRequest: prepare,
+ webSocketTransforms: piWebSocketTransforms,
+ routingTransform: () => ({ localHandler: async ({ rawBody, parsedBody, ctx, res }) => {
+ const index = requests.length;
++ uploads.push({ transport: 'sse', bytes: rawBody.length });
+ const decoded = parsedBody ?? JSON.parse((ctx.headers['content-encoding'] === 'zstd' ? zstdDecompressSync(rawBody) : rawBody).toString());
+ requests.push({ ...decoded, fallback: true });
+ res.writeHead(200, { 'content-type': 'text/event-stream' });
+ for (const event of responseEvents(index, index < 3)) res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+ res.end();
+ } }),
+ });
+ let child: ReturnType<typeof spawn> | undefined;
+ try {
+ const model = scenario.fast ? 'gpt-6-astra[1m]' : 'gpt-6-astra';
+ const key = `fixture.${Buffer.from(JSON.stringify({ 'https://api.openai.com/auth': { chatgpt_account_id: 'child-placeholder' } })).toString('base64url')}.fixture`;
+ await writeFile(join(directory, 'models.json'), JSON.stringify({ providers: { [scenario.provider]: {
+ baseUrl: proxy.url, api: 'openai-codex-responses', apiKey: '$CINDY_FIXTURE_KEY',
+ headers: { 'x-cindy-pi-session-id': 'fixture-session', 'x-cindy-pi-session-token': 'fixture-token', 'x-cindy-pi-provider-id': scenario.source },
+ models: [{ id: model, name: 'Fixture', api: 'openai-codex-responses', contextWindow: 2_000_000, maxTokens: 4096, input: ['text', 'image'], reasoning: false,
+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } }],
+ } } }));
+ await writeFile(join(directory, 'auth.json'), '{}');
+ await writeFile(join(directory, 'options.json'), JSON.stringify({ fast: scenario.fast }));
+ // Keep the global setting at SSE: only the production subscription adapter may override it.
+ await writeFile(join(directory, 'settings.json'), JSON.stringify({ transport: 'sse', retry: { enabled: false } }));
+ await writeFile(join(directory, 'adapter.ts'), PI_NATIVE_PROVIDER_ADAPTER_SOURCE + '\n' + fastHookSource + `
+import { Type } from '@earendil-works/pi-ai';
+import { readFileSync } from 'node:fs';
+export default async function(pi: any) {
+ await registerCindyNativeProviderAdapters(pi);
+ if (!${Boolean(scenario.baseline)}) pi.on('before_provider_request', (event, ctx) => nativeFastPayload(event.payload, ctx.model, {
+ ui: { input: async () => JSON.stringify(JSON.parse(readFileSync(process.env.CINDY_FIXTURE_OPTIONS_FILE, 'utf8'))) },
+ }));
+ let count = 0;
+ pi.registerTool({ name: 'fixture_probe', label: 'Fixture', description: 'Fixture probe', parameters: Type.Object({}),
+ execute: async () => {
+ ++count;
+ if (${scenario.reconnect} && count === 2) await fetch('${upstreamUrl}/wait-for-disconnect');
++ if ((${JSON.stringify(scenario.oversized)} === 'tool' && count === 1) || (${JSON.stringify(scenario.oversized)} === 'reconnect' && count === 2)) {
++ return { content: Array.from({ length: 20 }, () => ({ type: 'image', data: '${image}', mimeType: 'image/png' })), details: {} };
++ }
+ return { content: count === 1
+ ? [{ type: 'image', data: '${image}', mimeType: 'image/png' }]
+ : [{ type: 'text', text: 'fixture-tool-ok' }], details: {} };
+ } });
+}
+`);
+ // Supply the large initial history through a file rather than exceeding argv limits.
- await writeFile(join(directory, 'prompt.txt'), 'Run the fixture tool.\n' + 'fixture-context '.repeat(65_536));
++ await writeFile(join(directory, 'prompt.txt'), 'Run the fixture tool.\n' + 'fixture-context '.repeat(scenario.oversized === 'initial' ? 1_200_000 : 65_536));
+ child = spawn(binary, ['--print', '--mode', 'json', '--no-session', '--no-extensions', '--extension', join(directory, 'adapter.ts'),
+ '--provider', scenario.provider, '--model', model, `@${join(directory, 'prompt.txt')}`], {
+ cwd: directory, env: { ...process.env, HOME: directory, PI_CODING_AGENT_DIR: directory, PI_OFFLINE: '1',
+ CINDY_FIXTURE_KEY: key, CINDY_FIXTURE_OPTIONS_FILE: join(directory, 'options.json'),
+ CINDY_PI_FAST_MODELS: JSON.stringify([{ provider: scenario.provider, id: model }]),
+ CINDY_PI_NATIVE_PROVIDER_ADAPTERS: JSON.stringify([{ id: scenario.provider, provider: scenario.provider, cachedCodex: !scenario.baseline, keyEnv: 'CINDY_FIXTURE_KEY' }]),
+ }, stdio: ['ignore', 'pipe', 'pipe'],
+ });
+ let output = ''; let errors = '';
+ child.stdout!.on('data', chunk => { output += chunk; });
+ child.stderr!.on('data', chunk => { errors += chunk; });
+ const timer = setTimeout(() => child?.kill(), 20_000);
+ const [exit] = await once(child, 'exit'); clearTimeout(timer);
+ expect(exit, errors + output.slice(-3000)).toBe(0);
+ expect(output).toContain('fixture-complete');
++ // Body bytes observed at the receiving endpoint: WS JSON versus native
++ // zstd SSE. Excludes handshake, RFC6455, HTTP and TLS framing overhead.
++ console.info('Pi fixture request body bytes', JSON.stringify({ scenario: scenario.label, uploads }));
+ expect(requests).toHaveLength(scenario.missingContinuation ? 5 : 4);
+ if (scenario.baseline) {
+ expect(handshakes).toHaveLength(0);
+ expect(requests.every(body => body.fallback && !body.previous_response_id && JSON.stringify(body).length > 900_000)).toBe(true);
+ expect(JSON.stringify(requests[3].input)).toContain('data:image/png;base64,');
++ } else if (scenario.oversized) {
++ const firstFallback = requests.findIndex(body => body.fallback);
++ expect(firstFallback, JSON.stringify(requests.map(body => ({ fallback: body.fallback, bytes: Buffer.byteLength(JSON.stringify(body)), previous: body.previous_response_id })))).toBe(scenario.oversized === 'initial' ? 0 : scenario.oversized === 'tool' ? 1 : 2);
++ expect(requests.slice(firstFallback).every(body => body.fallback && !body.previous_response_id)).toBe(true);
++ expect(Buffer.byteLength(JSON.stringify(requests[firstFallback]))).toBeGreaterThan(16 * 1024 * 1024);
++ expect(requests.filter(body => !body.fallback).every(body => Buffer.byteLength(JSON.stringify(body)) <= 15 * 1024 * 1024)).toBe(true);
++ expect(handshakes).toHaveLength(scenario.reconnect ? 2 : 1);
++ expect(JSON.stringify(requests.at(-1)!.input)).toContain('data:image/png;base64,');
++ if (scenario.oversized === 'initial') expect(JSON.stringify(requests.at(-1)!.input)).toContain('fixture-context');
++ else expect(JSON.stringify(requests.at(-1)!.input).match(/data:image\/png;base64,/g)).toHaveLength(scenario.oversized === 'reconnect' ? 21 : 20);
+ } else if (scenario.fallback) {
+ expect(requests.every(body => body.fallback)).toBe(true);
+ } else {
+ for (const [index, body] of requests.entries()) {
+ const tier = scenario.restrictFast && index > 0 ? 'default'
+ : scenario.fast || (scenario.toggleFast && index > 0) ? 'priority' : undefined;
+ expect(body.model).toBe('gpt-6-astra');
+ expect(body.service_tier, `request ${index}`).toBe(tier);
+ }
+ expect(JSON.stringify(requests[0]).length).toBeGreaterThan(900_000);
+ expect(JSON.stringify(requests[1].input)).toContain('data:image/png;base64,');
+ expect(requests[1].previous_response_id).toBe(scenario.toggleFast ? undefined : 'resp_0');
+ const last = requests.at(-1)!;
+ expect(last.previous_response_id).toBe('resp_2');
+ expect(JSON.stringify(last).length).toBeLessThan(20_000);
++ expect(uploads.at(-1)).toMatchObject({ transport: 'websocket' });
++ expect(uploads.at(-1)!.bytes).toBeLessThan(20_000);
+ expect(JSON.stringify(last.input)).not.toContain('data:image/png;base64,');
+ if (scenario.reconnect) {
+ expect(connections).toBe(2);
+ expect(requests[2].previous_response_id).toBeUndefined();
+ expect(JSON.stringify(requests[2].input)).toContain('data:image/png;base64,');
+ } else if (scenario.missingContinuation) {
+ expect(requests[2].previous_response_id).toBe('resp_1');
+ expect(requests[3].previous_response_id).toBeUndefined();
+ expect(JSON.stringify(requests[3].input)).toContain('data:image/png;base64,');
+ } else {
+ expect(connections).toBe(1);
+ expect(requests[2].previous_response_id).toBe('resp_1');
+ expect(JSON.stringify(requests[2].input)).not.toContain('data:image/png;base64,');
+ }
+ }
+ if (!scenario.baseline) {
+ expect(handshakes[0]).toMatchObject({ authorization: 'Bearer fixture-upstream-token', 'chatgpt-account-id': 'fixture-upstream-account' });
+ expect(Object.keys(handshakes[0]).some(key => key.startsWith('x-cindy-'))).toBe(false);
+ }
+ } finally {
+ child?.kill(); closeAuth(); await proxy.dispose();
+ for (const client of ws.clients) client.terminate(); ws.close();
+ upstream.closeAllConnections(); await new Promise<void>(resolve => upstream.close(() => resolve()));
+ await rm(directory, { recursive: true, force: true });
+ }
+ }, 30_000);
+});
diff --cc apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.test.ts
index 0df3d80040,0000000000..7cc51b93eb
mode 100644,000000..100644
--- a/apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.test.ts
@@@ -1,147 -1,0 +1,203 @@@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createWebSocketMessageTransform } from '@cindy/anthropic-compat-proxy';
+
+const state = vi.hoisted(() => ({ owner: 'owner-a', pending: false, provider: 'openai' as string | null, guest: false, hosted: false, fastAllowed: true }));
+vi.mock('../../appSessionState.js', () => ({ activeOwnerScopeKey: () => state.owner, isAppSessionBoundaryPending: () => state.pending }));
+vi.mock('../codex-account-auth.js', () => ({ isOpenAiSubscriptionProviderId: (id: string) => id === 'openai' || id === 'account-b' }));
+vi.mock('../session-provider-store.js', () => ({ getSessionProvider: () => state.provider, hasHostedSessionModelAccess: () => state.hosted }));
+vi.mock('../guest-provider-route-store.js', () => ({ guestProviderRouteForSession: () => state.guest ? {} : null }));
- vi.mock('../anthropic-responses-bridge-host.js', () => ({ getChatgptBridgeAuthForDispatch: vi.fn() }));
++vi.mock('../anthropic-responses-bridge-host.js', () => ({ getChatgptBridgeAuthForDispatch: vi.fn(), invalidateChatgptBridgeAuth: vi.fn(async () => false) }));
+
+vi.mock('../subscription-fast-request-policy.js', () => ({ subscriptionRequestAllowsFast: vi.fn(() => state.fastAllowed) }));
+
+import { subscriptionRequestAllowsFast } from '../subscription-fast-request-policy.js';
+import { createPiWebSocketRequestPreparer, resolvePiWebSocketUpstream, piWebSocketTransforms } from '../pi-subscription-websocket.js';
+import { registerPiProxySession, resetPiProxySessionsForTest } from '../pi-proxy-session-auth.js';
+
+const context = (provider = 'openai', token = 'fixture-token') => ({ url: '/codex/responses', headers: {
+ 'x-cindy-pi-session-id': 'fixture-session', 'x-cindy-pi-session-token': token,
+ 'x-cindy-pi-provider-id': provider, authorization: 'Bearer child-placeholder',
+ 'chatgpt-account-id': 'child-placeholder', session_id: 'native-session',
+ 'sec-websocket-key': 'fixture-handshake', 'sec-websocket-version': '13',
+ 'openai-beta': 'responses_websockets=2026-02-06',
+} });
+
+function frame(body: unknown): Buffer {
+ const payload = Buffer.from(JSON.stringify(body));
+ const mask = Buffer.from([1, 2, 3, 4]);
+ const header = Buffer.alloc(payload.length < 126 ? 6 : 8);
+ header[0] = 129; header[1] = 128 | (payload.length < 126 ? payload.length : 126);
+ if (payload.length >= 126) header.writeUInt16BE(payload.length, 2);
+ mask.copy(header, header.length - 4);
+ for (let i = 0; i < payload.length; i++) payload[i] ^= mask[i % 4]!;
+ return Buffer.concat([header, payload]);
+}
+
+describe('Pi subscription WebSocket routing', () => {
+ beforeEach(() => {
+ resetPiProxySessionsForTest();
+ state.owner = 'owner-a'; state.pending = false; state.provider = 'openai';
+ state.guest = false; state.hosted = false; state.fastAllowed = true;
+ });
+
+ // Regression #7427: the native Fast intent can remain true before the policy poll.
+ // A reused socket must enforce the live account/task restriction on the actual request.
+ it('downgrades stale Fast intent on reused sockets and preserves unrelated messages', async () => {
+ registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ const { outbound, inbound } = piWebSocketTransforms(context());
+ const messages: unknown[] = [];
+ const decode = createWebSocketMessageTransform(true, bytes => {
+ messages.push(JSON.parse(bytes.toString())); return bytes;
+ });
+ outbound.pipe(decode); decode.resume();
+ const send = (body: unknown) => new Promise<void>((resolve, reject) =>
+ outbound.write(frame(body), error => error ? reject(error) : resolve()));
+ try {
+ const request = { type: 'response.create', model: 'gpt-6-astra', service_tier: 'priority', previous_response_id: 'resp_fixture', input: [{ type: 'function_call_output', call_id: 'call_fixture', output: 'next' }] };
+ await send(request);
+ expect(messages.at(-1)).toEqual(request);
+ state.fastAllowed = false; // No timer, setFastMode, or notification has run.
+ await send(request);
+ expect(messages.at(-1)).toEqual({ ...request, service_tier: 'default' });
+ expect(subscriptionRequestAllowsFast).toHaveBeenLastCalledWith('fixture-session', 'openai');
+ const cancel = { type: 'response.cancel', response_id: 'resp_fixture' };
+ await send(cancel); expect(messages.at(-1)).toEqual(cancel);
+ state.fastAllowed = true;
+ await send({ ...request, service_tier: 'default' });
+ expect(messages.at(-1)).toEqual({ ...request, service_tier: 'default' });
+ } finally { outbound.destroy(); inbound.destroy(); decode.destroy(); }
+ });
+
++ // Regression #7427: a WS refusal must use the token proof captured for that
++ // connection, while late failures from replaced credentials are ignored.
++ it('invalidates explicit handshake authentication errors only for the current account proof', async () => {
++ state.provider = 'account-b';
++ registerPiProxySession('fixture-session', 'fixture-token', () => 'account-b');
++ let current = true;
++ const invalidate = vi.fn(async (_failure: { status: number; body: string; failedAccessToken: string }, _provider?: string) => true);
++ const prepared = await createPiWebSocketRequestPreparer(async () => ({
++ accessToken: 'fixture-rejected-token', accountId: null, canDispatch: () => current,
++ }), invalidate)(context('account-b'));
++ await prepared.onUpgradeFailure!(401, '{"error":{"code":"token_revoked"}}');
++ expect(invalidate).toHaveBeenCalledExactlyOnceWith({ status: 401,
++ body: '{"error":{"code":"token_revoked"}}', failedAccessToken: 'fixture-rejected-token' }, 'account-b');
++ invalidate.mockClear();
++ await prepared.onUpgradeFailure!(401, '{"error":"unauthorized"}');
++ await prepared.onUpgradeFailure!(403, '{"error":"permission denied"}');
++ current = false;
++ await prepared.onUpgradeFailure!(401, '{"error":{"code":"token_revoked"}}');
++ current = true; state.owner = 'owner-b';
++ await prepared.onUpgradeFailure!(401, '{"error":{"code":"token_revoked"}}');
++ expect(invalidate).not.toHaveBeenCalled();
++ });
++
++ it.each([
++ { type: 'error', status: 401, error: { code: 'token_revoked' } },
++ { type: 'error', error: { code: 'token_invalidated', status: 401 } },
++ { type: 'error', error: { code: 'token_revoked' } },
++ { type: 'response.failed', response: { error: { code: 'token_revoked', status: 401 } } },
++ ])('observes established WS authentication failures and preserves the response: %j', async event => {
++ registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
++ const invalidate = vi.fn(async (_failure: { status: number; body: string; failedAccessToken: string }, _provider?: string) => true);
++ const prepared = await createPiWebSocketRequestPreparer(async () => ({
++ accessToken: 'fixture-rejected-token', accountId: null, canDispatch: () => true,
++ }), invalidate)(context());
++ const transforms = prepared.transforms!();
++ const inbound = transforms.inbound;
++ const observed: unknown[] = [];
++ const decode = createWebSocketMessageTransform(false, message => {
++ observed.push(JSON.parse(message.toString())); return message;
++ });
++ inbound.pipe(decode); decode.resume();
++ const send = async (body: unknown) => {
++ const payload = Buffer.from(JSON.stringify(body));
++ const header = payload.length < 126 ? Buffer.from([129, payload.length]) : Buffer.from([129, 126, payload.length >> 8, payload.length & 255]);
++ await new Promise<void>((resolve, reject) => inbound.write(Buffer.concat([header, payload]), error => error ? reject(error) : resolve()));
++ };
++ try {
++ await send({ type: 'response.output_text.delta', delta: 'token_revoked' });
++ expect(invalidate).not.toHaveBeenCalled();
++ await send(event);
++ expect(invalidate).toHaveBeenCalledOnce();
++ expect(invalidate.mock.calls[0]![0]).toMatchObject({ status: 401, failedAccessToken: 'fixture-rejected-token' });
++ expect(observed.at(-1)).toEqual(event);
++ } finally { inbound.destroy(); transforms.outbound.destroy(); decode.destroy(); }
++ });
++
+ it('keeps hosted and shared-provider routes on HTTP for live per-model authorization', () => {
+ registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ state.guest = true; expect(resolvePiWebSocketUpstream(context())).toBeNull();
+ state.guest = false; state.hosted = true; expect(resolvePiWebSocketUpstream(context())).toBeNull();
+ });
+
+ it('rejects forged, wrong-provider, expired, non-subscription and wrong-path requests', () => {
+ expect(resolvePiWebSocketUpstream(context())).toBeNull();
+ const close = registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ expect(resolvePiWebSocketUpstream(context())).toBe('https://chatgpt.com/backend-api');
+ expect(resolvePiWebSocketUpstream(context('openai', 'forged'))).toBeNull();
+ expect(resolvePiWebSocketUpstream(context('account-b'))).toBeNull();
+ expect(resolvePiWebSocketUpstream(context('xai'))).toBeNull();
+ expect(resolvePiWebSocketUpstream({ ...context(), url: '/messages' })).toBeNull();
+ state.provider = 'account-b'; expect(resolvePiWebSocketUpstream(context())).toBeNull();
+ state.provider = 'openai'; state.pending = true; expect(resolvePiWebSocketUpstream(context())).toBeNull();
+ state.pending = false; close(); expect(resolvePiWebSocketUpstream(context())).toBeNull();
+ });
+
+ it('injects the selected account, preserves the native session and strips local secrets', async () => {
+ state.provider = 'account-b';
+ const close = registerPiProxySession('fixture-session', 'fixture-token', () => 'account-b');
+ const read = vi.fn(async () => ({ accessToken: 'fixture-upstream-token', accountId: 'fixture-upstream-account', canDispatch: () => true }));
+ const prepared = await createPiWebSocketRequestPreparer(read)(context('account-b'));
+ expect(read).toHaveBeenCalledWith('account-b');
+ expect(prepared.headers).toMatchObject({ authorization: 'Bearer fixture-upstream-token',
+ 'chatgpt-account-id': 'fixture-upstream-account', session_id: 'native-session',
+ 'openai-beta': 'responses_websockets=2026-02-06', 'sec-websocket-key': 'fixture-handshake' });
+ expect(Object.keys(prepared.headers).some(key => key.startsWith('x-cindy-'))).toBe(false);
+ expect(prepared.signal.aborted).toBe(false);
+ close(); expect(prepared.signal.aborted).toBe(true);
+ });
+
+ it('rejects revoked or replaced native OAuth proof during establishment and socket reuse', async () => {
+ registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ let connected = true;
+ const prepare = createPiWebSocketRequestPreparer(async () => ({ accessToken: 'fixture-token', accountId: null, canDispatch: () => connected }));
+ const prepared = await prepare(context());
+ expect(prepared.authorize?.()).toBe(true);
+ connected = false;
+ expect(prepared.authorize?.()).toBe(false);
+ await expect(prepare(context())).rejects.toThrow('PI_WEBSOCKET_ROUTE_CHANGED');
+ });
+
+ it.each(['owner', 'pending', 'provider', 'guest', 'hosted'])('rejects %s changes on an already established socket', async kind => {
+ registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ const prepared = await createPiWebSocketRequestPreparer(async () => ({ accessToken: 'fixture-token', accountId: null, canDispatch: () => true }))(context());
+ expect(prepared.authorize?.()).toBe(true);
+ if (kind === 'owner') state.owner = 'owner-b';
+ if (kind === 'pending') state.pending = true;
+ if (kind === 'provider') state.provider = 'account-b';
+ if (kind === 'guest') state.guest = true;
+ if (kind === 'hosted') state.hosted = true;
+ expect(prepared.authorize?.()).toBe(false);
+ });
+
+ it.each(['owner', 'pending', 'provider', 'revoked', 'replaced'])('revalidates %s changes while authentication is pending', async kind => {
+ const close = registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ const read = vi.fn(async () => {
+ if (kind === 'owner') state.owner = 'owner-b';
+ if (kind === 'pending') state.pending = true;
+ if (kind === 'provider') state.provider = 'account-b';
+ if (kind === 'revoked') close();
+ if (kind === 'replaced') registerPiProxySession('fixture-session', 'fixture-token', () => 'openai');
+ return { accessToken: 'fixture-token', accountId: null, canDispatch: () => true };
+ });
+ await expect(createPiWebSocketRequestPreparer(read)(context())).rejects.toThrow('PI_WEBSOCKET_ROUTE_CHANGED');
+ });
+
+ it('keeps provider-scoped children independent of the parent route and token lifetime', async () => {
+ const closeParent = registerPiProxySession('fixture-session', 'parent-token', () => 'openai');
+ registerPiProxySession('fixture-session', 'fixture-token', () => 'account-b', { scope: 'subagent-route' });
+ const prepared = await createPiWebSocketRequestPreparer(async () => ({ accessToken: 'fixture-token', accountId: null, canDispatch: () => true }))(context('account-b'));
+ closeParent(); expect(prepared.signal.aborted).toBe(false);
+ expect(resolvePiWebSocketUpstream(context('account-b'))).toBe('https://chatgpt.com/backend-api');
+ });
+});
diff --cc apps/desktop/src/main/maker-host/pi-subscription-websocket.ts
index 9d3a9b9dec,0000000000..7953c782b5
mode 100644,000000..100644
--- a/apps/desktop/src/main/maker-host/pi-subscription-websocket.ts
+++ b/apps/desktop/src/main/maker-host/pi-subscription-websocket.ts
@@@ -1,79 -1,0 +1,107 @@@
+import { PassThrough } from 'node:stream';
+import { standardSpeedRequest } from '@cindy/maker-core';
+import { subscriptionRequestAllowsFast } from './subscription-fast-request-policy.js';
+import { createWebSocketMessageTransform, type ProxyOptions } from '@cindy/anthropic-compat-proxy';
+import { activeOwnerScopeKey, isAppSessionBoundaryPending } from '../appSessionState.js';
- import { getChatgptBridgeAuthForDispatch } from './anthropic-responses-bridge-host.js';
++import { getChatgptBridgeAuthForDispatch, invalidateChatgptBridgeAuth } from './anthropic-responses-bridge-host.js';
+import { isOpenAiSubscriptionProviderId } from './codex-account-auth.js';
++import { detectChatgptBridgeAuthInvalidationReason } from './chatgpt-bridge-auth-invalidation.js';
+import { buildChatgptBridgeHeaders } from './chatgpt-bridge-headers.js';
+import {
+ authenticatePiProxySession,
+ getPiProxySessionProvider,
+ getPiProxySessionSignal,
+ isPiProxySubagentRoute,
+} from './pi-proxy-session-auth.js';
+import { getSessionProvider, hasHostedSessionModelAccess } from './session-provider-store.js';
+import { guestProviderRouteForSession } from './guest-provider-route-store.js';
+
+type Context = Parameters<NonNullable<ProxyOptions['resolveWebSocketUpstream']>>[0];
+
+function authenticatedRoute({ url, headers }: Context): { sessionId: string; providerId: string; signal: AbortSignal } | null {
+ if (url !== '/codex/responses' || isAppSessionBoundaryPending()) return null;
+ const sessionId = headers['x-cindy-pi-session-id'];
+ const token = headers['x-cindy-pi-session-token'];
+ const providerId = headers['x-cindy-pi-provider-id'];
+ if (!sessionId || !token || !isOpenAiSubscriptionProviderId(providerId)
+ || !authenticatePiProxySession(sessionId, token)
+ || getPiProxySessionProvider(sessionId, token) !== providerId) return null;
+ // These routes require a live per-model grant check for every request body.
+ // A transparent socket tunnel cannot enforce that contract.
+ if (guestProviderRouteForSession(sessionId) || hasHostedSessionModelAccess(sessionId)) return null;
+ const selectedProvider = getSessionProvider(sessionId);
+ if (!isPiProxySubagentRoute(sessionId, token) && selectedProvider !== null && selectedProvider !== providerId) return null;
+ const signal = getPiProxySessionSignal(sessionId, token);
+ return signal && !signal.aborted ? { sessionId, providerId, signal } : null;
+}
+
+/** Only authenticated ChatGPT subscription requests can reach the fixed upstream. */
+export const resolvePiWebSocketUpstream: NonNullable<ProxyOptions['resolveWebSocketUpstream']> = (ctx) =>
+ authenticatedRoute(ctx) ? 'https://chatgpt.com/backend-api' : null;
+
+export function createPiWebSocketRequestPreparer(
+ readAuth: (providerId: string) => ReturnType<typeof getChatgptBridgeAuthForDispatch>
+ = providerId => getChatgptBridgeAuthForDispatch(providerId),
++ invalidate: typeof invalidateChatgptBridgeAuth = invalidateChatgptBridgeAuth,
+): NonNullable<ProxyOptions['prepareWebSocketRequest']> {
+ return async (ctx) => {
+ const owner = activeOwnerScopeKey();
+ const route = authenticatedRoute(ctx);
+ if (!route) throw new Error('PI_WEBSOCKET_ROUTE_UNAVAILABLE');
+ const auth = await readAuth(route.providerId);
+ const current = authenticatedRoute(ctx);
+ if (owner !== activeOwnerScopeKey() || !current || route.signal !== current.signal
+ || route.providerId !== current.providerId || !auth.canDispatch()) throw new Error('PI_WEBSOCKET_ROUTE_CHANGED');
+ const headers = buildChatgptBridgeHeaders({ ...auth, sessionId: ctx.headers.session_id ?? route.sessionId });
+ // Preserve negotiated transport metadata, never child credentials or Cindy-only headers.
+ for (const name of ['sec-websocket-key', 'sec-websocket-version', 'sec-websocket-protocol', 'sec-websocket-extensions', 'openai-beta']) {
+ if (ctx.headers[name]) headers[name] = ctx.headers[name];
+ }
- return { headers, signal: route.signal, authorize: () => {
++ const authorize = () => {
+ const live = authenticatedRoute(ctx);
+ return auth.canDispatch() && owner === activeOwnerScopeKey() && live?.signal === route.signal
+ && live.providerId === route.providerId;
- } };
++ };
++ const onUpgradeFailure = async (status: number, body: string) => {
++ if (!authorize() || !detectChatgptBridgeAuthInvalidationReason(status, body)) return;
++ await invalidate({ status, body, failedAccessToken: auth.accessToken }, route.providerId);
++ };
++ const transforms = () => piWebSocketTransforms(ctx, onUpgradeFailure);
++ return { headers, signal: route.signal, authorize, onUpgradeFailure, transforms };
+ };
+}
+
+/** Enforce live account/task Fast restrictions at each response.create dispatch. */
- export const piWebSocketTransforms: NonNullable<ProxyOptions['webSocketTransforms']> = (ctx) => {
++export function piWebSocketTransforms(
++ ctx: Context,
++ onAuthFailure?: (status: number, body: string) => Promise<void>,
++): ReturnType<NonNullable<ProxyOptions['webSocketTransforms']>> {
+ const route = authenticatedRoute(ctx);
+ if (!route) throw new Error('PI_WEBSOCKET_ROUTE_UNAVAILABLE');
+ return {
+ outbound: createWebSocketMessageTransform(true, message => {
+ // Check after the complete message arrives, including fragmented requests.
+ if (subscriptionRequestAllowsFast(route.sessionId, route.providerId)) return message;
+ const restricted = standardSpeedRequest(JSON.parse(message.toString('utf8')));
+ return restricted === null ? message : Buffer.from(JSON.stringify(restricted));
+ }),
- inbound: new PassThrough(),
++ inbound: onAuthFailure ? createWebSocketMessageTransform(false, async message => {
++ // Ordinary content, including text mentioning authentication, cannot revoke
++ // credentials. Only bounded explicit provider error events are inspected.
++ if (message.length <= 64 * 1024) {
++ let event: any;
++ try { event = JSON.parse(message.toString('utf8')); } catch { return message; }
++ if (event?.type === 'error' || event?.type === 'response.failed') {
++ const error = event.error ?? event.response?.error;
++ const status = event.status ?? error?.status;
++ if (status === undefined || status === 401 || status === 403) {
++ // WS errors may omit HTTP status; the existing invalidator still
++ // requires an explicit OAuth revocation reason in the error body.
++ await onAuthFailure(status ?? 401, JSON.stringify(error ?? event)).catch(() => {});
++ }
++ }
++ }
++ return message;
++ }) : new PassThrough(),
+ };
- };
++}
diff --cc packages/anthropic-compat-proxy/src/server-websocket.test.ts
index 8614508ff9,abc63c86ec..97b5b733da
--- a/packages/anthropic-compat-proxy/src/server-websocket.test.ts
+++ b/packages/anthropic-compat-proxy/src/server-websocket.test.ts
@@@ -753,6 -691,6 +753,35 @@@ describe('anthropic-compat-proxy websoc
expect(response).toContain(`{"error":{"status":${status}}}`);
});
++ // Regression #7427: host OAuth handling must see complete 401/403 upgrade
++ // bodies, including 403 responses mapped to native HTTP fallback. Collection
++ // is bounded and observer failures never replace the original response.
++ it.each([
++ { status: 401, bytes: 128, observed: true },
++ { status: 403, bytes: 128, observed: true },
++ { status: 401, bytes: 65_537, observed: false },
++ ])('observes bounded upgrade authentication refusals: %j', async ({ status, bytes, observed }) => {
++ const body = JSON.stringify({ error: { code: 'token_revoked', padding: 'x'.repeat(bytes) } });
++ const upstream = createServer((_req, res) => {
++ res.writeHead(status, { 'content-type': 'application/json' });
++ res.end(body);
++ });
++ const port = await listenOnAvailableLoopbackPort(upstream);
++ cleanups.push(() => new Promise<void>((resolve) => upstream.close(() => resolve())));
++ const observe = vi.fn(async () => { throw new Error('fixture observer failure'); });
++ proxy = await createAnthropicCompatProxy({
++ upstream: 'http://unused.invalid', transformRequest: [],
++ resolveWebSocketUpstream: () => `http://127.0.0.1:${port}`,
++ prepareWebSocketRequest: async ({ headers }) => ({ headers: { ...headers },
++ signal: new AbortController().signal, onUpgradeFailure: observe }),
++ });
++ const response = await readUpgradeFailure(proxy.url);
++ expect(response).toContain(status === 403 ? 'HTTP/1.1 426' : 'HTTP/1.1 401');
++ if (status === 401) expect(response).toContain(body);
++ if (observed) expect(observe).toHaveBeenCalledExactlyOnceWith(status, body);
++ else expect(observe).not.toHaveBeenCalled();
++ });
++
it('does not impose a local websocket capacity limit', async () => {
// 容量由 Codex / 上游控制。proxy 自设连接上限会凭空制造 503,让 Cindy 的
// at-capacity 行为与官方 Codex 不一致。
diff --cc packages/anthropic-compat-proxy/src/server.ts
index ba55aee342,b9e30b7899..0f61a016cd
--- a/packages/anthropic-compat-proxy/src/server.ts
+++ b/packages/anthropic-compat-proxy/src/server.ts
@@@ -2872,8 -2872,6 +2872,10 @@@ export async function createAnthropicCo
let upstreamReqForEarlyClose: ClientRequest | null = null;
let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
let upstreamAttempt = 0;
+ let removeAuthorizationListener: (() => void) | undefined;
+ let authorizeWebSocket: (() => boolean) | undefined;
++ let preparedTransforms: (() => { outbound: Transform; inbound: Transform }) | undefined;
++ let onUpgradeFailure: ((status: number, body: string) => Promise<void>) | undefined;
// bundled Codex 0.145.0 的 startup-prewarm / reconnect 都带稳定 thread-id。
// 真正无 scope 的非 Codex / 通用 socket 仍保留空值隔离;不能把泛用的
// x-client-request-id 当作稳定 recovery key,误逐出其它 thread 的连接。
@@@ -2990,23 -2987,6 +2992,26 @@@
void (async () => {
const outbound = await resolveOutboundForTarget(target, reqId);
if (settled || clientSocket.destroyed) return;
+ let outboundHeaders = headers;
+ if (opts.prepareWebSocketRequest) {
+ const prepared = await opts.prepareWebSocketRequest({ url, headers });
+ if (settled || clientSocket.destroyed) return;
+ const revoke = (): void => {
+ settle('host-authorization-revoked');
+ upstreamReqForEarlyClose?.destroy();
+ connection.upstreamSocket?.destroy();
+ clientSocket.destroy();
+ };
+ if (prepared.signal.aborted) { revoke(); return; }
+ removeAuthorizationListener?.();
+ prepared.signal.addEventListener('abort', revoke, { once: true });
+ removeAuthorizationListener = () => prepared.signal.removeEventListener('abort', revoke);
+ outboundHeaders = prepared.headers;
+ authorizeWebSocket = prepared.authorize;
++ onUpgradeFailure = prepared.onUpgradeFailure;
++ if (prepared.transforms && !opts.webSocketTransforms) throw new Error('WEBSOCKET_TRANSFORMS_REQUIRE_UNCOMPRESSED_NEGOTIATION');
++ preparedTransforms = prepared.transforms;
+ }
let attemptSettled = false;
// codex 构造 WS URL 的规则是 `base_url + "/responses"`。宿主给 codex 的 base_url
@@@ -3145,7 -3125,7 +3150,7 @@@
upstreamSocket.on('error', abort('upstream-error'));
let guarded: ReturnType<NonNullable<ProxyOptions['webSocketTransforms']>> | undefined;
-- try { guarded = opts.webSocketTransforms?.({ url, headers }); }
++ try { guarded = preparedTransforms?.() ?? opts.webSocketTransforms?.({ url, headers }); }
catch { abort('websocket-guard-failed')(); return; }
if (guarded) {
guarded.outbound.on('error', abort('websocket-outbound-rejected'));
@@@ -3211,6 -3173,6 +3216,18 @@@
upstreamReqForEarlyClose = null;
settle('upstream-refused');
const status = upstreamRes.statusCode ?? 502;
++ if (onUpgradeFailure && (status === 401 || status === 403)) {
++ const observe = onUpgradeFailure;
++ const chunks: Buffer[] = [];
++ let bytes = 0;
++ upstreamRes.on('data', (chunk: Buffer) => {
++ bytes += chunk.length;
++ if (bytes <= 64 * 1024) chunks.push(Buffer.from(chunk));
++ });
++ upstreamRes.once('end', () => {
++ if (bytes <= 64 * 1024) void observe(status, Buffer.concat(chunks).toString('utf8')).catch(() => {});
++ });
++ }
logger.warn?.('upstream refused websocket upgrade', {
reqId,
status,
diff --cc packages/anthropic-compat-proxy/src/types.ts
index cecec96b0a,014bfc0865..279f7df742
--- a/packages/anthropic-compat-proxy/src/types.ts
+++ b/packages/anthropic-compat-proxy/src/types.ts
@@@ -353,17 -353,6 +353,25 @@@ export interface ProxyOptions
readonly url: string;
readonly headers: Readonly<Record<string, string>>;
}) => string | null;
+ /** Optional host authentication immediately before opening an upstream socket.
+ * Replaces outbound headers, preserving only host-approved handshake metadata.
+ * The signal revokes pending and established connections with the owning runtime.
+ * authorize rechecks mutable route ownership before forwarding each outbound chunk,
+ * without decoding frames or changing compression negotiation.
+ * Omitted by existing callers, whose forwarding remains unchanged.
+ */
+ prepareWebSocketRequest?: (ctx: {
+ readonly url: string;
+ readonly headers: Readonly<Record<string, string>>;
- }) => Promise<{ headers: Record<string, string>; signal: AbortSignal; authorize?: () => boolean }>;
++ }) => Promise<{
++ headers: Record<string, string>;
++ signal: AbortSignal;
++ authorize?: () => boolean;
++ /** Observe a complete, bounded HTTP upgrade refusal without consuming its body. */
++ onUpgradeFailure?: (status: number, body: string) => Promise<void>;
++ /** Connection-bound message guards; requires webSocketTransforms (uncompressed negotiation). */
++ transforms?: () => { outbound: Transform; inbound: Transform };
++ }>;
/**
* 对带稳定 thread id、且此前已真实完成过上游 101 的 WebSocket 重连启用 Cindy 侧保活。
* proxy 会先用已证明一致的协商参数接住该条客户端 socket,再以有界退避回探上游;只要