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。

feat(providers): 支持订阅账号与供应商组统一禁止 Fast

yanaa4f786a92ef
diff --git a/apps/desktop/scripts/fixtures/subscription-fast/subscription-fast-fixture.tsx b/apps/desktop/scripts/fixtures/subscription-fast/subscription-fast-fixture.tsx
new file mode 100644
index 0000000000..61fadf5e44
--- /dev/null
+++ b/apps/desktop/scripts/fixtures/subscription-fast/subscription-fast-fixture.tsx
@@ -0,0 +1,82 @@
+import { mountPage, subscription, forbid } from '../../ui-page/harness';
+import { SubscriptionFastSetting } from '../../../src/renderer/features/provider-share/SubscriptionFastSetting';
+import { ProviderGroupSection } from '../../../src/renderer/features/provider-group/ProviderGroupSection';
+import type { ProviderView } from '@cindy/model-providers';
+import type { ProviderGroupConfig } from '../../../src/shared/providerGroup';
+
+mountPage({
+ host: (ctx) => {
+ let config: ProviderGroupConfig = {
+ strategy: 'least',
+ autoSwitch: true,
+ allowFast: ctx.data.allowFast !== false,
+ members: [
+ {
+ key: 'local',
+ kind: 'local',
+ agentDeviceId: null,
+ providerId: 'openai',
+ limit: 10,
+ weight: 1,
+ paused: false,
+ },
+ ],
+ };
+ const view = () => ({
+ providerId: 'openai',
+ config,
+ fastPolicyPending: ctx.data.pending === true,
+ members: [{ key: 'local', state: 'ready', running: 0, limit: 10, label: 'Mac Studio' }],
+ });
+ return {
+ providerGroup: {
+ command: async (command: any) => {
+ if (command.action === 'get') return view();
+ if (command.action === 'list') return { openai: config };
+ if (command.action === 'save' || command.action === 'save-if-current') {
+ config = command.config;
+ return view();
+ }
+ return forbid(`providerGroup.${command.action}`)();
+ },
+ onChanged: subscription('providerGroupChanged'),
+ },
+ providerShare: {
+ command: async (command: any) => {
+ if (command.action === 'received') return [];
+ if (command.action === 'received-snapshot') return { received: [], confirmedRegions: [] };
+ if (command.action === 'set-fast-policy')
+ return { supported: true, allowFast: command.allowFast };
+ return forbid(`providerShare.${command.action}`)();
+ },
+ onReceivedChanged: subscription('received'),
+ onOwnedChanged: subscription('owned'),
+ },
+ deviceLink: {
+ listDevices: async () => ({ devices: [] }),
+ getState: async () => ({ linkStatus: 'online' }),
+ onPresenceChanged: subscription('presence'),
+ onStatusChanged: subscription('status'),
+ },
+ };
+ },
+ render: (ctx) => (
+ <div
+ data-testid="subscription-fast-fixture"
+ className="flex h-screen min-w-0 flex-col gap-5 overflow-auto bg-content-area p-4"
+ >
+ <SubscriptionFastSetting
+ provider={
+ {
+ id: 'openai',
+ subscriptionFastPolicy: {
+ allowFast: ctx.data.allowFast !== false,
+ groupAllowsFast: true,
+ },
+ } as ProviderView
+ }
+ />
+ <ProviderGroupSection providerId="openai" providerName="OpenAI" fastPolicySupported />
+ </div>
+ ),
+});
diff --git a/apps/desktop/scripts/fixtures/subscription-fast/ui-page.mjs b/apps/desktop/scripts/fixtures/subscription-fast/ui-page.mjs
new file mode 100644
index 0000000000..8867271fa9
--- /dev/null
+++ b/apps/desktop/scripts/fixtures/subscription-fast/ui-page.mjs
@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+
+export default {
+ name: 'subscription-fast',
+ entry: './subscription-fast-fixture.tsx',
+ viewport: { width: 760, height: 800 },
+ real: 'SubscriptionFastSetting, ProviderGroupSection, settings rows, switches, translations and themes',
+ notCovered:
+ 'Real subscriptions, native Agent settings and cross-device delivery. Host APIs use fixture memory.',
+ cases: {
+ default: { about: 'Supplier and group allow Fast', data: { allowFast: true } },
+ prohibited: { about: 'Both levels prohibit Fast', data: { allowFast: false } },
+ pending: {
+ about: 'Group reports an unconfirmed executor',
+ data: { allowFast: false, pending: true },
+ },
+ narrow: {
+ about: 'Subscription controls at 320 px',
+ viewport: { width: 320, height: 950 },
+ data: { allowFast: false, pending: true },
+ },
+ },
+ async ready(page) {
+ await page.getByTestId('subscription-fast-fixture').waitFor();
+ },
+ async check(page, ui) {
+ const switches = page.getByRole('switch', {
+ name: await ui.t('subscriptionFastPolicy.label'),
+ exact: true,
+ });
+ assert.equal(await switches.count(), 2);
+ for (let index = 0; index < 2; index++) {
+ const control = switches.nth(index);
+ const before = await control.getAttribute('aria-checked');
+ await control.click();
+ await page.waitForFunction(
+ ({ name, index, before }) => {
+ const controls = [...document.querySelectorAll('[role="switch"]')].filter(
+ (el) => el.getAttribute('aria-label') === name,
+ );
+ return controls[index]?.getAttribute('aria-checked') !== before;
+ },
+ { name: await ui.t('subscriptionFastPolicy.label'), index, before },
+ );
+ await control.click();
+ await page.waitForFunction(
+ ({ name, index, before }) => {
+ const controls = [...document.querySelectorAll('[role="switch"]')].filter(
+ (el) => el.getAttribute('aria-label') === name,
+ );
+ return controls[index]?.getAttribute('aria-checked') === before;
+ },
+ { name: await ui.t('subscriptionFastPolicy.label'), index, before },
+ );
+ const box = await control.boundingBox();
+ assert.ok(box && box.x >= 0 && box.x + box.width <= page.viewportSize().width);
+ }
+ if (ui.case === 'pending' || ui.case === 'narrow')
+ await page.getByText(await ui.t('subscriptionFastPolicy.pending'), { exact: true }).waitFor();
+ },
+};
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
index b188220f99..7f73a9c915 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
@@ -17,6 +17,11 @@ const memberNotes = vi.hoisted(() => ({ read: vi.fn(), set: vi.fn() }));
vi.mock('../providerShareQuota.js', () => ({ readProviderShareQuota: vi.fn(), readProviderShareQuotaAccount: vi.fn() }));
const visibility = vi.hoisted(() => ({ read: vi.fn(), set: vi.fn() }));
const modelAccess = vi.hoisted(() => ({ read: vi.fn(), set: vi.fn(), allows: vi.fn() }));
+const fastPolicy = vi.hoisted(() => ({ allows: vi.fn(), set: vi.fn(), changed: vi.fn(), publish: vi.fn() }));
+const localBroadcast = vi.hoisted(() => vi.fn());
+vi.mock('../index.js', () => ({ broadcast: localBroadcast }));
+vi.mock('../../maker-host/provider-fast-policy-store.js', () => ({ providerFastPolicy: fastPolicy }));
+vi.mock('../../maker-host/subscription-fast-policy.js', () => ({ notifySubscriptionFastPolicyChanged: fastPolicy.changed }));
vi.mock('../remoteModelAccess.js', () => ({ remoteModelAccess: modelAccess }));
vi.mock('../providerShareVisibility.js', () => ({ providerShareVisibility: visibility }));
vi.mock('../providerShareMemberNotes.js', () => ({ providerShareMemberNotes: memberNotes }));
@@ -52,6 +57,7 @@ vi.mock('../providerShareApi.js', () => ({
providerShareLinkFor: () => 'https://cindy.app/s#test-link',
}));
vi.mock('../dispatch.js', () => ({
+ notifyProviderShareCatalogChanged: fastPolicy.publish,
getControllerDisplayName: vi.fn(), providerShareActiveControllers: vi.fn(),
revalidateRemoteModelAccess: vi.fn(async () => undefined), revokeProviderShareControllers: vi.fn(), setProviderShareAccess: vi.fn(),
}));
@@ -113,6 +119,9 @@ beforeEach(() => {
memberNotes.set.mockResolvedValue(undefined);
modelAccess.read.mockReturnValue({ models: null, providerModels: null });
modelAccess.set.mockImplementation(async (_provider, _models, _member, assertCurrent) => { assertCurrent(); });
+ fastPolicy.allows.mockReturnValue(true);
+ fastPolicy.set.mockImplementation(async (_provider, allowed, assertCurrent) => { assertCurrent(); fastPolicy.allows.mockReturnValue(allowed); });
+ fastPolicy.changed.mockResolvedValue(undefined);
host.snapshot.mockReturnValue([{ requests: [{ requestId: 'r1' }], members: [{ memberId: 'm1' }] }]);
usageStores.ownHistory.mockReturnValue({ self: { lastUsedAt: null, days: [] }, relays: [] });
usageStores.memberHistory.mockReturnValue([]);
@@ -425,3 +434,42 @@ describe('share visibility management and guest query', () => {
expect(invoke).toHaveBeenCalledWith('share:s', 'provider-share:insights:v1', [{ version: 1, includeUsage: false }], expect.any(Object));
});
});
+
+describe('subscription Fast management through the owner command', () => {
+ const command = { action: 'set-fast-policy', providerId: 'openai', allowFast: false } as const;
+ const subscription = { id: 'openai', auth: { method: 'oauth', native: 'codex' } };
+
+ it('refreshes local catalogs even when the user has not started device-link sharing', async () => {
+ stopProviderShareRuntime();
+ listProviders.mockResolvedValue([subscription]);
+ await expect(executeProviderShareManagementCommand(command)).resolves.toEqual({ supported: true, allowFast: false });
+ expect(localBroadcast).toHaveBeenCalledWith('maker:provider:changed', {});
+ });
+
+ it('persists a subscription restriction and publishes the catalog before awaiting the native update', async () => {
+ listProviders.mockResolvedValue([subscription]);
+ fastPolicy.changed.mockImplementation(async () => {
+ expect(fastPolicy.allows('openai')).toBe(false);
+ expect(fastPolicy.publish).toHaveBeenCalledWith('openai');
+ throw Error('native still busy');
+ });
+ await expect(executeProviderShareManagementCommand(command)).rejects.toThrow('native still busy');
+ expect(fastPolicy.set).toHaveBeenCalledWith('openai', false, expect.any(Function));
+ fastPolicy.changed.mockResolvedValue(undefined);
+ await expect(executeProviderShareManagementCommand(command)).resolves.toEqual({ supported: true, allowFast: false });
+ });
+
+ it('rejects a custom API named openai and requires a real boolean', async () => {
+ listProviders.mockResolvedValue([{ ...subscription, auth: { method: 'apiKey' } }]);
+ await expect(executeProviderShareManagementCommand(command)).rejects.toThrow('INVALID_PARAMS');
+ expect(fastPolicy.set).not.toHaveBeenCalled();
+ expect(() => parseProviderShareCommand({ ...command, allowFast: 'false' })).toThrow('INVALID_PARAMS');
+ });
+
+ it('does not persist after the owner changes during catalog lookup', async () => {
+ listProviders.mockImplementation(async () => { state.owner = 'owner-b'; return [subscription]; });
+ await expect(executeProviderShareManagementCommand(command)).rejects.toThrow('PRECONDITION_FAILED');
+ expect(fastPolicy.set).not.toHaveBeenCalled();
+ expect(fastPolicy.publish).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/device-link/dispatch.ts b/apps/desktop/src/main/device-link/dispatch.ts
index 39c08d6a92..7baebfc7e1 100644
--- a/apps/desktop/src/main/device-link/dispatch.ts
+++ b/apps/desktop/src/main/device-link/dispatch.ts
@@ -409,6 +409,14 @@ function providerShareGuestAccess(controller: string): ReturnType<ProviderShareA
return providerShareAccess?.guestAccess(controller) ?? null;
}
+/** Empty invalidation only, scoped to the currently authorized shared provider. Never subscribe guests to owner topics. */
+export function notifyProviderShareCatalogChanged(providerId: string): void {
+ for (const peer of acceptedLinkControllers) {
+ if (!isProviderSharePeer(peer) || providerShareGuestAccess(peer)?.providerId !== providerId) continue;
+ sendPushBestEffort(peer, 'maker:provider:changed', {});
+ }
+}
+
/**
* 受邀者被拒时在本机日志记下原因(同一对端、同一位置、同一原因每分钟最多一条)。对方只收到
* 「暂时不可用」,排查「受邀者读不到模型」只能靠这里。
@@ -4268,7 +4276,7 @@ const PROVIDER_SHARE_CHANNELS: ReadonlySet<string> = new Set([
const PROVIDER_SHARE_AGENT_ARG_CHANNELS: ReadonlySet<string> = new Set(['maker:get-capabilities', 'maker:agent:status']);
const PROVIDER_SHARE_AGENT_KINDS: ReadonlySet<string> = new Set(['claude-code', 'codex', 'pi']);
-type SharedProviderView = { agents: string[]; models: Record<string, string[]> };
+type SharedProviderView = { agents: string[]; models: Record<string, string[]>; fastAllowed: boolean };
/**
* The shared provider as the guest sees it: `null` when it is no longer open for remote use,
@@ -4293,7 +4301,8 @@ async function sharedProviderView(
: [];
}
}
- return { agents, models };
+ const policy = provider.subscriptionFastPolicy as { allowFast?: boolean; groupAllowsFast?: boolean } | undefined;
+ return { agents, models, fastAllowed: policy?.allowFast !== false && policy?.groupAllowsFast !== false };
}
/**
@@ -4333,11 +4342,13 @@ async function projectProviderShareRead(
ok: true,
value: {
...capabilities,
+ ...(view?.fastAllowed === false ? { hasFastMode: false } : {}),
availableModels: Array.isArray(capabilities.availableModels)
? capabilities.availableModels.filter((model) => {
const id = model && typeof (model as { id?: unknown }).id === 'string' ? (model as { id: string }).id : '';
return id !== '' && offered.has(id);
- })
+ }).map(model => view?.fastAllowed === false
+ ? { ...(model as object), supportsFastMode: false, supportsUltrafastMode: false } : model)
: [],
},
};
diff --git a/apps/desktop/src/main/device-link/index.ts b/apps/desktop/src/main/device-link/index.ts
index bba8d1cc27..8eee6eca28 100644
--- a/apps/desktop/src/main/device-link/index.ts
+++ b/apps/desktop/src/main/device-link/index.ts
@@ -28,6 +28,7 @@ import {
FILE_PEER_CHANNEL,
isScopedPeer,
parseSharedTaskPeer,
+ parseProviderSharePeer,
probeSharedTaskHost,
PROVIDER_SHARE_RELAY_CAPABILITY,
sharedTaskTopics,
@@ -151,6 +152,7 @@ import { startSharedTaskRuntime, stopSharedTaskRuntime } from './sharedTaskRunti
import { startProviderShareRuntime, stopProviderShareRuntime } from './providerShareRuntime.js';
import {
isProviderShareRefusal,
+ getReceivedShares,
noteProviderShareAccessFailure,
PROVIDER_SHARE_UNAVAILABLE_MESSAGE,
resolveRemoteAgentTargetWhenReady,
@@ -1062,6 +1064,13 @@ export function initDeviceLinkService(options: DeviceLinkServiceOptions = {}): v
}
if (env.kind !== 'push') return;
const p = env.payload as PushPayload;
+ const sharePeer = parseProviderSharePeer(env.src);
+ if (sharePeer && p?.channel === 'maker:provider:changed') {
+ if (sharePeer.role !== 'host' || !getReceivedShares().some(share => share.shareId === sharePeer.shareId
+ && share.hostDeviceId === sharePeer.deviceId && share.status === 'active')) return;
+ broadcast(DEVICE_LINK_PUSH.REMOTE_PUSH, { deviceId: `share:${sharePeer.shareId}`, channel: p.channel, payload: {} });
+ return;
+ }
const sourceEpoch = sharedHostStreams.get(env.src)?.epoch;
// 词典同步帧在 main 侧消费,不转给 renderer —— 它不是远程视图事件,
// renderer 也不该看到别的设备的同步状态。
diff --git a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
index f4e9cf8b35..6a609ada53 100644
--- a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
+++ b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
@@ -56,6 +56,7 @@ const MARKER_FILE = 'provider-share-regions.json';
export interface CrossRegionEvents {
changed(): void;
+ catalogChanged?(agentDeviceId: string): void;
}
interface RegionState {
@@ -287,6 +288,15 @@ function createClient(rt: Runtime, state: RegionState): DeviceLinkClient {
},
timing: { pingIntervalMs: 15_000 },
});
+ client.onFrame?.(frame => {
+ if (!current(rt) || frame.kind !== 'push' || !frame.src) return;
+ const peer = parseProviderSharePeer(frame.src);
+ const payload = frame.payload as { channel?: unknown };
+ if (peer?.role !== 'host' || payload?.channel !== 'maker:provider:changed') return;
+ if (state.shares.some(share => share.shareId === peer.shareId && share.hostDeviceId === peer.deviceId && share.status === 'active')) {
+ rt.events.catalogChanged?.(`share:${peer.shareId}`);
+ }
+ });
client.start();
return client;
}
diff --git a/apps/desktop/src/main/device-link/providerShareGuest.ts b/apps/desktop/src/main/device-link/providerShareGuest.ts
index 41a5e99aa1..e606538ae0 100644
--- a/apps/desktop/src/main/device-link/providerShareGuest.ts
+++ b/apps/desktop/src/main/device-link/providerShareGuest.ts
@@ -57,6 +57,7 @@ const SHARE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,121}$/;
type Region = 'cn' | 'global';
export interface ProviderShareGuestEvents {
+ catalogChanged?(agentDeviceId: string): void;
changed(received: readonly ProviderShareReceived[]): void;
/** 发出的申请有了结果(同意、拒绝、过期、撤回)。 */
settled(state: ProviderShareRequestState, preview: ProviderShareLinkPreview | null): void;
@@ -230,7 +231,9 @@ export function startProviderShareGuest(events: ProviderShareGuestEvents, option
};
runtime = rt;
void refreshReceivedShares('start');
- if (options.userDataDir) startProviderShareCrossRegion({ changed: () => emitChanged(rt) }, { userDataDir: options.userDataDir });
+ if (options.userDataDir) startProviderShareCrossRegion({ changed: () => emitChanged(rt),
+ catalogChanged: device => { if (current(rt)) rt.events.catalogChanged?.(device); },
+ }, { userDataDir: options.userDataDir });
}
export function stopProviderShareGuest(): void {
diff --git a/apps/desktop/src/main/device-link/providerShareRuntime.ts b/apps/desktop/src/main/device-link/providerShareRuntime.ts
index cde52ef723..b06601b425 100644
--- a/apps/desktop/src/main/device-link/providerShareRuntime.ts
+++ b/apps/desktop/src/main/device-link/providerShareRuntime.ts
@@ -1,4 +1,9 @@
import { isRemoteAgentLimitsPatch } from '../../shared/remoteAgentLimits.js';
+import { supportsSubscriptionFastPolicy } from '@cindy/model-providers';
+import { providerFastPolicy } from '../maker-host/provider-fast-policy-store.js';
+import { notifySubscriptionFastPolicyChanged } from '../maker-host/subscription-fast-policy.js';
+import { notifyProviderShareCatalogChanged } from './dispatch.js';
+import { DEVICE_LINK_PUSH } from '../../shared/deviceLinkIpc.js';
import { readRemoteAgentLimitsState, saveRemoteAgentLimits } from '../remote-agent/host/limitsStore.js';
import { remoteAgentLimitUsage, revalidateRemoteModelAccess } from './dispatch.js';
/**
@@ -70,6 +75,7 @@ import {
import { getDeviceLinkInvokeContext } from './invoke-context.js';
import { tapWindowBroadcast } from './broadcast-tap.js';
import { MAKER_PUSH } from '../maker-ipc/channels.js';
+import { broadcast as broadcastLocal } from './index.js';
import { fetchIdentityCard, providerShareApi, providerShareLinkFor, sha256Hex } from './providerShareApi.js';
import { configureProviderShareApprovalWindows } from './providerShareApprovalWindows.js';
import {
@@ -300,6 +306,7 @@ export function startProviderShareRuntime(broadcast: Broadcast, options: { invok
},
}, { readWatchedShares: readInvoke ? (hostDeviceId) => readProviderManagementShares(readInvoke, hostDeviceId) : undefined });
startProviderShareGuest({
+ catalogChanged(deviceId) { emit(DEVICE_LINK_PUSH.REMOTE_PUSH, { deviceId, channel: 'maker:provider:changed', payload: {} }); },
changed(received) {
emit(PROVIDER_SHARE_IPC.RECEIVED_CHANGED, received);
},
@@ -348,6 +355,13 @@ export function parseProviderShareCommand(raw: unknown): ProviderShareCommand {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throwIpcError('INVALID_PARAMS', 'Invalid command');
const value = raw as Record<string, unknown>;
switch (value.action) {
+ case 'get-fast-policy':
+ case 'set-fast-policy': {
+ if (!isProviderGroupProviderId(value.providerId)) throwIpcError('INVALID_PARAMS', 'Invalid providerId');
+ if (value.action === 'get-fast-policy') return { action: value.action, providerId: value.providerId };
+ if (typeof value.allowFast !== 'boolean') throwIpcError('INVALID_PARAMS', 'allowFast must be a boolean');
+ return { action: value.action, providerId: value.providerId, allowFast: value.allowFast };
+ }
case 'get-model-access':
case 'set-model-access': {
if (!isProviderGroupProviderId(value.providerId)) throwIpcError('INVALID_PARAMS', 'Invalid providerId');
@@ -725,6 +739,28 @@ async function createLink(
async function execute(command: ProviderShareCommand, assertCurrent: () => void = () => undefined): Promise<unknown> {
assertCurrent();
switch (command.action) {
+ case 'get-fast-policy':
+ case 'set-fast-policy': {
+ const assertOwner = captureProviderManagementScope();
+ const assertScope = () => { assertCurrent(); assertOwner(); };
+ const providers = await getDesktopProviderService().listProviders({ allowSideEffects: false });
+ assertScope();
+ const provider = providers.find(entry => entry.id === command.providerId);
+ const supported = supportsSubscriptionFastPolicy(provider);
+ if (command.action === 'set-fast-policy') {
+ if (!supported) throwIpcError('INVALID_PARAMS', 'Fast policy is available only for supported subscription accounts');
+ await providerFastPolicy.set(command.providerId, command.allowFast, assertScope);
+ // Publish catalog invalidation even if a native live update needs retrying.
+ emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
+ // Local subscription use also works without a running account/share transport.
+ broadcastLocal(MAKER_PUSH.PROVIDER_CHANGED, {});
+ tapWindowBroadcast(MAKER_PUSH.PROVIDER_CHANGED, {});
+ notifyProviderShareCatalogChanged(command.providerId);
+ await notifySubscriptionFastPolicyChanged();
+ assertScope();
+ }
+ return { supported, allowFast: supported ? providerFastPolicy.allows(command.providerId) : true };
+ }
case 'get-model-access':
case 'set-model-access': {
const assertOwner = captureProviderManagementScope();
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
index 7bb1df40cb..e8f25776b6 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
@@ -4645,8 +4645,10 @@ describe('codex proxy host', () => {
}
expect(current).toEqual(original);
- await expect(Promise.resolve(routingTransform(current, ctx))).resolves.toEqual({
+ await expect(Promise.resolve(routingTransform(current, ctx))).resolves.toMatchObject({
upstreamOverride: 'https://chatgpt.com/backend-api/codex',
+ transformRequestBody: expect.any(Function),
+ dispatchGenerationValid: expect.any(Function),
});
host.clearCodexProxyAuthInjection();
clearSessionProvider('session-subscription-search');
diff --git a/apps/desktop/src/main/maker-host/__tests__/piNativeSubscriptionForwarding.test.ts b/apps/desktop/src/main/maker-host/__tests__/piNativeSubscriptionForwarding.test.ts
index c3dfc23440..54f82a36ee 100644
--- a/apps/desktop/src/main/maker-host/__tests__/piNativeSubscriptionForwarding.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/piNativeSubscriptionForwarding.test.ts
@@ -8,6 +8,8 @@ const { ownerState } = vi.hoisted(() => ({
ownerState: {
pending: false,
scope: 'cloud:owner-a:1',
+ fastAllowed: true,
+ afterFastRead: undefined as 'relax' | 'owner' | undefined,
},
}));
@@ -19,6 +21,18 @@ vi.mock('../../appSessionState.js', () => ({
isAppSessionBoundaryPending: () => ownerState.pending,
activeOwnerScopeKey: () => ownerState.scope,
}));
+vi.mock('../subscription-fast-policy.js', () => ({ createSubscriptionFastPolicy: () => ({
+ isAllowed: () => {
+ const allowed = ownerState.fastAllowed;
+ const action = ownerState.afterFastRead;
+ ownerState.afterFastRead = undefined;
+ if (action) queueMicrotask(() => {
+ if (action === 'relax') ownerState.fastAllowed = true;
+ else ownerState.scope = 'cloud:owner-b:2';
+ });
+ return allowed;
+ },
+}) }));
vi.mock('../logger-adapter.js', () => ({
createMakerLogger: () => {
@@ -99,6 +113,30 @@ describe('PI native subscription forwarding', () => {
clearUsagePricing('session-fast');
ownerState.pending = false;
ownerState.scope = 'cloud:owner-a:1';
+ ownerState.fastAllowed = true;
+ ownerState.afterFastRead = undefined;
+ });
+
+ it.each(['relax', 'owner'] as const)('preserves the final boundary when %s changes during speed decompression', async action => {
+ ownerState.fastAllowed = false;
+ ownerState.afterFastRead = action;
+ const injected = deps();
+ const res = responseRecorder();
+ await getPiNativeSubscriptionHandler('openai', 'session-fast', injected)({
+ rawBody: zstdCompressSync(Buffer.from(JSON.stringify({ model: 'gpt-6.1-sol', input: [], service_tier: 'priority' }))),
+ parsedBody: undefined,
+ ctx: { reqId: 1, method: 'POST', url: '/codex/responses', headers: { 'content-encoding': 'zstd' } },
+ res,
+ } as never);
+ if (action === 'owner') {
+ expect(injected.fetch).not.toHaveBeenCalled();
+ expect(res.status).toBe(503);
+ } else {
+ expect(injected.fetch).toHaveBeenCalledOnce();
+ const sent = vi.mocked(injected.fetch).mock.calls[0][1]!;
+ expect(JSON.parse(Buffer.from(sent.body as Uint8Array).toString()).service_tier).toBe('default');
+ expect(sent.headers).not.toHaveProperty('content-encoding');
+ }
});
it.each([['grok-4.7', true, 'grok-4.7-build-fast'], ['grok-4.7', false, 'grok-4.7'],
diff --git a/apps/desktop/src/main/maker-host/__tests__/subscription-fast-policy.test.ts b/apps/desktop/src/main/maker-host/__tests__/subscription-fast-policy.test.ts
new file mode 100644
index 0000000000..25f2922bca
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/subscription-fast-policy.test.ts
@@ -0,0 +1,130 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { ProviderView } from '@cindy/model-providers';
+
+const state = vi.hoisted(() => ({
+ owner: 'owner',
+ supplier: true,
+ group: true,
+ executor: true,
+ binding: null as { providerId: string; groupDeviceId?: string } | null,
+ providers: [] as ProviderView[],
+}));
+vi.mock('../../appSessionState.js', () => ({ activeOwnerScopeKey: () => state.owner }));
+vi.mock('../../provider-group/bindings.js', () => ({
+ readProviderGroupBinding: () => state.binding,
+}));
+vi.mock('../../provider-group/store.js', () => ({
+ readProviderGroup: () => ({ allowFast: state.group }),
+}));
+vi.mock('../../provider-group/fastPolicyStore.js', () => ({
+ groupFastPolicyStore: { allows: () => state.executor },
+}));
+vi.mock('../active-catalog.js', () => ({
+ getActiveCatalog: () => ({ providers: state.providers }),
+}));
+vi.mock('../provider-fast-policy-store.js', () => ({
+ providerFastPolicy: { allows: () => state.supplier },
+}));
+import {
+ createSubscriptionFastPolicy,
+ notifySubscriptionFastPolicyChanged,
+ projectSubscriptionFastPolicy,
+} from '../subscription-fast-policy.js';
+
+const subscription = {
+ id: 'my-login',
+ auth: { method: 'oauth', native: 'codex' },
+ models: { codex: [{ id: 'gpt-6.1-sol', supportsFastMode: true, supportsUltrafastMode: true }] },
+} as unknown as ProviderView;
+const customApi = { ...subscription, id: 'openai', auth: { method: 'apiKey' } } as ProviderView;
+afterEach(() => {
+ state.owner = 'owner';
+ state.supplier = state.group = state.executor = true;
+ state.binding = null;
+ state.providers = [];
+});
+
+describe('subscription-only policy composition and catalog projection', () => {
+ it('projects effective capabilities without overwriting native capabilities or custom APIs', () => {
+ state.supplier = false;
+ const projected = projectSubscriptionFastPolicy(subscription);
+ expect(projected.subscriptionFastPolicy).toEqual({ allowFast: false, groupAllowsFast: true });
+ expect(projected.models.codex?.[0]).toMatchObject({
+ supportsFastMode: false,
+ supportsUltrafastMode: false,
+ });
+ expect(subscription.models.codex?.[0].supportsFastMode).toBe(true);
+ expect(projectSubscriptionFastPolicy(customApi)).toBe(customApi);
+ state.supplier = true;
+ expect(projectSubscriptionFastPolicy(subscription).models).toBe(subscription.models);
+ });
+
+ it('combines supplier, local group and authenticated executor constraints, scoped to subscriptions', () => {
+ state.providers = [subscription, customApi];
+ let provider = subscription.id;
+ const policy = createSubscriptionFastPolicy('task', () => provider);
+ expect(policy.isAllowed()).toBe(true);
+ state.group = false;
+ expect(policy.isAllowed()).toBe(true); // direct use does not inherit an unrelated group
+ state.binding = { providerId: subscription.id };
+ expect(policy.isAllowed()).toBe(false);
+ state.binding = { providerId: subscription.id, groupDeviceId: 'group-owner' };
+ expect(policy.isAllowed()).toBe(true); // remote owner enforces on the selected executor
+ state.executor = false;
+ expect(policy.isAllowed()).toBe(false);
+ provider = customApi.id;
+ state.supplier = false;
+ expect(policy.isAllowed()).toBe(true);
+ state.owner = 'another-owner';
+ expect(policy.isAllowed()).toBe(false);
+ });
+
+ it('notifies a running task, retries a failed native update, and never enables Fast on relaxation', async () => {
+ state.providers = [subscription];
+ const policy = createSubscriptionFastPolicy('task', () => subscription.id);
+ const listener = vi
+ .fn()
+ .mockRejectedValueOnce(Error('native busy'))
+ .mockResolvedValue(undefined);
+ const off = policy.subscribe(listener);
+ try {
+ state.supplier = false;
+ await expect(notifySubscriptionFastPolicyChanged()).rejects.toThrow('native busy');
+ await notifySubscriptionFastPolicyChanged();
+ await notifySubscriptionFastPolicyChanged();
+ expect(listener).toHaveBeenCalledTimes(2);
+ state.supplier = true;
+ await notifySubscriptionFastPolicyChanged();
+ expect(listener).toHaveBeenCalledTimes(3);
+ } finally {
+ off();
+ }
+ });
+
+ it('retains standard at the exit after relaxation until an explicit enable, scoped to task, source and owner', () => {
+ state.providers = [subscription, customApi];
+ const policy = createSubscriptionFastPolicy('suppressed-task', () => subscription.id);
+ state.supplier = false;
+ policy.onFastModeChanged!(false);
+ state.supplier = true;
+ expect(policy.isAllowed()).toBe(true);
+ expect(policy.isRequestAllowed!()).toBe(false);
+ expect(
+ createSubscriptionFastPolicy('another-task', () => subscription.id).isRequestAllowed!(),
+ ).toBe(true);
+ expect(
+ createSubscriptionFastPolicy('suppressed-task', () => customApi.id).isRequestAllowed!(),
+ ).toBe(true);
+ policy.onFastModeChanged!(true);
+ expect(policy.isRequestAllowed!()).toBe(true);
+ policy.onFastModeChanged!(false);
+ state.providers = [{ ...subscription, auth: { method: 'apiKey' } } as ProviderView];
+ expect(policy.isRequestAllowed!()).toBe(true);
+ state.providers = [subscription, customApi];
+ state.owner = 'new-owner';
+ const otherOwner = createSubscriptionFastPolicy('suppressed-task', () => subscription.id);
+ expect(otherOwner.isRequestAllowed!()).toBe(true);
+ policy.onFastModeChanged!(false);
+ expect(otherOwner.isRequestAllowed!()).toBe(true);
+ });
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/subscriptionFastBridge.test.ts b/apps/desktop/src/main/maker-host/__tests__/subscriptionFastBridge.test.ts
new file mode 100644
index 0000000000..055312fad2
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/subscriptionFastBridge.test.ts
@@ -0,0 +1,136 @@
+/**
+ * Production entry: Claude routing -> real Responses handler -> captured fetch.
+ * Regression: disabling Fast while bridge authentication awaits must affect this
+ * still-unsent request. Earlier exit tests did not enter the async bridge.
+ * Unit tier: synthetic auth, in-memory response, no sockets or user credentials.
+ * Load the real speed clamp directly; unrelated Agent bootstraps in the core
+ * barrel are outside this routing/handler regression. Review finding R1.
+ */
+import { EventEmitter } from 'node:events';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const state = vi.hoisted(() => ({
+ allowed: true,
+ afterAuth: () => {},
+ bodies: [] as Record<string, unknown>[],
+}));
+vi.mock('../outbound-fetch.js', () => ({ outboundFetch: vi.fn() }));
+vi.mock('@cindy/maker-core', async () => {
+ const { standardSpeedRequest } = await import(
+ '../../../../../../packages/maker-core/src/agents/shared/fast-mode-policy.js'
+ );
+ return { standardSpeedRequest };
+});
+vi.mock('../../appCapabilities.js', () => ({
+ getAppCapabilities: () => ({ canUseCindyGateway: true }),
+}));
+vi.mock('../runtime-configs', () => ({ claudeUpstreamEndpoint: () => 'https://gateway.invalid' }));
+vi.mock('../silent-encrypted-retry-store', () => ({
+ readSilentEncryptedRetrySettings: () => ({ enabled: false }),
+}));
+vi.mock('../logger-adapter', () => {
+ const logger = {
+ trace() {},
+ debug() {},
+ info() {},
+ warn() {},
+ error() {},
+ child() {
+ return logger;
+ },
+ };
+ return { createMakerLogger: () => logger, desktopMakerLogger: logger };
+});
+vi.mock('../subscription-fast-policy.js', () => ({
+ createSubscriptionFastPolicy: () => ({ isAllowed: () => state.allowed }),
+}));
+vi.mock('../anthropic-responses-bridge-host', async () => {
+ const { createResponsesHandler } = await import('@cindy/anthropic-responses-bridge');
+ return {
+ getResponsesBridgeHandler: () =>
+ createResponsesHandler({
+ providers: [
+ {
+ prefix: 'chatgpt/',
+ upstreamBase: 'https://subscription.invalid',
+ fastServiceTier: 'priority',
+ buildHeaders: async () => {
+ await Promise.resolve();
+ state.afterAuth();
+ return { authorization: 'Bearer fixture-not-a-token' };
+ },
+ },
+ ],
+ fetchImpl: async (_url, init) => {
+ state.bodies.push(JSON.parse(String(init?.body)));
+ return new Response('fixture upstream rejection', { status: 400 });
+ },
+ }),
+ getPiNativeSubscriptionHandler: () => undefined,
+ };
+});
+
+import {
+ createModelRoutingTransform,
+ setClaudeProxyGatewayKeyReader,
+ setClaudeProxySessionIdResolver,
+} from '../anthropic-compat-proxy-host';
+import { setPendingCredentialSwitchReader } from '../provider-route';
+import { setSessionProvider, clearSessionProvider } from '../session-provider-store';
+import { setSessionFastMode } from '../session-effort-store';
+
+afterEach(() => {
+ state.allowed = true;
+ state.afterAuth = () => {};
+ state.bodies = [];
+ clearSessionProvider('bridge-fast-task');
+ setSessionFastMode('bridge-fast-task', false);
+ setClaudeProxySessionIdResolver(() => null);
+});
+
+describe('ChatGPT subscription Fast at the Claude bridge exit', () => {
+ it.each([false, true])(
+ 'rechecks after authentication when policy tightens=%s',
+ async (tighten) => {
+ setClaudeProxyGatewayKeyReader(() => 'fixture-gateway-key');
+ setPendingCredentialSwitchReader(() => undefined);
+ setClaudeProxySessionIdResolver(() => 'bridge-fast-task');
+ setSessionProvider('bridge-fast-task', 'openai');
+ setSessionFastMode('bridge-fast-task', true);
+ state.afterAuth = () => {
+ if (tighten) state.allowed = false;
+ };
+ const body = {
+ model: 'chatgpt/gpt-6.1-sol',
+ max_tokens: 32,
+ messages: [{ role: 'user', content: 'fixture' }],
+ };
+ const ctx = {
+ reqId: 1,
+ method: 'POST',
+ url: '/v1/messages',
+ headers: { 'x-claude-code-session-id': 'sdk-fast-task' },
+ };
+ const route = await createModelRoutingTransform()(body, ctx);
+ expect(route?.localHandler).toBeTypeOf('function');
+ const res = Object.assign(new EventEmitter(), {
+ headersSent: false,
+ writeHead() {
+ return res;
+ },
+ end() {
+ return res;
+ },
+ });
+ await route!.localHandler!({
+ parsedBody: body,
+ rawBody: Buffer.from(JSON.stringify(body)),
+ ctx,
+ res: res as never,
+ });
+ expect(state.bodies).toHaveLength(1);
+ expect(state.bodies[0].service_tier).toBe(tighten ? undefined : 'priority');
+ expect(state.bodies[0].model).toBe('gpt-6.1-sol');
+ },
+ );
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/subscriptionFastPolicy.native.test.ts b/apps/desktop/src/main/maker-host/__tests__/subscriptionFastPolicy.native.test.ts
new file mode 100644
index 0000000000..81038b26c8
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/subscriptionFastPolicy.native.test.ts
@@ -0,0 +1,272 @@
+/** Opt in with CINDY_TEST_CODEX_BINARY; uses a temporary home and loopback upstream, never real credentials. */
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { CodexAgent, withFastModePolicy, type Logger } from '@cindy/maker-core';
+import { createAnthropicCompatProxy } from '@cindy/anthropic-compat-proxy';
+import { withSubscriptionFastRequestPolicy } from '../subscription-fast-request-policy.js';
+
+const state = vi.hoisted(() => ({ allowed: true, suppressed: false }));
+vi.mock('../subscription-fast-policy.js', () => ({
+ createSubscriptionFastPolicy: () => ({
+ isAllowed: () => state.allowed,
+ isRequestAllowed: () => state.allowed && !state.suppressed,
+ }),
+}));
+vi.mock('../active-catalog.js', () => ({
+ getActiveCatalog: () => ({
+ providers: [{ id: 'cprov-fixture', auth: { method: 'oauth', native: 'codex' } }],
+ }),
+}));
+
+const binaryPath = process.env.CINDY_TEST_CODEX_BINARY;
+const logger: Logger = {
+ trace() {},
+ debug() {},
+ info() {},
+ warn() {},
+ error() {},
+ fatal() {},
+ child: () => logger,
+};
+
+describe.skipIf(!binaryPath)('native Codex subscription speed enforcement', () => {
+ it('changes actual Responses bodies to standard, clamps stale re-enables and keeps standard after relaxation', async () => {
+ const root = await mkdtemp(path.join(tmpdir(), 'cindy-fast-native-test-'));
+ const home = path.join(root, 'codex');
+ const workingDir = path.join(root, 'work');
+ await mkdir(home);
+ await mkdir(workingDir);
+ const requests: Array<Record<string, unknown>> = [];
+ let prohibitDuringTurn: (() => Promise<void>) | undefined;
+ let relaxDuringTurn: (() => Promise<void>) | undefined;
+ const server = createServer(async (req, res) => {
+ let body = '';
+ for await (const chunk of req) body += chunk;
+ if (req.url === '/provider/responses') {
+ requests.push(JSON.parse(body));
+ const toolLoop = requests.length === 2 || requests.length === 3;
+ if (requests.length === 2) await prohibitDuringTurn!();
+ if (requests.length === 3) await relaxDuringTurn!();
+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });
+ res.end(
+ [
+ { type: 'response.created', response: { id: `response-${requests.length}` } },
+ {
+ type: 'response.output_item.done',
+ item: toolLoop
+ ? {
+ type: 'function_call',
+ call_id: `fixture-tool-${requests.length}`,
+ name: 'exec_command',
+ arguments: JSON.stringify({
+ cmd: 'echo fast-policy-fixture',
+ max_output_tokens: 20,
+ }),
+ }
+ : {
+ type: 'message',
+ role: 'assistant',
+ id: 'fixture-message',
+ content: [{ type: 'output_text', text: 'fixture complete' }],
+ },
+ },
+ {
+ type: 'response.completed',
+ response: {
+ id: `response-${requests.length}`,
+ usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+ },
+ },
+ ]
+ .map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`)
+ .join(''),
+ );
+ } else {
+ res.writeHead(200, { 'content-type': 'application/json' });
+ res.end(JSON.stringify({ models: [] }));
+ }
+ });
+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+ const endpoint = `http://127.0.0.1:${(server.address() as import('node:net').AddressInfo).port}`;
+ const proxy = await createAnthropicCompatProxy({
+ upstream: `${endpoint}/provider`,
+ transformRequest: [],
+ routingTransform: () =>
+ withSubscriptionFastRequestPolicy(null, {
+ sessionId: 'native-fast-policy',
+ providerId: 'cprov-fixture',
+ }),
+ });
+ await writeFile(
+ path.join(home, 'config.toml'),
+ [
+ 'model="gpt-6.1-sol"',
+ 'model_provider="fixture"',
+ 'cli_auth_credentials_store="file"',
+ `chatgpt_base_url="${endpoint}"`,
+ 'check_for_update_on_startup=false',
+ '[analytics]',
+ 'enabled=false',
+ '[mcp_servers.cindy_memory]',
+ 'command="unused-fixture-command"',
+ 'enabled=false',
+ '[model_providers.fixture]',
+ 'name="Fixture"',
+ `base_url="${proxy.url}"`,
+ 'wire_api="responses"',
+ 'requires_openai_auth=true',
+ 'supports_websockets=false',
+ 'request_max_retries=0',
+ ].join('\n'),
+ );
+ state.allowed = true;
+ state.suppressed = false;
+ let update: (() => Promise<void>) | undefined;
+ const policy = {
+ isAllowed: () => state.allowed,
+ onFastModeChanged: (enabled: boolean | 'ultrafast') => {
+ state.suppressed = !enabled;
+ },
+ subscribe: (listener: () => Promise<void>) => {
+ update = listener;
+ return () => {};
+ },
+ };
+ const token = `test.${Buffer.from(
+ JSON.stringify({
+ exp: 4102444800,
+ 'https://api.openai.com/auth': { chatgpt_account_id: 'fixture', chatgpt_plan_type: 'pro' },
+ }),
+ ).toString('base64url')}.synthetic`;
+ await writeFile(
+ path.join(home, 'auth.json'),
+ JSON.stringify({
+ auth_mode: 'chatgpt',
+ tokens: {
+ id_token: token,
+ access_token: token,
+ refresh_token: 'synthetic-refresh',
+ account_id: 'fixture',
+ },
+ last_refresh: new Date().toISOString(),
+ }),
+ );
+ const agent = new CodexAgent({
+ binaryPath: binaryPath!,
+ logger,
+ runtimeConfig: {},
+ resolveCodexLocalAuthPolicy: () => 'legacy-shared',
+ prepareCodexExtraSpawnConfig: async () => ({
+ extraArgs: [],
+ extraEnv: {},
+ codexProxyActive: true,
+ }),
+ auth: {
+ getState: async () => ({ authenticated: true }),
+ triggerLogin: async () => ({ authenticated: true }),
+ logout: async () => {},
+ getAuthEnv: async () => ({
+ HOME: root,
+ USERPROFILE: root,
+ CODEX_HOME: home,
+ TMPDIR: root,
+ TEMP: root,
+ TMP: root,
+ FIXTURE_API_KEY: 'synthetic-invalid-api-key',
+ OPENAI_API_KEY: '',
+ CODEX_API_KEY: '',
+ HTTP_PROXY: endpoint,
+ HTTPS_PROXY: endpoint,
+ ALL_PROXY: endpoint,
+ NO_PROXY: '127.0.0.1,localhost',
+ }),
+ },
+ });
+ try {
+ const handle = withFastModePolicy(
+ await agent.startSession({
+ sessionId: 'native-fast-policy',
+ providerId: 'cprov-fixture',
+ model: 'gpt-6.1-sol',
+ workingDir,
+ fastMode: true,
+ fastModePolicy: policy,
+ }),
+ policy,
+ );
+ let done = 0;
+ const errors: unknown[] = [];
+ const events = (async () => {
+ for await (const event of handle.events()) {
+ if (event.type === 'done') done++;
+ if (event.type === 'error') errors.push(event);
+ }
+ })();
+ const turn = async () => {
+ const target = done + 1;
+ await handle.send(
+ { type: 'user', content: 'return fixture complete' },
+ { throwOnStartFailure: true },
+ );
+ await expect.poll(() => done, { timeout: 15_000 }).toBe(target);
+ expect(errors).toEqual([]);
+ };
+ await turn();
+ expect(requests[0].service_tier).toBe('priority'); // Positive control: the real binary can send Fast.
+ prohibitDuringTurn = async () => {
+ state.allowed = false;
+ await update!();
+ };
+ relaxDuringTurn = async () => {
+ state.allowed = true;
+ await update!();
+ };
+ await turn();
+ expect(requests[1].service_tier).toBe('priority'); // Already admitted before the switch.
+ expect(requests[2].input).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ type: 'function_call_output', call_id: 'fixture-tool-2' }),
+ ]),
+ );
+ expect(requests[3].input).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ type: 'function_call_output', call_id: 'fixture-tool-3' }),
+ ]),
+ );
+ state.allowed = false;
+ await update!();
+ await handle.setFastMode!('ultrafast');
+ await turn();
+ state.allowed = true;
+ await update!();
+ await turn();
+ expect(requests).toHaveLength(6);
+ expect(
+ requests
+ .slice(2)
+ .every(
+ (body) =>
+ body.service_tier === undefined ||
+ body.service_tier === null ||
+ body.service_tier === 'default',
+ ),
+ ).toBe(true);
+ await handle.setFastMode!(true);
+ await turn();
+ expect(requests[6].service_tier).toBe('priority');
+ await handle.close();
+ await events;
+ } finally {
+ await agent.dispose();
+ await proxy.dispose();
+ await new Promise<void>((resolve) => {
+ server.close(() => resolve());
+ server.closeAllConnections();
+ });
+ await rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+ }
+ }, 60_000);
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/subscriptionFastRequestPolicy.test.ts b/apps/desktop/src/main/maker-host/__tests__/subscriptionFastRequestPolicy.test.ts
new file mode 100644
index 0000000000..179b1d292c
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/subscriptionFastRequestPolicy.test.ts
@@ -0,0 +1,143 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { zstdCompressSync } from 'node:zlib';
+import type { RequestTransformCtx, RoutingDecision } from '@cindy/anthropic-compat-proxy';
+import {
+ restrictSubscriptionRequest,
+ withSubscriptionFastRequestPolicy,
+} from '../subscription-fast-request-policy.js';
+
+const state = vi.hoisted(() => ({ allowed: true }));
+vi.mock('../subscription-fast-policy.js', () => ({
+ createSubscriptionFastPolicy: () => ({ isAllowed: () => state.allowed }),
+}));
+vi.mock('../active-catalog.js', () => ({
+ getActiveCatalog: () => ({
+ providers: [
+ { id: 'subscription', auth: { method: 'oauth', native: 'codex' } },
+ { id: 'claude', auth: { method: 'oauth', native: 'claude' } },
+ { id: 'openai', auth: { method: 'apiKey' } },
+ ],
+ }),
+}));
+const identity = { sessionId: 'task', providerId: 'subscription' };
+const ctx = {
+ reqId: 1,
+ method: 'POST',
+ url: '/responses',
+ headers: {},
+} as RequestTransformCtx;
+const bytes = (body: unknown) => Buffer.from(JSON.stringify(body));
+afterEach(() => {
+ state.allowed = true;
+});
+
+describe('subscription request speed policy at the actual exit', () => {
+ it('decodes compressed subscription HTTP requests without affecting API routes', async () => {
+ state.allowed = false;
+ const decision = withSubscriptionFastRequestPolicy(null, identity, {
+ ...ctx,
+ headers: { 'content-encoding': 'zstd' },
+ })!;
+ const result = await decision.transformRequestBody!(
+ zstdCompressSync(bytes({ input: [], service_tier: 'priority' })),
+ ctx,
+ );
+ expect(JSON.parse(result.body.toString())).toEqual({ input: [], service_tier: 'default' });
+ expect(decision.headerDelete).toContain('content-encoding');
+ });
+ it('keeps control and token counting endpoints unchanged', () => {
+ state.allowed = false;
+ const decision: RoutingDecision = { upstreamOverride: 'https://api.example.invalid' };
+ expect(
+ withSubscriptionFastRequestPolicy(decision, identity, {
+ ...ctx,
+ url: '/v1/messages/count_tokens',
+ }),
+ ).toBe(decision);
+ });
+ it('keeps custom API routes and bodies identical, including an API provider named openai', () => {
+ state.allowed = false;
+ const decision: RoutingDecision = { upstreamOverride: 'https://api.example.invalid' };
+ expect(withSubscriptionFastRequestPolicy(decision, { ...identity, providerId: 'openai' })).toBe(
+ decision,
+ );
+ expect(restrictSubscriptionRequest({ service_tier: 'priority' }, 'task', 'openai')).toBeNull();
+ });
+
+ it('clamps stale tool-loop payloads and rejects a captured Fast dispatch after policy tightens', async () => {
+ const decision = withSubscriptionFastRequestPolicy(null, identity)!;
+ const raw = bytes({ model: 'gpt', service_tier: 'priority', input: [] });
+ expect((await decision.transformRequestBody!(raw, ctx)).body).toBe(raw);
+ state.allowed = false;
+ expect(decision.dispatchGenerationValid!()).toBe(false);
+ const next = withSubscriptionFastRequestPolicy(null, identity)!;
+ expect(JSON.parse((await next.transformRequestBody!(raw, ctx)).body.toString())).toMatchObject({
+ service_tier: 'default',
+ input: [],
+ });
+ expect(next.dispatchGenerationValid!()).toBe(true);
+ });
+
+ it('clamps after an asynchronous route body adapter, never before its changes', async () => {
+ const decision = withSubscriptionFastRequestPolicy(
+ {
+ transformRequestBody: async () => {
+ state.allowed = false;
+ return { body: bytes({ service_tier: 'ultrafast', input: [] }) };
+ },
+ },
+ identity,
+ )!;
+ expect(
+ JSON.parse((await decision.transformRequestBody!(bytes({}), ctx)).body.toString())
+ .service_tier,
+ ).toBe('default');
+ });
+
+ it('keeps Claude payloads valid and handles native Pi compressed local dispatch', async () => {
+ state.allowed = false;
+ let seen: Parameters<NonNullable<RoutingDecision['localHandler']>>[0] | undefined;
+ const decision = withSubscriptionFastRequestPolicy(
+ {
+ localHandler: async (args) => {
+ seen = args;
+ },
+ },
+ { ...identity, providerId: 'claude' },
+ )!;
+ await decision.localHandler!({
+ rawBody: zstdCompressSync(bytes({ model: 'claude', messages: [], speed: 'fast' })),
+ parsedBody: undefined,
+ ctx: { ...ctx, headers: { 'content-encoding': 'zstd' } },
+ res: {} as never,
+ });
+ expect(seen!.parsedBody).toEqual({ model: 'claude', messages: [], speed: 'standard' });
+ expect(seen!.ctx.headers).not.toHaveProperty('content-encoding');
+ });
+
+ it('rewrites each WebSocket create payload against the live policy', () => {
+ expect(
+ restrictSubscriptionRequest(
+ { type: 'response.create', service_tier: 'priority' },
+ 'task',
+ 'subscription',
+ ),
+ ).toBeNull();
+ state.allowed = false;
+ expect(
+ restrictSubscriptionRequest(
+ { type: 'response.create', service_tier: 'ultrafast' },
+ 'task',
+ 'subscription',
+ ),
+ ).toEqual({ type: 'response.create', service_tier: 'default' });
+ });
+
+ it.each(['session.update', 'conversation.item.create', 'response.cancel', 'ping'])(
+ 'leaves the WebSocket control event %s unchanged when Fast is forbidden',
+ (type) => {
+ state.allowed = false;
+ expect(restrictSubscriptionRequest({ type }, 'task', 'subscription')).toBeNull();
+ },
+ );
+});
diff --git a/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts b/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts
index 24dcf038b6..b0bd4ac967 100644
--- a/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts
+++ b/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts
@@ -63,6 +63,7 @@ import {
isOwnerBoundaryPendingError,
} from './owner-boundary-error.js';
import { getSessionEffort, getSessionFastMode } from './session-effort-store.js';
+import { subscriptionRequestAllowsFast, withSubscriptionFastRequestPolicy } from './subscription-fast-request-policy.js';
import {
isExclusiveXaiModelId,
isSubscriptionDirectRoute,
@@ -599,6 +600,7 @@ function unavailablePiProviderRoute(providerId: string): RoutingDecision {
* chip 用全局活性状态重算会与 child 真实路由发散。export 仅供单测。
*/
export function createModelRoutingTransform(): RoutingTransform {
+ const fastIdentities = new WeakMap<Readonly<Record<string, string>>, { sessionId?: string | null; providerId?: string | null }>();
// guest:供应商分享受邀者的 Claude Code 请求(带路由令牌,已核对模型),按其会话显式来源路由,
// 不走隐式推断与默认网关(分享的就是网关时除外)。缺省 = 本机用户自己的请求,路由不变。
const route = async (
@@ -762,6 +764,7 @@ export function createModelRoutingTransform(): RoutingTransform {
if (pendingRoute) return pendingRoute;
const selectedProviderId = sessionId ? getSessionProvider(sessionId) : null;
+ fastIdentities.set(ctx.headers, { sessionId, providerId: piSessionId ? piProviderId : selectedProviderId });
// CC may resolve a different provider for this request (subscriptions and
// implicit child routes). Check the grant where the actual route is known.
const authorizeClaudeRoute = (providerId: string | null | undefined, model = wireModel): RoutingDecision | null =>
@@ -810,6 +813,7 @@ export function createModelRoutingTransform(): RoutingTransform {
const bridgeProviderId = isExclusiveXaiModelId(wireModel)
? (isXaiSubscriptionProviderId(selectedProviderId) ? selectedProviderId : 'xai')
: (isOpenAiSubscriptionProviderId(selectedProviderId) ? selectedProviderId : 'openai');
+ fastIdentities.set(ctx.headers, { sessionId, providerId: bridgeProviderId });
const denied = authorizeClaudeRoute(bridgeProviderId, bridgedSubscriptionModel(wireModel));
if (denied) return denied;
const bridgeHandler = getResponsesBridgeHandler((isOpenAiSubscriptionProviderId(selectedProviderId) || isXaiSubscriptionProviderId(selectedProviderId)) ? selectedProviderId! : undefined);
@@ -837,7 +841,12 @@ export function createModelRoutingTransform(): RoutingTransform {
}
return bridgeHandler.handle({
...args,
- prefs: { reasoningEffort: effort ?? undefined, fast },
+ prefs: {
+ reasoningEffort: effort ?? undefined,
+ // The bridge reads this after awaiting authentication. Keep the
+ // request's preference, but recheck the live host restriction.
+ get fast() { return fast && subscriptionRequestAllowsFast(sessionId, bridgeProviderId); },
+ },
});
},
};
@@ -969,7 +978,10 @@ export function createModelRoutingTransform(): RoutingTransform {
bridged && bridgeRoute.routing.requestPath
? { ...bridged, pathOverride: bridgeRoute.routing.requestPath }
: bridged;
- if (withRequestPath) return attachClaudeProviderBridge(withRequestPath, bridgeRoute.providerId, wireModel, sessionId ?? undefined);
+ if (withRequestPath) {
+ fastIdentities.set(ctx.headers, { sessionId, providerId: bridgeRoute.providerId });
+ return attachClaudeProviderBridge(withRequestPath, bridgeRoute.providerId, wireModel, sessionId ?? undefined);
+ }
}
const implicitOAuth = resolveImplicitProviderOAuthRouteDecision(
wireModel,
@@ -988,6 +1000,7 @@ export function createModelRoutingTransform(): RoutingTransform {
// ② 未显式选供应商 → 据请求凭证判定 spawn 形态(见上方注释)。
// 函数声明提升:①.5 的回落分支在自身解析落空时复用本段,行为与引入 ①.5 前一致。
function decideDefaultRoute(): RoutingDecision | null {
+ fastIdentities.delete(ctx.headers);
const denied = authorizeClaudeRoute('xd');
if (denied) return denied;
// 计费路由旁路只记「未显式选供应商」的会话(registry 声明的语义,消费方也只在
@@ -1087,6 +1100,7 @@ export function createModelRoutingTransform(): RoutingTransform {
// pending 与 activeOwnerScopeKey 合成同一条 ownerBoundDispatchUnsafe:
// 切换在 await 里完整完成时两端 pending 都是 false。
if (ownerBoundDispatchUnsafe(ctx)) return ownerBoundaryPendingRoute();
+ resolved = withSubscriptionFastRequestPolicy(resolved, fastIdentities.get(ctx.headers) ?? {}, ctx);
return withOwnerBoundaryDispatchGate(
refuseUnsafePlaceholderPassthrough(stripGuestRouteHeader(stripInternalPiHeaders(resolved)), ctx),
ctx,
diff --git a/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts b/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts
index f2e227ecb7..478a31275b 100644
--- a/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts
+++ b/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts
@@ -2,6 +2,8 @@ import { fastModelId, rewriteFastModel } from './model-fast-mode.js';
import { captureUsagePricing, createUsagePricingObserver } from './model-usage-pricing.js';
import type { ResponseObserverSink } from '@cindy/anthropic-compat-proxy';
import { getSessionFastMode } from './session-effort-store.js';
+import { standardSpeedRequest } from '@cindy/maker-core';
+import { subscriptionRequestAllowsFast } from './subscription-fast-request-policy.js';
import { isXaiSubscriptionProviderId } from './subscription-account-auth.js';
/**
* Desktop 端 anthropic-responses-bridge 装配 ——
@@ -821,6 +823,15 @@ export function getPiNativeSubscriptionHandler(
throwIfOwnerBoundDispatchUnsafe(scopeAtStart);
if (contentEncoding) headers['content-encoding'] = contentEncoding;
+ // Native Pi sends each tool-loop request here; recheck after auth/context awaits.
+ if (isOpenAiSubscriptionProviderId(providerId) && !subscriptionRequestAllowsFast(sessionId, providerId)) {
+ const bytes = contentEncoding?.toLowerCase() === 'zstd' ? await zstdDecompressAsync(outboundBody) : outboundBody;
+ const standard = standardSpeedRequest(JSON.parse(bytes.toString('utf8')));
+ outboundBody = Buffer.from(JSON.stringify(standard));
+ delete headers['content-encoding'];
+ }
+
+ throwIfOwnerBoundDispatchUnsafe(scopeAtStart);
const response = await deps.fetch(upstream.url, {
method: 'POST',
headers,
diff --git a/apps/desktop/src/main/maker-host/codex-proxy-host.ts b/apps/desktop/src/main/maker-host/codex-proxy-host.ts
index bdcf504fb5..7ae2048286 100644
--- a/apps/desktop/src/main/maker-host/codex-proxy-host.ts
+++ b/apps/desktop/src/main/maker-host/codex-proxy-host.ts
@@ -2,6 +2,7 @@ import { captureUsagePricing, createUsagePricingObserver } from './model-usage-p
import { rewriteFastModel } from './model-fast-mode.js';
import { createAttachmentRecovery } from './oversized-attachment-recovery.js';
import { clearCodexTextOnlyPolicies, codexTextOnlyRequestGuard, codexTextOnlyWebSocketTransforms, isCodexTextOnly } from './codex-text-only-policy.js';
+import { restrictSubscriptionRequest, withSubscriptionFastRequestPolicy } from './subscription-fast-request-policy.js';
import {
resolveConversationSessionHeaders,
withChatBridgeUserAgent,
@@ -3422,6 +3423,15 @@ async function createCodexProxyHandle(
const frozenReasoning = createCustomProviderReasoningTransform(frozenCustomProviderRoutes);
const routeWithUsageEncoding: RoutingTransform = (body, ctx) => {
const uncompressed = (decision: RoutingDecision | null): RoutingDecision | null => {
+ const model = isPlainObject(body) && typeof body.model === 'string' ? body.model : '';
+ const context = providerContextForRequest(ctx.headers, model);
+ const customPath = parseCodexCustomProviderPath(ctx.url);
+ const customProviderId = customPath.kind === 'route' ? customProviderRouteSnapshot(customPath.routeId, frozenCustomProviderRoutes)?.providerId : null;
+ decision = withSubscriptionFastRequestPolicy(decision, {
+ sessionId: context.sessionId ?? guestSessionId,
+ providerId: customProviderId ?? gatewayProviderIdForRewrittenModel(model) ?? context.providerId ?? guestProviderId
+ ?? (gatewayProviderIdForRewrittenModel(model) ? null : (frozenAuthInjection ?? getCodexProxyAuthInjection()) === 'oauth-bearer' ? 'openai' : null),
+ }, ctx);
if (decision?.localHandler || !isXaiUpstream(decision?.upstreamOverride ?? '')
|| ctx.method !== 'POST' || !ctx.url.split('?', 1)[0]?.endsWith('/responses')) return decision;
// The observer receives raw wire bytes. Negotiate plaintext so the execution-price
@@ -3461,7 +3471,12 @@ async function createCodexProxyHandle(
},
requestGuard: ctx => codexTextOnlyRequestGuard(isCodexTextOnly(selectedThreadIdFromHeaders(ctx.headers)), ctx, isChatGptUpstreamBase),
// Accepted WebSockets route exclusively to CODEX_OAUTH_UPSTREAM (see resolver below).
- webSocketTransforms: ctx => codexTextOnlyWebSocketTransforms(() => isCodexTextOnly(selectedThreadIdFromHeaders(ctx.headers)), true),
+ webSocketTransforms: ctx => codexTextOnlyWebSocketTransforms(() => isCodexTextOnly(selectedThreadIdFromHeaders(ctx.headers)), true, message => {
+ const body: unknown = JSON.parse(message.toString('utf8'));
+ const context = providerContextForRequest(ctx.headers, isPlainObject(body) && typeof body.model === 'string' ? body.model : '');
+ const next = restrictSubscriptionRequest(body, context.sessionId ?? guestSessionId, context.providerId ?? guestProviderId ?? 'openai');
+ return next ? Buffer.from(JSON.stringify(next)) : message;
+ }),
transformResponse: (ctx) => {
const response = {
contentType: ctx.responseHeaders['content-type'] ?? '',
diff --git a/apps/desktop/src/main/maker-host/codex-text-only-policy.ts b/apps/desktop/src/main/maker-host/codex-text-only-policy.ts
index 6b2966d7dd..f336074653 100644
--- a/apps/desktop/src/main/maker-host/codex-text-only-policy.ts
+++ b/apps/desktop/src/main/maker-host/codex-text-only-policy.ts
@@ -152,7 +152,7 @@ export function codexTextOnlyRequestGuard(
};
}
-export function codexTextOnlyWebSocketTransforms(disabled: () => boolean, requiresSerial = false) {
+export function codexTextOnlyWebSocketTransforms(disabled: () => boolean, requiresSerial = false, transformRequest: (message: Buffer) => Buffer = message => message) {
// Frozen at each request, never relaxed by a subsequent UI send or teardown.
let restricted = false;
let completed = true;
@@ -162,7 +162,7 @@ export function codexTextOnlyWebSocketTransforms(disabled: () => boolean, requir
if (restricted && !completed) reject();
restricted = next;
completed = false;
- return restricted ? restrictCodexRequest(message, { serial: requiresSerial }) : message;
+ return transformRequest(restricted ? restrictCodexRequest(message, { serial: requiresSerial }) : message);
}),
inbound: createWebSocketMessageTransform(false, message => {
if (restricted) {
diff --git a/apps/desktop/src/main/maker-host/createDesktopProviderService.ts b/apps/desktop/src/main/maker-host/createDesktopProviderService.ts
index 53f77fa490..5d6a5cc197 100644
--- a/apps/desktop/src/main/maker-host/createDesktopProviderService.ts
+++ b/apps/desktop/src/main/maker-host/createDesktopProviderService.ts
@@ -1,4 +1,5 @@
import { readProviderPresentation } from './provider-presentation-store.js';
+import { projectSubscriptionFastPolicy } from './subscription-fast-policy.js';
import { filterLegacyGptContextProfiles } from './legacy-context-profiles.js';
import { subscriptionAccountState, isXaiSubscriptionProviderId, resetSubscriptionAccountCaches } from './subscription-account-auth.js';
/**
@@ -1005,6 +1006,7 @@ export function getDesktopProviderService(options: { allowSideEffects?: boolean
}
if (singleton) return singleton;
singleton = createProviderService({
+ projectProvider: projectSubscriptionFastPolicy,
getProviderPresentation: readProviderPresentation,
getCatalog: getDesktopSelectableCatalog,
connection: {
diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.ts
index 6bf265ccd2..65736b8bae 100644
--- a/apps/desktop/src/main/maker-host/index.ts
+++ b/apps/desktop/src/main/maker-host/index.ts
@@ -128,6 +128,7 @@ import {
} from '../maker-ipc/register.js';
import { MAKER_PUSH } from '../maker-ipc/channels.js';
import { readProviderGroupBinding } from '../provider-group/bindings.js';
+import { createSubscriptionFastPolicy } from './subscription-fast-policy.js';
import { getProviderGroupGuestSwitch } from '../provider-group/guestSwitch.js';
import { tapWindowBroadcast } from '../device-link/broadcast-tap.js';
import { remoteBackgroundInvoke, remoteInvoke } from '../device-link/index.js';
@@ -2950,6 +2951,10 @@ export function getMaker(): Maker {
}
// 所有创建路径共用的派发边界,opts.providerId 此刻已是本次启动的终值。
freezeSessionProviderAtStart(sessionId, opts.providerId);
+ if (!opts.remoteHostId && !opts.agentDeviceId) {
+ opts.fastModePolicy = createSubscriptionFastPolicy(sessionId, () => getSessionProvider(sessionId)
+ ?? resolveDesktopModelContextProviderId(getDesktopSelectableCatalog(), opts.agentKind, null, opts.model));
+ }
await preparePersistedOrcaSessionStart(sessionId, opts as MakerSessionCreateOpts);
if (opts.agentKind === 'pi' && opts.thinkingEnabled === undefined) {
const thinkingEnabled = getThinkingEnabledFromMemory(
diff --git a/apps/desktop/src/main/maker-host/provider-fast-policy-store.ts b/apps/desktop/src/main/maker-host/provider-fast-policy-store.ts
new file mode 100644
index 0000000000..a7ce29b69d
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/provider-fast-policy-store.ts
@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
+import { createLogger } from '../logger.js';
+import { createOverrideSettingsFile } from './override-settings-file.js';
+
+interface Settings {
+ providers: Record<string, boolean> | null;
+}
+
+/** Sparse overrides keyed by the actual account connection, never the public catalog brand. */
+export function createProviderFastPolicyStore(options: { filePath(): string; scopeKey(): string }) {
+ const store = createOverrideSettingsFile<Settings>({
+ ...options,
+ defaults: () => {
+ try {
+ fs.statSync(options.filePath());
+ return { providers: null };
+ } catch (error) {
+ return { providers: (error as NodeJS.ErrnoException).code === 'ENOENT' ? {} : null };
+ }
+ },
+ normalize(raw) {
+ const providers = (raw as Settings | null)?.providers;
+ if (!providers || typeof providers !== 'object' || Array.isArray(providers))
+ return { providers: null };
+ if (Object.keys(providers).length > 4096) return { providers: null };
+ return {
+ providers: Object.fromEntries(
+ Object.entries(providers).map(([id, allowed]) => [id, allowed === true]),
+ ),
+ };
+ },
+ log: createLogger('provider-fast-policy'),
+ label: 'provider-fast-policy',
+ maxBytes: 256 * 1024,
+ preserveUnreadableFile: true,
+ logLoadedValue: false,
+ logReadErrorDetails: false,
+ });
+ return {
+ allows(providerId: string): boolean {
+ store.invalidateIfChanged();
+ const providers = store.read().providers;
+ return (
+ providers !== null &&
+ (!Object.hasOwn(providers, providerId) || providers[providerId] === true)
+ );
+ },
+ async set(providerId: string, allowed: boolean, assertCurrent: () => void): Promise<void> {
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ if (value.providers === null) throw new Error('Subscription Fast policy could not be read');
+ if (
+ !Object.hasOwn(value.providers, providerId) &&
+ Object.keys(value.providers).length >= 4096
+ )
+ throw new Error('Too many subscription Fast policies');
+ return { providers: { ...value.providers, [providerId]: allowed } };
+ });
+ assertCurrent();
+ },
+ };
+}
+
+export const providerFastPolicy = createProviderFastPolicyStore({
+ filePath: () => ownerScopedUserDataPath('provider-fast-policy.json'),
+ scopeKey: activeOwnerScopeKey,
+});
diff --git a/apps/desktop/src/main/maker-host/provider-service.ts b/apps/desktop/src/main/maker-host/provider-service.ts
index c6a61f487d..34c4870166 100644
--- a/apps/desktop/src/main/maker-host/provider-service.ts
+++ b/apps/desktop/src/main/maker-host/provider-service.ts
@@ -75,6 +75,7 @@ export interface ProviderConnectionReaders {
}
export interface ProviderServiceDeps {
+ projectProvider?: (provider: ProviderView) => ProviderView;
getProviderPresentation?: (providerId: string) => { name?: string; removed?: boolean };
/** 返回当前生效目录(同步)。桌面端注入 active-catalog 的 getActiveCatalog。 */
getCatalog: () => Catalog;
@@ -230,7 +231,7 @@ export function createProviderService(deps: ProviderServiceDeps): ProviderServic
),
],
},
- );
+ ).map(provider => deps.projectProvider?.(provider) ?? provider);
}
return { listProviders };
diff --git a/apps/desktop/src/main/maker-host/subscription-fast-policy.ts b/apps/desktop/src/main/maker-host/subscription-fast-policy.ts
new file mode 100644
index 0000000000..57fb34456a
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/subscription-fast-policy.ts
@@ -0,0 +1,123 @@
+import { supportsSubscriptionFastPolicy, type ProviderView } from '@cindy/model-providers';
+import type { StartSessionOptions } from '@cindy/maker-core';
+import { activeOwnerScopeKey } from '../appSessionState.js';
+import { readProviderGroupBinding } from '../provider-group/bindings.js';
+import { readProviderGroup } from '../provider-group/store.js';
+import { groupFastPolicyStore } from '../provider-group/fastPolicyStore.js';
+import { getActiveCatalog } from './active-catalog.js';
+import { providerFastPolicy } from './provider-fast-policy-store.js';
+import { setSessionFastMode } from './session-effort-store.js';
+
+type Policy = NonNullable<StartSessionOptions['fastModePolicy']>;
+const listeners = new Set<() => Promise<void>>();
+let timer: ReturnType<typeof setInterval> | undefined;
+let suppressedOwner: string | undefined;
+const suppressedBySession = new Map<string, Set<string>>();
+
+function ownerSuppression(owner: string): Map<string, Set<string>> | undefined {
+ if (activeOwnerScopeKey() !== owner) return undefined;
+ if (suppressedOwner !== owner) {
+ suppressedOwner = owner;
+ suppressedBySession.clear();
+ }
+ return suppressedBySession;
+}
+
+/** Also catches edits from another instance without starting a timer for each task. */
+export async function notifySubscriptionFastPolicyChanged(): Promise<void> {
+ const results = await Promise.allSettled([...listeners].map((listener) => listener()));
+ const failure = results.find((result) => result.status === 'rejected');
+ if (failure?.status === 'rejected') throw failure.reason;
+}
+
+export function createSubscriptionFastPolicy(
+ sessionId: string,
+ providerId: () => string | null | undefined,
+): Policy {
+ const owner = activeOwnerScopeKey();
+ const isAllowed = () => {
+ if (activeOwnerScopeKey() !== owner) return false;
+ const id = providerId();
+ const provider = getActiveCatalog().providers.find((p) => p.id === id);
+ if (!supportsSubscriptionFastPolicy(provider)) return true;
+ const binding = readProviderGroupBinding(sessionId);
+ const groupAllows =
+ !binding ||
+ !!binding.groupDeviceId ||
+ readProviderGroup(binding.providerId)?.allowFast !== false;
+ return providerFastPolicy.allows(id!) && groupAllows && groupFastPolicyStore.allows(sessionId);
+ };
+ return {
+ isAllowed,
+ isRequestAllowed() {
+ const id = providerId();
+ const provider = getActiveCatalog().providers.find((p) => p.id === id);
+ return (
+ isAllowed() &&
+ (!supportsSubscriptionFastPolicy(provider) ||
+ !ownerSuppression(owner)
+ ?.get(sessionId)
+ ?.has(id ?? ''))
+ );
+ },
+ onFastModeChanged(enabled) {
+ const id = providerId();
+ const provider = getActiveCatalog().providers.find((p) => p.id === id);
+ const suppressed = ownerSuppression(owner);
+ if (!suppressed || !id || !supportsSubscriptionFastPolicy(provider)) return;
+ if (enabled) {
+ const ids = suppressed.get(sessionId);
+ ids?.delete(id);
+ if (!ids?.size) suppressed.delete(sessionId);
+ } else {
+ const ids = suppressed.get(sessionId) ?? new Set<string>();
+ ids.add(id);
+ suppressed.set(sessionId, ids);
+ }
+ setSessionFastMode(sessionId, enabled);
+ },
+ subscribe(listener) {
+ let previous = isAllowed();
+ const check = async () => {
+ const allowed = isAllowed();
+ if (allowed === previous) return;
+ await listener();
+ previous = allowed;
+ };
+ listeners.add(check);
+ timer ??= setInterval(() => {
+ void notifySubscriptionFastPolicyChanged().catch(() => undefined);
+ }, 1_000);
+ timer.unref?.();
+ return () => {
+ listeners.delete(check);
+ if (!listeners.size) {
+ clearInterval(timer);
+ timer = undefined;
+ }
+ };
+ },
+ };
+}
+
+/** Effective presentation only: raw catalog capabilities and user model patches stay intact. */
+export function projectSubscriptionFastPolicy(provider: ProviderView): ProviderView {
+ if (!supportsSubscriptionFastPolicy(provider)) return provider;
+ const allowFast = providerFastPolicy.allows(provider.id);
+ const groupAllowsFast = readProviderGroup(provider.id)?.allowFast !== false;
+ const view = { ...provider, subscriptionFastPolicy: { allowFast, groupAllowsFast } };
+ if (allowFast && groupAllowsFast) return view;
+ return {
+ ...view,
+ models: Object.fromEntries(
+ Object.entries(provider.models).map(([agent, models]) => [
+ agent,
+ models?.map((model) => ({
+ ...model,
+ supportsFastMode: false,
+ supportsUltrafastMode: false,
+ })),
+ ]),
+ ),
+ } as ProviderView;
+}
diff --git a/apps/desktop/src/main/maker-host/subscription-fast-request-policy.ts b/apps/desktop/src/main/maker-host/subscription-fast-request-policy.ts
new file mode 100644
index 0000000000..4b6744eb89
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/subscription-fast-request-policy.ts
@@ -0,0 +1,125 @@
+import type { RoutingDecision, RequestTransformCtx } from '@cindy/anthropic-compat-proxy';
+import { promisify } from 'node:util';
+import { brotliDecompress, gunzip, zstdDecompress } from 'node:zlib';
+import { standardSpeedRequest } from '@cindy/maker-core';
+import { supportsSubscriptionFastPolicy } from '@cindy/model-providers';
+import { getActiveCatalog } from './active-catalog.js';
+import { createSubscriptionFastPolicy } from './subscription-fast-policy.js';
+
+const decompressors: Record<string, (bytes: Uint8Array) => Promise<Buffer>> = {
+ zstd: promisify(zstdDecompress),
+ gzip: promisify(gunzip),
+ br: promisify(brotliDecompress),
+};
+
+export function subscriptionRequestAllowsFast(
+ sessionId: string | null | undefined,
+ providerId: string | null | undefined,
+): boolean {
+ const policy = createSubscriptionFastPolicy(sessionId ?? '', () => providerId);
+ return policy.isRequestAllowed?.() ?? policy.isAllowed();
+}
+
+export function restrictSubscriptionRequest(
+ body: unknown,
+ sessionId: string | null | undefined,
+ providerId: string | null | undefined,
+): unknown | null {
+ if (
+ !supportsSubscriptionFastPolicy(getActiveCatalog().providers.find((p) => p.id === providerId))
+ )
+ return null;
+ if (subscriptionRequestAllowsFast(sessionId, providerId)) return null;
+ return standardSpeedRequest(body);
+}
+
+/** Apply after route selection, before every HTTP/handler dispatch; API routes keep their original object. */
+export function withSubscriptionFastRequestPolicy(
+ decision: RoutingDecision | null,
+ identity: { sessionId?: string | null; providerId?: string | null },
+ ctx?: RequestTransformCtx,
+): RoutingDecision | null {
+ if (
+ ctx &&
+ (ctx.method !== 'POST' ||
+ !/\/(?:responses|messages|chat\/completions)\/?(?:\?.*)?$/.test(ctx.url))
+ )
+ return decision;
+ if (
+ !supportsSubscriptionFastPolicy(
+ getActiveCatalog().providers.find((p) => p.id === identity.providerId),
+ )
+ )
+ return decision;
+ const policy = createSubscriptionFastPolicy(identity.sessionId ?? '', () => identity.providerId);
+ const allowsRequest = () => policy.isRequestAllowed?.() ?? policy.isAllowed();
+ let dispatchedWithFastAllowed = allowsRequest();
+ const encoding = ctx?.headers['content-encoding']?.toLowerCase();
+ const decodeForwarded =
+ encoding && Object.hasOwn(decompressors, encoding) ? decompressors[encoding] : undefined;
+ const restrict = async (body: Buffer) => {
+ dispatchedWithFastAllowed = allowsRequest();
+ if (!body.length || (dispatchedWithFastAllowed && !decodeForwarded)) return body;
+ let parsed: unknown;
+ try {
+ parsed = JSON.parse(body.toString('utf8'));
+ } catch (error) {
+ if (!decodeForwarded) throw error;
+ parsed = JSON.parse((await decodeForwarded(body)).toString('utf8'));
+ }
+ // Re-read after asynchronous decompression too.
+ dispatchedWithFastAllowed = allowsRequest();
+ const next = dispatchedWithFastAllowed ? parsed : (standardSpeedRequest(parsed) ?? parsed);
+ return Buffer.from(JSON.stringify(next));
+ };
+ if (decision?.localHandler) {
+ const handler = decision.localHandler;
+ return {
+ ...decision,
+ localHandler: async (args) => {
+ if (allowsRequest() || !args.rawBody.length) return handler(args);
+ let parsedBody = args.parsedBody;
+ if (parsedBody === undefined) {
+ const encoding = args.ctx.headers['content-encoding']?.toLowerCase();
+ const decode =
+ encoding && Object.hasOwn(decompressors, encoding)
+ ? decompressors[encoding]
+ : undefined;
+ const bytes = decode ? await decode(args.rawBody) : args.rawBody;
+ parsedBody = JSON.parse(bytes.toString('utf8'));
+ }
+ parsedBody = standardSpeedRequest(parsedBody) ?? parsedBody;
+ const headers = { ...args.ctx.headers };
+ delete headers['content-encoding'];
+ delete headers['content-length'];
+ return handler({
+ ...args,
+ rawBody: Buffer.from(JSON.stringify(parsedBody)),
+ parsedBody,
+ ctx: { ...args.ctx, headers },
+ });
+ },
+ };
+ }
+ return {
+ ...decision,
+ ...(decodeForwarded
+ ? {
+ headerDelete: [
+ ...new Set([...(decision?.headerDelete ?? []), 'content-encoding', 'content-length']),
+ ],
+ }
+ : {}),
+ // If policy changes during asynchronous routing/forwarding or a transparent retry,
+ // reject a previously admitted Fast payload rather than leaking it to the upstream.
+ dispatchGenerationValid: () =>
+ decision?.dispatchGenerationValid?.() !== false &&
+ (!dispatchedWithFastAllowed || allowsRequest()),
+ transformRequestBody: async (body, ctx) => {
+ const rewritten = decision?.transformRequestBody
+ ? await decision.transformRequestBody(body, ctx)
+ : { body };
+ return { ...rewritten, body: await restrict(rewritten.body) };
+ },
+ };
+}
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 18dae74717..c5b562597d 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -135,6 +135,7 @@ import { readSshCodexModelList, assertSshCodexModel, isVerifiedSshCodexResume }
import { prepareCodexCustomContextCatalog } from '../maker-host/codex-custom-context-catalog.js';
import { inferProviderIdForModel } from '../maker-host/provider-route.js';
import { resolveConfiguredContextWindow, resolveDesktopModelContextProviderId } from '../maker-host/model-context-settings.js';
+import { bindGroupFastPolicy } from '../provider-group/fastPolicyRuntime.js';
import { getCodexHome } from '../maker-host/auth-adapters.js';
import { getCachedBinaryStatus } from '../agent-binaries/index.js';
import { AsyncLocalStorage } from 'node:async_hooks';
@@ -1152,6 +1153,7 @@ import {
setSessionProvider,
} from '../maker-host/session-provider-store.js';
import { getActiveCatalog, setDiscoveredProviderModels } from '../maker-host/active-catalog.js';
+import { createSubscriptionFastPolicy } from '../maker-host/subscription-fast-policy.js';
import { readCompactionPct } from '../maker-host/compaction-settings-store.js';
import { resolveVerifiedContextWindow, resolveModelDefaultContextWindow } from '../maker-host/catalog-to-descriptors.js';
import {
@@ -8558,6 +8560,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
o.agentDeviceId = context.route.agentDeviceId;
o.providerId = context.route.providerId;
}
+ if (context && !context.groupDeviceId && context.route.agentDeviceId) {
+ await bindGroupFastPolicy({ group: context.groupProviderId, deviceId: context.route.agentDeviceId, sessionId: o.id });
+ }
return context;
}
@@ -23957,7 +23962,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
if (typeof sessionId !== 'string' || (typeof requestedSpeed !== 'boolean' && requestedSpeed !== 'ultrafast')) {
throwIpcError('INVALID_PARAMS', 'sessionId + enabled required');
}
- const enabled: boolean | 'ultrafast' = requestedSpeed;
+ let enabled: boolean | 'ultrafast' = requestedSpeed;
const runtimeOwnerEpoch = captureSessionRuntimeControlOwnerEpoch();
const assertSharedTaskCurrent = captureSharedTaskSettingGuard(sessionId);
const assertOwnerCurrent = () => {
@@ -23995,6 +24000,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
);
}
const userIntent = agentSwitchPending.get(sessionId);
+ const fastProfile = (await readSessionRuntimeProfiles(sessionId))?.effective;
+ assertOwnerCurrent();
+ const subscriptionForbidsFast = !fastProfile?.agentDeviceId && !createSubscriptionFastPolicy(sessionId,
+ () => fastProfile?.providerId ?? getSessionProvider(sessionId)).isAllowed();
+ if (subscriptionForbidsFast) enabled = false;
if (enabled === 'ultrafast') {
const profiles = await readSessionRuntimeProfiles(sessionId);
const profile = isUserPendingAgentSwitchIntent(userIntent)
@@ -24052,7 +24062,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
log.debug('set-fast-mode: session not found, no-op', { sessionId });
return remoteResponse;
}
- if (sess.agentKind !== 'codex' && sess.agentKind !== 'pi') {
+ if (sess.agentKind !== 'codex' && sess.agentKind !== 'pi' && !(sess.agentKind === 'claude-code' && subscriptionForbidsFast)) {
await commitRuntimeAxisAfterPersistence({
persist: persistFastMode,
commit: commitFastMode,
@@ -24078,6 +24088,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
assertOwnerCurrent();
assertSharedTaskCurrent.admit();
await sess.setFastMode(enabled);
+ enabled = sess.getFastMode() ?? enabled;
+ livePatch.fastMode = enabled;
+ pendingPatch.fastMode = enabled;
await commitRuntimeAxisAfterPersistence({
persist: persistFastMode,
commit: commitFastMode,
diff --git a/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts b/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts
new file mode 100644
index 0000000000..f117db302b
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts
@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ProviderGroupConfig } from '../../../shared/providerGroup.js';
+import { hostSessionIdFor } from '../../remote-agent/host/sessionIdentity.js';
+
+const state = vi.hoisted(() => ({
+ owner: 'test',
+ config: null as ProviderGroupConfig | null,
+ subscription: true,
+ old: new Set<string>(),
+ offline: new Set<string>(),
+ broken: new Set<string>(),
+ beforeCaps: undefined as undefined | (() => Promise<void>),
+ calls: [] as Array<{ device: string; command: Record<string, any> }>,
+ notify: vi.fn(async () => {}),
+}));
+const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-fast-sync-'));
+vi.mock('../../logger.js', () => ({ createLogger: () => ({ info() {}, warn() {}, error() {} }) }));
+vi.mock('../../appSessionState.js', () => ({
+ activeOwnerScopeKey: () => state.owner,
+ ownerScopedUserDataPath: (file: string) => path.join(temporary, state.owner, file),
+ isAppSessionBoundaryPending: () => false,
+}));
+vi.mock('../../maker-host/active-catalog.js', () => ({
+ getActiveCatalog: () => ({
+ providers: [
+ { id: 'openai', auth: { method: state.subscription ? 'oauth' : 'apiKey', native: 'codex' } },
+ ],
+ }),
+}));
+vi.mock('../../maker-host/subscription-fast-policy.js', () => ({
+ notifySubscriptionFastPolicyChanged: () => state.notify(),
+}));
+vi.mock('../store.js', () => ({
+ readProviderGroup: () => state.config,
+ listProviderGroups: () => (state.config ? { openai: state.config } : {}),
+}));
+vi.mock('../../device-link/index.js', () => ({
+ getSelfDeviceId: () => 'self',
+ remoteBackgroundInvoke: async (
+ device: string,
+ _channel: string,
+ args: Array<Record<string, any>>,
+ ) => {
+ const command = args[0];
+ state.calls.push({ device, command });
+ if (command.op === 'caps') await state.beforeCaps?.();
+ if (state.broken.has(device)) throw Error('[LINK_NOT_OPEN] disconnected');
+ if (state.offline.has(device))
+ return { ok: false, error: { code: 'IPC_ERROR', message: 'offline' } };
+ if (command.op === 'caps')
+ return {
+ ok: true,
+ result: {
+ version: 1,
+ maxRuns: 10,
+ uploadChunkBytes: 1024,
+ maxPayloadBytes: 8192,
+ ...(!state.old.has(device) ? { subscriptionFastPolicy: true } : {}),
+ },
+ };
+ return { ok: true, result: { revision: command.revision, allowFast: command.allowFast } };
+ },
+}));
+const runtime = await import('../fastPolicyRuntime.js');
+const { groupFastPolicyStore } = await import('../fastPolicyStore.js');
+let sequence = 0;
+beforeEach(() => {
+ state.owner = `owner-${++sequence}`;
+ state.subscription = true;
+ state.calls = [];
+ state.old.clear();
+ state.offline.clear();
+ state.broken.clear();
+ state.beforeCaps = undefined;
+ state.notify.mockReset().mockResolvedValue(undefined);
+ state.config = {
+ strategy: 'least',
+ autoSwitch: true,
+ allowFast: false,
+ members: ['one', 'two'].map((device) => ({
+ key: `device:${device}:openai`,
+ kind: 'device',
+ agentDeviceId: device,
+ providerId: 'openai',
+ limit: 10,
+ weight: 1,
+ paused: false,
+ })),
+ };
+});
+afterAll(() => fs.rmSync(temporary, { recursive: true, force: true }));
+
+describe('group owner to executor enforcement handshake', () => {
+ it('coalesces repeated sync requests while the same offline revision is in flight', async () => {
+ let release!: () => void;
+ state.beforeCaps = () =>
+ new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ // Only one remote endpoint makes the blocked request count unambiguous.
+ state.config!.members = state.config!.members.slice(0, 1);
+ state.offline.add('one');
+ const first = runtime.syncGroupFastPolicy('openai');
+ await expect.poll(() => state.calls.length).toBe(1);
+ const repeats = Array.from({ length: 5 }, () => runtime.syncGroupFastPolicy('openai'));
+ state.beforeCaps = undefined;
+ release();
+ await Promise.all([first, ...repeats]);
+ expect(state.calls).toHaveLength(1);
+ expect(runtime.groupFastPolicyPending('openai')).toBe(true);
+ });
+
+ it('reports a changed setting as pending before it has been sent to executors', async () => {
+ await runtime.syncGroupFastPolicy('openai');
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ state.config!.allowFast = true;
+ expect(runtime.groupFastPolicyPending('openai')).toBe(true);
+ });
+
+ it('still applies a newer setting requested while an earlier revision is in flight', async () => {
+ let release!: () => void;
+ state.beforeCaps = () =>
+ new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ state.config!.members = state.config!.members.slice(0, 1);
+ const first = runtime.syncGroupFastPolicy('openai');
+ await expect.poll(() => state.calls.length).toBe(1);
+ state.config!.allowFast = true;
+ const changed = runtime.syncGroupFastPolicy('openai');
+ state.beforeCaps = undefined;
+ release();
+ await Promise.all([first, changed]);
+ expect(
+ state.calls
+ .filter(({ command }) => command.op === 'fast-policy')
+ .map(({ command }) => command.allowFast),
+ ).toEqual([false, true]);
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ });
+
+ it('intersects a relay source with the executor local group and releases it even without a local member', async () => {
+ const relay = 'abcdefghijklmnop';
+ const task = hostSessionIdFor(`upstream\0relay:${relay}`, 'task');
+ await groupFastPolicyStore.receive(
+ 'upstream',
+ {
+ group: 'outer',
+ revision: 1,
+ allowFast: true,
+ binding: { sessionId: 'task', relay },
+ },
+ 'self',
+ () => {},
+ );
+ await runtime.bindLocalHostedGroupFastPolicy('openai', task);
+ expect(groupFastPolicyStore.allows(task)).toBe(false);
+ state.config!.allowFast = true;
+ await runtime.syncGroupFastPolicy('openai');
+ expect(groupFastPolicyStore.allows(task)).toBe(true);
+ await groupFastPolicyStore.receive(
+ 'upstream',
+ { group: 'outer', revision: 2, allowFast: false },
+ 'self',
+ () => {},
+ );
+ expect(groupFastPolicyStore.allows(task)).toBe(false);
+ });
+
+ it('keeps offline and old executors pending, retries after recovery, and releases removed members with a newer revision', async () => {
+ state.old.add('one');
+ state.offline.add('two');
+ await runtime.syncGroupFastPolicy('openai');
+ expect(runtime.groupFastPolicyPending('openai')).toBe(true);
+ state.old.clear();
+ state.offline.clear();
+ await runtime.syncGroupFastPolicy('openai');
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ const revision = groupFastPolicyStore.outgoing().openai.revision;
+ state.config!.members = state.config!.members.slice(1);
+ state.calls = [];
+ await runtime.syncGroupFastPolicy('openai');
+ expect(state.calls).toContainEqual({
+ device: 'one',
+ command: expect.objectContaining({
+ op: 'fast-policy',
+ allowFast: true,
+ revision: revision + 1,
+ }),
+ });
+ expect(state.calls).toContainEqual({
+ device: 'two',
+ command: expect.objectContaining({
+ op: 'fast-policy',
+ allowFast: false,
+ revision: revision + 1,
+ }),
+ });
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ });
+
+ it('does not grant a direct route before an old executor can enforce a prohibition', async () => {
+ state.old.add('one');
+ await expect(
+ runtime.bindGroupFastPolicy({
+ group: 'openai',
+ deviceId: 'one',
+ sessionId: 'task',
+ controllerDeviceId: 'consumer',
+ }),
+ ).rejects.toThrow('REMOTE_AGENT_PEER_TOO_OLD');
+ state.config!.allowFast = true;
+ await expect(
+ runtime.bindGroupFastPolicy({ group: 'openai', deviceId: 'one', sessionId: 'task' }),
+ ).resolves.toBeUndefined();
+ });
+
+ it('reports an unreachable executor as unavailable, without marking it as an old version', async () => {
+ state.offline.add('one');
+ await expect(
+ runtime.bindGroupFastPolicy({ group: 'openai', deviceId: 'one', sessionId: 'task' }),
+ ).rejects.toThrow('REMOTE_AGENT_UNAVAILABLE');
+ });
+
+ it('normalizes thrown transport errors so automatic group selection can try another member', async () => {
+ state.broken.add('one');
+ await expect(
+ runtime.bindGroupFastPolicy({ group: 'openai', deviceId: 'one', sessionId: 'task' }),
+ ).rejects.toThrow('REMOTE_AGENT_UNAVAILABLE');
+ });
+
+ it('forgets an acknowledged release and does not contact that removed member on later toggles', async () => {
+ await runtime.syncGroupFastPolicy('openai');
+ state.config!.members = state.config!.members.slice(1);
+ await runtime.syncGroupFastPolicy('openai');
+ expect(groupFastPolicyStore.outgoing().openai.targets).not.toHaveProperty('one');
+ state.offline.add('one');
+ state.calls = [];
+ state.config!.allowFast = true;
+ await runtime.syncGroupFastPolicy('openai');
+ expect(state.calls.some(({ device }) => device === 'one')).toBe(false);
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ });
+
+ it('shows local native failures as pending instead of acknowledging the whole group', async () => {
+ state.config!.members.push({
+ key: 'local',
+ kind: 'local',
+ agentDeviceId: null,
+ providerId: 'openai',
+ limit: 10,
+ weight: 1,
+ paused: false,
+ });
+ state.notify.mockRejectedValue(Error('native busy'));
+ await expect(runtime.syncGroupFastPolicy('openai')).rejects.toThrow('native busy');
+ expect(runtime.groupFastPolicyPending('openai')).toBe(true);
+ state.notify.mockResolvedValue(undefined);
+ await runtime.syncGroupFastPolicy('openai');
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ });
+
+ it('does not touch custom API groups or their discovery/refresh paths', async () => {
+ state.subscription = false;
+ await runtime.syncGroupFastPolicy('openai');
+ await runtime.bindGroupFastPolicy({ group: 'openai', deviceId: 'one', sessionId: 'task' });
+ expect(state.calls).toEqual([]);
+ expect(runtime.groupFastPolicyPending('openai')).toBe(false);
+ expect(
+ fs.existsSync(path.join(temporary, state.owner, 'provider-group-fast-policy.json')),
+ ).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/fastPolicyStore.test.ts b/apps/desktop/src/main/provider-group/__tests__/fastPolicyStore.test.ts
new file mode 100644
index 0000000000..a4f3f2edc4
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/fastPolicyStore.test.ts
@@ -0,0 +1,317 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { afterAll, describe, expect, it, vi } from 'vitest';
+import { providerShareGuestPeer } from '@cindy/device-link';
+import { hostSessionIdFor } from '../../remote-agent/host/sessionIdentity.js';
+
+vi.mock('../../logger.js', () => ({ createLogger: () => ({ info() {}, warn() {}, error() {} }) }));
+vi.mock('../../appSessionState.js', () => ({
+ activeOwnerScopeKey: () => 'test',
+ ownerScopedUserDataPath: () => {
+ throw Error('unexpected singleton IO');
+ },
+}));
+const { createGroupFastPolicyStore } = await import('../fastPolicyStore.js');
+const { createProviderFastPolicyStore } =
+ await import('../../maker-host/provider-fast-policy-store.js');
+const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-fast-policy-'));
+afterAll(() => fs.rmSync(temporary, { recursive: true, force: true }));
+let sequence = 0;
+const fixture = () => {
+ sequence++;
+ const file = path.join(temporary, `${sequence}.json`);
+ return { filePath: () => file, scopeKey: () => 'test' };
+};
+const current = () => {};
+
+describe('durable subscription Fast constraints', () => {
+ it('updates actual account keys atomically across instances and survives reload', async () => {
+ const config = fixture();
+ const a = createProviderFastPolicyStore(config),
+ b = createProviderFastPolicyStore(config);
+ expect(a.allows('account-a')).toBe(true);
+ await Promise.all([a.set('account-a', false, current), b.set('account-b', false, current)]);
+ const restored = createProviderFastPolicyStore(config);
+ expect(restored.allows('account-a')).toBe(false);
+ expect(restored.allows('account-b')).toBe(false);
+ expect(restored.allows('account-c')).toBe(true);
+ await restored.set('account-a', true, current);
+ expect(createProviderFastPolicyStore(config).allows('account-a')).toBe(true);
+ });
+
+ it('never interprets unreadable or invalid policy files as permission', async () => {
+ for (const contents of ['{broken', '{"providers":null}', '{"providers":[]}']) {
+ const config = fixture();
+ fs.writeFileSync(config.filePath(), contents);
+ const store = createProviderFastPolicyStore(config);
+ expect(store.allows('account')).toBe(false);
+ await expect(store.set('account', true, current)).rejects.toThrow();
+ expect(fs.readFileSync(config.filePath(), 'utf8')).toBe(contents);
+ }
+ });
+
+ it('binds same-account direct controllers and local hosted tasks without affecting other tasks', async () => {
+ const config = fixture(),
+ store = createGroupFastPolicyStore(config);
+ await store.receive(
+ 'group-owner',
+ {
+ group: 'openai',
+ revision: 1,
+ allowFast: false,
+ binding: { sessionId: 'task-1', controllerDeviceId: 'consumer' },
+ },
+ 'executor',
+ current,
+ );
+ expect(store.allows(hostSessionIdFor('consumer', 'task-1'))).toBe(false);
+ expect(store.allows('task-1')).toBe(true);
+ expect(store.allows(hostSessionIdFor('other', 'task-1'))).toBe(true);
+ await store.receive(
+ 'owner',
+ {
+ group: 'openai',
+ revision: 1,
+ allowFast: false,
+ binding: { sessionId: 'local-task', controllerDeviceId: 'executor' },
+ },
+ 'executor',
+ current,
+ );
+ expect(store.allows('local-task')).toBe(false);
+ expect(createGroupFastPolicyStore(config).allows('local-task')).toBe(false);
+ });
+
+ it('cannot bind another share member or the executor owner from a guest command', async () => {
+ const store = createGroupFastPolicyStore(fixture());
+ const guest = providerShareGuestPeer('share-a', 'member-a', 'owner-device');
+ await store.receive(
+ guest,
+ {
+ group: 'openai',
+ revision: 1,
+ allowFast: false,
+ binding: { sessionId: 'task', controllerDeviceId: 'executor' },
+ },
+ 'executor',
+ current,
+ );
+ const constrained = providerShareGuestPeer('share-a', 'member-a', 'executor');
+ expect(store.allows(hostSessionIdFor(constrained, 'task'))).toBe(false);
+ expect(store.allows('task')).toBe(true);
+ expect(
+ store.allows(
+ hostSessionIdFor(providerShareGuestPeer('share-a', 'member-b', 'executor'), 'task'),
+ ),
+ ).toBe(true);
+ });
+
+ it('keeps relay identities isolated and ignores out-of-order relaxation', async () => {
+ const store = createGroupFastPolicyStore(fixture());
+ const binding = { sessionId: 'task', relay: 'abcdefghijklmnop' };
+ await store.receive(
+ 'owner',
+ { group: 'openai', revision: 4, allowFast: false, binding },
+ 'executor',
+ current,
+ );
+ const task = hostSessionIdFor('owner\0relay:abcdefghijklmnop', 'task');
+ expect(store.allows(task)).toBe(false);
+ await store.receive(
+ 'owner',
+ { group: 'openai', revision: 3, allowFast: true },
+ 'executor',
+ current,
+ );
+ await store.receive(
+ 'owner',
+ { group: 'openai', revision: 4, allowFast: true },
+ 'executor',
+ current,
+ );
+ expect(store.allows(task)).toBe(false);
+ expect(store.allows(hostSessionIdFor('owner', 'task'))).toBe(true);
+ await store.receive(
+ 'owner',
+ { group: 'openai', revision: 5, allowFast: true },
+ 'executor',
+ current,
+ );
+ expect(store.allows(task)).toBe(true);
+ });
+
+ it('invalidates acknowledgements on membership changes and rejects stale acknowledgements', async () => {
+ const store = createGroupFastPolicyStore(fixture());
+ const initial = await store.prepare('group', false, ['one', 'two'], current, true);
+ await store.acknowledge('group', 'one', initial.revision, current);
+ const changed = await store.prepare('group', false, ['two'], current, true);
+ expect(changed.revision).toBeGreaterThan(initial.revision);
+ expect(changed.targets.one).toBe(initial.revision);
+ await store.acknowledge('group', 'two', initial.revision, current);
+ expect(store.outgoing().group.targets.two).toBe(-1);
+ });
+
+ it('admits tasks beyond the old 10,000 binding limit without evicting resumable restrictions', async () => {
+ const config = fixture();
+ const source = JSON.stringify(['owner', 'openai']);
+ fs.writeFileSync(
+ config.filePath(),
+ JSON.stringify({
+ sources: { [source]: { revision: 1, allowFast: false } },
+ bindings: Object.fromEntries(
+ Array.from({ length: 10_000 }, (_, i) => [`old-${i}`, { owner: source }]),
+ ),
+ outgoing: {},
+ }),
+ );
+ const store = createGroupFastPolicyStore(config);
+ await store.receive(
+ 'owner',
+ {
+ group: 'openai',
+ revision: 1,
+ allowFast: false,
+ binding: { sessionId: 'new-task', controllerDeviceId: 'executor' },
+ },
+ 'executor',
+ current,
+ );
+ const restored = createGroupFastPolicyStore(config);
+ expect(restored.allows('old-0')).toBe(false);
+ expect(restored.allows('old-9999')).toBe(false);
+ expect(restored.allows('new-task')).toBe(false);
+ await restored.receive(
+ 'owner',
+ { group: 'openai', revision: 2, allowFast: true },
+ 'executor',
+ current,
+ );
+ expect(store.allows('old-0')).toBe(true);
+ expect(store.allows('new-task')).toBe(true);
+ });
+
+ it('denies an interrupted binding write until its policy source commits, then recovers on retry', async () => {
+ const config = fixture();
+ const shard = path.join(
+ `${config.filePath()}.bindings`,
+ `${createHash('sha256').update('new-task').digest('hex').slice(0, 2)}.json`,
+ );
+ const command = {
+ group: 'openai',
+ revision: 1,
+ allowFast: true,
+ binding: { sessionId: 'new-task', controllerDeviceId: 'executor' },
+ };
+ const store = createGroupFastPolicyStore(config);
+ await expect(
+ store.receive('owner', command, 'executor', () => {
+ if (fs.existsSync(shard)) throw Error('owner changed after binding commit');
+ }),
+ ).rejects.toThrow('owner changed');
+ expect(fs.existsSync(shard)).toBe(true);
+ expect(createGroupFastPolicyStore(config).allows('new-task')).toBe(false);
+ await store.receive('owner', command, 'executor', current);
+ expect(createGroupFastPolicyStore(config).allows('new-task')).toBe(true);
+ });
+
+ it('preserves a damaged binding shard and denies instead of treating it as an empty task history', async () => {
+ const config = fixture();
+ const store = createGroupFastPolicyStore(config);
+ const command = {
+ group: 'openai',
+ revision: 1,
+ allowFast: false,
+ binding: { sessionId: 'new-task', controllerDeviceId: 'executor' },
+ };
+ await store.receive('owner', command, 'executor', current);
+ const shard = path.join(
+ `${config.filePath()}.bindings`,
+ fs.readdirSync(`${config.filePath()}.bindings`).find((name) => name.endsWith('.json'))!,
+ );
+ fs.writeFileSync(shard, '{broken');
+ const restored = createGroupFastPolicyStore(config);
+ expect(restored.allows('new-task')).toBe(false);
+ await expect(restored.receive('owner', command, 'executor', current)).rejects.toThrow();
+ expect(fs.readFileSync(shard, 'utf8')).toBe('{broken');
+ });
+
+ it('reclaims only permanently purged tasks and retains other tasks and revision tombstones', async () => {
+ const config = fixture();
+ const source = JSON.stringify(['owner', 'openai']);
+ fs.writeFileSync(
+ config.filePath(),
+ JSON.stringify({
+ sources: { [source]: { revision: 3, allowFast: false } },
+ bindings: { legacy: { owner: source } },
+ outgoing: {},
+ }),
+ );
+ const store = createGroupFastPolicyStore(config);
+ for (const sessionId of ['purged', 'retained'])
+ await store.receive(
+ 'owner',
+ {
+ group: 'openai',
+ revision: 3,
+ allowFast: false,
+ binding: { sessionId, controllerDeviceId: 'executor' },
+ },
+ 'executor',
+ current,
+ );
+ await store.forgetSessions(['legacy', 'purged'], current);
+ const restored = createGroupFastPolicyStore(config);
+ expect(restored.allows('legacy')).toBe(true);
+ expect(restored.allows('purged')).toBe(true);
+ expect(restored.allows('retained')).toBe(false);
+ await restored.receive(
+ 'owner',
+ { group: 'openai', revision: 2, allowFast: true },
+ 'executor',
+ current,
+ );
+ expect(restored.allows('retained')).toBe(false);
+ });
+
+ it('preserves concurrent bindings in the same shard across store instances', async () => {
+ const config = fixture();
+ const first = 'collision-0';
+ const prefix = (id: string) => createHash('sha256').update(id).digest('hex').slice(0, 2);
+ let second = '';
+ for (let i = 1; !second; i++)
+ if (prefix(`collision-${i}`) === prefix(first)) second = `collision-${i}`;
+ const a = createGroupFastPolicyStore(config),
+ b = createGroupFastPolicyStore(config);
+ await Promise.all(
+ [a, b].map((store, i) =>
+ store.receive(
+ `owner-${i}`,
+ {
+ group: 'openai',
+ revision: 1,
+ allowFast: false,
+ binding: { sessionId: i === 0 ? first : second, controllerDeviceId: 'executor' },
+ },
+ 'executor',
+ current,
+ ),
+ ),
+ );
+ const restored = createGroupFastPolicyStore(config);
+ expect(restored.allows(first)).toBe(false);
+ expect(restored.allows(second)).toBe(false);
+ });
+
+ it('does not write across an account boundary', async () => {
+ const config = fixture(),
+ store = createProviderFastPolicyStore(config);
+ await expect(
+ store.set('account', false, () => {
+ throw Error('owner changed');
+ }),
+ ).rejects.toThrow('owner changed');
+ expect(fs.existsSync(config.filePath())).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts b/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
index d73591f579..6ea9379285 100644
--- a/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
@@ -5,6 +5,8 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { ipcMain, type IpcMainInvokeEvent } from 'electron';
vi.mock('electron', () => ({ ipcMain: { handle: vi.fn() } }));
+vi.mock('../fastPolicyRuntime.js', () => ({ groupFastPolicyPending: vi.fn(() => false), syncGroupFastPolicy: vi.fn(async () => {}) }));
+vi.mock('../../device-link/dispatch.js', () => ({ notifyProviderShareCatalogChanged: vi.fn() }));
vi.mock('../runtime.js', () => ({
getProviderGroupDirectory: vi.fn(),
getProviderGroupRouter: vi.fn(),
@@ -35,6 +37,7 @@ import {
markMembersUnreachableHere,
parseProviderGroupCommand,
registerProviderGroupIpc,
+ createProviderGroupCommandDeps,
PROVIDER_GROUP_REACHABILITY_CHECK_TIMEOUT_MS,
type ProviderGroupCommandDeps,
} from '../ipc';
@@ -45,6 +48,7 @@ import { getProviderGroupDirectory, getProviderGroupRouter } from '../runtime';
import { invokeProviderManagement } from '../managementClient';
import { pruneProviderGroupBindings } from '../bindings';
import { readProviderGroup, writeProviderGroup } from '../store';
+import { broadcast } from '../../device-link/index';
const LOCAL = { key: 'local', kind: 'local' as const, agentDeviceId: null, providerId: 'anthropic', limit: 4, weight: 1, paused: false };
const MINI = {
@@ -363,6 +367,36 @@ describe('provider group IPC remote management', () => {
});
describe('executeProviderGroupCommand save', () => {
+ it.each(['save-if-current', 'delete-if-current'] as const)(
+ 'does not publish or prune %s under a new owner after Fast synchronization fails',
+ async (action) => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ const d = deps([], config);
+ d.syncFastPolicy = vi.fn(async () => { d.switchOwner('owner-b'); throw Error('native busy'); });
+ await expect(executeProviderGroupCommand(d, {
+ action, providerId: 'anthropic', expectedConfig: config, config: { ...config, allowFast: false },
+ })).rejects.toThrow('PRECONDITION_FAILED');
+ expect(d.pruneBindings).not.toHaveBeenCalled();
+ expect(d.changed).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['save-if-current', 'delete-if-current'] as const)(
+ 'publishes the committed %s and prunes bindings even if native Fast synchronization fails',
+ async (action) => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ const d = deps([], config);
+ d.syncFastPolicy = vi.fn(async () => { throw Error('native busy'); });
+ await expect(executeProviderGroupCommand(d, {
+ action, providerId: 'anthropic', expectedConfig: config,
+ config: { ...config, allowFast: false },
+ })).rejects.toThrow('native busy');
+ expect(d.pruneBindings).toHaveBeenCalledWith('anthropic', action === 'delete-if-current' ? null : new Set(['local']));
+ expect(d.changed).toHaveBeenCalledWith('anthropic');
+ expect(d.readGroup('anthropic')).toEqual(action === 'delete-if-current' ? null : { ...config, allowFast: false });
+ },
+ );
+
it.each(['save-if-current', 'delete-if-current'] as const)('refuses %s before any work while the old owner is being torn down', async (action) => {
const d = deps([]);
vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
@@ -551,6 +585,14 @@ describe('executeProviderGroupCommand save', () => {
});
describe('provider management receiver account boundary', () => {
+ it('invalidates the local model catalog when a subscription group changes', () => {
+ vi.mocked(broadcast).mockClear();
+ createProviderGroupCommandDeps().changed('openai');
+ expect(broadcast).toHaveBeenCalledWith('maker:provider:changed', {});
+ vi.mocked(broadcast).mockClear();
+ createProviderGroupCommandDeps().changed('xai');
+ expect(broadcast).not.toHaveBeenCalledWith('maker:provider:changed', {});
+ });
it('refreshes reshare coordination after a remote group edit without adding local-only consent details to the reply', async () => {
const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
const d = deps([], config);
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
index c22f92e7ee..e5205f13c8 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -92,6 +92,15 @@ function deps(overrides: Partial<ProviderGroupRemoteHandlerDeps> = {}) {
const PICK = { action: 'pick', sessionId: 's1', providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: ['local'] };
describe('provider-group:remote', () => {
+ it('tries another member when the selected executor cannot acknowledge a prohibited Fast policy', async () => {
+ const bind = vi.fn().mockRejectedValueOnce(Error('[REMOTE_AGENT_PEER_TOO_OLD] update')).mockResolvedValue(undefined);
+ const d = deps({ bindFastPolicy: bind });
+ d.router.pick.mockResolvedValueOnce({ kind: 'member', member: MINI, label: 'Mini', resolved: [] })
+ .mockResolvedValueOnce({ kind: 'member', member: CONFIG.members[0], label: 'Local', resolved: [] });
+ expect(await handleProviderGroupRemote(d, 'laptop', { ...PICK, exclude: [] })).toMatchObject({ kind: 'member', member: { key: 'local' } });
+ expect(d.router.pick.mock.calls[1][0].exclude?.has(MINI.key)).toBe(true);
+ expect(bind).toHaveBeenLastCalledWith({ group: 'anthropic', deviceId: null, sessionId: 's1', controllerDeviceId: 'laptop' });
+ });
// Unit/protocol: old owners ignored the final rebalance constraints. Verify the real wire and acknowledgement.
it('requires the owner to acknowledge the rebalance constraint before accepting its pick', async () => {
const d = deps();
diff --git a/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts b/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts
new file mode 100644
index 0000000000..f67793d018
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts
@@ -0,0 +1,253 @@
+import { REMOTE_AGENT_CHANNEL, parseRemoteAgentCaps } from '@cindy/device-link';
+import type { RemoteAgentFastPolicy } from '@cindy/device-link';
+import { supportsSubscriptionFastPolicy } from '@cindy/model-providers';
+import { getSelfDeviceId, remoteBackgroundInvoke } from '../device-link/index.js';
+import { getActiveCatalog } from '../maker-host/active-catalog.js';
+import { notifySubscriptionFastPolicyChanged } from '../maker-host/subscription-fast-policy.js';
+import { captureProviderManagementScope } from './managementScope.js';
+import { activeOwnerScopeKey } from '../appSessionState.js';
+import { readProviderGroup, listProviderGroups } from './store.js';
+import { groupFastPolicyStore } from './fastPolicyStore.js';
+
+const eligible = (group: string) =>
+ supportsSubscriptionFastPolicy(getActiveCatalog().providers.find((p) => p.id === group));
+const LOCAL_TARGET = '@local';
+const targets = (group: string) => {
+ const config = readProviderGroup(group);
+ if (!config) return [];
+ // A guest may already have been assigned here by another group. Local
+ // enforcement is independent of membership, so its source must also receive
+ // later prohibitions/releases when this group has only remote members.
+ return [
+ ...new Set([
+ LOCAL_TARGET,
+ ...config.members.flatMap((member) =>
+ member.kind === 'local' ? [] : member.agentDeviceId ? [member.agentDeviceId] : [],
+ ),
+ ]),
+ ];
+};
+const syncing = new Map<string, Promise<void>>();
+
+async function send(
+ device: string,
+ command: RemoteAgentFastPolicy,
+ assertCurrent: () => void,
+): Promise<void> {
+ assertCurrent();
+ const invoke = async (request: Record<string, unknown>) => {
+ try {
+ return await remoteBackgroundInvoke(device, REMOTE_AGENT_CHANNEL, [request]);
+ } catch {
+ // Transport failures can reject instead of returning an IPC error. Keep
+ // them retryable without disguising an owner change as a link failure.
+ assertCurrent();
+ throw new Error(
+ '[REMOTE_AGENT_UNAVAILABLE] Subscription Fast policy executor is unreachable',
+ );
+ }
+ };
+ const caps = await invoke({ op: 'caps' });
+ assertCurrent();
+ if (!caps.ok) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Subscription Fast policy executor is unreachable');
+ }
+ if (!parseRemoteAgentCaps(caps.result).subscriptionFastPolicy) {
+ throw new Error(
+ '[REMOTE_AGENT_PEER_TOO_OLD] Update this computer to enforce the subscription Fast policy',
+ );
+ }
+ const result = await invoke({ op: 'fast-policy', ...command });
+ assertCurrent();
+ const ack = (result.ok ? result.result : undefined) as
+ { revision?: number; allowFast?: boolean } | undefined;
+ if (
+ !result.ok ||
+ !ack ||
+ ack.revision !== command.revision ||
+ ack.allowFast !== command.allowFast
+ ) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Subscription Fast policy has not been confirmed');
+ }
+}
+
+export async function receiveGroupFastPolicy(
+ origin: string,
+ command: RemoteAgentFastPolicy,
+): Promise<unknown> {
+ const assertCurrent = captureProviderManagementScope();
+ const result = await groupFastPolicyStore.receive(
+ origin,
+ command,
+ getSelfDeviceId(),
+ assertCurrent,
+ );
+ await notifySubscriptionFastPolicyChanged();
+ assertCurrent();
+ return result;
+}
+
+export async function bindLocalHostedGroupFastPolicy(
+ group: string,
+ hostSessionId: string,
+): Promise<void> {
+ if (!eligible(group)) return;
+ const assertCurrent = captureProviderManagementScope();
+ const state = await groupFastPolicyStore.prepare(
+ group,
+ readProviderGroup(group)?.allowFast !== false,
+ [],
+ assertCurrent,
+ );
+ const self = getSelfDeviceId();
+ if (!self) throw new Error('[REMOTE_AGENT_UNAVAILABLE] Computer identity is not ready');
+ await groupFastPolicyStore.receive(
+ self,
+ { group, ...state, binding: { sessionId: hostSessionId } },
+ self,
+ assertCurrent,
+ hostSessionId,
+ );
+ await notifySubscriptionFastPolicyChanged();
+}
+
+/** Registration is authenticated from group owner to executor, before returning a route to the consumer. */
+export async function bindGroupFastPolicy(input: {
+ group: string;
+ deviceId?: string | null;
+ sessionId: string;
+ controllerDeviceId?: string;
+ relay?: string;
+}): Promise<void> {
+ if (!eligible(input.group)) return;
+ const assertCurrent = captureProviderManagementScope();
+ const config = readProviderGroup(input.group);
+ const state = await groupFastPolicyStore.prepare(
+ input.group,
+ config?.allowFast !== false,
+ input.deviceId ? [input.deviceId] : [],
+ assertCurrent,
+ );
+ const command: RemoteAgentFastPolicy = {
+ group: input.group,
+ revision: state.revision,
+ allowFast: state.allowFast,
+ binding: {
+ sessionId: input.sessionId,
+ ...(input.controllerDeviceId ? { controllerDeviceId: input.controllerDeviceId } : {}),
+ ...(input.relay ? { relay: input.relay } : {}),
+ },
+ };
+ if (input.deviceId) {
+ try {
+ await send(input.deviceId, command, assertCurrent);
+ await groupFastPolicyStore.acknowledge(
+ input.group,
+ input.deviceId,
+ state.revision,
+ assertCurrent,
+ );
+ } catch (error) {
+ assertCurrent();
+ // Allowed-by-default groups retain compatibility with old executors. A prohibition requires explicit support.
+ if (!state.allowFast) throw error;
+ }
+ } else {
+ const self = getSelfDeviceId();
+ if (!self) throw new Error('[REMOTE_AGENT_UNAVAILABLE] Computer identity is not ready');
+ await receiveGroupFastPolicy(self, command);
+ }
+}
+
+export function groupFastPolicyPending(group: string): boolean {
+ if (!eligible(group)) return false;
+ const state = groupFastPolicyStore.outgoing()[group];
+ if (!state) return readProviderGroup(group)?.allowFast === false;
+ return (
+ state.allowFast !== (readProviderGroup(group)?.allowFast !== false) ||
+ Object.values(state.targets).some((ack) => ack !== state.revision) ||
+ targets(group).some((device) => state.targets[device] !== state.revision)
+ );
+}
+
+export function syncGroupFastPolicy(group: string): Promise<void> {
+ if (!eligible(group) && !groupFastPolicyStore.outgoing()[group]) return Promise.resolve();
+ const key = `${activeOwnerScopeKey()}\0${group}`;
+ const current = syncing.get(key);
+ if (current) {
+ const assertCurrent = captureProviderManagementScope();
+ return current.then(() => {
+ assertCurrent();
+ const state = groupFastPolicyStore.outgoing()[group];
+ // Share an in-flight retry instead of queuing another full retry for
+ // every poll. A genuine settings change still waits for its own revision.
+ if (
+ !state ||
+ state.allowFast !== (!eligible(group) || readProviderGroup(group)?.allowFast !== false) ||
+ JSON.stringify(state.members) !== JSON.stringify([...new Set(targets(group))].sort())
+ ) {
+ return syncGroupFastPolicy(group);
+ }
+ });
+ }
+ const work = (async () => {
+ const assertCurrent = captureProviderManagementScope();
+ const config = readProviderGroup(group);
+ const destinations = targets(group);
+ const state = await groupFastPolicyStore.prepare(
+ group,
+ !eligible(group) || config?.allowFast !== false,
+ destinations,
+ assertCurrent,
+ true,
+ );
+ const active = new Set(destinations);
+ await Promise.allSettled(
+ Object.entries(state.targets)
+ .filter(([, ack]) => ack !== state.revision)
+ .map(async ([device]) => {
+ const command = {
+ group,
+ revision: state.revision,
+ allowFast: active.has(device) ? state.allowFast : true,
+ };
+ if (device === LOCAL_TARGET) {
+ const self = getSelfDeviceId();
+ if (!self) throw new Error('[REMOTE_AGENT_UNAVAILABLE] Computer identity is not ready');
+ await receiveGroupFastPolicy(self, command);
+ } else await send(device, command, assertCurrent);
+ await groupFastPolicyStore.acknowledge(group, device, state.revision, assertCurrent);
+ }),
+ );
+ assertCurrent();
+ await notifySubscriptionFastPolicyChanged();
+ })().finally(() => {
+ if (syncing.get(key) === work) syncing.delete(key);
+ });
+ syncing.set(key, work);
+ return work;
+}
+
+/** Retry only unacknowledged policy changes; never reset a shared device-link connection. */
+export function startGroupFastPolicySync(): () => void {
+ const sync = () => {
+ const outgoing = groupFastPolicyStore.outgoing();
+ const groups = listProviderGroups();
+ for (const group of new Set([...Object.keys(outgoing), ...Object.keys(groups)])) {
+ if (!eligible(group) && !outgoing[group]) continue;
+ if (syncing.has(`${activeOwnerScopeKey()}\0${group}`)) continue;
+ const state = outgoing[group];
+ if (
+ !state ||
+ state.allowFast !== (!eligible(group) || groups[group]?.allowFast !== false) ||
+ JSON.stringify(state.members) !== JSON.stringify([...new Set(targets(group))].sort()) ||
+ Object.values(state.targets).some((ack) => ack !== state.revision)
+ ) {
+ void syncGroupFastPolicy(group).catch(() => undefined);
+ }
+ }
+ };
+ const timer = setInterval(sync, 5_000);
+ timer.unref?.();
+ return () => clearInterval(timer);
+}
diff --git a/apps/desktop/src/main/provider-group/fastPolicyStore.ts b/apps/desktop/src/main/provider-group/fastPolicyStore.ts
new file mode 100644
index 0000000000..1b6ea2a469
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/fastPolicyStore.ts
@@ -0,0 +1,293 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
+import {
+ parseProviderSharePeer,
+ providerShareGuestPeer,
+ type RemoteAgentFastPolicy,
+} from '@cindy/device-link';
+import { createLogger } from '../logger.js';
+import {
+ createOverrideSettingsFile,
+ type OverrideSettingsFile,
+} from '../maker-host/override-settings-file.js';
+import { hostSessionIdFor } from '../remote-agent/host/sessionIdentity.js';
+
+interface Policy {
+ revision: number;
+ allowFast: boolean;
+}
+interface Outgoing extends Policy {
+ targets: Record<string, number>;
+ members?: string[];
+}
+interface State {
+ sources: Record<string, Policy>;
+ bindings: Record<string, Record<string, string>>;
+ outgoing: Record<string, Outgoing>;
+ unreadable?: true;
+}
+interface BindingShard {
+ bindings: State['bindings'];
+ unreadable?: true;
+}
+
+const object = (value: unknown): value is Record<string, unknown> =>
+ !!value && typeof value === 'object' && !Array.isArray(value);
+const empty = (): State => ({ sources: {}, bindings: {}, outgoing: {} });
+
+/** Per-owner durable constraints. A reconnect cannot erase a prohibition or reuse another guest's binding. */
+export function createGroupFastPolicyStore(options: { filePath(): string; scopeKey(): string }) {
+ // Keep resumable tasks' constraints without putting every task in one bounded
+ // settings file. Shards use the same atomic/owner-guarded writer as policies.
+ // Legacy bindings remain readable; no age-based eviction can restore Fast.
+ const shards = new Map<string, OverrideSettingsFile<BindingShard>>();
+ const bindingShard = (sessionId: string) => {
+ const key = createHash('sha256').update(sessionId).digest('hex').slice(0, 2);
+ let shard = shards.get(key);
+ if (!shard) {
+ const filePath = () => path.join(`${options.filePath()}.bindings`, `${key}.json`);
+ shard = createOverrideSettingsFile<BindingShard>({
+ filePath,
+ scopeKey: options.scopeKey,
+ defaults: () => {
+ try {
+ fs.statSync(filePath());
+ return { bindings: {}, unreadable: true };
+ } catch (error) {
+ return (error as NodeJS.ErrnoException).code === 'ENOENT'
+ ? { bindings: {} }
+ : { bindings: {}, unreadable: true };
+ }
+ },
+ normalize: (raw) =>
+ object(raw) &&
+ object(raw.bindings) &&
+ Object.values(raw.bindings).every(
+ (binding) =>
+ object(binding) &&
+ Object.values(binding).every((source) => typeof source === 'string'),
+ )
+ ? { bindings: raw.bindings as State['bindings'] }
+ : { bindings: {}, unreadable: true },
+ log: createLogger('group-fast-bindings'),
+ label: 'group-fast-bindings',
+ maxBytes: 4 * 1024 * 1024,
+ preserveUnreadableFile: true,
+ logLoadedValue: false,
+ logReadErrorDetails: false,
+ });
+ shards.set(key, shard);
+ }
+ return shard;
+ };
+ const store = createOverrideSettingsFile<State>({
+ ...options,
+ defaults: () => {
+ try {
+ fs.statSync(options.filePath());
+ return { ...empty(), unreadable: true };
+ } catch (error) {
+ return (error as NodeJS.ErrnoException).code === 'ENOENT'
+ ? empty()
+ : { ...empty(), unreadable: true };
+ }
+ },
+ normalize(raw) {
+ if (!object(raw) || !object(raw.sources) || !object(raw.bindings) || !object(raw.outgoing))
+ return { ...empty(), unreadable: true };
+ const valid =
+ Object.values(raw.sources).every(
+ (p) => object(p) && Number.isSafeInteger(p.revision) && typeof p.allowFast === 'boolean',
+ ) &&
+ Object.values(raw.bindings).every(
+ (b) =>
+ object(b) &&
+ Object.values(b).every(
+ (key) => typeof key === 'string' && Object.hasOwn(raw.sources as object, key),
+ ),
+ ) &&
+ Object.values(raw.outgoing).every(
+ (p) =>
+ object(p) &&
+ Number.isSafeInteger(p.revision) &&
+ typeof p.allowFast === 'boolean' &&
+ object(p.targets) &&
+ Object.values(p.targets).every(Number.isSafeInteger) &&
+ (p.members === undefined ||
+ (Array.isArray(p.members) && p.members.every((d) => typeof d === 'string'))),
+ );
+ return valid
+ ? ({
+ sources: raw.sources,
+ bindings: raw.bindings,
+ outgoing: raw.outgoing,
+ } as unknown as State)
+ : { ...empty(), unreadable: true };
+ },
+ log: createLogger('group-fast-policy'),
+ label: 'group-fast-policy',
+ maxBytes: 4 * 1024 * 1024,
+ preserveUnreadableFile: true,
+ logLoadedValue: false,
+ logReadErrorDetails: false,
+ });
+ const read = () => {
+ store.invalidateIfChanged();
+ return store.read();
+ };
+ const writable = (value: State) => {
+ if (value.unreadable) throw new Error('Group Fast policy could not be read');
+ };
+ return {
+ allows(sessionId: string): boolean {
+ const value = read();
+ const shard = bindingShard(sessionId);
+ shard.invalidateIfChanged();
+ const bindings = shard.read();
+ return (
+ !value.unreadable &&
+ !bindings.unreadable &&
+ Object.values({ ...value.bindings[sessionId], ...bindings.bindings[sessionId] }).every(
+ (source) => value.sources[source]?.allowFast === true,
+ )
+ );
+ },
+ async receive(
+ origin: string,
+ command: RemoteAgentFastPolicy,
+ selfDeviceId: string | null,
+ assertCurrent: () => void,
+ trustedLocalTask?: string,
+ ): Promise<Policy> {
+ const source = JSON.stringify([origin, command.group]);
+ assertCurrent();
+ writable(read());
+ if (command.binding) {
+ const peer = parseProviderSharePeer(origin);
+ const device = command.binding.controllerDeviceId;
+ // A guest cannot choose another member's or the owner's task namespace.
+ const controller = device
+ ? peer?.role === 'guest'
+ ? providerShareGuestPeer(peer.shareId, peer.memberId, device)
+ : device
+ : origin;
+ const scope = command.binding.relay
+ ? `${controller}\0relay:${command.binding.relay}`
+ : controller;
+ const task =
+ trustedLocalTask ??
+ (!peer && device === selfDeviceId && !command.binding.relay
+ ? command.binding.sessionId
+ : hostSessionIdFor(scope, command.binding.sessionId));
+ // Persist the binding first. A missing/uncommitted source is denied by
+ // allows(), and an ACK is returned only after both writes are durable.
+ await bindingShard(task).updateAtomic(({ value }) => {
+ assertCurrent();
+ if (value.unreadable) throw new Error('Group Fast bindings could not be read');
+ return {
+ bindings: { ...value.bindings, [task]: { ...value.bindings[task], [origin]: source } },
+ };
+ });
+ }
+ const value = await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ writable(value);
+ const sources = { ...value.sources };
+ const previous = sources[source];
+ if (!previous || command.revision > previous.revision)
+ sources[source] = { revision: command.revision, allowFast: command.allowFast };
+ // Equal revisions with conflicting values may only tighten, never loosen.
+ else if (command.revision === previous.revision && !command.allowFast)
+ sources[source] = { ...previous, allowFast: false };
+ return { sources };
+ });
+ assertCurrent();
+ return value.sources[source];
+ },
+ async prepare(
+ group: string,
+ allowFast: boolean,
+ destinations: readonly string[],
+ assertCurrent: () => void,
+ replaceMembers = false,
+ ): Promise<Outgoing> {
+ const value = await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ writable(value);
+ const previous = value.outgoing[group];
+ const members = replaceMembers ? [...new Set(destinations)].sort() : previous?.members;
+ const sameMembers =
+ !replaceMembers || JSON.stringify(previous?.members) === JSON.stringify(members);
+ const revision =
+ previous && previous.allowFast === allowFast && sameMembers
+ ? previous.revision
+ : (previous?.revision ?? 0) + 1;
+ const targets = { ...previous?.targets };
+ for (const device of destinations) targets[device] ??= -1;
+ return {
+ outgoing: {
+ ...value.outgoing,
+ [group]: { revision, allowFast, targets, ...(members ? { members } : {}) },
+ },
+ };
+ });
+ assertCurrent();
+ return value.outgoing[group];
+ },
+ async acknowledge(group: string, device: string, revision: number, assertCurrent: () => void) {
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ writable(value);
+ const current = value.outgoing[group];
+ if (!current || current.revision !== revision) return {};
+ const targets = { ...current.targets, [device]: revision };
+ // Retain an offline member until its release is confirmed. Once it has
+ // acknowledged the release, future group changes no longer concern it.
+ if (current.members && !current.members.includes(device)) delete targets[device];
+ return {
+ outgoing: {
+ ...value.outgoing,
+ [group]: { ...current, targets },
+ },
+ };
+ });
+ },
+ /** Only after permanent guest-history purge; never on ordinary close/idle. */
+ async forgetSessions(sessionIds: readonly string[], assertCurrent: () => void): Promise<void> {
+ assertCurrent();
+ if (!sessionIds.length) return;
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ writable(value);
+ const bindings = { ...value.bindings };
+ for (const id of sessionIds) delete bindings[id];
+ return { bindings };
+ });
+ const byShard = new Map<OverrideSettingsFile<BindingShard>, string[]>();
+ for (const id of sessionIds) {
+ const shard = bindingShard(id);
+ const ids = byShard.get(shard) ?? [];
+ ids.push(id);
+ byShard.set(shard, ids);
+ }
+ for (const [shard, ids] of byShard) {
+ await shard.updateAtomic(({ value }) => {
+ assertCurrent();
+ if (value.unreadable) throw new Error('Group Fast bindings could not be read');
+ const bindings = { ...value.bindings };
+ for (const id of ids) delete bindings[id];
+ return { bindings };
+ });
+ }
+ assertCurrent();
+ },
+ outgoing: () => read().outgoing,
+ };
+}
+
+export const groupFastPolicyStore = createGroupFastPolicyStore({
+ filePath: () => ownerScopedUserDataPath('provider-group-fast-policy.json'),
+ scopeKey: activeOwnerScopeKey,
+});
diff --git a/apps/desktop/src/main/provider-group/guestRelay.ts b/apps/desktop/src/main/provider-group/guestRelay.ts
index c83e8898ce..fce50e7a30 100644
--- a/apps/desktop/src/main/provider-group/guestRelay.ts
+++ b/apps/desktop/src/main/provider-group/guestRelay.ts
@@ -25,6 +25,7 @@ import type { ProviderGroupOwnerScope } from './runtime.js';
export const PROVIDER_GROUP_GUEST_INCAPABLE_MS = 10 * 60_000;
export interface ProviderGroupGuestRelayDeps {
+ bindFastPolicy?: RemoteAgentGroupRelayDeps['bindFastPolicy'];
/** 当前账号的分配器与负载(每次选电脑开头取一次)。 */
scope(): ProviderGroupOwnerScope;
readGroup(providerId: string): ProviderGroupConfig | null;
@@ -72,6 +73,7 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
}
return {
+ ...(deps.bindFastPolicy ? { bindFastPolicy: deps.bindFastPolicy } : {}),
sharedStatus: (providerId, guestController) => {
const reshareKey = guestController ? reshareKeyForGuest(guestController) : undefined;
return readSharedGroupStatus({
diff --git a/apps/desktop/src/main/provider-group/ipc.ts b/apps/desktop/src/main/provider-group/ipc.ts
index 468e6c9f7d..c582808413 100644
--- a/apps/desktop/src/main/provider-group/ipc.ts
+++ b/apps/desktop/src/main/provider-group/ipc.ts
@@ -2,6 +2,8 @@
* 本机窗口的组命令入口;同账号远程管理由专用命令转交组所在电脑。
*/
import { ipcMain } from 'electron';
+import { supportsSubscriptionFastPolicy } from '@cindy/model-providers';
+import { getActiveCatalog } from '../maker-host/active-catalog.js';
import { activeOwnerScopeKey } from '../appSessionState.js';
@@ -40,10 +42,14 @@ import {
import { listProviderGroups, readProviderGroup, writeProviderGroup } from './store.js';
import { invokeProviderManagement } from './managementClient.js';
import { captureProviderManagementScope } from './managementScope.js';
+import { groupFastPolicyPending, syncGroupFastPolicy } from './fastPolicyRuntime.js';
+import { notifyProviderShareCatalogChanged } from '../device-link/dispatch.js';
const log = createLogger('provider-group');
export interface ProviderGroupCommandDeps {
+ syncFastPolicy?(providerId: string): Promise<void>;
+ fastPolicyPending?(providerId: string): boolean;
router: ProviderGroupRouter;
directory: ProviderGroupDirectory;
readGroup(providerId: string): ProviderGroupConfig | null;
@@ -77,6 +83,7 @@ export interface ProviderGroupCommandDeps {
/** 本机自己的组:分享来的组内电脑补上转分享的结果(只给本机设置页,不经设备互联发出)。 */
function withReshare(deps: ProviderGroupCommandDeps, view: ProviderGroupView): ProviderGroupView {
+ if (deps.fastPolicyPending?.(view.providerId)) view = { ...view, fastPolicyPending: true };
const reshare = deps.reshare;
if (!reshare || !view.config) return view;
reshare.refreshIfStale();
@@ -242,9 +249,16 @@ async function runProviderGroupCommand(
if (command.action === 'delete-if-current') await deps.writeGroup(providerId, null, command.expectedConfig);
else await deps.writeGroup(providerId, null);
assertCurrent();
- await deps.pruneBindings(providerId, null);
- assertCurrent();
- deps.changed(providerId);
+ try {
+ await deps.syncFastPolicy?.(providerId);
+ } finally {
+ // The setting is already committed. Publish it even when a native
+ // engine is busy, so views show the restriction and pending status.
+ assertCurrent();
+ await deps.pruneBindings(providerId, null);
+ assertCurrent();
+ deps.changed(providerId);
+ }
return deps.router.view(providerId, { includeGuestSupport: true });
case 'save':
case 'save-if-current': {
@@ -288,9 +302,14 @@ async function runProviderGroupCommand(
? await deps.writeGroup(providerId, next, command.expectedConfig)
: await deps.writeGroup(providerId, next);
assertCurrent();
- await deps.pruneBindings(providerId, written ? new Set(written.members.map((m) => m.key)) : null);
- assertCurrent();
- deps.changed(providerId);
+ try {
+ await deps.syncFastPolicy?.(providerId);
+ } finally {
+ assertCurrent();
+ await deps.pruneBindings(providerId, written ? new Set(written.members.map((m) => m.key)) : null);
+ assertCurrent();
+ deps.changed(providerId);
+ }
const view = await deps.router.view(providerId, { includeGuestSupport: true });
assertCurrent();
return withReshare(deps, view);
@@ -313,6 +332,8 @@ export function createProviderGroupCommandDeps(
): ProviderGroupCommandDeps {
const reshare = options.reshare;
return {
+ syncFastPolicy: syncGroupFastPolicy,
+ fastPolicyPending: groupFastPolicyPending,
router: getProviderGroupRouter(),
directory: getProviderGroupDirectory(),
readGroup: readProviderGroup,
@@ -329,8 +350,14 @@ export function createProviderGroupCommandDeps(
// 组里的电脑变了:重新报转分享(加进来的分享来的电脑要请它的主人同意,移出的不再列着)。
reshare?.kick('group');
options.onGroupChanged?.(providerId);
+ if (supportsSubscriptionFastPolicy(getActiveCatalog().providers.find(provider => provider.id === providerId))) {
+ notifyProviderShareCatalogChanged(providerId);
+ }
try {
broadcast(PROVIDER_GROUP_IPC.CHANGED, { providerId });
+ if (supportsSubscriptionFastPolicy(getActiveCatalog().providers.find(provider => provider.id === providerId))) {
+ broadcast(MAKER_PUSH.PROVIDER_CHANGED, {});
+ }
// 同账号其他电脑的模型列表按本机目录里的组摘要收起组内电脑:组变化后让它们重读目录。
tapWindowBroadcast(MAKER_PUSH.PROVIDER_CHANGED, {});
} catch (error) {
diff --git a/apps/desktop/src/main/provider-group/management.ts b/apps/desktop/src/main/provider-group/management.ts
index 0dc4b0c8ac..41a72371b1 100644
--- a/apps/desktop/src/main/provider-group/management.ts
+++ b/apps/desktop/src/main/provider-group/management.ts
@@ -20,7 +20,7 @@ export function parseProviderManagementRequest(raw: unknown): ProviderManagement
return { action: 'manage-group', command: command as ProviderGroupManagementCommand };
}
const command = parseProviderShareCommand(raw.command);
- if (!['owned', 'own-usage', 'usage-history', 'create-link', 'approve', 'reject', 'set-member', 'set-member-note', 'reshare-decide', 'get-run-limits', 'set-run-limits', 'reset-run-limits', 'get-visibility', 'set-visibility', 'quota-account', 'get-model-access', 'set-model-access'].includes(command.action)) {
+ if (!['owned', 'own-usage', 'usage-history', 'create-link', 'approve', 'reject', 'set-member', 'set-member-note', 'reshare-decide', 'get-run-limits', 'set-run-limits', 'reset-run-limits', 'get-visibility', 'set-visibility', 'quota-account', 'get-model-access', 'set-model-access', 'get-fast-policy', 'set-fast-policy'].includes(command.action)) {
throwIpcError('PERMISSION_DENIED', 'Only owner operations are available through management');
}
return { action: 'manage-share', command: command as ProviderShareManagementCommand };
diff --git a/apps/desktop/src/main/provider-group/remoteHandler.ts b/apps/desktop/src/main/provider-group/remoteHandler.ts
index 7f19dea1eb..99c5c2dea8 100644
--- a/apps/desktop/src/main/provider-group/remoteHandler.ts
+++ b/apps/desktop/src/main/provider-group/remoteHandler.ts
@@ -34,6 +34,7 @@ import { throwIpcError } from '../utils/ipcValidate.js';
export const PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS = 8 * 24 * 60 * 60_000;
export interface ProviderGroupRemoteHandlerDeps {
+ bindFastPolicy?(input: { group: string; deviceId?: string | null; sessionId: string; controllerDeviceId?: string }): Promise<void>;
/** 当前账号的分配器与负载(每个请求开头取一次,整个请求都用这一份)。 */
scope(): ProviderGroupOwnerScope;
readGroup(providerId: string): ProviderGroupConfig | null;
@@ -139,23 +140,54 @@ export async function handleProviderGroupRemote(
case 'pick': {
const { providerId } = request;
if (!deps.isRemoteAllowed(providerId) || !deps.readGroup(providerId)) return { kind: 'none' };
- const pick = await scope.router.pick({
- providerId,
- agentKind: request.agentKind,
- model: request.model,
- exclude: new Set(request.exclude),
- ...(request.quotaRebalance ? { quotaRebalance: request.quotaRebalance } : {}),
- // 带着这一轮试过的来问:那台电脑试过不行,本机现读最新状态再选(状态以本机为准,2026-10-11)。
- ...(request.exclude.length > 0 ? { fresh: true } : {}),
- // 选中的同一步记上临时占用:同时来的几个请求不会读到同一份负载、全落到同一台。
- onPicked: (memberKey) => scope.externalLoad.recordPick(controller, request.sessionId, providerId, memberKey),
- });
- // 等目录期间换了账号:这是上一个账号的组(占用也记在上一个账号那份里,随它作废),不作数。
- if (!scope.isCurrent() || pick.kind === 'none') return { kind: 'none' };
- if (pick.kind === 'unavailable') return { kind: 'unavailable', ...(pick.usageLimit ? { usageLimit: pick.usageLimit } : {}) };
- const { key, kind, agentDeviceId, providerId: memberProviderId } = pick.member;
- return { kind: 'member', member: { key, kind, agentDeviceId, providerId: memberProviderId }, label: pick.label,
- ...(request.quotaRebalance ? { quotaRebalance: true as const } : {}) };
+ const excluded = new Set(request.exclude);
+ while (true) {
+ const pick = await scope.router.pick({
+ providerId,
+ agentKind: request.agentKind,
+ model: request.model,
+ exclude: excluded,
+ ...(request.quotaRebalance ? { quotaRebalance: request.quotaRebalance } : {}),
+ // 带着这一轮试过的来问:那台电脑试过不行,本机现读最新状态再选(状态以本机为准,2026-10-11)。
+ ...(excluded.size > 0 ? { fresh: true } : {}),
+ // 选中的同一步记上临时占用:同时来的几个请求不会读到同一份负载、全落到同一台。
+ onPicked: (memberKey) =>
+ scope.externalLoad.recordPick(controller, request.sessionId, providerId, memberKey),
+ });
+ // 等目录期间换了账号:这是上一个账号的组(占用也记在上一个账号那份里,随它作废),不作数。
+ if (!scope.isCurrent() || pick.kind === 'none') return { kind: 'none' };
+ if (pick.kind === 'unavailable')
+ return {
+ kind: 'unavailable',
+ ...(pick.usageLimit ? { usageLimit: pick.usageLimit } : {}),
+ };
+ const { key, kind, agentDeviceId, providerId: memberProviderId } = pick.member;
+ try {
+ await deps.bindFastPolicy?.({
+ group: providerId,
+ deviceId: kind === 'local' ? null : agentDeviceId,
+ sessionId: request.sessionId,
+ controllerDeviceId: controller,
+ });
+ } catch (error) {
+ if (!scope.isCurrent()) return { kind: 'none' };
+ if (
+ !deps.readGroup(providerId)?.autoSwitch ||
+ !/REMOTE_AGENT_PEER_TOO_OLD|REMOTE_AGENT_UNAVAILABLE/.test(String(error))
+ )
+ throw error;
+ if (excluded.has(key)) return { kind: 'unavailable' };
+ excluded.add(key);
+ continue;
+ }
+ if (!scope.isCurrent()) return { kind: 'none' };
+ return {
+ kind: 'member',
+ member: { key, kind, agentDeviceId, providerId: memberProviderId },
+ label: pick.label,
+ ...(request.quotaRebalance ? { quotaRebalance: true as const } : {}),
+ };
+ }
}
case 'cool':
case 'cool-model': {
diff --git a/apps/desktop/src/main/provider-group/remoteRegistration.ts b/apps/desktop/src/main/provider-group/remoteRegistration.ts
index 2e3c471920..cbf4f41cbf 100644
--- a/apps/desktop/src/main/provider-group/remoteRegistration.ts
+++ b/apps/desktop/src/main/provider-group/remoteRegistration.ts
@@ -22,9 +22,11 @@ import {
import { readProviderGroup } from './store.js';
import { isProviderManagementRequest } from '../../shared/providerManagement.js';
import { handleProviderManagementRequest } from './management.js';
+import { bindGroupFastPolicy } from './fastPolicyRuntime.js';
export function registerProviderGroupRemoteHandler(options: { onGroupChanged?: (providerId: string) => void } = {}): void {
const deps: ProviderGroupRemoteHandlerDeps = {
+ bindFastPolicy: bindGroupFastPolicy,
scope: getProviderGroupOwnerScope,
readGroup: readProviderGroup,
isRemoteAllowed: isRemoteProviderInvocationAllowed,
diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
index a6423382fa..14ad23fc76 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
@@ -630,6 +630,23 @@ describe('provider group relay for shared users', () => {
.rejects.toThrow(/cannot be resumed/);
await client.close('close', 'navigation');
});
+
+ it.each([
+ { groupAssigned: true },
+ { groupAssigned: true, relay: relayKeyFor(GUEST_A) },
+ ])('keeps the local group policy on a guest execution even when routing was already assigned: %j', async (extra) => {
+ const env = setup({ plans: [{ kind: 'local' }] });
+ const started: Started[] = [];
+ const host = fakeAgentHost('policy-host', started, { trust: () => 'guest', groupRelay: env.relay });
+ try {
+ await host.handle(GUEST_A, { op: 'open', runId: runId(), agentKind: 'claude-code', payload: { json: openPayload('policy-task', extra) } });
+ await waitFor(() => started.length > 0);
+ expect(started[0].input.groupProviderId).toBe('shared-provider');
+ expect(env.relay.plan).not.toHaveBeenCalled();
+ } finally {
+ await host.dispose();
+ }
+ });
});
describe('provider group relay: starting, load and cleanup', () => {
diff --git a/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts b/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts
index 4233d76238..411f8be391 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts
@@ -119,6 +119,30 @@ function sessionRoot(controller: string, sessionId: string): string {
}
describe('hosted shadow workspace cleanup', () => {
+ it('authorizes policy updates before persistence and waits for native confirmation', async () => {
+ let allowed = false;
+ let confirm!: () => void;
+ const fastPolicy = vi.fn(async (_origin: string, command: { revision: number; allowFast: boolean }) => {
+ await new Promise<void>(resolve => { confirm = resolve; });
+ return { revision: command.revision, allowFast: command.allowFast };
+ });
+ const host = createRemoteAgentHost({ isAgentAvailable: () => true, startHosted: async input => idleHandle(input),
+ isControllerAuthorized: () => allowed, captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot, fastPolicy });
+ try {
+ const command = { op: 'fast-policy', group: 'openai', revision: 2, allowFast: false };
+ await expect(host.handle('controller-1', command)).rejects.toThrow();
+ expect(fastPolicy).not.toHaveBeenCalled();
+ allowed = true;
+ expect(await host.handle('controller-1', { op: 'caps' })).toHaveProperty('subscriptionFastPolicy', true);
+ let acknowledged = false;
+ const pending = host.handle('controller-1', command).then(value => { acknowledged = true; return value; });
+ await vi.waitFor(() => expect(fastPolicy).toHaveBeenCalledOnce());
+ expect(acknowledged).toBe(false);
+ confirm();
+ await expect(pending).resolves.toEqual({ revision: 2, allowFast: false });
+ expect(fastPolicy).toHaveBeenCalledWith('controller-1', expect.objectContaining({ group: 'openai', revision: 2, allowFast: false }));
+ } finally { host.dispose(); }
+ });
it('removes the shadow workspace once the run is disposed', async () => {
const starts: Array<() => void> = [];
const first = whenStarted();
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index ac40311c16..fc421c443e 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -94,6 +94,8 @@ import {
type RemoteAgentControllerTrust,
} from './guestIsolation';
import { createRunTunnel, type RunTunnel, type TunnelHttpRequest, type TunnelHttpResponse } from './tunnel';
+import { hostSessionIdFor } from './sessionIdentity.js';
+export { hostSessionIdFor } from './sessionIdentity.js';
const gunzipAsync = promisify(gunzip);
@@ -131,6 +133,7 @@ const STATE_INTERVAL_MS = 2_000;
const MAX_REMEMBERED_CALLS = 256;
export interface HostedStartInput {
+ groupProviderId?: string;
kind: RemoteAgentKind;
/** 本机侧的任务 id(由控制端与任务 id 派生,恢复同一任务时不变)。 */
hostSessionId: string;
@@ -180,6 +183,7 @@ export interface OwnerProviderRouteBinding {
}
export interface RemoteAgentHostDeps {
+ fastPolicy?(controller: string, command: import('@cindy/device-link').RemoteAgentFastPolicy): Promise<unknown>;
/** Prepare native bytes; retain recovery ownership only for receipted controllers. */
prepareImageEvent?(hostSessionId: string, event: AgentEvent, upstream: GeneratedImageUpstream | undefined, retainForRecovery: boolean): Promise<AgentEvent>;
imageArtifacts?(hostSessionId: string, request: Extract<RemoteAgentRequest, { op: 'images' }>): Promise<unknown>;
@@ -299,6 +303,7 @@ export type GroupRelayPlan =
| { kind: 'unavailable' };
export interface RemoteAgentGroupRelayDeps {
+ bindFastPolicy?(input: { group: string; deviceId?: string | null; sessionId: string; relay?: string }): Promise<void>;
/**
* 受邀者的新任务该交给谁;这个供应商没有组返回 null(照常在本机运行)。`reserve`:选中的同一步就计入那台的负载
* (返回的 `load`),同时来的几个任务不会全落到同一台;只是问问有没有能接的电脑时不预占。
@@ -369,6 +374,7 @@ interface PendingReverse {
}
interface Run {
+ groupProviderId?: string;
id: string;
controller: string;
trust: RemoteAgentControllerTrust;
@@ -507,10 +513,6 @@ export function remoteAgentErrorInfo(error: unknown): RemoteAgentErrorInfo {
}
/** 本机侧的任务 id:控制端设备 + 控制端任务 id 派生,避免与本机自己的任务撞 id。 */
-export function hostSessionIdFor(controller: string, sessionId: string): string {
- const hex = createHash('sha256').update(`${controller}\0${sessionId}`).digest('hex');
- return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
-}
function safeCall<T>(fn: (() => T) | undefined): T | undefined {
if (!fn) return undefined;
@@ -1319,6 +1321,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
: undefined);
}
const handle = await deps.startHosted({
+ ...(run.groupProviderId ? { groupProviderId: run.groupProviderId } : {}),
kind: run.kind,
hostSessionId,
shadowDir,
@@ -1808,6 +1811,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (run.hostSessionId) await recordRelayDevice(run.controller, run.hostSessionId, current.agentDeviceId);
if (run.closing) return;
openSent = true;
+ await deps.groupRelay?.bindFastPolicy?.({ group: groupProviderId, deviceId: current.agentDeviceId,
+ sessionId: relaySessionIdFor(run.controller, payload.sessionId), relay: relayKeyFor(run.controller) });
+ if (run.closing) return;
const started = await backend.client.open(run.kind, relayedOpenPayload(run, payload, current));
if (run.closing) {
await backend.client.close('close', 'navigation').catch(() => undefined);
@@ -2338,6 +2344,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const request = parseRemoteAgentRequest(raw);
if (!deps.isControllerAuthorized(controller)) fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');
switch (request.op) {
+ case 'fast-policy':
+ if (!deps.fastPolicy) fail('REMOTE_AGENT_UNSUPPORTED', 'subscription Fast policy is not supported');
+ return deps.fastPolicy!(controller, request);
case 'fork': {
const owner = deps.captureOwner();
const controllerTrust = trustOf(controller);
@@ -2435,6 +2444,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const guest = trustOf(controller) === 'guest';
const limits = deps.readLimits?.() ?? DEFAULT_REMOTE_AGENT_LIMITS;
const caps: RemoteAgentCaps = {
+ ...(deps.fastPolicy ? { subscriptionFastPolicy: true as const } : {}),
version: REMOTE_AGENT_VERSION,
agents: (['claude-code', 'codex', 'pi'] as const).map((kind) => ({
kind,
@@ -2601,6 +2611,10 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
throw error;
}
const run: Run = {
+ // Routing hints prevent group loops; they are not permission to skip
+ // this executor's policy. Direct and relayed guests inherit its local
+ // group restriction even when the caller says it was already assigned.
+ ...(trust === 'guest' && deps.groupRelay && providerId ? { groupProviderId: providerId } : {}),
id: request.runId,
authorizedModel: payload.options.model,
acceptsImageDeliveryReceipts: payload.acceptsImageDeliveryReceipts === true,
diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.ts
index 4e45f32fae..ad755aa9c1 100644
--- a/apps/desktop/src/main/remote-agent/host/service.ts
+++ b/apps/desktop/src/main/remote-agent/host/service.ts
@@ -24,6 +24,11 @@ import { createProviderGroupGuestRelay } from '../../provider-group/guestRelay.j
import { providerGroupReshare } from '../../provider-group/reshareRuntime.js';
import { getProviderGroupOwnerScope } from '../../provider-group/runtime.js';
import { readProviderGroup } from '../../provider-group/store.js';
+import { bindGroupFastPolicy, bindLocalHostedGroupFastPolicy, receiveGroupFastPolicy, startGroupFastPolicySync } from '../../provider-group/fastPolicyRuntime.js';
+import { groupFastPolicyStore } from '../../provider-group/fastPolicyStore.js';
+import { captureProviderManagementScope } from '../../provider-group/managementScope.js';
+import { createSubscriptionFastPolicy } from '../../maker-host/subscription-fast-policy.js';
+import { getSessionProvider } from '../../maker-host/session-provider-store.js';
import { remoteAgentPollerFor } from '../controller/service';
import { getProviderShareUsageStore, installProviderShareUsageStore } from '../../device-link/providerShareUsageStore.js';
import { currentProviderPartyUsageStore, flushProviderPartyUsage } from '../../usage/providerPartyUsageStore.js';
@@ -93,6 +98,7 @@ export function hostedStartOptions(input: HostedStartInput): StartSessionOptions
}
let host: RemoteAgentHost | null = null;
+let stopFastPolicySync: (() => void) | undefined;
/** 受邀者能用的供应商:分享的那一个,且本机仍开放「允许被远程调用」。 */
function guestAllows(controller: string, providerId: string): boolean {
@@ -110,6 +116,7 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
};
// 同一份受邀者分配器同时提供匿名状态,沿用实际分配时记录的版本兼容情况。
const groupRelay = createProviderGroupGuestRelay({
+ bindFastPolicy: bindGroupFastPolicy,
scope: getProviderGroupOwnerScope,
readGroup: readProviderGroup,
connect: (agentDeviceId) => {
@@ -126,6 +133,7 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
log,
});
host = createRemoteAgentHost({
+ fastPolicy: receiveGroupFastPolicy,
prepareImageEvent: (sessionId, event, upstream, retainForRecovery) => prepareGeneratedImageTransport(`remote:${sessionId}`, event, { upstream, retainForRecovery, invoke: remoteBackgroundInvoke }),
imageArtifacts: async (sessionId, request) => {
try { return await handleGeneratedImageArtifacts(sessionId, request, remoteBackgroundInvoke); }
@@ -139,7 +147,13 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
return false;
}
},
- startHosted: (input) => options.getMaker().startHostedAgentSession(input.kind, hostedStartOptions(input)),
+ startHosted: async (input) => {
+ if (input.groupProviderId) await bindLocalHostedGroupFastPolicy(input.groupProviderId, input.hostSessionId);
+ return options.getMaker().startHostedAgentSession(input.kind, {
+ ...hostedStartOptions(input),
+ fastModePolicy: createSubscriptionFastPolicy(input.hostSessionId, () => getSessionProvider(input.hostSessionId) ?? input.options.providerId),
+ });
+ },
forkHosted: (kind, opts) => options.getMaker().forkSdkSession(kind, opts),
bindOwnerProviderRoute: bindHostedSessionProvider,
ownerModelAllowed: (hostSessionId, providerId, kind, model) => hasHostedSessionModelAccess(hostSessionId)
@@ -195,6 +209,7 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
}),
// Codex 与 Pi 的会话历史在受邀者目录里,随它整体删除;这里清 Claude Code 的项目记录与 Pi 子代理运行目录。
purgeHostedTranscripts: async (hostSessionIds, nativeIds) => {
+ const assertCurrent = captureProviderManagementScope();
const images = captureGeneratedImageStorage();
for (const id of hostSessionIds) {
for (const record of await images.journal.list(`remote:${id}`)) await images.release(record.scope, record.id);
@@ -202,6 +217,9 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
await purgeClaudeHostedTranscripts(hostSessionIds);
await purgeClaudeHostedSessionArtifacts(nativeIds);
await purgePiHostedSubagentRuns(hostSessionIds, path.join(options.userDataDir, 'pi-agent-home'));
+ // These histories have been permanently revoked and purged. Ordinary
+ // task close/idle retains bindings so resuming cannot restore Fast.
+ await groupFastPolicyStore.forgetSessions(hostSessionIds, assertCurrent);
},
recordGuestUsage: (controller, sample) => {
const peer = parseProviderSharePeer(controller);
@@ -220,6 +238,7 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
log,
});
const current = host;
+ stopFastPolicySync = startGroupFastPolicySync();
setRemoteAgentHandler({
handle: (controller, raw) => current.handle(controller, raw),
abortAll: () => {
@@ -247,6 +266,8 @@ export function resolveRemoteAgentHostClaudeSessionId(sdkSessionId: string): str
/** 退出时结束全部远程 Agent 任务。 */
export function disposeRemoteAgentHost(): void {
+ stopFastPolicySync?.();
+ stopFastPolicySync = undefined;
setRemoteAgentHandler(null);
host?.dispose();
host = null;
diff --git a/apps/desktop/src/main/remote-agent/host/sessionIdentity.ts b/apps/desktop/src/main/remote-agent/host/sessionIdentity.ts
new file mode 100644
index 0000000000..09fa85a4ee
--- /dev/null
+++ b/apps/desktop/src/main/remote-agent/host/sessionIdentity.ts
@@ -0,0 +1,7 @@
+import { createHash } from 'node:crypto';
+
+/** Shared by hosted runs and authenticated group speed bindings. */
+export function hostSessionIdFor(controller: string, sessionId: string): string {
+ const hex = createHash('sha256').update(`${controller}\0${sessionId}`).digest('hex');
+ return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
diff --git a/apps/desktop/src/renderer/__tests__/deviceProvidersCache.test.ts b/apps/desktop/src/renderer/__tests__/deviceProvidersCache.test.ts
index 400cda16c6..c9533c43d8 100644
--- a/apps/desktop/src/renderer/__tests__/deviceProvidersCache.test.ts
+++ b/apps/desktop/src/renderer/__tests__/deviceProvidersCache.test.ts
@@ -15,6 +15,43 @@ beforeEach(() => {
vi.resetModules();
});
+it('expires only subscription share snapshots and preserves ordinary API discovery cache semantics', async () => {
+ const login = { ...provider('subscription'), subscriptionFastPolicy: { allowFast: true, groupAllowsFast: true } };
+ const api = provider('openai');
+ const invoke = vi.fn(async (device: string) => ({ providers: [device === 'share:subscription' ? login : api] }));
+ vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
+ const mod = await import('@/hooks/useDeviceProviders');
+ await mod.prefetchDeviceProviders('share:subscription');
+ await mod.prefetchDeviceProviders('share:api');
+ expect(mod.isSubscriptionShareCatalogStale('share:subscription')).toBe(false);
+ const later = Date.now() + 61_000;
+ expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(true);
+ expect(mod.isSubscriptionShareCatalogStale('share:api', later)).toBe(false);
+ expect(mod.isSubscriptionShareCatalogStale('same-account-computer', later)).toBe(false);
+ mod.evictDeviceProviders('share:subscription');
+ expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(false);
+ await mod.prefetchDeviceProviders('share:api');
+ expect(invoke.mock.calls.filter(([device]) => device === 'share:api')).toHaveLength(1);
+});
+
+// A failed policy refresh evicts the authoritative cache. Its subscription
+// identity must survive that soft eviction so the next membership poll retries;
+// account/disconnect eviction must still discard the hint and any late result.
+it('retains subscription freshness after a failed soft refresh and clears it at the owner boundary', async () => {
+ const login = { ...provider('subscription'), subscriptionFastPolicy: { allowFast: true, groupAllowsFast: true } };
+ const invoke = vi.fn().mockResolvedValueOnce({ providers: [login] }).mockRejectedValueOnce(Error('temporary disconnect'));
+ vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
+ const mod = await import('@/hooks/useDeviceProviders');
+ await mod.prefetchDeviceProviders('share:subscription');
+ const later = Date.now() + 61_000;
+ mod.evictDeviceProviders('share:subscription', { retainDisplaySnapshot: true });
+ await mod.prefetchDeviceProviders('share:subscription');
+ expect(mod.getCachedDeviceProviders('share:subscription')).toBeNull();
+ expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(true);
+ mod.evictAllDeviceProviders();
+ expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(false);
+});
+
type Providers = {
providers: ProviderView[];
modelVisibilityOverrides?: Record<string, boolean>;
diff --git a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
index 83ddd33879..edf9031513 100644
--- a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
@@ -1,6 +1,7 @@
import { AddSpeechModelsDialog } from './AddSpeechModelsDialog';
import { providerSpeechSetup } from '../../../shared/speechProviderSetup';
import { useCodexRateLimits } from '@/hooks/useCodexRateLimits';
+import { SubscriptionFastSetting } from '@/features/provider-share/SubscriptionFastSetting';
import { useCodexRateLimitReset } from '@/hooks/useCodexRateLimitReset';
import { CodexResetCredits } from '../status/CodexResetCredits';
import { providerWeeklyQuotaSource } from '../new-chat/useProviderWeeklyQuota';
@@ -868,6 +869,7 @@ function DetailHeader({
className="flex min-h-0 min-w-0 flex-1 flex-col overflow-x-hidden overflow-y-auto overscroll-contain [&>*]:shrink-0"
>
{detail && <div className="px-5 pb-4">{detail}</div>}
+ {provider?.subscriptionFastPolicy && <div className="px-5 pb-4"><SubscriptionFastSetting key={provider.id} provider={provider} /></div>}
{assetModule ??
(subscription && (
<div
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index 229efab05d..59e63dd8f5 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -66,13 +66,14 @@ const selectableStrategy = (strategy: ProviderGroupStrategy): ProviderGroupStrat
const LIMIT_OPTIONS = Array.from({ length: PROVIDER_GROUP_MAX_LIMIT }, (_, i) => String(i + 1));
const WEIGHT_OPTIONS = ['1', '2', '3', '5', '10', '20', '50', String(PROVIDER_GROUP_MAX_WEIGHT)];
-export function ProviderGroupSection({ providerId, providerName, deviceId, deviceName, initialConfig, remoteProvider, onConfigChange }: {
+export function ProviderGroupSection({ providerId, providerName, deviceId, deviceName, initialConfig, remoteProvider, fastPolicySupported, onConfigChange }: {
providerId: string;
providerName: string;
deviceId?: string;
deviceName?: string;
initialConfig?: ProviderGroupConfig | null;
remoteProvider?: ProviderView;
+ fastPolicySupported?: boolean;
onConfigChange?: (config: ProviderGroupConfig | null) => void;
}) {
const { t } = useTranslation();
@@ -258,6 +259,17 @@ export function ProviderGroupSection({ providerId, providerName, deviceId, devic
onCheckedChange={(autoSwitch) => void save({ ...config, autoSwitch })}
/>
</div>
+ {fastPolicySupported && (
+ <div className="flex items-start justify-between gap-3 border-t border-[var(--settings-theme-card-border)] px-4 py-4">
+ <div className="flex min-w-0 flex-col gap-1">
+ <span className="text-13 font-medium text-[var(--text-primary)]">{t('subscriptionFastPolicy.label')}</span>
+ <span className="text-12 leading-[1.4] text-[var(--text-secondary)]">{t('subscriptionFastPolicy.groupHint')}</span>
+ {group.view?.fastPolicyPending && <span role="status" className="text-12 leading-[1.4] text-[var(--text-secondary)]">{t('subscriptionFastPolicy.pending')}</span>}
+ </div>
+ <Switch checked={config.allowFast !== false} disabled={blocked} aria-label={t('subscriptionFastPolicy.label')}
+ onCheckedChange={allowFast => void save({ ...config, allowFast })} />
+ </div>
+ )}
</>
)}
</div>
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
index e28e47133a..b32b9190e1 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
@@ -1,4 +1,5 @@
import { ProviderShareVisibilitySection } from './ProviderShareVisibilitySection';
+import { SubscriptionFastSetting } from './SubscriptionFastSetting';
import { RemoteModelAccessSection, RemoteModelAccessDialog } from './RemoteModelAccessSection';
import { RemoteAgentLimitsSection } from './RemoteAgentLimitsSection';
/**
@@ -506,10 +507,12 @@ export function ProviderShareManagePage({
</section>
)}
+ {providerForApproval?.subscriptionFastPolicy && <SubscriptionFastSetting provider={providerForApproval} deviceId={deviceId} />}
<RemoteModelAccessSection key={`models:${deviceId ?? 'local'}:${providerId}`} providerId={providerId} deviceId={deviceId} />
<ProviderGroupSection
providerId={providerId} providerName={providerName} deviceId={deviceId} deviceName={deviceName}
+ fastPolicySupported={Boolean(providerForApproval?.subscriptionFastPolicy)}
initialConfig={initialGroup} remoteProvider={remoteProvider} onConfigChange={setRemoteGroup}
/>
diff --git a/apps/desktop/src/renderer/features/provider-share/SubscriptionFastSetting.tsx b/apps/desktop/src/renderer/features/provider-share/SubscriptionFastSetting.tsx
new file mode 100644
index 0000000000..62200824e0
--- /dev/null
+++ b/apps/desktop/src/renderer/features/provider-share/SubscriptionFastSetting.tsx
@@ -0,0 +1,81 @@
+import { useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import type { ProviderView } from '@cindy/model-providers';
+import { Switch } from '@/components/ui/switch';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+} from '@/contexts/dataOwnerGeneration';
+import { toast } from '@/lib/toast';
+import {
+ SETTINGS_CARD_CLASS,
+ SETTINGS_ROW_CLASS,
+ SETTINGS_ROW_HINT_CLASS,
+ SETTINGS_ROW_LABEL_CLASS,
+} from '@/components/settings/settingsRowClasses';
+import { providerShareManagementCommand } from '../provider-group/providerManagement';
+
+/** Provider/account control, intentionally absent for custom API connections and older hosts. */
+export function SubscriptionFastSetting({
+ provider,
+ deviceId,
+}: {
+ provider: ProviderView;
+ deviceId?: string;
+}) {
+ const { t } = useTranslation();
+ const [allowed, setAllowed] = useState(provider.subscriptionFastPolicy?.allowFast !== false);
+ const [busy, setBusy] = useState(false);
+ const saving = useRef(false);
+ const sequence = useRef(0);
+ const alive = useRef(true);
+ useEffect(() => {
+ alive.current = true;
+ sequence.current++;
+ setAllowed(provider.subscriptionFastPolicy?.allowFast !== false);
+ return () => {
+ alive.current = false;
+ sequence.current++;
+ };
+ }, [provider.id, deviceId, provider.subscriptionFastPolicy?.allowFast]);
+ if (!provider.subscriptionFastPolicy) return null;
+ const change = async (allowFast: boolean) => {
+ if (saving.current) return;
+ saving.current = true;
+ setBusy(true);
+ const owner = getDataOwnerGeneration();
+ const request = sequence.current;
+ try {
+ const next = await providerShareManagementCommand(
+ { action: 'set-fast-policy', providerId: provider.id, allowFast },
+ deviceId,
+ );
+ if (alive.current && request === sequence.current && isDataOwnerGenerationCurrent(owner))
+ setAllowed(next.allowFast);
+ } catch {
+ if (alive.current && request === sequence.current && isDataOwnerGenerationCurrent(owner))
+ toast.error(t('subscriptionFastPolicy.saveFailed'));
+ } finally {
+ saving.current = false;
+ if (alive.current) setBusy(false);
+ }
+ };
+ return (
+ <div className={SETTINGS_CARD_CLASS}>
+ <div className={SETTINGS_ROW_CLASS}>
+ <div className="flex min-w-0 flex-col gap-1">
+ <span className={SETTINGS_ROW_LABEL_CLASS}>{t('subscriptionFastPolicy.label')}</span>
+ <span className={SETTINGS_ROW_HINT_CLASS}>
+ {t('subscriptionFastPolicy.providerHint')}
+ </span>
+ </div>
+ <Switch
+ checked={allowed}
+ disabled={busy}
+ aria-label={t('subscriptionFastPolicy.label')}
+ onCheckedChange={(value) => void change(value)}
+ />
+ </div>
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx b/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx
index f20755d0cb..2fd03de375 100644
--- a/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx
@@ -29,6 +29,8 @@ vi.mock('@/contexts/AuthContext', () => ({ useAuth: () => bus.auth }));
vi.mock('@/lib/remoteCatalogSnapshot', () => ({ refreshRemoteCatalogSnapshot: vi.fn(async () => undefined) }));
vi.mock('@/hooks/useDeviceProviders', () => ({
getCachedDeviceProviders: () => null,
+ isSubscriptionShareCatalogStale: () => false,
+ hasSubscriptionShareCatalog: () => false,
useDeviceProviders: () => remoteCatalog,
}));
vi.mock('@/hooks/useProviders', () => ({ useProviders: () => localCatalog }));
diff --git a/apps/desktop/src/renderer/features/provider-share/__tests__/useProviderShareAgentDevices.test.tsx b/apps/desktop/src/renderer/features/provider-share/__tests__/useProviderShareAgentDevices.test.tsx
index dde0cb3d82..c1d7b67142 100644
--- a/apps/desktop/src/renderer/features/provider-share/__tests__/useProviderShareAgentDevices.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/__tests__/useProviderShareAgentDevices.test.tsx
@@ -23,10 +23,16 @@ vi.mock('react-i18next', () => ({
const catalog = vi.hoisted(() => ({
refresh: vi.fn<(deviceId: string) => Promise<void>>(async () => undefined),
cached: new Set<string>(),
+ subscriptions: new Set<string>(),
+ stale: new Set<string>(),
}));
vi.mock('@/lib/remoteCatalogSnapshot', () => ({ refreshRemoteCatalogSnapshot: catalog.refresh }));
vi.mock('@/hooks/useDeviceProviders', () => ({
- getCachedDeviceProviders: (deviceId: string) => (catalog.cached.has(deviceId) ? { providers: [] } : null),
+ getCachedDeviceProviders: (deviceId: string) => (catalog.cached.has(deviceId) ? {
+ providers: catalog.subscriptions.has(deviceId) ? [{ subscriptionFastPolicy: { allowFast: false } }] : [],
+ } : null),
+ isSubscriptionShareCatalogStale: (deviceId: string) => catalog.stale.has(deviceId),
+ hasSubscriptionShareCatalog: (deviceId: string) => catalog.subscriptions.has(deviceId),
}));
function share(partial: Partial<ProviderShareReceived>): ProviderShareReceived {
@@ -46,6 +52,7 @@ function share(partial: Partial<ProviderShareReceived>): ProviderShareReceived {
}
let push: ((list: ProviderShareReceived[]) => void) | null = null;
+let catalogPush: ((event: { deviceId: string; channel: string; payload: unknown }) => void) | null = null;
let initial: ProviderShareReceived[] = [];
let linkStatus: ((payload: { status: 'online' | 'connecting' | 'stopped' }) => void) | null = null;
let linkPresence: ((payload: { deviceId: string; online: boolean; remoteControlEnabled: boolean }) => void) | null = null;
@@ -67,6 +74,9 @@ beforeEach(() => {
resetProviderShareStoreForTests();
catalog.refresh.mockClear();
catalog.cached.clear();
+ catalog.subscriptions.clear();
+ catalog.stale.clear();
+ catalogPush = null;
push = null;
initial = [];
linkStatus = null;
@@ -79,6 +89,7 @@ beforeEach(() => {
electronAPI: {
deviceLink: {
invoke,
+ onRemotePush: (callback: typeof catalogPush) => { catalogPush = callback; return () => { catalogPush = null; }; },
onStatusChanged: (callback: typeof linkStatus) => {
linkStatus = callback;
return () => { linkStatus = null; };
@@ -110,6 +121,38 @@ beforeEach(() => {
afterEach(() => cleanup());
describe('useProviderShareAgentDevices', () => {
+ it('refreshes an authorized subscription share on catalog invalidation and ignores custom API shares and unrelated peers', async () => {
+ initial = [share({ shareId: 'subscription', providerId: 'openai' }), share({ shareId: 'api' })];
+ const { result } = renderHook(() => useProviderShareAgentDevices());
+ await waitFor(() => expect(result.current.loaded).toBe(true));
+ catalog.refresh.mockClear();
+ catalog.cached.add('share:subscription'); catalog.cached.add('share:api');
+ catalog.subscriptions.add('share:subscription');
+ act(() => {
+ catalogPush?.({ deviceId: 'share:subscription', channel: 'maker:provider:changed', payload: {} });
+ catalogPush?.({ deviceId: 'share:api', channel: 'maker:provider:changed', payload: {} });
+ catalogPush?.({ deviceId: 'share:unknown', channel: 'maker:provider:changed', payload: {} });
+ catalogPush?.({ deviceId: 'share:subscription', channel: 'maker:event', payload: {} });
+ });
+ expect(catalog.refresh.mock.calls).toEqual([['share:subscription']]);
+ // A failed soft refresh leaves no authoritative cache, but another push
+ // must still retry the previously recognized subscription (never API peers).
+ catalog.cached.delete('share:subscription');
+ act(() => catalogPush?.({ deviceId: 'share:subscription', channel: 'maker:provider:changed', payload: {} }));
+ expect(catalog.refresh.mock.calls).toEqual([['share:subscription'], ['share:subscription']]);
+ });
+
+ it('refreshes stale subscription catalogs even when a membership snapshot has no changes', async () => {
+ initial = [share({ shareId: 'subscription', providerId: 'openai' }), share({ shareId: 'api' })];
+ const { result } = renderHook(() => useProviderShareAgentDevices());
+ await waitFor(() => expect(result.current.loaded).toBe(true));
+ catalog.refresh.mockClear();
+ catalog.cached.add('share:subscription');
+ catalog.subscriptions.add('share:subscription');
+ catalog.stale.add('share:subscription');
+ act(() => push?.(initial));
+ expect(catalog.refresh.mock.calls).toEqual([['share:subscription']]);
+ });
it('only offers new shares that the controlled host has loaded, even if the controller has more cross-region shares', async () => {
initial = [share({ shareId: 'both' }), share({ shareId: 'controller-only' })];
invoke.mockResolvedValue(hostShares({ shareId: 'both' }, { shareId: 'host-only' }));
diff --git a/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts b/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
index e64c30f3bd..5fda3b1e9e 100644
--- a/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
+++ b/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
@@ -16,7 +16,7 @@ import { useSyncExternalStore } from 'react';
import type { ProviderShareReceived } from '@cindy/device-link';
-import { getCachedDeviceProviders } from '@/hooks/useDeviceProviders';
+import { getCachedDeviceProviders, hasSubscriptionShareCatalog, isSubscriptionShareCatalogStale } from '@/hooks/useDeviceProviders';
import { refreshRemoteCatalogSnapshot } from '@/lib/remoteCatalogSnapshot';
import { createLogger } from '@/lib/logger';
import { getDataOwnerGeneration, isDataOwnerGenerationCurrent } from '@/contexts/dataOwnerGeneration';
@@ -53,6 +53,7 @@ export interface ReceivedSnapshot {
let receivedSnapshot: ReceivedSnapshot = { received: [], loaded: false };
let receivedStarted = false;
+let unsubscribeCatalogPush: (() => void) | undefined;
/** 推送序号:首次 `received` 命令晚于推送返回时,不得用旧列表覆盖。 */
let receivedPushSeq = 0;
const receivedSubscribers = new Set<() => void>();
@@ -75,6 +76,12 @@ function invalidateShareCatalogs(
void refreshRemoteCatalogSnapshot(deviceId).catch(() => undefined);
}
}
+ for (const share of next) {
+ const deviceId = providerShareAgentDeviceId(share.shareId);
+ if (share.status === 'active' && isSubscriptionShareCatalogStale(deviceId)) {
+ void refreshRemoteCatalogSnapshot(deviceId).catch(() => undefined);
+ }
+ }
}
function setReceived(next: readonly ProviderShareReceived[]): void {
@@ -136,6 +143,13 @@ export function ensureProviderShareReceivedStarted(): void {
const api = providerShareApi();
if (!api) return;
receivedStarted = true;
+ unsubscribeCatalogPush = window.electronAPI?.deviceLink?.onRemotePush?.(push => {
+ if (push.channel !== 'maker:provider:changed' || !push.deviceId.startsWith('share:')) return;
+ if (!receivedSnapshot.received.some(share => providerShareAgentDeviceId(share.shareId) === push.deviceId && share.status === 'active')) return;
+ if (hasSubscriptionShareCatalog(push.deviceId)) {
+ void refreshRemoteCatalogSnapshot(push.deviceId).catch(() => undefined);
+ }
+ });
api.onReceivedChanged((list) => {
receivedPushSeq += 1;
setReceived(Array.isArray(list) ? list : []);
@@ -350,6 +364,8 @@ export async function refreshProviderShareOwnerPending(): Promise<ProviderShareO
/** 仅测试用:重置模块状态。 */
export function resetProviderShareStoreForTests(): void {
+ unsubscribeCatalogPush?.();
+ unsubscribeCatalogPush = undefined;
receivedSnapshot = { received: [], loaded: false };
receivedStarted = false;
receivedPushSeq = 0;
diff --git a/apps/desktop/src/renderer/hooks/useDeviceProviders.ts b/apps/desktop/src/renderer/hooks/useDeviceProviders.ts
index e33aa0ebb5..e16ce74a00 100644
--- a/apps/desktop/src/renderer/hooks/useDeviceProviders.ts
+++ b/apps/desktop/src/renderer/hooks/useDeviceProviders.ts
@@ -46,6 +46,9 @@ export interface DeviceProvidersPayload {
const EMPTY_PAYLOAD: DeviceProvidersPayload = { providers: [] };
const cache = new Map<string, DeviceProvidersPayload>();
+// Retained across a policy refresh failure; discarded on disconnect/owner
+// eviction. Otherwise a failed refresh loses the identity needed to retry it.
+const subscriptionFetchedAt = new Map<string, number>();
const inflight = new Map<string, Promise<DeviceProvidersPayload>>();
const deviceGen = new Map<string, number>();
export type DeviceProvidersEvent =
@@ -230,6 +233,9 @@ async function fetchDeviceProviders(deviceId: string): Promise<DeviceProvidersPa
const payload = parseDeviceProvidersPayload(res);
if (isCurrent()) {
cache.set(deviceId, payload);
+ if (deviceId.startsWith('share:') && payload.providers.some(provider => !!provider.subscriptionFastPolicy))
+ subscriptionFetchedAt.set(deviceId, Date.now());
+ else subscriptionFetchedAt.delete(deviceId);
inflight.delete(deviceId);
notifyDeviceProviders(deviceId, { status: 'ready', ...payload });
}
@@ -403,6 +409,16 @@ export function getCachedDeviceProviders(deviceId: string): DeviceProvidersPaylo
return cache.get(deviceId) ?? null;
}
+/** Only subscription shares opt into freshness polling; custom API catalogs keep their existing lifetime. */
+export function hasSubscriptionShareCatalog(deviceId: string): boolean {
+ return subscriptionFetchedAt.has(deviceId);
+}
+
+export function isSubscriptionShareCatalogStale(deviceId: string, now = Date.now()): boolean {
+ return hasSubscriptionShareCatalog(deviceId)
+ && now - (subscriptionFetchedAt.get(deviceId) ?? 0) >= 60_000;
+}
+
export function isDeviceProvidersGenerationCurrent(deviceId: string, generation: number): boolean {
return (deviceGen.get(deviceId) ?? 0) === generation;
}
@@ -412,6 +428,7 @@ export function evictDeviceProviders(
options?: { retainDisplaySnapshot?: boolean },
): number {
cache.delete(deviceId);
+ if (!options?.retainDisplaySnapshot) subscriptionFetchedAt.delete(deviceId);
inflight.delete(deviceId);
deviceGen.set(deviceId, (deviceGen.get(deviceId) ?? 0) + 1);
notifyDeviceProviders(deviceId, {
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index 9dd472ee30..4713890b93 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -17129,5 +17129,12 @@
"taskSource": "[Task source] A companion started this task.",
"taskId": "Task ID:",
"contextReferences": "Context references:"
+ },
+ "subscriptionFastPolicy": {
+ "label": "Allow Fast",
+ "providerHint": "When off, this subscription account uses standard speed for your own and shared tasks, including Ultrafast.",
+ "groupHint": "When off, all tasks routed through this group use standard speed, including Ultrafast.",
+ "pending": "Some computers have not confirmed the setting. Keep them connected and update group computers that do not support this setting.",
+ "saveFailed": "The setting may be saved, but some running tasks have not confirmed standard speed. Check the connection and retry."
}
}
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 0e3135d5bb..e61f1177bf 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -17075,5 +17075,12 @@
"taskSource": "[タスクの出典] このタスクはパートナーが開始しました。",
"taskId": "タスク ID:",
"contextReferences": "参考資料:"
+ },
+ "subscriptionFastPolicy": {
+ "label": "Fast を許可",
+ "providerHint": "オフにすると、このサブスクリプションの自分用・共有タスクは通常速度になります。Ultrafast も対象です。",
+ "groupHint": "オフにすると、このグループ経由のすべてのタスクは通常速度になります。Ultrafast も対象です。",
+ "pending": "一部のコンピューターが設定を確認していません。接続を維持し、この設定に対応していないグループ内のコンピューターを更新してください。",
+ "saveFailed": "設定は保存された可能性がありますが、一部の実行中タスクが通常速度への切り替えを確認していません。接続を確認して再試行してください。"
}
}
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 69ae4b9a6c..e14dc97239 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -17075,5 +17075,12 @@
"taskSource": "[작업 출처] 파트너가 시작한 작업입니다.",
"taskId": "작업 ID:",
"contextReferences": "참고 자료:"
+ },
+ "subscriptionFastPolicy": {
+ "label": "Fast 허용",
+ "providerHint": "끄면 이 구독 계정의 본인 및 공유 작업이 일반 속도로 실행됩니다. Ultrafast에도 적용됩니다.",
+ "groupHint": "끄면 이 그룹을 통해 실행하는 모든 작업이 일반 속도로 실행됩니다. Ultrafast에도 적용됩니다.",
+ "pending": "일부 컴퓨터가 설정을 확인하지 않았습니다. 연결을 유지하고 이 설정을 지원하지 않는 그룹 컴퓨터를 업데이트하세요.",
+ "saveFailed": "설정은 저장되었을 수 있지만 일부 실행 중인 작업이 일반 속도 전환을 확인하지 않았습니다. 연결을 확인한 후 다시 시도하세요."
}
}
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index c26432d922..b054ef3a3e 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -17075,5 +17075,12 @@
"taskSource": "[任务来源] 本任务由伙伴发起。",
"taskId": "任务 ID:",
"contextReferences": "参考资料:"
+ },
+ "subscriptionFastPolicy": {
+ "label": "允许使用 Fast",
+ "providerHint": "关闭后,此订阅账号使用普通模式,包括自己使用和分享使用。也适用于 Ultrafast。",
+ "groupHint": "关闭后,经此组运行的任务使用普通模式,也适用于 Ultrafast。",
+ "pending": "部分电脑尚未确认设置。请保持连接,并更新不支持此设置的组内电脑。",
+ "saveFailed": "设置可能已保存,但运行中的任务尚未全部确认切换为普通模式。请检查连接后重试。"
}
}
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
index 8aef2d238e..ad8c2e5925 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -17075,5 +17075,12 @@
"taskSource": "[任務來源] 本任務由夥伴發起。",
"taskId": "任務 ID:",
"contextReferences": "參考資料:"
+ },
+ "subscriptionFastPolicy": {
+ "label": "允許使用 Fast",
+ "providerHint": "關閉後,此訂閱帳號使用普通模式,包括自己使用和分享使用。也適用於 Ultrafast。",
+ "groupHint": "關閉後,經此組執行的任務使用普通模式,也適用於 Ultrafast。",
+ "pending": "部分電腦尚未確認設定。請保持連線,並更新不支援此設定的組內電腦。",
+ "saveFailed": "設定可能已儲存,但執行中的任務尚未全部確認切換為普通模式。請檢查連線後重試。"
}
}
diff --git a/apps/desktop/src/shared/__tests__/providerGroup.test.ts b/apps/desktop/src/shared/__tests__/providerGroup.test.ts
index 220b9cb1da..69e48fca39 100644
--- a/apps/desktop/src/shared/__tests__/providerGroup.test.ts
+++ b/apps/desktop/src/shared/__tests__/providerGroup.test.ts
@@ -24,6 +24,13 @@ it.each([undefined, {}, { resetAtMs: '5000' }, { resetAtMs: -1 }, { resetAtMs: I
);
describe('group detail diagnostics compatibility', () => {
+ it('round-trips a Fast prohibition and retains only a strict pending flag', () => {
+ const config = normalizeProviderGroupConfig({ allowFast: false, members: [{ kind: 'local' }] }, 'openai')!;
+ expect(providerGroupSummaryForWire(config).allowFast).toBe(false);
+ expect(parseProviderGroupRemoteView({ config, members: [], fastPolicyPending: true }, 'openai')).toMatchObject({ config: { allowFast: false }, fastPolicyPending: true });
+ expect(parseProviderGroupRemoteView({ config, members: [], fastPolicyPending: 'true' }, 'openai')).not.toHaveProperty('fastPolicyPending');
+ expect(normalizeProviderGroupConfig({ members: [{ kind: 'local' }] }, 'openai')).not.toHaveProperty('allowFast');
+ });
const config = { members: [{ kind: 'local' }] };
const payload = (extra: Record<string, unknown>) => ({ config, members: [{ key: 'local', state: 'available', ...extra }] });
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index aa433de6e6..f53ef1c0d0 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -58,6 +58,8 @@ export interface ProviderGroupMember {
}
export interface ProviderGroupConfig {
+ /** Subscription-only speed policy. Absent preserves the existing allowed default. */
+ allowFast?: boolean;
strategy: ProviderGroupStrategy;
/** 组内电脑失败时自动换一台继续,默认开启。 */
autoSwitch: boolean;
@@ -190,6 +192,8 @@ export interface ProviderGroupReshareSummary {
}
export interface ProviderGroupView {
+ /** Some executors have not confirmed this group's subscription speed policy yet. */
+ fastPolicyPending?: boolean;
providerId: string;
/** null = 还没有组。 */
config: ProviderGroupConfig | null;
@@ -383,7 +387,8 @@ export function normalizeProviderGroupConfig(raw: unknown, groupProviderId: stri
members.push(member);
}
if (members.length === 0) return null;
- return { strategy, autoSwitch: value.autoSwitch !== false, members };
+ return { strategy, autoSwitch: value.autoSwitch !== false, members,
+ ...(typeof value.allowFast === 'boolean' ? { allowFast: value.allowFast } : {}) };
}
// ─── 同账号电脑之间(`maker:provider:list` 的 `group` 字段与 `provider-group:remote` 通道) ─────
@@ -393,6 +398,7 @@ export function normalizeProviderGroupConfig(raw: unknown, groupProviderId: stri
* 组员的坐标是组所在电脑视角(`local` = 组所在电脑自己)。并发上限与权重只在组所在电脑上生效,不外发。
*/
export interface ProviderGroupWireSummary {
+ allowFast?: boolean;
strategy: ProviderGroupStrategy;
autoSwitch: boolean;
members: Array<Pick<ProviderGroupMember,
@@ -401,6 +407,7 @@ export interface ProviderGroupWireSummary {
export function providerGroupSummaryForWire(config: ProviderGroupConfig): ProviderGroupWireSummary {
return {
+ ...(config.allowFast !== undefined ? { allowFast: config.allowFast } : {}),
strategy: config.strategy,
autoSwitch: config.autoSwitch,
members: config.members.map((m) => ({
@@ -754,5 +761,6 @@ export function parseProviderGroupRemoteView(raw: unknown, groupProviderId: stri
...(fiveHourTight ? { fiveHourTight: true as const } : {}),
}];
});
- return { providerId: groupProviderId, config, members, ...(model ? { model } : {}) };
+ return { providerId: groupProviderId, config, members, ...(model ? { model } : {}),
+ ...(value.fastPolicyPending === true ? { fastPolicyPending: true } : {}) };
}
diff --git a/apps/desktop/src/shared/providerManagement.ts b/apps/desktop/src/shared/providerManagement.ts
index 66a5a8a766..21872eca70 100644
--- a/apps/desktop/src/shared/providerManagement.ts
+++ b/apps/desktop/src/shared/providerManagement.ts
@@ -12,7 +12,7 @@ export type ProviderGroupManagementCommand = Extract<
export type ProviderShareManagementCommand = Extract<
ProviderShareCommand,
- { action: 'owned' | 'own-usage' | 'usage-history' | 'create-link' | 'approve' | 'reject' | 'set-member' | 'set-member-note' | 'reshare-decide' | 'get-run-limits' | 'set-run-limits' | 'reset-run-limits' | 'get-visibility' | 'set-visibility' | 'quota-account' | 'get-model-access' | 'set-model-access' }
+ { action: 'owned' | 'own-usage' | 'usage-history' | 'create-link' | 'approve' | 'reject' | 'set-member' | 'set-member-note' | 'reshare-decide' | 'get-run-limits' | 'set-run-limits' | 'reset-run-limits' | 'get-visibility' | 'set-visibility' | 'quota-account' | 'get-model-access' | 'set-model-access' | 'get-fast-policy' | 'set-fast-policy' }
>;
export type ProviderManagementRequest =
diff --git a/apps/desktop/src/shared/providerShare.ts b/apps/desktop/src/shared/providerShare.ts
index 566198cac9..2d9f22848f 100644
--- a/apps/desktop/src/shared/providerShare.ts
+++ b/apps/desktop/src/shared/providerShare.ts
@@ -193,6 +193,8 @@ export interface ProviderShareSettledEvent {
export type ProviderShareCommand =
+ | { action: 'get-fast-policy'; providerId: string }
+ | { action: 'set-fast-policy'; providerId: string; allowFast: boolean }
| { action: 'get-model-access'; providerId: string; memberId?: string }
| { action: 'set-model-access'; providerId: string; memberId?: string; models: RemoteModelSelection }
| { action: 'get-visibility'; providerId: string }
@@ -230,6 +232,8 @@ export interface ProviderShareCredentialConsentView {
}
export interface ProviderShareCommandResult {
+ 'get-fast-policy': { supported: boolean; allowFast: boolean };
+ 'set-fast-policy': { supported: boolean; allowFast: boolean };
'get-model-access': RemoteModelAccessView;
'set-model-access': RemoteModelAccessView;
'get-visibility': ProviderShareVisibility;
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 6eeb2547e1..ad92dd89ea 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -3232,3 +3232,25 @@ namespace + id 下同一插件的有界 JSON 请求;`deviceSync: true` 是独
本机新增 `local-db:bots:projects:list/set` 仅用于受信 renderer,不进入远程 IPC allowlist。
旧 `workbench.json` 目录及设备归属沿用原格式;关联不进入任务负责范围或扩大文件权限。
不改服务端、数据库 schema、Mobile 原生配置或指纹。
+
+## 订阅 Fast 的账号与组约束
+
+`remote-agent` 的 caps 新增可选 `subscriptionFastPolicy: true`,仅严格的 `true` 表示执行端支持。
+新的 `fast-policy` 操作携带组 ID、修订号、`allowFast`,以及可选的任务绑定;只经已有认证通道
+发送,不传策略函数,不授予模型或账号权限。执行端持久化并等待原生设置应用后,回传对应
+修订与允许状态。旧修订不能解除较新的禁止,同修订冲突只能收紧。
+
+`open` 的 `groupAssigned` / `relay` 是路由防环提示,不是策略豁免。执行端本机实际以 guest
+身份运行时,仍绑定本机原生订阅组的限制,与已接收的上游约束取交集;调用方不能自报
+已分配来跳过本机限制。绑定先于来源提交时,未能解析的来源按禁止处理,持久化及原生应用
+全部成功才确认;旧绑定继续兼容读取,普通 close/idle 不删除禁令记录。
+
+缺省仍允许 Fast,因此旧控制端和未配置禁止的组保持原有行为。新组设置禁止时,未声明能力
+或没有正确确认的旧执行端保持待确认,不能用于新的受限分配;自动换电脑沿用已有策略。
+旧接收方即使保留 Fast 选项,也由新版实际执行端钳制。首次使用要求组所在电脑与执行电脑
+均升级;未更新的执行端不能宣称已受控。
+
+供应商目录新增可选 `subscriptionFastPolicy` 展示字段;受限目录投影为不支持 Fast / Ultrafast。
+分享的刷新通知复用已有 `maker:provider:changed` 空载荷,只发给当前被授权的接收方,并核对
+对应 host。自定义 API 不进入这套策略与新增刷新规则。详细范围及验证见
+[订阅 Fast 控制交接说明](../subscription-fast-policy.md)。
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index bf48c4a16e..e2279fb320 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -819,3 +819,15 @@
- 本地数据:供应商组设置只新增存储,不改已有的供应商、远程调用与分享数据;涉及数据库时按
`docs/dev-rules/database-and-migrations.md` 只做新增。
- 测试要覆盖上表每一行:新组所在电脑配旧组内电脑、旧同账号电脑、旧受邀者,以及降级后的组所在电脑。
+
+## 15. 订阅 Fast 限制
+
+OpenAI / Claude 原生订阅组可在「自动换电脑」下关闭「允许使用 Fast」。关闭后,经此组分配的任务按普通模式运行,包含 Fast 与 Ultrafast;在组内其他电脑上单独使用其账号的任务不继承这一组的限制。账号本身另有独立开关,账号与组任一层禁止都有效。
+
+组所在电脑自己执行的分享任务始终受本机组限制,包括调用方自报已经分配或经中转到来的任务。`groupAssigned` / `relay` 用于路由防环,不能作为跳过本机 Fast 限制的权限证明。执行电脑同时收到多个组约束时取交集。
+
+执行电脑负责最终限制,分享接收方的旧目录或旧任务设置不能越过限制。目录下发隐藏有效的 Fast 能力,收到变更后自动刷新;通用自定义 API 模型发现和请求不受影响。
+
+组所在电脑与执行电脑通过带修订的约束和确认同步;未确认时显示待确认,禁止设置下不分配到不支持约束的旧电脑,开启自动换电脑时尝试其他可用成员。离线成员重试,移出成员和删除组也须下发解除约束。已经发出的请求正常完成,不以切换开关为由中断它。
+
+首次使用需更新应用,之后设置热生效;重新允许不会主动给当前任务开启 Fast。实现入口、兼容边界和验证记录见 [订阅 Fast 控制交接说明](../subscription-fast-policy.md)。
diff --git a/docs/subscription-fast-policy-review.md b/docs/subscription-fast-policy-review.md
new file mode 100644
index 0000000000..1691d78107
--- /dev/null
+++ b/docs/subscription-fast-policy-review.md
@@ -0,0 +1,185 @@
+# 订阅 Fast 控制:独立审查与修复记录
+
+日期:2026-10-23。审查分支:`feat/subscription-fast-controls`;基线:`0a9987b416cd551a76402fc7da12c99f8639bc50`。
+
+下文记录提交前的完整功能审查,包含当时新增、未跟踪的源码、测试和文档。审查阶段没有提交、推送、创建 PR、部署或重启正式版。用户随后授权 rebase、提交 PR 和自动跟进;提交前追加验证另见文末。
+
+## 结论与边界
+
+主审独立阅读代码,并通过真实 Orca 委托五个 DeepSeek V4 Pro 审核者。共确认并修复 10 项问题,最重要的是远程分配提示可绕过组限制,以及桥接鉴权等待期间可能漏发一条 Fast 请求。其余涉及协议载荷、失败恢复、同步确认、界面通知、长期存储和重试积压。
+
+每项已确认缺陷均补了会在旧实现失败的回归条件,再修复代码。额外覆盖换号、损坏文件、写入中断和并发写入。审核者复核结果与验证范围见下文。没有把审核者提出的每个建议直接当作缺陷,也没有采用会丢失旧任务禁令的淘汰方案。
+
+本次不声称完成 macOS、Claude 原生付费请求或不同物理电脑上的完整实测。之前两套已登录隔离 dev 的实测记录仍在[交接说明](subscription-fast-policy.md);本轮追加修复通过自动化与原生 CLI loopback 测试,没有重新发送真实付费请求。
+
+## 五个 Orca 委托
+
+团队:`wfhr3zcmmrd365elc12n3jrt`。五个 Worker 均实际创建成功,模型为 `deepseek/deepseek-v4-pro`,供应商 `xd`,推理强度 high,Fast 关闭。审核者共享当前未提交代码,只读审查;由主审统一修改,避免同时写入。
+
+| 审核者 | 侧面 | Worker ID |
+| --- | --- | --- |
+| `ds-exit` | Codex HTTP/WS、Claude/Pi、桥接鉴权、工具循环、重新启用 | `ox8tk2dms5f5etcsuf3sjt1l` |
+| `ds-groups` | 组分发、身份隔离、修订与 ACK、离线/旧版、绑定与释放 | `gcjnx9l10ivk79ul6ssckxpr` |
+| `ds-sharing` | 分享目录、启动加载、推送、缓存失败、代次隔离、自定义 API | `jl3l2ues9wfvoxl6hnpkuyld` |
+| `ds-ui-scope` | UI 与管理权限、订阅识别、设置保存失败、目录通知 | `k4yjat0753n0t9bpbro5ngto` |
+| `ds-tests` | 反向测试、异常路径、自动换机、测试真实性与资源边界 | `s4g0jnka5z67hfheorfeq13f` |
+
+## 已修复发现
+
+### R1 / P1:桥接鉴权等待期间可能漏出 Fast
+
+- 位置:`apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts` 的桥接 `prefs.fast`;消费端为 `packages/anthropic-responses-bridge/src/handler.ts`。
+- 触发:Claude 引擎桥接 ChatGPT 订阅,先快照允许 Fast;`buildHeaders` 等待鉴权时关闭 Fast;之后用旧快照构造 `service_tier: priority`。
+- 修复:`prefs.fast` 使用 getter,在桥接 handler 完成异步鉴权后读取实际宿主策略。保留用户本次请求的偏好,不改变 bridge package API 和依赖方向。
+- 回归:新增 `subscriptionFastBridge.test.ts`,走真实路由变换和真实 Responses handler,捕获模拟 fetch。允许时必须确实出现 priority;鉴权期间禁止时必须没有 priority。旧代码该禁止用例失败,新代码通过。
+- 复核:`ds-exit` 独立确认缺陷并复核 getter 修复。
+
+### R2 / P1:客户端的分配提示可跳过组 Fast 限制
+
+- 位置:`apps/desktop/src/main/remote-agent/host/runHost.ts` 构造 `Run.groupProviderId`;`service.ts` 启动前绑定本机组策略。
+- 触发:账号允许、组禁止;受邀者发送 `groupAssigned: true`,或通过 relay 到达;原先 `groupRouted=false`,本机组策略没有绑定,执行出口会认为允许 Fast。
+- 修复:把本机策略绑定与选机判断分开。实际以 guest 身份在本机执行的请求,都从宿主解析出的供应商继承本机组约束,再与上游约束取交集;`groupAssigned` / `relay` 仍保留防转圈用途。
+- 回归:`remote-agent/__tests__/groupRelay.test.ts` 分别覆盖已分配直连与 relay,旧实现两条都缺少 `groupProviderId`,修复后通过。原有组分配、转分享授权、负载与续接测试同时通过。
+- 修复闭环:追加真实 runtime 交集测试又捕获了本次修复的恢复遗漏——组只有远程成员时,本机已绑定的策略没有收到后续解除。同步目标现始终包含仍存在的组的本机策略端点;删除组仍发送解除。测试验证上游允许+本机禁止、解除本机禁止、上游再禁止三步均正确。这次返工没有计成新的原始发现,也没有略去失败记录。
+- 范围澄清:组所在电脑自己的分享执行入口不能凭调用方提示绕过本机禁令;组内其他电脑单独使用自己的账号,不继承别台电脑的组设置。自定义 API 不进入原生订阅策略。
+- 复核:`ds-groups` 独立确认绕过并逐项核对实际宿主任务 ID 和约束交集。
+
+### R3 / P2:禁止 Fast 会改写 WebSocket 控制消息
+
+- 位置:`packages/maker-core/src/agents/shared/fast-mode-policy.ts` 的 `standardSpeedRequest`。
+- 触发:禁 Fast 时,无速度字段的 `session.update`、`conversation.item.create`、`response.cancel`、`ping` 也被塞入 `service_tier: default`,改变控制帧协议。
+- 修复:带有字符串 `type` 且不是 `response.create` 的控制消息返回 null,由出口原样透传;HTTP 请求和 WS create 仍强制普通档。
+- 回归:`subscriptionFastRequestPolicy.test.ts` 表驱动覆盖四种控制帧,旧代码全部失败,修复后通过。实际出口 null 分支保留原始字节。
+- 限度:确认的是错误注入字段,不把“某上游一定因此拒绝控制帧”当作已经实测的事实。
+- 复核:`ds-exit`、`ds-tests` 均复核通过。
+
+### R4 / P2:目录刷新失败后可能失去自动重试资格
+
+- 位置:`renderer/hooks/useDeviceProviders.ts`、`features/provider-share/providerShareStore.ts`。
+- 触发:已识别订阅分享收到刷新通知,先软失效缓存,随后请求失败;原先仅凭权威缓存识别订阅,空缓存令后续推送和过期检查都跳过它。
+- 修复:单独保存成功识别订阅分享时的时间戳。软失效保留识别,下一次推送/过期检查可以重试;断链或账号边界的硬失效清除。成功变成非订阅目录也清除,不扩展通用 API 刷新行为。
+- 回归:缓存用例先复现失败;另外在分享 hook 中覆盖缓存为空后的下一次 push。三个 Renderer 文件共 89 项通过,`ds-sharing` 独立复跑并复核通过。
+
+### R5 / P2:离线被误判成版本过旧
+
+- 位置:`provider-group/fastPolicyRuntime.ts` 的 `send`。
+- 触发:caps 返回 `{ok:false}`,原先统一抛 `REMOTE_AGENT_PEER_TOO_OLD`,造成错误升级提示,还可能把短暂掉线记成长期能力不足。
+- 修复:调用失败归为 `REMOTE_AGENT_UNAVAILABLE`;只有成功响应缺少策略能力,才归为 `PEER_TOO_OLD`。
+- 回归:离线返回与真实旧版分别断言错误类别,旧实现离线用例失败,修复后通过。
+- 复核:`ds-groups` 提出,`ds-tests` 复核通过。
+
+### R6 / P2:抛出的传输异常阻止自动换电脑
+
+- 位置:同一 `send` 的远程调用,以及 `remoteHandler.ts` 的选机重试。
+- 触发:链路调用直接 reject `LINK_NOT_OPEN` 等异常,而非返回 `{ok:false}`;原先错误没有归一化,自动换机只识别标准可重试错误,因此整次分配失败。
+- 修复:两次远程调用统一包装。catch 中先核对 owner,再转 `REMOTE_AGENT_UNAVAILABLE`,避免把账号切换误认成链路故障。
+- 回归:显式 reject 的链路异常与返回错误分别覆盖;选机回归验证排除失败成员并继续。没有放宽受限组需要 ACK 的条件。
+- 复核:`ds-tests` 提出并复核通过。
+
+### R7 / P2:设置已保存但同步失败会漏掉通知与绑定清理
+
+- 位置:`provider-group/ipc.ts` 的 save/delete 分支。
+- 触发:写盘成功后,原生引擎 busy 导致同步抛错;后续 prune/changed 被跳过,界面仍显示旧值,分享目录缺少推送;删除组也会留下旧任务分配绑定。
+- 修复:同步置于 try,已提交状态的清理与发布置于 finally;先核对 owner,再清理、再核对、再发布。同步错误仍向上传递,本地未应用的策略继续 pending,不能谎报 ACK。
+- 回归:save/delete 的 native busy 两条先红后绿;另补同步期间换 owner 的两条回归,确保不清理或通知新账号。
+- 复核:`ds-ui-scope` 确认并复核,实际复跑相关三文件 106 项;新增 owner 边界后 IPC 文件 59 项通过。
+
+### R8 / P2:已确认解除的旧成员持续留在同步目标
+
+- 位置:`provider-group/fastPolicyStore.ts` 的 `acknowledge`。
+- 触发:成员移除并已经收到解除后,目标仍永久保留;后续开关提高修订号时重新联系旧成员,若其离线就再次出现无意义 pending。
+- 修复:当前修订的解除已确认、且不属于当前成员时删除该发送目标。尚未确认的离线解除继续保留,不能擅自丢掉解除意图。
+- 回归:先移除并确认,再让旧成员离线、切换组设置,断言不再联系它且没有虚假 pending。旧实现失败,修复后通过。
+- 复核:`ds-groups` 提出并复核。
+
+### R9 / P2:历史绑定到 10,000 个后拒绝新受限任务
+
+- 位置:`provider-group/fastPolicyStore.ts` 的持久绑定。
+- 触发:绑定只有新增没有回收,第 10,001 个任务抛错,禁止 Fast 的组无法继续创建任务。
+- 修复:新绑定按宿主任务 ID 的 SHA-256 前两位存入 256 个分片,继续兼容主文件旧绑定,移除任务数硬门槛。复用已有跨进程原子写、owner 作用域和损坏保护。先持久绑定,再提交来源策略,二者成功后才 ACK;缺失来源默认禁止。
+- 回收:仅在 `service.ts` 的受邀者历史永久清退全部成功后删除对应 legacy/shard 绑定,保留来源修订号墓碑。普通 close/idle 不清理,旧任务仍可安全续聊。
+- 回归:预置 10,000 个旧绑定后增加新任务,旧实现抛错;修复后新旧任务均保留禁令。额外覆盖中断后未知来源禁止、重试恢复、损坏文件保留、跨实例同分片并发写、永久清退不影响其他任务、旧修订不解禁。
+- 限度:每片仍有 4 MiB 资源保护;不是无限容量承诺。同账号任务的永久删除尚未接入同款回收,记录保守保留而不冒险解除禁令,后续可补安全回收入口。
+- 复核:`ds-groups` 复核写入顺序、清退入口、失败方向与修订墓碑,无新增阻断项。
+
+### R10 / P2:慢同步期间重复轮询会累积完整重试
+
+- 位置:`provider-group/fastPolicyRuntime.ts` 的在途同步合并和 5 秒轮询。
+- 触发:一次离线 caps 调用持续超过轮询间隔;原先每次重入都在当前 Promise 后追加一次完整同步,慢链路下重试队列持续增长。另有旧修订已 ACK、配置已变但尚未发出的短窗口,pending 原先可能错误为 false。
+- 修复:后台轮询跳过正在同步的组;并发调用共用在途结果,仅当最新 allow/members 与已准备的状态不同才追加同步,保留 owner guard。pending 同时检查当前配置与准备中的状态。
+- 回归:阻塞一个离线端点时同时追加五次同步,旧实现发送六次 caps,新实现只一次;配置未发出时必须 pending;在途禁止变为允许时仍发送两代设置,不能因去重吞掉新设置。
+- 主审先用两条失败回归复现,再修复;`ds-tests` 独立复核通过,并实跑 runtime + IPC 共 70 项,无新增阻断项。
+
+## 不采纳或撤回的建议
+
+1. **普通关闭时清除 suppressedBySession**:独立审核者复核后撤回。该状态跨原生进程关闭保留,防止解除限制后续聊自动恢复旧 Fast 偏好;普通 close 清理会破坏“需显式重新开启”语义。
+2. **LRU 淘汰组禁令绑定**:未采用。旧任务仍可续聊,淘汰记录会丢失执行约束。
+3. **嵌套 A→B→C 丢失上游限制**:现有 relay payload 同时携带防环标记,执行端不会继续按自己的组再次转发,该假设路径不可达。实际可达的客户端标记绕过已按 R2 修复。
+4. **尚未确认的离线解除直接删除**:未采用。必须保留意图直到执行端收到更高修订并确认。
+
+## 本轮验证
+
+以下四个批次没有重叠,合计 **48 个测试文件、2515 项通过**。这不是整仓全测计数,也没有累加此前交接记录或审核者重复运行的用例。
+
+| 批次 | 文件 | 通过 |
+| --- | ---: | ---: |
+| provider-group 全目录、组中转与 host 生命周期、策略和桥接回归 | 34 | 793 |
+| Codex、Claude 设置/重建、Fast 策略、Maker 远程分支 | 5 | 1129 |
+| Codex/Claude/Pi 出口、分享管理、Renderer 缓存/刷新 | 8 | 592 |
+| 原生 Codex 0.159.2 + loopback 上游 | 1 | 1 |
+
+原生测试只用临时 HOME/CODEX_HOME、合成授权与本地模拟上游。正向对照先确认 priority,然后验证工具循环中禁止、解除后仍普通、旧 Ultrafast 请求被钳制、用户显式再启用后恢复 priority。没有发送真实付费请求。
+
+第一次原生复测误选仓库中的旧 `apps/codex-bin` 0.145.0,正向 priority 断言失败;没有弱化断言,改用当前包实际使用的 `apps/codex-package-bin` 0.159.2 后通过。旧二进制不记为通过。
+
+- Desktop 完整类型检查:通过;最后一次在源码冻结后启动,2026-10-23 12:32(+08:00)确认退出码 0。
+- 本轮新增核心源文件及缓存/分享路径 ESLint:通过。
+- `pnpm check:test-hygiene`:通过,364 个文件在基线内,没有放宽基线。
+- `git diff --check`:通过。
+- 最终 34 文件批次的机器报告:工作区忽略目录 `artifacts/fast-review/final-desktop-groups.json`。
+- Orca 原始审核回复保存在忽略目录 `artifacts/fast-review/orca-reports.json`,最后一项复核另存 `orca-final-r10.json`;五个 Worker 最终均为 done。
+
+主要复现命令:
+
+```powershell
+pnpm --filter desktop exec vitest run src/main/provider-group/__tests__ src/main/maker-host/__tests__/subscription-fast-policy.test.ts src/main/maker-host/__tests__/subscriptionFastBridge.test.ts src/main/maker-host/__tests__/subscriptionFastRequestPolicy.test.ts src/main/remote-agent/__tests__/groupRelay.test.ts src/main/remote-agent/__tests__/hostLifecycle.test.ts --maxWorkers=2
+pnpm --filter @cindy/maker-core exec vitest run src/agents/shared/__tests__/fast-mode-policy.test.ts src/agents/codex/index.test.ts src/agents/claude-code/__tests__/flag-settings.test.ts src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts src/maker.agentDevice.test.ts --maxWorkers=2
+$env:CINDY_TEST_CODEX_BINARY=(Resolve-Path apps/codex-package-bin/win32-x64/bin/codex.exe).Path
+pnpm --filter desktop exec vitest run src/main/maker-host/__tests__/subscriptionFastPolicy.native.test.ts --maxWorkers=1
+pnpm --filter desktop run typecheck
+```
+
+## 未验证与既有问题
+
+- macOS、Claude 原生订阅真实请求、不同物理电脑执行:本轮未实测。没有把 mock、Windows 或 loopback 当成这些场景的证据。
+- Core 独立 `pnpm --filter @cindy/maker-core run build` 仍失败于既有的 `packages/lizi-mcps/src/browser/recipe-loader.ts:180,190`:`TS2339 ImportMeta.glob`。该文件不在本次 diff 中;不把独立 Core 构建写为通过,也不为本功能跨范围修改其环境类型。
+- 之前 Windows Claude hosted e2e 清理曾遇到基线可复现的 `EBUSY`;本轮未重复运行该已知故障套件,未弱化其断言。
+- 两套 dev 的启动包装此前返回 `STARTUP_TIMEOUT`,实际 UI 随后加载并完成测试;启动门禁仍不记为通过。
+- 两套 dev 的上一轮真实分享测试使用的是追加审查前的源码快照;本轮修复没有重新复制并重跑双实例付费流程,不能把旧截图作为最终补丁的实机证据。
+
+正式版 PID `37892` 的启动时间复核仍为 `2026-10-22 15:53:45 +08:00`,保持持续运行。本次修改停留在开发分支的工作区。
+
+## 提交 PR 前追加验证(2026-10-23)
+
+已同步 fork,并将完整功能补丁 rebase 到检查时最新的上游 `70b32d757868f24df988c41e9fc31c0a2a3b4fbe`。第一轮冲突只涉及 caps 解码和协议文档:保留上游 `idleReclaimMinutes` 校验及伙伴关联项目说明,同时加入 Fast 能力与协议说明。第二轮吸收权限热切换等后续 PR,无冲突;`range-diff` 确认相对上游的功能补丁未改变。未覆盖或回退上游其他 PR。
+
+用户确认兼容性要求:首次升级或登录默认允许 Fast,是否分享不改变默认值。已有 Fast / Ultrafast 偏好保留;只有明确关闭账号或组开关才限制。现有持久 store 回归覆盖缺省允许及其他账号未被误伤,真实 Codex loopback 正向对照确认允许状态仍发出 `priority`。
+
+以下为最后一次 rebase 后的独立批次,共 **55 个文件、3114 项通过**,未累加历史批次和单文件重复计时:
+
+| 批次 | 文件 | 通过 |
+| --- | ---: | ---: |
+| Desktop 策略、完整组目录、分享管理与缓存、Codex/Claude/Pi 出口 | 42 | 1390 |
+| Core Fast、Codex、Claude 设置与权限、Pi 权限、Maker 运行时 | 9 | 1667 |
+| 原生 Codex 0.159.2 loopback 与共享组配置 | 2 | 33 |
+| device-link 协议与供应商身份 | 2 | 24 |
+
+- Desktop 全量 `typecheck` 退出码 0;device-link 与 model-providers 的实际 `build`(`tsc --noEmit`)通过。
+- Core 独立 build 仍只有未改动的 `recipe-loader.ts:205,227` 两处 `TS2339 ImportMeta.glob`,上游改动导致旧记录行号移动;没有把该项记成通过。
+- `check:test-hygiene` 通过(363 个文件在原基线内),未放宽基线;i18n key、术语表和开发文档合同检查通过。新增策略及缓存/分享关键路径 ESLint 通过。
+- 订阅开关 UI 最终矩阵 **40/40** 通过:明暗主题、五种语言、允许/禁止/待确认/320px 窄屏;截图为真实组件与模拟数据,用户已确认可发布到 fork。最终证据目录 `artifacts/ui-check/subscription-fast-VbITJI/`。
+- 受影响页面双主题默认场景 **54/54** 通过,已查看总览;`ProvidersSection.tsx` 被工具列为 `UNCOVERED`,不将该设置页入口记为本轮截图覆盖。复用的订阅开关组件另有上述矩阵。
+- 首次 Electron 全矩阵扫描未产出图片,终止的仅是该扫描进程树;改用 Chromium 完成以上检查,没有重启正在供给的 Cindy。
+- 24 个改动测试文件分别运行通过,独立计时在 `artifacts/fast-rebase/standalone-timings.json`。桥接回归保留真实路由和 handler,直接加载实际速度钳制函数,减少无关 Agent 初始化;优化后单文件 8.15 秒、测试体 66 毫秒,尚高于 5 秒目标,如实登记。
+
+机器报告与日志在忽略目录 `artifacts/fast-rebase/`。macOS、Claude 原生真实付费请求和不同物理机仍未补测;之前隔离 dev 的真实分享记录不代替最终 rebase 后的实机证据。
diff --git a/docs/subscription-fast-policy.md b/docs/subscription-fast-policy.md
new file mode 100644
index 0000000000..76c5f59c91
--- /dev/null
+++ b/docs/subscription-fast-policy.md
@@ -0,0 +1,260 @@
+# 订阅账号与供应商组的 Fast 控制
+
+本文是本次实现的交接说明,包含产品范围、执行路径、代码入口、验证方法和发布边界。
+
+2026-10-23 追加的主审独立 review、五个 Orca DeepSeek 审核及十项修复,见[独立审查与修复记录](subscription-fast-policy-review.md)。
+
+## 1. 交付范围
+
+订阅账号所有者可以在供应商设置或「远程与分享」管理页关闭「允许使用 Fast」。供应商组所在电脑也有独立的同名开关,位于「自动换电脑」下面。
+
+首次升级或登录时,账号与组的「允许使用 Fast」默认开启,不因未分享或开始分享而改变。现有任务的 Fast / Ultrafast 偏好继续生效;登录本身不会替任务开启 Fast。只有用户明确关闭相应开关后,才新增普通速度限制。
+
+| 设置 | 影响范围 |
+| --- | --- |
+| 订阅账号关闭 Fast | 使用这个实际账号的本机、同账号远程和分享任务 |
+| 供应商组关闭 Fast | 经这个组分配的任务,包括组内远程执行与转分享;组所在电脑直接执行的分享任务也必须遵守本机组限制 |
+| 两处都允许 | 恢复 Fast 的可用性;不会主动把正在运行的任务切回 Fast |
+
+禁用同时覆盖 Fast 和 Ultrafast。收到旧客户端或旧任务发来的加速设置时,执行电脑按普通模式运行。
+
+第一版提供账号、组两层开关,不提供逐模型开关。不修改通用模型能力的正本,也不把模型的原生支持情况永久改成不支持。
+
+### 范围识别
+
+只识别真实的 OpenAI / Claude 原生订阅授权:`auth.method === 'oauth'`,并符合其原生授权身份。
+
+- 自定义 API 供应商不增加这个开关,不改模型发现、缓存规则或请求载荷。
+- 自定义 API 供应商即使名称或 ID 是 `openai`,也不能仅凭名字进入限制范围。
+- 不迁移 Claude 原生订阅的凭证,也不把它改为经 Cindy 代理处理授权。
+- 不修改服务端仓库、Mobile 原生配置、系统 CLI 配置或正在使用的真实订阅文件。
+
+## 2. 生效语义
+
+有效限制取以下约束的交集:实际订阅账号、任务所属的本地供应商组、执行电脑已经接收的远程组约束。执行电脑以 guest 身份处理分享或中转任务时,它自己对该订阅设置的本地组限制也参与交集,无论该组是否包含本机成员。任一层禁止就使用普通模式。
+
+保存设置后热生效,不需要为了反复开关而重启 Cindy。首次获得此功能仍需要更新应用;组所在电脑和实际执行电脑都需要支持新协议。
+
+已经发给上游的请求正常完成。后续用户发送、工具循环、重试、切模型和续接路径会重新应用限制。Codex 的实际请求出口另有保护,因为原生引擎可能在同一轮工具循环中保留旧的加速档。
+
+同一轮中先禁止、再重新允许,出口仍保持普通档,直到用户明确再次启用 Fast。该状态按当前 owner、任务和实际订阅来源隔离,不会串到其他任务或自定义 API;执行侧的模式变化也同步到本机运行时偏好,避免 bridge 和用量记录继续使用旧档。
+
+原生设置更新失败时不能谎报成功:保留限制并重试;组页面显示部分电脑尚未确认设置。此时尚未确认的旧版或离线电脑不能作为已经受控的执行电脑使用。
+
+### 旧版与离线电脑
+
+1. 执行电脑声明 `subscriptionFastPolicy` 能力。
+2. 组所在电脑发送带修订号的限制,实际执行电脑持久化并更新原生会话后确认。
+3. 新分配必须先完成绑定;组禁止 Fast 时,不能把未确认的旧版执行电脑当成成功。
+4. 开启自动换电脑时,按既有策略尝试其他可用成员。
+5. 未确认设置每 5 秒重试,不重建共享的 device-link 连接。
+6. 移出成员或删除组时发送更高修订的解除约束;离线电脑保持待确认,恢复连接后重试。
+
+已有请求不会因开关设置被强制中止。未确认的旧电脑上,原有加速任务也不能声称已切成普通模式;需要让那台电脑更新并确认。建议按电脑滚动更新后再把待确认状态作为完成标准。
+
+## 3. 分享目录更新
+
+执行限制与目录展示相互独立,目录不是最终授权依据。
+
+- 导出有效模型目录时,受限订阅模型的 `supportsFastMode` 和 `supportsUltrafastMode` 均为 `false`。
+- 原始目录和用户自己的模型覆盖保持原样,解除限制后可以恢复能力展示。
+- 分享接收方启动时按既有加载流程获取目录;收到受限供应商的目录变更事件后刷新缓存。
+- 收到未变化的分享列表时,仅对已经识别为订阅分享、且目录超过 60 秒的缓存补刷新。
+- 同区域、跨区域分享都使用已有的 `maker:provider:changed` 推送,不增加服务端接口。
+- 推送只针对当前被授权的分享及对应 host,载荷不包含账号凭证、组员名单或真实设备身份。
+- 刷新失败继续保留原有目录;实际执行电脑仍按当前策略限制请求。
+
+60 秒是目录过期阈值,不是所有场景的刷新时限。检查由既有分享列表同步触发;空闲时同步可能更慢。即使接收方没有主动更新供应商组,执行侧限制仍生效。
+
+## 4. 数据与安全边界
+
+配置存储使用当前 owner 的数据目录和既有原子写文件设施:
+
+| 文件 | 内容 |
+| --- | --- |
+| `provider-fast-policy.json` | 实际订阅账号的 Fast override |
+| 现有供应商组配置 | 可选 `allowFast`;缺省允许 |
+| `provider-group-fast-policy.json` | 已接收来源、修订号、任务绑定、已发送限制及各电脑确认情况 |
+| `provider-group-fast-policy.json.bindings/<00..ff>.json` | 按任务 ID 的 SHA-256 前两位分片保存新任务绑定;兼容读取主文件内的旧绑定 |
+
+不新增数据库 migration,不把授权凭证写入这些文件。配置缺失按默认允许;已有文件损坏或不可读时,对订阅限制按禁止处理,并拒绝用默认值覆盖原文件。API 供应商不受此回退影响。
+
+远程消息只携带组、修订号、允许状态和必要的任务绑定信息。它不能携带可执行的策略函数。执行电脑根据已认证的控制方重建实际任务 ID,分享 guest 不能绑定到另一个 guest 或所有者的任务。
+
+同修订号冲突只能收紧限制,不能放宽。跨账号切换期间使用既有 owner guard,旧异步结果不能写入新账号。
+
+任务绑定不按时间或普通关闭淘汰,避免旧任务续聊丢失禁令。永久清退受邀者历史成功后,回收对应绑定并保留修订号墓碑。每个分片保留 4 MiB 的文件保护上限;损坏、不可读或写入失败时禁止放行,不声称存储容量无限。调用方传来的 `groupAssigned` / `relay` 只用于路由和防环,不是跳过执行端本机组限制的授权。
+
+## 5. 代码入口
+
+以下均为仓库相对路径。
+
+| 层 | 文件与职责 |
+| --- | --- |
+| 订阅身份 | `packages/model-providers/src/provider-identity.ts`:`supportsSubscriptionFastPolicy` |
+| 目录投影 | `apps/desktop/src/main/maker-host/subscription-fast-policy.ts`;`provider-service.ts` 与 `createDesktopProviderService.ts` 接入投影 |
+| 账号存储 | `apps/desktop/src/main/maker-host/provider-fast-policy-store.ts` |
+| 组存储 | `apps/desktop/src/main/provider-group/fastPolicyStore.ts` |
+| 分发与确认 | `apps/desktop/src/main/provider-group/fastPolicyRuntime.ts` |
+| 组内分配 | `provider-group/remoteHandler.ts`、`remoteRegistration.ts`、`guestRelay.ts`、`maker-ipc/register.ts` |
+| 托管执行 | `apps/desktop/src/main/remote-agent/host/runHost.ts`、`service.ts`、`sessionIdentity.ts` |
+| 通道协议 | `packages/device-link/src/remoteAgent.ts`:可选能力及 `fast-policy` 操作 |
+| 启动与实时约束 | `packages/maker-core/src/maker.ts`、`agents/shared/fast-mode-policy.ts` |
+| Codex | `packages/maker-core/src/agents/codex/index.ts`:原生 tier、设置更新及子线程保护 |
+| Claude Code | `packages/maker-core/src/agents/claude-code/index.ts` 与 `flag-settings.ts`:最高优先级显式 false、实时设置复核 |
+| Pi | `packages/maker-core/src/agents/pi/index.ts`:原生偏好钳制 |
+| 请求出口 | `apps/desktop/src/main/maker-host/subscription-fast-request-policy.ts`;接入 `codex-proxy-host.ts`、`codex-text-only-policy.ts`、`anthropic-compat-proxy-host.ts`、`anthropic-responses-bridge-host.ts` |
+| 供应商管理命令 | `apps/desktop/src/main/device-link/providerShareRuntime.ts`;共享命令类型与管理白名单在 `apps/desktop/src/shared/` |
+| 分享刷新 | `device-link/dispatch.ts`、`index.ts`、`providerShareCrossRegion.ts`、`providerShareGuest.ts`;Renderer 的 `providerShareStore.ts`、`useDeviceProviders.ts` |
+| UI | `SubscriptionFastSetting.tsx`,接入 `ProvidersSection.tsx` 和 `ProviderShareManagePage.tsx`;组开关在 `ProviderGroupSection.tsx` |
+| 文案 | `apps/desktop/src/renderer/i18n/locales/{zh-CN,zh-TW,en,ja,ko}/common.json` 的 `subscriptionFastPolicy` |
+
+## 6. 维护时必须保留的行为
+
+1. 目录上的「支持 Fast」是展示能力,账号和组的禁止策略是执行约束,不能互相替代。
+2. 不能仅过滤接收方的按钮,必须保留执行电脑和请求出口检查。
+3. Codex 仅更新 `thread/settings/update` 不足以保护进行中的工具循环,HTTP 和 WebSocket 出口都要保留。
+4. 自定义 API 路由保持原决策与请求内容;控制面、token 计数接口也不添加加速字段。
+5. Claude 的普通偏好 false 过去表示不写字段。订阅禁止必须显式写 `fastMode: false`,覆盖原生和用户设置。
+6. 解除禁止只恢复能力,不主动调用 `setFastMode(true)`。请求出口还必须保留已关闭状态,直到明确重新启用,防止进行中的原生工具循环恢复旧 Fast。
+7. 设置保存在组所在电脑仍不等于所有成员已经执行,确认失败必须保持待确认状态。
+8. 新配置的默认值必须兼容已有用户;无禁止设置时旧执行电脑仍可照常使用。
+9. 分享目录刷新必须保留 owner、设备代次和请求合并保护,不能扩展成通用 API 目录轮询。
+
+## 7. 验证与复现
+
+### 单元与回归
+
+以下为本次执行过的主要批次;批次有重叠,不应简单相加为独立用例数。
+
+| 批次 | 结果 |
+| --- | --- |
+| 组、分享 Renderer、目录缓存、分发、策略存储与投影 | 45 个文件,933 项通过 |
+| Codex、Claude Code 全目录、Pi 路由、通用运行时约束 | 2146 项通过,2 项按环境跳过 |
+| Claude 显式 false、回退重建与通用运行时约束补测 | 80 项通过 |
+| 请求出口、自定义 API、远程通道与托管回归 | 902 项通过;另 1 项原有 Claude 托管用例遇到 `EBUSY`,见下文 |
+| 协议鉴权、组、分享、目录及请求出口的后续定向回归 | 39 个文件,1235 项通过;异步压缩请求与连续开关另有补测 |
+| 最终出口、组分发与 API 兼容回归 | 7 个文件,411 项通过 |
+| 管理命令、账号切换及禁止解除状态补测 | 2 个文件,83 项通过 |
+| Pi 原生转发与解压期间的模式、账号切换补测 | 43 项通过 |
+| Maker 本机与托管启动、续接、Claude 重建及模式回读补测 | 5 个文件,229 项通过 |
+| Windows 实机发现的本机目录通知回归 | 2 个文件,135 项通过;新增用例在修复前均复现失败 |
+| Desktop 全量类型检查、新增模块 ESLint | 通过;最终类型检查在功能代码固定后执行 |
+| model-providers / device-link 构建 | 通过 |
+| 真实 Codex + 真实本地代理 + 模拟上游 | 通过;见原生验证 |
+| Light / Dark、默认 / 禁止 / 待确认 / 320 px 窄屏 | 8/8 通过,包含两个开关来回切换及边界位置断言 |
+| i18n key 与术语 | 五种语言对齐,无新增术语违规;保留仓库已有告警 |
+
+UI 证据位于 `artifacts/ui-check/subscription-fast-FsIswe/`:`summary.json` 记录逐项结果,`overview.png` 与各场景目录保存截图。已查看 320 px 窄屏的 Light / Dark 成品;自动化还验证了开关往返操作及布局边界。
+
+主要命令:
+
+```sh
+pnpm --filter desktop run typecheck
+pnpm --filter @cindy/model-providers run build
+pnpm --filter @cindy/device-link run build
+pnpm check:i18n
+pnpm check:i18n-glossary
+pnpm ui:check --page subscription-fast --case all --theme all --locale zh-CN --engine chromium
+```
+
+策略测试分别位于 `provider-group/__tests__/fastPolicy{Store,Runtime}.test.ts`、`maker-host/__tests__/subscription-fast-policy.test.ts`、`subscriptionFastRequestPolicy.test.ts` 和 Core 的 `agents/shared/__tests__/fast-mode-policy.test.ts`。
+
+管理命令的真实入口用例在 `device-link/__tests__/providerShareManagement.test.ts`;解压期间解除禁止或切换账号的用例在 `maker-host/__tests__/piNativeSubscriptionForwarding.test.ts`。已进入普通档处理的请求不会因解压期间放开策略而发送空载荷或旧 Fast;账号发生变化则在实际 fetch 前拒绝发送。
+
+Maker 的本机和托管启动都使用已关闭状态过滤旧启动参数;Claude 的 Query 重建继续显式覆盖原生 `fastMode`,模式回读也必须与实际普通档一致。这部分用例在 `packages/maker-core/src/maker.agentDevice.test.ts` 和 `agents/claude-code/__tests__/rewind-runtime-settings.test.ts`。
+
+### 原生验证
+
+`apps/desktop/src/main/maker-host/__tests__/subscriptionFastPolicy.native.test.ts` 使用显式指定的 Codex 二进制、临时 HOME / CODEX_HOME、合成凭证、本地代理和 loopback 模拟上游,不读取真实账号。
+
+```sh
+CINDY_TEST_CODEX_BINARY=/absolute/path/to/codex pnpm --filter desktop exec vitest run src/main/maker-host/__tests__/subscriptionFastPolicy.native.test.ts --maxWorkers=1
+```
+
+本次使用 Windows 原生 Codex 0.159.2。正向对照先确认真实请求含 `service_tier: priority`,随后在当前响应尚未完成时禁用,再让引擎执行工具并继续同一轮;下一次实际出站请求必须为普通档。同一轮下一次工具调用期间解除限制,继续保持普通档;还覆盖旧任务再次请求 Ultrafast,以及用户明确重新开启 Fast 后实际请求恢复 `priority`。
+
+这项验证实际发现并促成了出口保护:原生设置更新成功,并不代表当前一轮工具循环不再沿用 Fast。
+
+### Windows 真实 Desktop 补充验证(2026-10-22)
+
+在用户这台 Windows 上运行隔离沙箱 `fast-policy-test`(Global、被动调度),通过独立 CDP 端口 `9337` 操作完整 Electron 应用。测试复用 OpenAI 登录态,不修改订阅凭证,不更新或重启正在提供服务的安装版。
+
+真实 UI + Main IPC、持久设置和目录缓存的六项检查通过:账号禁止刷新后仍保留、重新允许恢复可用能力、组禁止覆盖账号允许、组禁止在 Dark 模式刷新后仍保留、账号禁止覆盖组允许,以及清理本次测试组后账号仍禁用 Fast。明暗截图已目检;不只检查 Main 返回值,还检查 Renderer 缓存无需手动刷新即可更新。测试组只有本机成员,没有添加真实远程供应电脑。
+
+这次实机操作发现并修复了本机目录通知遗漏:未登录 Cindy 账号时,分享运行时尚未启动,原来的通知函数没有本机接收者;组变化也仅通知远端。现在订阅策略变化始终通知本机窗口,组通知只对适用的订阅增加目录刷新。回归位于 `providerShareManagement.test.ts` 和 `provider-group/__tests__/ipc.test.ts`。
+
+证据位于 `artifacts/fast-desktop-live/`,包括 `live-results.json`、`group-disabled-light.png`、`group-disabled-dark.png` 和 `supplier-disabled-group-allowed-dark.png`。过程中的定位脚本曾因建组后入口改名而超时,修正定位后完整重跑;最终结果也包含缓存自动更新断言。
+
+需要如实区分的限制和用量:
+
+- 安全启动包装两次返回 `STARTUP_TIMEOUT`(120 秒);之后实际窗口完成加载并可交互。此处记录的是随后完成的窗口测试,启动门禁不算通过,没有通过修改启动门禁掩盖超时。
+- 沙箱未登录 Cindy 云端账号,因此未完成实体多机分享下发、执行端确认或接收方刷新验收;本机组显示待确认符合这一测试环境。相关场景目前仍由自动化夹具覆盖。
+- 首次进入沙箱会自动生成伙伴欢迎语,实际产生约 11.3k token 用量;日志记录 `fastMode: false`。没有手动发送付费模型测试消息,也没有用真实账号发送 Fast 请求;前述模拟上游原生验证仍使用合成凭证。
+
+### 同机多实例分享验收准备(2026-10-22)
+
+真实跨账号分享不要求两台物理电脑。两个隔离 Desktop dev 使用不同的 Cindy 登录态、认证设备身份、数据库和 CDP 端口,即可走真实分享服务与 device-link;不能把同机两端替代测试描述成已经覆盖 macOS 或真实跨网断连。组所在实例与执行实例需要分开验收时,可再增加第三个独立 dev。
+
+本仓启动器一个 checkout 同时只保留一个隔离 dev,换沙箱名再次 restart 仍会替换同 checkout 的旧实例。因此接收端使用额外的独立测试 checkout,复制当前未提交功能源码并逐文件核对,不复制用户数据、凭证或其它 checkout 的 `node_modules`。独立运行 `pnpm install --frozen-lockfile --prefer-offline --prod=false` 后,按安全包装启动:
+
+```powershell
+# 当前功能 checkout:供应端,复用此前的本机测试沙箱
+$env:XDT_CDP_PORT='9337'
+pnpm restart:desktop:remote --region=global --isolated=fast-policy-test --passive
+
+# 独立测试 checkout:接收端。--isolated-auth 避免自动复用本机 OpenAI 凭证
+$env:XDT_CDP_PORT='9338'
+pnpm restart:desktop:remote --region=global --isolated=fast-policy-guest --isolated-auth --passive
+```
+
+两个登录页均已实际加载并截图,认证状态回读确认两个不同的 `dev-fast-policy-*` 设备身份;`get-device-id` 返回物理机指纹,不能用它证明认证设备身份隔离。证据位于 `artifacts/fast-desktop-live/peer-status.json`、`peer-login-0.png` 和 `peer-login-1.png`。正式版原进程仍在运行,没有重启。
+
+准备过程中快照校验遇到 CRLF 与 Windows 路径表示差异,已改为规范化路径并逐文件复制、核对源码字节。两次安全启动包装仍返回 `STARTUP_TIMEOUT`,实际登录页随后完成加载;不计为启动门禁通过。此时尚未登录两个不同的 Cindy 账号,因此只完成了双实例隔离与登录页准备,尚未完成真实分享申请、审批、目录下发或请求执行验收。账号登录需要用户在各测试实例界面自行完成,不能复制正式版登录凭证代替。
+
+2026-10-23 登录准备阶段:供应端已由用户登录 Cindy;接收端尚未登录且用户需要手机号入口。登录页按构建区域选择标识方式,Global 显示邮箱、中国大陆版显示手机号,不能通过往邮箱框填写手机号解决。仅将接收端测试 checkout 改为 `--region=cn` 启动(其余隔离参数及 CDP `9338` 不变),保留已登录的 Global 供应端及正式版。构建区域不能直接当作本次分享所属服务区域的证据;下方真实分享响应报告 owner region 为 `cn`,因此不把这次验收记为跨区域服务验证通过。供应端测试账号的 OpenAI / Claude 订阅 Fast 均已关闭,返回目录的 Fast / Ultrafast 能力计数为 0。
+
+手机号入口已实际核验:接收端为 `#/login`、`input[type="tel"]` 可见、无邮箱输入框,登录服务下发 `providers.phone: true`;截图及结果在 `peer-login-phone-cn.png`、`peer-phone-status.json`。已登录供应端与正式版保持原 PID / 启动时间。该次安全启动包装仍返回 `STARTUP_TIMEOUT`(120 秒);第一次等待手机号输入框 20 秒也超时,随后页面加载完成,重新验证通过,没有重启已登录实例或绕过登录验证。
+
+### 两账号真实分享与订阅请求验收(2026-10-23)
+
+用户完成两端登录后,回读确认两个不同的云端账号及 `dev-fast-policy-*` 认证设备身份。供应端开启测试沙箱的远程调用并生成一次性链接,接收端经真实服务预览和申请;审批在自动化读到待处理快照前已由界面完成,之后按生成的申请编号核验为 approved,未重复创建链接或批准其它申请。链接口令只在测试进程内存中传递,没有写入脚本、输出或结果文件。测试只操作新建分享,不修改供应端原来收到的分享。
+
+真实目录与自动刷新完成以下检查:
+
+1. 授权目录只返回本次分享的 OpenAI,9 个模型,禁止时 Fast / Ultrafast 能力计数为 0。
+2. 已缓存的接收端不手工刷新,账号重新允许后 Fast 模型计数变为 8,再禁止后自动变为 0。
+3. 账号允许、组禁止时仍为 0;组重新允许后自动恢复;账号禁止也覆盖组允许。
+4. 重新加载接收端实际任务页面,由应用自身加载分享目录,仍读到组禁止,输入区没有 Fast / Ultrafast 按钮。设置页尚未选择分享时保留既有按需加载行为;测试不把空缓存当成已经刷新成功。
+5. 接收端临时建立仅含该分享的 OpenAI 组,执行端确认组禁止后,`fastPolicyPending` 为 false,组员 available。该组随后解除并确认,未留在用户配置里。
+
+另用原生 Codex 和真实 ChatGPT 订阅完成两条极短请求。两条任务的发起端持久设置均故意保留 `fastMode: 'ultrafast'`;供应端原生日志的 thread/start 和 turn/end 均为 `serviceTier: null`,结束时 `fastMode: false`,收到并保存了 `FAST_POLICY_OK`。
+
+| 请求 | 执行时的限制 | 输入 token | 输出 token |
+| --- | --- | ---: | ---: |
+| 旧 Ultrafast 设置,经真实分享使用订阅 | 账号禁止,无组 | 18,839 | 7 |
+| 旧 Ultrafast 设置,经真实分享使用供应端的组 | 账号允许、组禁止,组内为本机成员 | 18,828 | 7 |
+
+这两条手动验证合计 37,667 个输入 token、14 个输出 token,均为普通模式;不能因为用户提示很短就忽略 Cindy / Agent 上下文本身的 token。前文欢迎语的约 11.3k token 是更早的另一笔用量,不合并成这两条请求。没有用真实订阅做 Fast 正向计费测试;带 priority 的正向对照仍只在模拟上游完成。
+
+本轮测试脚本也修正了几个测试自身的问题:审批已经完成时不再死等 pending;自动刷新断言改为连续读取缓存至稳定,避免把瞬时读数当成最终结果;首条请求的监听器起初读错 `event.data`,通过已保存消息、完成事件和原生日志恢复验收,没有重发该请求。首次创建参数误用 `workspaceKind: scratch` 被拒绝,改为已有的 `project`。尝试从未连接本机 OpenAI 的接收端直接创建本地组任务时,既有模型准入拒绝了该模型,尚未产生模型请求;没有通过改数据库或放宽准入绕过它,也没有把该路径记成通过。实际组请求使用供应端组的本机成员;独立远程执行成员的绑定、离线和多跳限制仍由原有集成夹具覆盖。
+
+证据均在忽略目录 `artifacts/fast-desktop-live/`:`cross-account-share.json`、`share-policy-results.json`、`share-task-results.json`、`group-task-results.json`、`group-live-setup.json`、`recipient-startup-results.json` 和 `recipient-real-task-group-prohibited.png`。原生订阅的证明是执行端实际日志,不能称为抓取了真实上游请求包;HTTP / WebSocket 出口载荷的逐请求断言见前述模拟上游原生验证。
+
+收尾已关闭两条测试任务的运行时,保留消息和工作目录;删除仅由测试建立的组并发送解除约束;供应端 Fast 恢复为禁止,测试沙箱的远程控制、OpenAI 远程调用恢复为开启测试前的关闭状态。两端 Cindy 登录态及测试分享关系保留,正式版及原有供应没有重启或更改。`teardown-results.json` 记录恢复结果。
+
+### 已知验证边界
+
+- `claudeHosted.e2e.test.ts` 的 `releases an idle task...` 在 Windows 临时工作目录上出现 `EBUSY`。完整回归和单独重跑均失败;以原始 `HEAD` 对照运行同一用例,复现相同错误。本次没有改写或跳过该测试来制造全绿。后续应单独修复托管释放过程的 Windows 文件占用问题。
+- Core 独立 `tsc --noEmit` 在未改动的 `packages/lizi-mcps/src/browser/recipe-loader.ts` 有 `ImportMeta.glob` 类型问题;Desktop 全量类型检查用于覆盖本次集成。不要为本功能放宽类型配置。
+- 单页 UI 矩阵使用 Chromium;原 Electron 单页运行器在当前 Windows DPI 环境存在视口/截图问题。随后已通过完整 Electron 应用补充 Windows 明暗实机目检,macOS 仍未实机验证。
+- Windows 同机双进程已完成真实跨账号分享、目录刷新、账号与供应端组限制、两条真实订阅请求;尚未在不同物理电脑和 macOS 上实测。远程组员绑定、多跳、离线、旧版、确认失败和跨区域消息处理使用测试夹具覆盖,本轮不声称已在生产跨区域服务验证。
+- Claude 原生订阅仍走原生 CLI 授权和最高优先级设置,没有把它伪装成代理已抓包验证;当前一轮中原生更新尚未确认时,必须保持待确认语义。
+
+## 8. 发布与使用
+
+本次交付为源码、测试和文档。用户另行授权 rebase、提交 PR 和自动跟进;提交前追加验证见[审查记录](subscription-fast-policy-review.md)。没有部署、更新或重启正在提供服务的 Cindy。真实账号测试只在两个隔离开发沙箱内进行;没有修改正式版偏好或订阅凭证。
+
+建议按组内电脑逐台更新,再更新组所在电脑。关闭 Fast 后检查待确认提示:所有参与执行的电脑确认后再视为全组已经应用。接收方目录刷新只是额外展示保护,不需要接收方手工更新组才能执行限制。
+
+若需要恢复,先在 UI 中重新允许 Fast,等待限制解除确认。不要直接删除组策略记录来代替解除:离线成员需要收到更高修订才能清理旧约束。应用降级会失去新版执行能力,不应把降级当成受控状态。
diff --git a/packages/device-link/src/__tests__/remoteAgent.test.ts b/packages/device-link/src/__tests__/remoteAgent.test.ts
index 8fe7065b6a..57b9596764 100644
--- a/packages/device-link/src/__tests__/remoteAgent.test.ts
+++ b/packages/device-link/src/__tests__/remoteAgent.test.ts
@@ -21,6 +21,24 @@ import {
const runId = '0f9c4a2e-6d1b-4c3a-9e8f-1a2b3c4d5e6f';
const otherId = '1a2b3c4d-5e6f-4a1b-8c2d-3e4f5a6b7c8d';
+describe('subscription Fast policy wire compatibility', () => {
+ it('advertises support only with an explicit capability', () => {
+ const caps = { version: 1, maxRuns: 10, uploadChunkBytes: 1024, maxPayloadBytes: 8192 };
+ expect(parseRemoteAgentCaps(caps).subscriptionFastPolicy).toBeUndefined();
+ expect(parseRemoteAgentCaps({ ...caps, subscriptionFastPolicy: true }).subscriptionFastPolicy).toBe(true);
+ expect(parseRemoteAgentCaps({ ...caps, subscriptionFastPolicy: 'true' }).subscriptionFastPolicy).toBeUndefined();
+ });
+ it('parses a narrow registration without trusting arbitrary execution options', () => {
+ const command = { op: 'fast-policy', group: 'openai-account', revision: 2, allowFast: false,
+ binding: { sessionId: runId, controllerDeviceId: 'computer', relay: 'abcdefghijklmnop' } };
+ expect(parseRemoteAgentRequest({ ...command, providerId: 'some-other-account' })).toEqual(command);
+ for (const patch of [{ allowFast: 'false' }, { revision: -1 }, { group: '../owner' },
+ { binding: { sessionId: '../task' } }, { binding: { sessionId: runId, controllerDeviceId: '{}' } }]) {
+ expect(() => parseRemoteAgentRequest({ ...command, ...patch })).toThrow();
+ }
+ });
+});
+
describe('remote agent channel', () => {
// Shared-model fork wire: old peers must not gain write support by default; task IDs
// include group-relay IDs, while filesystem roots are never accepted from callers.
diff --git a/packages/device-link/src/remoteAgent.ts b/packages/device-link/src/remoteAgent.ts
index cd8aeca899..41f2de2287 100644
--- a/packages/device-link/src/remoteAgent.ts
+++ b/packages/device-link/src/remoteAgent.ts
@@ -149,6 +149,8 @@ export const REMOTE_AGENT_MAX_PUSH_CHARS = 3 * 1024 * 1024;
export type RemoteAgentRequest =
| { op: 'caps' }
+ /** Authenticated group owner updates only its own task speed constraints, never model grants. */
+ | ({ op: 'fast-policy' } & RemoteAgentFastPolicy)
| ({ op: 'fork' } & RemoteAgentForkRequest)
/** Native image recovery is scoped to the caller's task; never accepts file paths. */
| { op: 'images'; sessionId: string; relay?: string; action: 'list'; offset: number }
@@ -183,6 +185,14 @@ export type RemoteAgentRequest =
*/
| { op: 'reshare'; entries: RemoteAgentReshareEntry[]; batch?: RemoteAgentReshareBatch };
+export interface RemoteAgentFastPolicy {
+ group: string;
+ revision: number;
+ allowFast: boolean;
+ /** Registration precedes opening the task; omitted for a group policy update. */
+ binding?: { sessionId: string; controllerDeviceId?: string; relay?: string };
+}
+
/** 供应商组为受邀者取的不透明键(组所在电脑按受邀者派生,不含身份信息);「需要换一台」凭证同一格式。 */
export const REMOTE_AGENT_RELAY_KEY_PATTERN = /^[A-Za-z0-9_-]{16,64}$/;
@@ -254,6 +264,7 @@ export interface RemoteAgentForkResult {
}
export interface RemoteAgentCaps {
+ subscriptionFastPolicy?: true;
nativeFork?: boolean;
imageRecovery?: boolean;
imageRecoveryRelay?: boolean;
@@ -425,6 +436,23 @@ export function parseRemoteAgentRequest(value: unknown): RemoteAgentRequest {
switch (v.op) {
case 'caps':
return { op: 'caps' };
+ case 'fast-policy': {
+ if (typeof v.group !== 'string' || !/^[A-Za-z0-9_.:-]{1,256}$/.test(v.group)
+ || typeof v.allowFast !== 'boolean') invalid();
+ let binding: RemoteAgentFastPolicy['binding'];
+ if (v.binding !== undefined) {
+ const b = record(v.binding);
+ if (typeof b.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(b.sessionId)) invalid();
+ if (b.controllerDeviceId !== undefined && (typeof b.controllerDeviceId !== 'string'
+ || !/^[A-Za-z0-9_.-]{1,128}$/.test(b.controllerDeviceId))) invalid();
+ if (b.relay !== undefined && (typeof b.relay !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(b.relay))) invalid();
+ binding = { sessionId: b.sessionId as string,
+ ...(typeof b.controllerDeviceId === 'string' ? { controllerDeviceId: b.controllerDeviceId } : {}),
+ ...(typeof b.relay === 'string' ? { relay: b.relay } : {}) };
+ }
+ return { op: 'fast-policy', group: v.group as string, allowFast: v.allowFast as boolean,
+ revision: count(v.revision, Number.MAX_SAFE_INTEGER), ...(binding ? { binding } : {}) };
+ }
case 'fork': {
const text = (value: unknown, max = 4096): string => {
if (typeof value !== 'string' || !value.length || value.length > max || value.includes('\0')) invalid();
@@ -638,6 +666,7 @@ export function parseRemoteAgentCaps(value: unknown): RemoteAgentCaps {
...(Number.isSafeInteger(v.idleReclaimMinutes) && (v.idleReclaimMinutes as number) >= 0
&& (v.idleReclaimMinutes as number) <= REMOTE_AGENT_IDLE_RECLAIM_MAX_MINUTES
? { idleReclaimMinutes: v.idleReclaimMinutes as number } : {}),
+ ...(v.subscriptionFastPolicy === true ? { subscriptionFastPolicy: true as const } : {}),
};
if (caps.version < 1 || caps.maxRuns < 1 || caps.uploadChunkBytes < 1) invalid();
return caps;
diff --git a/packages/maker-core/src/agents/base-agent.ts b/packages/maker-core/src/agents/base-agent.ts
index 30f6277eb9..152c5435b5 100644
--- a/packages/maker-core/src/agents/base-agent.ts
+++ b/packages/maker-core/src/agents/base-agent.ts
@@ -1934,6 +1934,8 @@ export interface StartSessionOptions {
* Undefined means do not override the agent/server default.
*/
fastMode?: boolean | 'ultrafast';
+ /** Trusted host restriction for this subscription run, including live policy changes. */
+ fastModePolicy?: import('./shared/fast-mode-policy.js').FastModePolicy;
/**
* Host-owned live pricing variant for request-level usage segments.
* Pi reads this at each provider request boundary so a mid-turn Fast toggle
diff --git a/packages/maker-core/src/agents/claude-code/__tests__/flag-settings.test.ts b/packages/maker-core/src/agents/claude-code/__tests__/flag-settings.test.ts
index 1f9703fbfb..815f74afef 100644
--- a/packages/maker-core/src/agents/claude-code/__tests__/flag-settings.test.ts
+++ b/packages/maker-core/src/agents/claude-code/__tests__/flag-settings.test.ts
@@ -2,6 +2,11 @@ import { describe, expect, it } from 'vitest';
import { buildClaudeFlagSettings } from '../flag-settings.js';
+it('a subscription prohibition writes explicit false over native Fast defaults', () => {
+ expect(buildClaudeFlagSettings({ showThinkingSummaries: false, fastMode: true, fastModeAllowed: false }).fastMode).toBe(false);
+ expect(buildClaudeFlagSettings({ showThinkingSummaries: false, fastMode: false, fastModeAllowed: false })).toHaveProperty('fastMode', false);
+});
+
describe('buildClaudeFlagSettings', () => {
it('恒置空 apiKeyHelper — 屏蔽用户级 helper 对 oauth-spawn 订阅鉴权的劫持(回归锚点)', () => {
// 用户 ~/.claude/settings.json 配了 apiKeyHelper 时,cc 鉴权优先级里它高于 claude.ai
diff --git a/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts b/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts
index 9a311c3018..78e39b950f 100644
--- a/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts
+++ b/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts
@@ -19,7 +19,7 @@ import path from 'node:path';
import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { AgentDeps } from '../../base-agent.js';
+import type { AgentDeps, StartSessionOptions } from '../../base-agent.js';
import { Session } from '../../../session.js';
import type { AuthAdapter } from '../../../interfaces/auth-adapter.js';
import type { AgentEvent } from '../../../types/events.js';
@@ -206,6 +206,8 @@ async function startRewindableSession(
autoCompactThresholdPct?: number;
idleTimeoutMs?: number;
remoteHostId?: string;
+ fastMode?: boolean;
+ fastModePolicy?: StartSessionOptions['fastModePolicy'];
model?: string;
effort?: Effort;
availableModels?: ModelDescriptor[];
@@ -252,6 +254,8 @@ async function startRewindableSession(
...(options.effort ? { effort: options.effort } : {}),
workingDir,
permissionMode: 'acceptEdits',
+ ...(options.fastMode !== undefined ? { fastMode: options.fastMode } : {}),
+ ...(options.fastModePolicy ? { fastModePolicy: options.fastModePolicy } : {}),
...(options.remoteHostId ? { remoteHostId: options.remoteHostId } : {}),
});
@@ -277,6 +281,28 @@ afterEach(async () => {
});
describe('ClaudeCodeAgent runtime settings during rewind window', () => {
+ it('keeps the explicit standard override when a suppressed task restarts after relaxation', async () => {
+ const policy = { isAllowed: () => true, isRequestAllowed: () => false, subscribe: () => () => {} };
+ const { handle } = await startRewindableSession({ fastMode: false, fastModePolicy: policy });
+ try {
+ expect(sdkMock.query.mock.calls[0][0].options.settings).toHaveProperty('fastMode', false);
+ expect(handle.getFastMode?.()).toBe(false);
+ } finally { await handle.close(); }
+ });
+
+ it('starts with explicit standard settings, clamps stale Fast enables and never re-enables on relaxation', async () => {
+ let allowed = false;
+ const policy = { isAllowed: () => allowed, subscribe: () => () => {} };
+ const { handle, firstQuery } = await startRewindableSession({ fastMode: true, fastModePolicy: policy });
+ try {
+ expect(sdkMock.query.mock.calls[0][0].options.settings).toHaveProperty('fastMode', false);
+ await handle.setFastMode?.(true);
+ expect(firstQuery.applyFlagSettings).toHaveBeenCalledWith({ fastMode: false });
+ expect(handle.getFastMode?.()).toBe(false);
+ allowed = true;
+ expect(handle.getFastMode?.()).toBe(false);
+ } finally { await handle.close(); }
+ });
it('does not relabel an in-flight result with a newly saved budget', async () => {
let budget = 1_000;
const { handle, firstQuery } = await startRewindableSession({ resolveModelContextLimit: () => budget });
diff --git a/packages/maker-core/src/agents/claude-code/flag-settings.ts b/packages/maker-core/src/agents/claude-code/flag-settings.ts
index 346eb8ad51..590fb0dba7 100644
--- a/packages/maker-core/src/agents/claude-code/flag-settings.ts
+++ b/packages/maker-core/src/agents/claude-code/flag-settings.ts
@@ -59,6 +59,8 @@ export interface ClaudeFlagSettingsInput {
* 缺省时整字段不出现 → 与未升级行为逐字节一致,零缓存影响。
*/
fastMode: boolean;
+ /** A trusted subscription prohibition must override native/user defaults explicitly. */
+ fastModeAllowed?: boolean;
/** Host-owned policy for colliding downstream skills. */
capabilityRouting?: CapabilityRoutingPolicy;
/** Bot Profile's native per-session Skill policy. */
@@ -104,7 +106,7 @@ export function buildClaudeFlagSettings(input: ClaudeFlagSettingsInput): Setting
autoMemoryEnabled: input.memoryOverride,
autoDreamEnabled: input.memoryOverride,
}),
- ...(input.fastMode && { fastMode: true }),
+ ...(input.fastModeAllowed === false ? { fastMode: false } : input.fastMode ? { fastMode: true } : {}),
...(input.availableModels && input.availableModels.length > 0 && {
availableModels: [...new Set(input.availableModels)],
}),
diff --git a/packages/maker-core/src/agents/claude-code/index.ts b/packages/maker-core/src/agents/claude-code/index.ts
index 939fcb23c6..2eeccc82ad 100644
--- a/packages/maker-core/src/agents/claude-code/index.ts
+++ b/packages/maker-core/src/agents/claude-code/index.ts
@@ -2875,7 +2875,8 @@ export class ClaudeCodeAgent extends BaseAgent {
// Fast 模式:进 flag settings 层(= --settings),解锁 cc 二进制在 Agent SDK 通道下的
// fast(否则二进制按 "Agent SDK 不可用" 拒绝)。是否 Opus/官方/firstParty 由二进制把关,
// agent 层不重复硬判(规则 9:确定性逻辑就近,但 fast 的最终门槛是二进制 + 配置门控)。
- fastMode: mutableFastMode,
+ fastMode: opts.fastModePolicy?.isAllowed() === false ? false : mutableFastMode,
+ fastModeAllowed: opts.fastModePolicy?.isRequestAllowed?.() ?? opts.fastModePolicy?.isAllowed(),
botSkillPolicy: reviewMode ? undefined : opts.botRuntimeProfile?.skillPolicy,
capabilityRouting: reviewMode ? undefined : this.deps.capabilityRouting,
});
@@ -3158,7 +3159,7 @@ export class ClaudeCodeAgent extends BaseAgent {
&& (planTurnActive || sdkInPlanMode) && !isReadOnlyClaudeTool(toolName);
// Fast 模式运行时态:启动取 opts.fastMode 快照,setFastMode 覆盖。buildSettings 每次读最新值;
// host 只在「该 model 支持 + 走官方供应商」时才传 true(renderer 配置门控),agent 忠实消费。
- let mutableFastMode = opts.fastMode === true;
+ let mutableFastMode = opts.fastMode === true && opts.fastModePolicy?.isAllowed() !== false;
// 附加只读引用目录: 启动时取 opts.extraDirs 快照, setExtraDirs 覆盖。
// SDK additionalDirectories 在 Query 创建时冻结;代际不一致时下一次 send
// 走 rewind 同款 resume+fork 重建,下一 turn 生效,不用 fresh:true。
@@ -4527,7 +4528,7 @@ export class ClaudeCodeAgent extends BaseAgent {
taintWorkspaceSettings(message);
throw new Error(message);
}
- return applyFlagSettings(settings);
+ return applyFlagSettings(opts.fastModePolicy?.isAllowed() === false ? { ...settings, fastMode: false } : settings);
};
}
if (newSdkSessionId && localQueryStarted && !unacceptedForks.has(query)) {
@@ -7569,7 +7570,8 @@ export class ClaudeCodeAgent extends BaseAgent {
},
async setFastMode(enabled: boolean | 'ultrafast') {
- if (reviewMode) return;
+ if (reviewMode && opts.fastModePolicy?.isAllowed() !== false) return;
+ if (opts.fastModePolicy?.isAllowed() === false) enabled = false;
if (enabled === 'ultrafast') throw new Error('Ultrafast requires the Codex runtime');
// 与 setEffort 同款:走 SDK applyFlagSettings 改 flag settings 层 `fastMode`。
// cc 二进制的 sticky-on latch 负责缓存安全(header 一旦发出整 session 保持,中途 toggle
@@ -7577,6 +7579,9 @@ export class ClaudeCodeAgent extends BaseAgent {
// 由二进制把关(不支持时优雅 no-op),agent 不重复硬判(规则 9 留给配置 + 二进制)。
const isControlBlocked = controlRequestsBlocked();
log.debug('setFastMode', { from: mutableFastMode, to: enabled, controlRequestsBlocked: isControlBlocked });
+ if (isControlBlocked && opts.fastModePolicy?.isAllowed() === false && mutableFastMode) {
+ throw new Error('Subscription Fast policy is waiting for the native runtime to accept settings');
+ }
if (!isControlBlocked) {
await q.applyFlagSettings({ fastMode: enabled });
}
diff --git a/packages/maker-core/src/agents/codex/index.test.ts b/packages/maker-core/src/agents/codex/index.test.ts
index f9f4fb8efa..cb7bc0db4d 100644
--- a/packages/maker-core/src/agents/codex/index.test.ts
+++ b/packages/maker-core/src/agents/codex/index.test.ts
@@ -7366,6 +7366,33 @@ describe('CodexAgent fast mode service tier', () => {
});
describe('CodexAgent thread/settings/update channel', () => {
+ it('forces standard native requests despite stale tier defaults, notifications and re-enables under a host prohibition', async () => {
+ const agent = new CodexAgent(createDeps());
+ const host = installFakeHost(agent, method => method === Method.ThreadSettingsUpdate ? {} : method === Method.ThreadStart ? {
+ thread: { id: 'start-thread-id' }, model: 'gpt-5.4', modelProvider: 'openai', cwd: '/repo', serviceTier: 'ultrafast',
+ } : undefined);
+ const handle = await agent.startSession({ sessionId: 's-policy', model: 'gpt-5.4', workingDir: '/repo', fastMode: true,
+ fastModePolicy: { isAllowed: () => false, subscribe: () => () => {} } });
+ expect((host.request.mock.calls.find(([method]) => method === Method.ThreadStart)?.[1] as { serviceTier?: unknown }).serviceTier).toBeNull();
+ expect(handle.getFastMode?.()).toBe(false);
+ host.getThreadHandlers()?.threadSettingsUpdated?.({ threadId: 'start-thread-id', threadSettings: { serviceTier: 'fast' } });
+ await handle.setFastMode?.('ultrafast');
+ expect(handle.getFastMode?.()).toBe(false);
+ await handle.send({ type: 'user', content: 'hello' });
+ const turns = host.request.mock.calls.filter(([method]) => method === Method.TurnStart);
+ expect(turns.length).toBeGreaterThan(0);
+ expect(turns.every(([, params]) => (params as { serviceTier?: unknown }).serviceTier === null)).toBe(true);
+ await handle.close();
+ });
+
+ it('reports a failed native policy update so the host cannot acknowledge enforcement prematurely', async () => {
+ const agent = new CodexAgent(createDeps());
+ installFakeHost(agent, method => { if (method === Method.ThreadSettingsUpdate) throw Error('native unavailable'); return undefined; });
+ const handle = await agent.startSession({ sessionId: 's-policy-failure', model: 'gpt-5.4', workingDir: '/repo',
+ fastModePolicy: { isAllowed: () => false, subscribe: () => () => {} } });
+ await expect(handle.setFastMode?.(false)).rejects.toThrow('native unavailable');
+ await handle.close();
+ });
const settingsCalls = (host: { request: { mock: { calls: Array<[string, unknown]> } } }) =>
host.request.mock.calls.filter(([m]) => m === Method.ThreadSettingsUpdate).map(([, p]) => p);
diff --git a/packages/maker-core/src/agents/codex/index.ts b/packages/maker-core/src/agents/codex/index.ts
index 32f6f24958..85dd6ba703 100644
--- a/packages/maker-core/src/agents/codex/index.ts
+++ b/packages/maker-core/src/agents/codex/index.ts
@@ -5037,8 +5037,17 @@ assertRouteCurrent();
// plan_review requestId 去重序号 (同一 turn 理论上只有一个 plan item, 防御性加序号)。
let planReviewSeq = 0;
// Undefined preserves app-server defaults; null selects standard; strings select a speed tier.
- let mutableServiceTier: ServiceTier | null | undefined =
+ let requestedServiceTier: ServiceTier | null | undefined =
opts.fastMode === undefined ? undefined : opts.fastMode === 'ultrafast' ? 'ultrafast' : opts.fastMode ? 'fast' : null;
+ // Read at every native request boundary, including resume, retries and autonomous continuations.
+ const serviceTierState = {
+ get value(): ServiceTier | null | undefined {
+ return opts.fastModePolicy?.isAllowed() === false ? null : requestedServiceTier;
+ },
+ set value(tier: ServiceTier | null | undefined) {
+ requestedServiceTier = opts.fastModePolicy?.isAllowed() === false ? null : tier;
+ },
+ };
// Older async thread start/resume responses must not overwrite a newer
// Fast mode choice made while the request was in flight.
let serviceTierMutationGeneration = 0;
@@ -6020,6 +6029,10 @@ assertRouteCurrent();
if (descendantThreadId === threadId || descendantMcpThreadIds.has(descendantThreadId)) return;
descendantMcpThreadIds.add(descendantThreadId);
registerCodexMcpContext(descendantThreadId, 'descendant');
+ if (opts.fastModePolicy?.isAllowed() === false) {
+ void host.request(Method.ThreadSettingsUpdate, { threadId: descendantThreadId, serviceTier: null })
+ .catch(error => log.warn('descendant standard-mode update failed', { error: String(error) }));
+ }
};
const unregisterDescendantCodexMcpContexts = (): void => {
for (const descendantThreadId of descendantMcpThreadIds) {
@@ -7162,7 +7175,7 @@ assertRouteCurrent();
...(sessionDynamicTools.length > 0 ? { dynamicTools: sessionDynamicTools } : {}),
...(threadModelProvider ? { modelProvider: threadModelProvider } : {}),
...(mutableModel && mutableModel !== 'gpt-5' ? { model: mutableModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
...(developerInstructions && !useProxyChannel ? { developerInstructions } : {}),
};
acquireHostBindingLeaseIfNeeded();
@@ -7179,7 +7192,7 @@ assertRouteCurrent();
});
assertCurrentHost('thread/start');
if (Object.hasOwn(resp, 'serviceTier')) {
- mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;
+ serviceTierState.value = normalizeServiceTier(resp.serviceTier) ?? null;
}
if (mutableModel === 'gpt-5' && resp.model) {
mutableModel = resp.model;
@@ -7205,7 +7218,7 @@ assertRouteCurrent();
threadId,
model: resp.model,
modelProvider: codexThreadModelProviderId ?? null,
- serviceTier: mutableServiceTier ?? null,
+ serviceTier: serviceTierState.value ?? null,
});
};
@@ -7228,25 +7241,25 @@ assertRouteCurrent();
* 返回入队任务的 promise (链已 catch, 永不 reject), 调用方可 await 到本次发送完成。
*/
let settingsUpdateChain: Promise<void> = Promise.resolve();
- const pushThreadSettings = (patch: Omit<ThreadSettingsUpdateParams, 'threadId'>): Promise<void> => {
+ const pushThreadSettings = (patch: Omit<ThreadSettingsUpdateParams, 'threadId'>, requireApplied = false): Promise<void> => {
if (!threadId || closed) return Promise.resolve();
const run = settingsUpdateChain.then(async () => {
if (!threadId || closed) return; // 排到队头时再校验一次 (期间可能已 close)
if (skipIfStaleHost('thread/settings/update')) return;
try {
- await host.request<ThreadSettingsUpdateResponse>(Method.ThreadSettingsUpdate, {
- threadId,
- ...patch,
- });
+ const effectivePatch = opts.fastModePolicy?.isAllowed() === false ? { ...patch, serviceTier: null } : patch;
+ await Promise.all([threadId, ...(requireApplied ? descendantMcpThreadIds : [])].map(id =>
+ host.request<ThreadSettingsUpdateResponse>(Method.ThreadSettingsUpdate, { threadId: id, ...effectivePatch })));
} catch (e) {
log.warn('thread/settings/update failed (turn/start carry remains fallback)', {
threadId,
patchKeys: Object.keys(patch),
error: e instanceof Error ? e.message : String(e),
});
+ if (requireApplied) throw e;
}
});
- settingsUpdateChain = run;
+ settingsUpdateChain = run.catch(() => undefined);
return run;
};
if (hosted && hostedEnvironmentId) {
@@ -7295,7 +7308,7 @@ assertRouteCurrent();
...currentThreadWorkspaceConfig(),
...(threadModelProvider ? { modelProvider: threadModelProvider } : {}),
...(mutableModel && mutableModel !== 'gpt-5' ? { model: mutableModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
...(shouldSendNativeDeveloperInstructions
? { developerInstructions }
: {}),
@@ -7337,7 +7350,7 @@ assertRouteCurrent();
}
assertCurrentHost('thread/resume');
if (Object.hasOwn(resp, 'serviceTier')) {
- mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;
+ serviceTierState.value = normalizeServiceTier(resp.serviceTier) ?? null;
}
if (mutableModel === 'gpt-5' && resp.model) {
mutableModel = resp.model;
@@ -7404,7 +7417,7 @@ assertRouteCurrent();
threadId,
model: resp.model,
modelProvider: codexThreadModelProviderId ?? null,
- serviceTier: mutableServiceTier ?? null,
+ serviceTier: serviceTierState.value ?? null,
});
} catch (e) {
if (!startup.threadDispatched && (e instanceof CodexRouteSelectionChangedError || startup.signal.aborted)) throw e;
@@ -7613,7 +7626,7 @@ assertRouteCurrent();
...(!retainHistory && sessionDynamicTools.length > 0 ? { dynamicTools: sessionDynamicTools } : {}),
...(threadModelProvider ? { modelProvider: threadModelProvider } : {}),
...(mutableModel && mutableModel !== 'gpt-5' ? { model: mutableModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
...(developerInstructions && !useProxyChannel ? { developerInstructions } : {}),
}, options)),
onLateResolve: async (lateResp) => {
@@ -7644,7 +7657,7 @@ assertRouteCurrent();
Object.hasOwn(resp, 'serviceTier') &&
replacementServiceTierGeneration === serviceTierMutationGeneration
) {
- mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;
+ serviceTierState.value = normalizeServiceTier(resp.serviceTier) ?? null;
}
if (retainHistory && resp.modelProvider !== localSummaryProvider) {
await unsubscribeDetachedThread(nextThreadId, 'summary fallback identity mismatch', false);
@@ -7684,7 +7697,7 @@ assertRouteCurrent();
// setFastMode() updated the old thread while thread/start was
// pending. turn/start still carries the current value; reapply the
// sticky thread setting without blocking dispatch.
- void pushThreadSettings({ serviceTier: mutableServiceTier ?? null });
+ void pushThreadSettings({ serviceTier: serviceTierState.value ?? null });
}
}
if (hostUsesCodexProxy) {
@@ -7754,7 +7767,7 @@ assertRouteCurrent();
...resumeThreadWorkspaceConfig,
...(threadModelProvider ? { modelProvider: threadModelProvider } : {}),
...(mutableModel && mutableModel !== 'gpt-5' ? { model: mutableModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
}, options),
});
} catch (e) {
@@ -7769,9 +7782,9 @@ assertRouteCurrent();
Object.hasOwn(resp, 'serviceTier') &&
resumeServiceTierGeneration === serviceTierMutationGeneration
) {
- mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;
+ serviceTierState.value = normalizeServiceTier(resp.serviceTier) ?? null;
} else if (resumeServiceTierGeneration !== serviceTierMutationGeneration) {
- void pushThreadSettings({ serviceTier: mutableServiceTier ?? null });
+ void pushThreadSettings({ serviceTier: serviceTierState.value ?? null });
}
codexThreadModelProviderId = resp.modelProvider?.trim() || undefined;
workspacePermissionProfileActive = 'permissions' in resumeThreadWorkspaceConfig;
@@ -7811,7 +7824,7 @@ assertRouteCurrent();
...workspaceConfig,
...(threadModelProvider ? { modelProvider: threadModelProvider } : {}),
...(mutableModel && mutableModel !== 'gpt-5' ? { model: mutableModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
...(developerInstructions && !useProxyChannel ? { developerInstructions } : {}),
}, options),
onLateResolve: async () => {
@@ -11218,8 +11231,8 @@ assertRouteCurrent();
startedAt: turn.startedAt ?? null,
completedAt: turn.completedAt ?? null,
durationMs: turn.durationMs ?? null,
- serviceTier: mutableServiceTier ?? null,
- fastMode: fastModeFromServiceTier(mutableServiceTier),
+ serviceTier: serviceTierState.value ?? null,
+ fastMode: fastModeFromServiceTier(serviceTierState.value),
// 本 turn 增量 (来自最近一次 thread/tokenUsage/updated 的 last)
inputTokens: lastTurnTokenUsage?.inputTokens ?? null,
cachedInputTokens: lastTurnTokenUsage?.cachedInputTokens ?? null,
@@ -12394,8 +12407,8 @@ assertRouteCurrent();
model: mutableModel,
effort: mutableEffort,
permissionMode: mutablePermissionMode,
- serviceTier: mutableServiceTier ?? null,
- fastMode: fastModeFromServiceTier(mutableServiceTier),
+ serviceTier: serviceTierState.value ?? null,
+ fastMode: fastModeFromServiceTier(serviceTierState.value),
});
},
tokenUsageUpdated: (params) => {
@@ -12455,9 +12468,9 @@ assertRouteCurrent();
inputTokens: totalInput,
outputTokens: last.outputTokens ?? 0,
cacheReadTokens: cached,
- }) ?? ((turnServiceTier !== undefined ? turnServiceTier : mutableServiceTier) === 'ultrafast'
+ }) ?? ((turnServiceTier !== undefined ? turnServiceTier : serviceTierState.value) === 'ultrafast'
? 'ultrafast'
- : fastModeFromServiceTier(turnServiceTier !== undefined ? turnServiceTier : mutableServiceTier)
+ : fastModeFromServiceTier(turnServiceTier !== undefined ? turnServiceTier : serviceTierState.value)
? 'priority'
: 'standard'),
});
@@ -12830,9 +12843,9 @@ assertRouteCurrent();
// 时 server 会把它降级, 这里第一时间感知, getFastMode() 立刻反映正确值, 不必等
// 某个 turn 的响应推断。通知恒带完整 ThreadSettings, 故 serviceTier 总是 present。
const s = params.threadSettings;
- const before = mutableServiceTier ?? null;
+ const before = serviceTierState.value ?? null;
const beforeModel = mutableModel;
- mutableServiceTier = normalizeServiceTier(s.serviceTier) ?? null;
+ serviceTierState.value = normalizeServiceTier(s.serviceTier) ?? null;
// 只对齐 wire 值: server 会把请求 id 规范化(`gpt-5.4` → `gpt-5.4-codex`),那个变体
// 目录里没有。**刻意不动 mutableCatalogModel** —— 否则窗口上限会因为查不到目录条目
// 而停止收敛(见该变量注释)。
@@ -12843,12 +12856,12 @@ assertRouteCurrent();
// ReasoningEffort 的 'none' 不属于 Effort; 排除后其余值都是合法 Effort, 无需 cast。
// A server default must not replace an explicit no-effort session choice.
if (mutableEffort && s.effort && s.effort !== 'none') mutableEffort = s.effort;
- if (before !== (mutableServiceTier ?? null)) {
+ if (before !== (serviceTierState.value ?? null)) {
log.debug('thread/settings/updated reconciled serviceTier', {
threadId: params.threadId,
from: before,
- to: mutableServiceTier ?? null,
- fastMode: fastModeFromServiceTier(mutableServiceTier),
+ to: serviceTierState.value ?? null,
+ fastMode: fastModeFromServiceTier(serviceTierState.value),
});
}
},
@@ -13320,7 +13333,7 @@ assertRouteCurrent();
model: mutableModel,
effort: mutableEffort,
permissionMode: mutablePermissionMode,
- serviceTier: mutableServiceTier ?? null,
+ serviceTier: serviceTierState.value ?? null,
threadId,
logTitle: sendOpts?.logTitle,
});
@@ -13459,7 +13472,7 @@ assertRouteCurrent();
// (v2.rs:5801-5803 turn/start 的 summary 会 override server config)
summary: 'auto',
...(mutableModel && mutableModel !== 'gpt-5' ? { model: mutableModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
...(collaborationMode ? { collaborationMode } : {}),
};
// 这一 turn 的用量按这里发出去的 (provider, model) 归属上下文窗口 —— 之后 setModel
@@ -13596,11 +13609,11 @@ assertRouteCurrent();
if (startEntry) startEntry.serviceTier = acceptedServiceTier;
const origin = turnOriginByTurnId.get(resp.turn.id);
if (origin) origin.serviceTier = acceptedServiceTier;
- mutableServiceTier = acceptedServiceTier;
+ serviceTierState.value = acceptedServiceTier;
log.debug('turn/start response serviceTier', {
turnId: resp.turn.id,
- serviceTier: mutableServiceTier,
- fastMode: fastModeFromServiceTier(mutableServiceTier),
+ serviceTier: serviceTierState.value,
+ fastMode: fastModeFromServiceTier(serviceTierState.value),
note: 'serviceTier calibrated before buffered turn replay',
});
}
@@ -13866,7 +13879,7 @@ assertRouteCurrent();
...turnThreadWorkspaceConfig,
...(threadModelProvider ? { modelProvider: threadModelProvider } : {}),
...(resumeModel && resumeModel !== 'gpt-5' ? { model: resumeModel } : {}),
- ...(mutableServiceTier !== undefined ? { serviceTier: mutableServiceTier } : {}),
+ ...(serviceTierState.value !== undefined ? { serviceTier: serviceTierState.value } : {}),
...(developerInstructions && !useProxyChannel ? { developerInstructions } : {}),
};
const resumeResp = await host.request<ThreadResumeResponse>(Method.ThreadResume, resumeParams, {
@@ -13883,9 +13896,9 @@ assertRouteCurrent();
Object.hasOwn(resumeResp, 'serviceTier') &&
resumeServiceTierGeneration === serviceTierMutationGeneration
) {
- mutableServiceTier = normalizeServiceTier(resumeResp.serviceTier) ?? null;
+ serviceTierState.value = normalizeServiceTier(resumeResp.serviceTier) ?? null;
} else if (resumeServiceTierGeneration !== serviceTierMutationGeneration) {
- void pushThreadSettings({ serviceTier: mutableServiceTier ?? null });
+ void pushThreadSettings({ serviceTier: serviceTierState.value ?? null });
}
turnParams.effort = clampEffortForCodex(mutableModel, mutableEffort);
if (mutableModel && mutableModel !== 'gpt-5') {
@@ -13898,8 +13911,8 @@ assertRouteCurrent();
activeTurnModel = mutableCatalogModel;
activeTurnContextLimit = effectiveThreadContextWindow(appliedContextLimit);
activeTurnProviderId = mutableProviderId;
- if (mutableServiceTier !== undefined) {
- turnParams.serviceTier = mutableServiceTier ?? null;
+ if (serviceTierState.value !== undefined) {
+ turnParams.serviceTier = serviceTierState.value ?? null;
} else {
delete turnParams.serviceTier;
}
@@ -14640,18 +14653,19 @@ assertRouteCurrent();
},
async setFastMode(enabled: boolean | 'ultrafast') {
- if (reviewMode) return;
+ if (reviewMode && opts.fastModePolicy?.isAllowed() !== false) return;
+ if (opts.fastModePolicy?.isAllowed() === false) enabled = false;
// Compare exact tiers; undefined/null/default all mean standard.
- if (fastModeFromServiceTier(mutableServiceTier) === enabled) return;
+ if (opts.fastModePolicy?.isAllowed() !== false && fastModeFromServiceTier(serviceTierState.value) === enabled) return;
const next: ServiceTier | null = enabled === 'ultrafast' ? 'ultrafast' : enabled ? 'fast' : null;
- log.debug('setFastMode', { from: mutableServiceTier ?? null, to: next });
+ log.debug('setFastMode', { from: serviceTierState.value ?? null, to: next });
serviceTierMutationGeneration += 1;
- mutableServiceTier = next;
+ serviceTierState.value = next;
// thread 已启动 → 立即经 thread/settings/update 生效 (serviceTier 双 Option:
// 'fast'=开 / null=清空 standard); 未启动则由首个 thread/start 携带。server 端
// 若因模型不支持 fast 而降级, 会经 thread/settings/updated 通知回带, handlers
- // 里把 mutableServiceTier 对齐到权威值。失败时 turn/start 透传仍是兜底。
- await pushThreadSettings({ serviceTier: next });
+ // 里把 serviceTierState.value 对齐到权威值。失败时 turn/start 透传仍是兜底。
+ await pushThreadSettings({ serviceTier: next }, opts.fastModePolicy?.isAllowed() === false);
},
async setVendorOptions(patch: Record<string, unknown>) {
@@ -14668,7 +14682,7 @@ assertRouteCurrent();
},
getFastMode() {
- return fastModeFromServiceTier(mutableServiceTier);
+ return fastModeFromServiceTier(serviceTierState.value);
},
async previewRewindFiles() {
diff --git a/packages/maker-core/src/agents/pi/index.ts b/packages/maker-core/src/agents/pi/index.ts
index 85792b2535..2602a96598 100644
--- a/packages/maker-core/src/agents/pi/index.ts
+++ b/packages/maker-core/src/agents/pi/index.ts
@@ -7996,7 +7996,8 @@ export class PiAgent extends BaseAgent {
},
async setFastMode(enabled: boolean | 'ultrafast'): Promise<void> {
- if (reviewMode) return;
+ if (reviewMode && opts.fastModePolicy?.isAllowed() !== false) return;
+ if (opts.fastModePolicy?.isAllowed() === false) enabled = false;
if (enabled === 'ultrafast') throw new Error('Ultrafast requires the Codex runtime');
updateRequestPrefs(enabled);
},
diff --git a/packages/maker-core/src/agents/shared/__tests__/fast-mode-policy.test.ts b/packages/maker-core/src/agents/shared/__tests__/fast-mode-policy.test.ts
new file mode 100644
index 0000000000..7c61a48f96
--- /dev/null
+++ b/packages/maker-core/src/agents/shared/__tests__/fast-mode-policy.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { AgentSessionHandle } from '../../base-agent.js';
+import { withFastModePolicy } from '../fast-mode-policy.js';
+
+// Protects live subscription speed enforcement through the production handle:
+// stale enables must not reach the engine, and failed native updates cannot admit a new message.
+function fixture() {
+ let allowed = true;
+ let listener: (() => Promise<void>) | undefined;
+ let fast: boolean | 'ultrafast' = true;
+ const native = {
+ setFastMode: vi.fn(async (value: boolean | 'ultrafast') => {
+ fast = value;
+ }),
+ getFastMode: () => fast,
+ send: vi.fn(async () => undefined),
+ close: vi.fn(async () => undefined),
+ };
+ const off = vi.fn();
+ const changed = vi.fn();
+ const handle = withFastModePolicy(native as unknown as AgentSessionHandle, {
+ isAllowed: () => allowed,
+ onFastModeChanged: changed,
+ subscribe: (callback) => {
+ listener = callback;
+ return off;
+ },
+ });
+ return {
+ handle,
+ native,
+ off,
+ changed,
+ change: async (value: boolean) => {
+ allowed = value;
+ await listener!();
+ },
+ };
+}
+
+describe('host subscription Fast policy', () => {
+ it('downgrades an active handle without a new message and blocks stale Fast/Ultrafast enables', async () => {
+ const f = fixture();
+ await f.change(false);
+ expect(f.native.getFastMode()).toBe(false);
+ expect(f.changed).toHaveBeenLastCalledWith(false);
+ await f.handle.setFastMode!(true);
+ await f.handle.setFastMode!('ultrafast');
+ expect(f.native.setFastMode.mock.calls).toEqual([[false], [false], [false]]);
+ await f.change(true);
+ expect(f.native.getFastMode()).toBe(false);
+ await f.handle.setFastMode!(true);
+ expect(f.changed).toHaveBeenLastCalledWith(true);
+ await f.handle.close();
+ expect(f.off).toHaveBeenCalledOnce();
+ });
+
+ it('rechecks queued enables after a policy change', async () => {
+ const f = fixture();
+ const enable = f.handle.setFastMode!('ultrafast');
+ const prohibit = f.change(false);
+ await Promise.all([enable, prohibit]);
+ expect(f.native.setFastMode.mock.calls.every(([value]) => value === false)).toBe(true);
+ });
+
+ it('does not send another message when the native standard-mode update fails', async () => {
+ const f = fixture();
+ f.native.setFastMode.mockRejectedValue(new Error('native settings unavailable'));
+ await expect(f.change(false)).rejects.toThrow('native settings unavailable');
+ expect(f.changed).toHaveBeenLastCalledWith(false);
+ await expect(f.handle.send({ type: 'user', content: 'hello' })).rejects.toThrow(
+ 'native settings unavailable',
+ );
+ expect(f.native.send).not.toHaveBeenCalled();
+ });
+
+ it('preserves unrelated providers without a host policy', () => {
+ const native = {} as AgentSessionHandle;
+ expect(withFastModePolicy(native)).toBe(native);
+ });
+
+ it('reports a suppressed turn as standard until an explicit enable succeeds', async () => {
+ let suppressed = true;
+ const native = {
+ getFastMode: () => true,
+ setFastMode: vi.fn(async () => {}),
+ } as unknown as AgentSessionHandle;
+ const handle = withFastModePolicy(native, {
+ isAllowed: () => true,
+ isRequestAllowed: () => !suppressed,
+ onFastModeChanged: (enabled) => {
+ suppressed = !enabled;
+ },
+ subscribe: () => () => {},
+ });
+ expect(handle.getFastMode!()).toBe(false);
+ await handle.setFastMode!(true);
+ expect(handle.getFastMode!()).toBe(true);
+ });
+});
diff --git a/packages/maker-core/src/agents/shared/fast-mode-policy.ts b/packages/maker-core/src/agents/shared/fast-mode-policy.ts
new file mode 100644
index 0000000000..059af0702e
--- /dev/null
+++ b/packages/maker-core/src/agents/shared/fast-mode-policy.ts
@@ -0,0 +1,99 @@
+import type { AgentSessionHandle } from '../base-agent.js';
+
+/** Only the trusted host supplies this policy; functions never cross device-link. */
+export interface FastModePolicy {
+ isAllowed(): boolean;
+ subscribe(listener: () => Promise<void>): () => void;
+ /** Keeps a native turn's stale Fast payload suppressed after a restriction is lifted. */
+ isRequestAllowed?(): boolean;
+ onFastModeChanged?(enabled: boolean | 'ultrafast'): void;
+}
+
+/** Native engines can retain a turn's speed through tool loops. Enforce again at the trusted HTTP/WS exit. */
+export function standardSpeedRequest(body: unknown): unknown | null {
+ if (!body || typeof body !== 'object' || Array.isArray(body)) return null;
+ const record = body as Record<string, unknown>;
+ // Responses WebSocket control events are not inference requests. Unknown
+ // speed fields can invalidate otherwise valid session/cancel/item frames.
+ if (typeof record.type === 'string' && record.type !== 'response.create') return null;
+ const next: Record<string, unknown> = { ...record };
+ if (Array.isArray(record.messages)) {
+ next.speed = 'standard';
+ if ('service_tier' in record) next.service_tier = 'standard_only';
+ } else next.service_tier = 'default';
+ if ('speed' in record) next.speed = 'standard';
+ if ('serviceTier' in record) next.serviceTier = null;
+ if (record.response && typeof record.response === 'object' && !Array.isArray(record.response)) {
+ next.response = standardSpeedRequest(record.response);
+ }
+ return next;
+}
+
+/**
+ * Serialize native updates with user changes. Checking inside the queue prevents a
+ * late Fast enable from overtaking a prohibition. Allowing Fast again never enables it.
+ */
+export function withFastModePolicy(
+ handle: AgentSessionHandle,
+ policy?: FastModePolicy,
+): AgentSessionHandle {
+ if (!policy) return handle;
+ let pending = Promise.resolve();
+ let closed = false;
+ const enqueue = (work: () => Promise<void>): Promise<void> => {
+ pending = pending.catch(() => undefined).then(work);
+ return pending;
+ };
+ const enforce = () =>
+ enqueue(async () => {
+ if (!closed && !policy.isAllowed()) {
+ policy.onFastModeChanged?.(false);
+ if (!handle.setFastMode)
+ throw new Error('Subscription Fast policy is not supported by this agent');
+ await handle.setFastMode(false);
+ }
+ });
+ const off = policy.subscribe(enforce);
+ // Policy may have tightened while the native process was starting.
+ if (!policy.isAllowed()) void enforce().catch(() => undefined);
+ const guarded = new Set(['send', 'steer', 'setModel', 'compactSession']);
+ return new Proxy(handle, {
+ get(target, key) {
+ if (key === 'getFastMode')
+ return () =>
+ (policy.isRequestAllowed?.() ?? policy.isAllowed())
+ ? (target.getFastMode?.() ?? false)
+ : false;
+ if (key === 'setFastMode')
+ return (enabled: boolean | 'ultrafast') =>
+ enqueue(async () => {
+ if (closed) return;
+ if (!target.setFastMode)
+ throw new Error('Subscription Fast policy is not supported by this agent');
+ const effective = policy.isAllowed() ? enabled : false;
+ if (!effective) policy.onFastModeChanged?.(false);
+ await target.setFastMode(effective);
+ policy.onFastModeChanged?.(
+ policy.isAllowed() ? (target.getFastMode?.() ?? effective) : false,
+ );
+ });
+ const value = Reflect.get(target, key, target);
+ if (typeof value !== 'function') return value;
+ if (key === 'close')
+ return async (...args: unknown[]) => {
+ closed = true;
+ off();
+ await pending.catch(() => undefined);
+ return Reflect.apply(value, target, args);
+ };
+ if (guarded.has(String(key)))
+ return async (...args: unknown[]) => {
+ await enforce();
+ const result = await Reflect.apply(value, target, args);
+ if (key === 'setModel') await enforce();
+ return result;
+ };
+ return value.bind(target);
+ },
+ });
+}
diff --git a/packages/maker-core/src/index.ts b/packages/maker-core/src/index.ts
index 69e2b7d7a9..88623e92d2 100644
--- a/packages/maker-core/src/index.ts
+++ b/packages/maker-core/src/index.ts
@@ -6,6 +6,7 @@
*/
export const VERSION = '0.0.0';
+export { standardSpeedRequest, withFastModePolicy } from './agents/shared/fast-mode-policy.js';
// types
export * from './types/index.js';
diff --git a/packages/maker-core/src/maker.agentDevice.test.ts b/packages/maker-core/src/maker.agentDevice.test.ts
index 5e6c24418a..b35f6ad60c 100644
--- a/packages/maker-core/src/maker.agentDevice.test.ts
+++ b/packages/maker-core/src/maker.agentDevice.test.ts
@@ -77,6 +77,31 @@ function localAgent(): BaseAgent & { startSession: ReturnType<typeof vi.fn> } {
}
describe('Maker: agent on another computer', () => {
+ it('starts local and hosted tasks as standard after relaxation when the task has not re-enabled Fast', async () => {
+ const agent = localAgent();
+ const policy = {
+ isAllowed: () => true,
+ isRequestAllowed: () => false,
+ subscribe: () => () => {},
+ };
+ const maker = new Maker({
+ agents: { pi: agent }, storage: storage(), logger,
+ lifecycleHooks: { prepareStartOptions: (_id, opts) => { opts.fastModePolicy = policy; } },
+ });
+ await maker.createSession({ id: 'task-standard', agentKind: 'pi', workingDir: '/repo', model: 'm', fastMode: true });
+ expect(agent.startSession.mock.lastCall?.[0].fastMode).toBe(false);
+ const hosted = await maker.startHostedAgentSession('pi', {
+ workingDir: '/shadow', model: 'm', fastMode: true, fastModePolicy: policy,
+ deviceHosted: {
+ workingDir: '/repo', extraDirs: [], writableDirs: [], platform: 'darwin', shell: 'zsh', isGitRepo: false,
+ tunnelUrl: 'http://127.0.0.1:1', tunnelToken: 't', mcpServers: [],
+ },
+ });
+ expect(agent.startSession.mock.lastCall?.[0].fastMode).toBe(false);
+ await hosted.close();
+ await maker.shutdown();
+ });
+
it('starts the agent through the device starter and records the computer on the task', async () => {
const store = storage();
const agent = localAgent();
diff --git a/packages/maker-core/src/maker.ts b/packages/maker-core/src/maker.ts
index c00cf7d0da..d638cbc0e7 100644
--- a/packages/maker-core/src/maker.ts
+++ b/packages/maker-core/src/maker.ts
@@ -44,6 +44,7 @@ import type { PiRuntimeCapabilityManifest } from './types/pi-runtime-capabilitie
import { piExplicitSkillRuntimePath } from './agents/pi/skill-runtime-provenance.js';
import { fingerprintPiProjectSkillEntrypoint } from './agents/pi/project-resource-assembly.js';
import { Session, generateSessionId, type SessionStartupPreferences } from './session.js';
+import { withFastModePolicy } from './agents/shared/fast-mode-policy.js';
import { NotSupportedError } from './types/capabilities.js';
import {
AgentNotAuthenticatedError,
@@ -795,6 +796,7 @@ export class Maker {
});
}
agentStartAttempted = true;
+ if (startOpts.fastModePolicy && !(startOpts.fastModePolicy.isRequestAllowed?.() ?? startOpts.fastModePolicy.isAllowed())) startOpts.fastMode = false;
if (startOpts.agentDeviceId) {
if (startOpts.remoteHostId) {
throw new Error('A session cannot run its agent on another computer and on an SSH host at the same time');
@@ -836,6 +838,7 @@ export class Maker {
this.invalidateAndClearSdkSessionId(id, expectedSdkSessionId)
: undefined,
});
+ handle = withFastModePolicy(handle, startOpts.fastModePolicy);
} catch (error) {
codexThreadClaim?.release();
// A generic adapter error does not prove its process stopped. Preserve
@@ -1540,7 +1543,8 @@ export class Maker {
if (this.shutdownStarted) throw new Error('Maker is shutting down; refusing to start a hosted session');
if (!opts.deviceHosted) throw new Error('hosted sessions require deviceHosted');
if (opts.remoteHostId) throw new Error('hosted sessions cannot target an SSH host');
- return this.requireAgent(kind).startSession(opts);
+ if (opts.fastModePolicy && !(opts.fastModePolicy.isRequestAllowed?.() ?? opts.fastModePolicy.isAllowed())) opts.fastMode = false;
+ return withFastModePolicy(await this.requireAgent(kind).startSession(opts), opts.fastModePolicy);
}
/** A local application owns the transcript; supplier execution stays in Maker. */
diff --git a/packages/model-providers/src/__tests__/provider-identity.test.ts b/packages/model-providers/src/__tests__/provider-identity.test.ts
index 37f927e82c..44ab8ff987 100644
--- a/packages/model-providers/src/__tests__/provider-identity.test.ts
+++ b/packages/model-providers/src/__tests__/provider-identity.test.ts
@@ -1,8 +1,16 @@
import { describe, expect, it } from 'vitest';
-import { isLocalOnlyProviderForAgent, isOpenAiSubscriptionProvider, providerCatalogId, isCustomRoutedProvider, isOrganizationManagedProvider } from '../provider-identity.js';
+import { isLocalOnlyProviderForAgent, isOpenAiSubscriptionProvider, providerCatalogId, isCustomRoutedProvider, isOrganizationManagedProvider, supportsSubscriptionFastPolicy } from '../provider-identity.js';
import type { Provider } from '../types.js';
describe('connection identity vs public catalog identity', () => {
+ it('offers Fast controls only for actual OpenAI and Claude subscription connections', () => {
+ for (const [id, native] of [['openai', undefined], ['account-1', 'codex'], ['anthropic', undefined], ['claude-login', 'claude']] as const) {
+ expect(supportsSubscriptionFastPolicy({ id, auth: { method: 'oauth', native } })).toBe(true);
+ expect(supportsSubscriptionFastPolicy({ id, auth: { method: 'apiKey', native } })).toBe(false);
+ }
+ expect(supportsSubscriptionFastPolicy({ id: 'xai', auth: { method: 'oauth', native: 'xai' } })).toBe(false);
+ expect(supportsSubscriptionFastPolicy(null)).toBe(false);
+ });
it.each([
['openai', 'codex', [false, true, true]],
['openai-account', 'codex', [true, true, true]],
diff --git a/packages/model-providers/src/index.ts b/packages/model-providers/src/index.ts
index 1dcc02c8fa..568118dfca 100644
--- a/packages/model-providers/src/index.ts
+++ b/packages/model-providers/src/index.ts
@@ -56,7 +56,7 @@ export type {
} from "./types.js";
export { NATIVE_SUBSCRIPTION_AUTHS, NATIVE_SUBSCRIPTION_DEFAULT_PROVIDER_IDS, PI_MODEL_APIS, PI_REASONING_EFFORTS } from "./types.js";
-export { isLocalOnlyProviderForAgent, isOpenAiSubscriptionProvider, providerCatalogId, isCustomRoutedProvider, isOrganizationManagedProvider, isCindyDistributedProvider, isCindyAutoModelId } from './provider-identity.js';
+export { isLocalOnlyProviderForAgent, isOpenAiSubscriptionProvider, supportsSubscriptionFastPolicy, providerCatalogId, isCustomRoutedProvider, isOrganizationManagedProvider, isCindyDistributedProvider, isCindyAutoModelId } from './provider-identity.js';
export { sourceProviderForPreset } from './providerPresetIdentity.js';
export { isMimoTokenPlanPreset } from './mimoPresentation.js';
diff --git a/packages/model-providers/src/provider-identity.ts b/packages/model-providers/src/provider-identity.ts
index cd8470b740..3cb9b670d5 100644
--- a/packages/model-providers/src/provider-identity.ts
+++ b/packages/model-providers/src/provider-identity.ts
@@ -24,6 +24,12 @@ export function isOpenAiSubscriptionProvider(provider: Pick<Provider, 'id' | 'au
&& (provider.id === 'openai' || provider.auth.native === 'codex');
}
+/** Account policy, never inferred from a display name, endpoint or model family. */
+export function supportsSubscriptionFastPolicy(provider: Pick<Provider, 'id' | 'auth'> | null | undefined): boolean {
+ return isOpenAiSubscriptionProvider(provider) || !!provider && provider.auth?.method === 'oauth'
+ && (provider.id === 'anthropic' || provider.auth.native === 'claude');
+}
+
/** Public catalog identity; never use this key to look up credentials or preferences. */
export function providerCatalogId(provider: Pick<Provider, 'id' | 'auth'>): string {
return provider.auth.native === 'claude' ? 'anthropic'
diff --git a/packages/model-providers/src/registry.ts b/packages/model-providers/src/registry.ts
index f2017571cb..05191c2545 100644
--- a/packages/model-providers/src/registry.ts
+++ b/packages/model-providers/src/registry.ts
@@ -95,6 +95,8 @@ export type ModelDiscoveryFailureState = Partial<
/** 供应商 + 连接状态。 */
export interface ProviderView extends Provider {
+ /** Host-owned subscription speed policy; absence means an unrelated provider or older host. */
+ subscriptionFastPolicy?: { allowFast: boolean; groupAllowsFast: boolean };
/** 本机是否允许同账号另一台电脑调用该供应商;缺省等同关闭。 */
remoteInvocationEnabled?: boolean;
/** Exact model IDs offered to remote Agents. Absent preserves the legacy unrestricted scope. */