Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(pi): preserve subscription auth failure handling
xuzini-xzn70e2bba63eaa
diff --cc apps/desktop/src/main/maker-host/__tests__/piSubscriptionWebsocket.e2e.test.tsindex c4390e592b,0000000000..89388422efmode 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.tsindex 0df3d80040,0000000000..7cc51b93ebmode 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.tsindex 9d3a9b9dec,0000000000..7953c782b5mode 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.tsindex 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 websocexpect(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.tsindex 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 createAnthropicColet 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.tsindex 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 ProxyOptionsreadonly 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,再以有界退避回探上游;只要