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(desktop): 供应商组第二期——同账号直连与模型列表只显示组

Lizib39d4f722d1b
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index e5f4c9ec67..3e1bd9cc15 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -584,6 +584,7 @@ import { closeSharedTasksBeforeAccountHandover } from './device-link/sharedTaskA
import { registerSharedTaskIpc } from './device-link/sharedTaskIpc.js';
import { registerProviderShareIpc } from './device-link/providerShareRuntime.js';
import { registerProviderGroupIpc } from './provider-group/ipc.js';
+import { registerProviderGroupRemoteHandler } from './provider-group/remoteRegistration.js';
import {
getUpdateRelaunchControllers,
hasInFlightRemoteInvokes,
@@ -9505,6 +9506,7 @@ app.on('ready', async () => {
registerSharedTaskIpc(isSharedTaskAvailable, () => getDeviceLinkStatus() === 'online');
registerProviderShareIpc();
registerProviderGroupIpc();
+ registerProviderGroupRemoteHandler();
registerFilePeerIpc();
registerRemoteDesktopIpc(isGlobalVoiceInputOverlaySender, {
name: getControllerName,
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts
index d43bfbd238..0601e6946a 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts
@@ -27,6 +27,7 @@ import {
providerShareActiveControllers,
revokeProviderShareControllers,
runInvoke,
+ setProviderGroupRemoteHandler,
setProviderShareAccess,
setRemoteAgentHandler,
} from '../dispatch';
@@ -199,6 +200,33 @@ describe('provider share invoke', () => {
expect(projected.providers[0]).toEqual({ id: 'openai-2', name: 'OpenAI', remoteInvocationEnabled: true });
expect(JSON.stringify(projected)).not.toContain('[email protected]');
});
+
+ it('never shows the guest which computers are in a provider group', () => {
+ const projected = __testing.projectProviderListForShare({
+ providers: [{
+ id: 'anthropic', name: 'Anthropic', remoteInvocationEnabled: true,
+ group: { strategy: 'least', autoSwitch: true, members: [{ key: 'device:mini:a', kind: 'device', agentDeviceId: 'mini', providerId: 'a', label: 'Mini' }] },
+ }],
+ }, 'anthropic') as { providers: Array<Record<string, unknown>> };
+ expect(projected.providers[0]).not.toHaveProperty('group');
+ expect(JSON.stringify(projected)).not.toContain('Mini');
+ });
+});
+
+describe('provider group channel', () => {
+ it('serves same-account computers only', async () => {
+ const handle = vi.fn(async () => ({ kind: 'none' }));
+ setProviderGroupRemoteHandler({ handle, decorateProviderList: (result) => result });
+ await expect(runInvoke('same-account-mac', { channel: 'provider-group:remote', args: [{ action: 'view', providerId: 'anthropic' }] }))
+ .resolves.toEqual({ ok: true, result: { kind: 'none' } });
+ expect(handle).toHaveBeenCalledWith('same-account-mac', { action: 'view', providerId: 'anthropic' });
+
+ state.access = ACCESS;
+ handle.mockClear();
+ await expect(runInvoke(GUEST, { channel: 'provider-group:remote', args: [{ action: 'view', providerId: 'anthropic' }] }))
+ .resolves.toMatchObject({ ok: false, error: { code: 'CHANNEL_NOT_ALLOWED' } });
+ expect(handle).not.toHaveBeenCalled();
+ });
});
describe('provider share revoke', () => {
diff --git a/apps/desktop/src/main/device-link/dispatch.ts b/apps/desktop/src/main/device-link/dispatch.ts
index a2d1c80a62..32879db21d 100644
--- a/apps/desktop/src/main/device-link/dispatch.ts
+++ b/apps/desktop/src/main/device-link/dispatch.ts
@@ -103,7 +103,7 @@ import { createLogger } from '../logger';
import { projectMobileMessagePage, projectMobileToolPush } from './mobileToolProjection';
import { normalizeSessionProviderId } from '../maker-host/session-provider-store.js';
import { readDeviceLinkSettings } from './settings-store';
-import { PLUGIN_OAUTH_CHANNEL } from '@cindy/device-link';
+import { PLUGIN_OAUTH_CHANNEL, PROVIDER_GROUP_REMOTE_CHANNEL } from '@cindy/device-link';
import { requestPluginOauth, invalidatePluginOauth } from '../plugin-oauth/runtime.js';
import { dispatchLocalInvoke } from './invoke-registry';
import {
@@ -396,6 +396,24 @@ export function setRemoteAgentHandler(handler: RemoteAgentHandler | null): void
remoteAgentHandler = handler;
}
+/** 供应商组(docs/product-rules/provider-groups.md):只服务同账号电脑。 */
+export interface ProviderGroupRemoteHandler {
+ /** `provider-group:remote` 请求。 */
+ handle(controller: string, raw: unknown): Promise<unknown>;
+ /** 给同账号电脑的 `maker:provider:list` 补上组摘要(组所属供应商的 `group` 字段)。 */
+ decorateProviderList(result: unknown): unknown;
+}
+let providerGroupRemoteHandler: ProviderGroupRemoteHandler | null = null;
+
+export function setProviderGroupRemoteHandler(handler: ProviderGroupRemoteHandler | null): void {
+ providerGroupRemoteHandler = handler;
+}
+
+/** 组摘要只给同账号电脑:分享受邀者与共享任务访客是其他账号,看不到组内电脑。 */
+function isSameAccountController(src: string): boolean {
+ return !isProviderSharePeer(src) && !isSharedTaskPeer(src);
+}
+
// Local renderer IPC keeps its sender guard; remote mutations enter the shared action here.
type RemoteTurnChangeAction = (
sessionId: unknown, id: unknown, action: unknown, assertAccess: () => Promise<void>,
@@ -4303,6 +4321,26 @@ async function executeRemoteInvoke(src: string, payload: InvokePayload | undefin
};
}
}
+ if (payload.channel === PROVIDER_GROUP_REMOTE_CHANNEL) {
+ // 供应商组只给同账号电脑:受邀者的通道清单与共享任务的清单里都没有它,这里再兜一层。
+ if (!isSameAccountController(src)) {
+ return { ok: false, error: { code: 'CHANNEL_NOT_ALLOWED', message: `channel '${payload.channel}' not allowed` } };
+ }
+ const handler = providerGroupRemoteHandler;
+ if (!handler) return { ok: false, error: { code: 'IPC_ERROR', message: '[UNAVAILABLE] provider groups are not ready yet' } };
+ try {
+ return {
+ ok: true,
+ result: await timing.measure('handler', () => runDeviceLinkInvokeContext(
+ { controllerDeviceId: src, channel: payload.channel },
+ () => handler.handle(src, payload.args?.[0]),
+ )),
+ };
+ } catch (error) {
+ const message = error instanceof Error ? error.message : String(error);
+ return { ok: false, error: { code: 'IPC_ERROR', message: /^\[[A-Z_]+\]/.test(message) ? message : '[INTERNAL] provider group request failed' } };
+ }
+ }
if (payload.channel === REMOTE_DESKTOP_CHANNEL) {
try { return { ok: true, result: await timing.measure('handler', () => requestRemoteDesktop(src, payload.args?.[0])) }; }
catch (error) { return { ok: false, error: { code: 'IPC_ERROR', message: error instanceof Error ? error.message : 'DESKTOP_UNAVAILABLE' } }; }
@@ -4534,8 +4572,12 @@ async function executeRemoteInvoke(src: string, payload: InvokePayload | undefin
|| listingCapabilities.includes(CONTROLLER_CAPABILITY_PROVIDER_LOGO_KINDS_V2),
args,
));
+ // 供应商组摘要只给同账号电脑(受邀者与共享任务访客另有投影,这里不加,scrubSharedProvider 再兜一层)。
+ const decorated = payload.channel === 'maker:provider:list' && isSameAccountController(src) && providerGroupRemoteHandler
+ ? providerGroupRemoteHandler.decorateProviderList(projected)
+ : projected;
if (!broadcastTap.isDataOwnerBroadcastScopeCurrent(invocationOwner)) throw new Error('[NOT_FOUND] Session does not exist');
- return { ok: true, result: projected };
+ return { ok: true, result: decorated };
} catch (err) {
// 被控端 handler 的 throwIpcError `[CODE] message` 原样透传,
// 控制端 renderer 继续用 extractIpcError 解码
@@ -4620,6 +4662,7 @@ export const __testing = {
inFlightRemoteInvokeCount = 0;
completedRemoteInvokeResults.clear();
providerShareDenialLoggedAt.clear();
+ providerGroupRemoteHandler = null;
completedRemoteInvokeResultBytes = 0;
inFlightRemoteInvokeResults.clear();
inFlightRemoteInvokeBytes = 0;
diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.ts
index 65b6868a63..0704daeacc 100644
--- a/apps/desktop/src/main/maker-host/index.ts
+++ b/apps/desktop/src/main/maker-host/index.ts
@@ -116,6 +116,7 @@ import {
wireSessionToIpc,
} from '../maker-ipc/register.js';
import { MAKER_PUSH } from '../maker-ipc/channels.js';
+import { readProviderGroupBinding } from '../provider-group/bindings.js';
import { tapWindowBroadcast } from '../device-link/broadcast-tap.js';
import { remoteBackgroundInvoke, remoteInvoke } from '../device-link/index.js';
import { handleListDevices, defaultDeps as deviceDirectoryDeps } from '../device-link/ipc.js';
@@ -2712,6 +2713,8 @@ export function getMaker(): Maker {
maxPages: lastPage,
maxInputBytes: REMOTE_AGENT_PDF_MAX_BYTES,
}),
+ // 供应商组分配到那台的任务:告诉那台直接运行,不再进入它自己的组(provider-groups.md §4 防转圈)。
+ isGroupAssigned: (sessionId) => readProviderGroupBinding(sessionId) !== null,
logger: desktopMakerLogger,
}),
makerMemory: makerMemoryManager,
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/sessionTurnActivityTracker.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/sessionTurnActivityTracker.test.ts
index 572100a6cb..f7f1e5ece8 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/sessionTurnActivityTracker.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/sessionTurnActivityTracker.test.ts
@@ -92,3 +92,28 @@ describe('isSessionTurnDispatchBoundaryBusy', () => {
expect(isSessionTurnDispatchBoundaryBusy(t, 's', null)).toBe(false);
});
});
+
+describe('SessionTurnActivityTracker per-session change listener', () => {
+ it('notifies only when a session enters or leaves its turn, including when it closes', () => {
+ const t = new SessionTurnActivityTracker();
+ const changes: string[] = [];
+ t.setSessionTurnChangeListener((sessionId) => changes.push(sessionId));
+ t.setSessionInTurn('s', true);
+ t.setSessionInTurn('s', true);
+ t.scheduleIdleAfterStatusBroadcast('s');
+ t.scheduleIdleAfterTerminalBroadcast('s');
+ t.setSessionInTurn('s', true);
+ t.deleteSession('s');
+ t.deleteSession('s');
+ expect(changes).toEqual(['s', 's', 's', 's']);
+ });
+
+ it('keeps tracking turns when the listener throws', () => {
+ const t = new SessionTurnActivityTracker();
+ t.setSessionTurnChangeListener(() => {
+ throw new Error('listener failed');
+ });
+ t.setSessionInTurn('s', true);
+ expect(t.isSessionInTurn('s')).toBe(true);
+ });
+});
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 92194191d2..d6fb342c44 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -27,8 +27,19 @@ import { describeProviderShareDevice } from '../device-link/providerShareGuest.j
import { readDeviceProviderViews } from '../remote-agent/controller/deviceCatalog.js';
import { checkDeviceRoute } from '../remote-agent/controller/deviceRouteCheck.js';
import { isProviderShareAgentDeviceId } from '../../shared/providerShare.js';
-import { readProviderGroupBinding, writeProviderGroupBinding } from '../provider-group/bindings.js';
-import { getProviderGroupDirectory, getProviderGroupRouter, setProviderGroupTurnProbe } from '../provider-group/runtime.js';
+import {
+ listRemoteProviderGroupBindings,
+ readProviderGroupBinding,
+ writeProviderGroupBinding,
+} from '../provider-group/bindings.js';
+import { createProviderGroupLeaseReporter, type ProviderGroupLeaseReporter } from '../provider-group/leaseReporter.js';
+import {
+ getProviderGroupDirectory,
+ getProviderGroupRemoteClient,
+ getProviderGroupRemoteGroups,
+ getProviderGroupRouter,
+ setProviderGroupTurnProbe,
+} from '../provider-group/runtime.js';
import {
createProviderGroupService,
PROVIDER_GROUP_SUPERSEDED_ERROR,
@@ -3757,6 +3768,7 @@ function resolveSwitchedSessionVendorOptions(sessionId: string): Record<string,
}
let gitSnapshotCoordinator: GitSnapshotCoordinator | null = null;
const sessionTurnActivityTracker = new SessionTurnActivityTracker();
+let providerGroupLeaseReporter: ProviderGroupLeaseReporter | null = null;
const reviewRunOwner: ReviewRunOwner = { instanceId: randomUUID(), processId: process.pid };
const sessionTurnLeaseTracker = new SessionTurnLeaseTracker({
getDbClient,
@@ -7497,14 +7509,22 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
async function applyProviderGroupAssignment(o: CreateOpts): Promise<ProviderGroupStartContext | null> {
if (!providerGroupService || !o.id || o.remoteHostId) return null;
if (typeof o.model !== 'string' || !o.model) return null;
- // 没有建任何组时不读数据库,启动路径与没有这个功能时完全一致。
- if (Object.keys(listProviderGroups()).length === 0) return null;
+ // 本机没有建组、任务不指向同账号另一台电脑(那台可能建了组)、也没有归组时不读数据库,
+ // 启动路径与没有这个功能时完全一致。
+ const pointsAtOtherComputer = Boolean(o.agentDeviceId) && !isProviderShareAgentDeviceId(o.agentDeviceId);
+ if (Object.keys(listProviderGroups()).length === 0 && !pointsAtOtherComputer && !readProviderGroupBinding(o.id)) {
+ return null;
+ }
const context = await providerGroupService.assignBeforeStart({
sessionId: o.id,
agentKind: o.agentKind,
model: o.model,
});
- if (context?.route.agentDeviceId && o.agentDeviceId === undefined) {
+ if (context?.overrideRoute) {
+ // 另一台电脑上的组选中的可能是任何一台,包括这台自己(改回本机运行)。
+ o.agentDeviceId = context.route.agentDeviceId ?? undefined;
+ o.providerId = context.route.providerId;
+ } else if (context?.route.agentDeviceId && o.agentDeviceId === undefined) {
o.agentDeviceId = context.route.agentDeviceId;
o.providerId = context.route.providerId;
}
@@ -7549,7 +7569,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
typeof o.id === 'string' ? getSessionRuntimeControlSnapshot(o.id).effectiveOverride : null;
if (runtimeOverride && runtimeOverride.agentKind === o.agentKind) {
o.model = runtimeOverride.model;
- o.providerId = runtimeOverride.providerId;
+ // 供应商组分配到另一台电脑(或经另一台电脑的组改到这里)时,来源由那次分配决定:选中的那台上这个
+ // 供应商的 id 可能与原来不同,不让临时调整盖掉。留在本机的照旧按临时调整。
+ const groupDecidesSource = providerGroupStart !== null
+ && (providerGroupStart.overrideRoute || providerGroupStart.route.agentDeviceId !== null);
+ if (!groupDecidesSource) o.providerId = runtimeOverride.providerId;
o.effort = runtimeOverride.effort ?? undefined;
o.fastMode = runtimeOverride.fastMode;
}
@@ -9451,6 +9475,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
router: getProviderGroupRouter(),
directory: getProviderGroupDirectory(),
readGroup: readProviderGroup,
+ // 同账号另一台电脑上的组(docs/product-rules/provider-groups.md §4「同账号直连」)。
+ remote: getProviderGroupRemoteGroups(),
+ localDeviceId: getSelfDeviceId,
readBinding: readProviderGroupBinding,
writeBinding: (sessionId, binding) => writeProviderGroupBinding(sessionId, binding),
readSessionRow: readProviderGroupSessionRow,
@@ -9512,6 +9539,17 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
log,
});
setProviderGroupTurnProbe((sessionId) => maker.getSession(sessionId)?.isTurnRunning() ?? false);
+ // 经另一台电脑上的组运行的任务:开始 / 结束一轮时报告给组所在电脑,让它的分配看到真实负载。
+ providerGroupLeaseReporter?.dispose();
+ providerGroupLeaseReporter = createProviderGroupLeaseReporter({
+ listRemoteBindings: listRemoteProviderGroupBindings,
+ isTurnRunning: (sessionId) => maker.getSession(sessionId)?.isTurnRunning() ?? false,
+ send: (ownerDeviceId, seq, entries) => getProviderGroupRemoteClient().leases(ownerDeviceId, seq, entries),
+ now: () => Date.now(),
+ log,
+ });
+ const leaseReporter = providerGroupLeaseReporter;
+ sessionTurnActivityTracker.setSessionTurnChangeListener((sessionId) => leaseReporter.notify(sessionId));
registerMakerMessageDeleteHandler(makerSessionRegistry, {
getSessionRow: async (sessionId) => {
const [row] = await getDbClient()
diff --git a/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts b/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts
index 6a3ff5438d..fa52413573 100644
--- a/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts
@@ -19,6 +19,7 @@ export class SessionTurnActivityTracker {
private readonly sessionTurnKeepaliveTimers = new Map<string, ReturnType<typeof setTimeout>>();
private lastAnySessionTurnKeepalive = false;
private onAnySessionTurnKeepaliveChange: ((isRunning: boolean) => void) | null = null;
+ private onSessionTurnChange: ((sessionId: string) => void) | null = null;
setTurnKeepaliveChangeListener(listener: ((isRunning: boolean) => void) | null): void {
this.onAnySessionTurnKeepaliveChange = listener;
@@ -26,6 +27,24 @@ export class SessionTurnActivityTracker {
listener?.(this.lastAnySessionTurnKeepalive);
}
+ /** 某个任务的逻辑 turn 开始 / 结束(含任务关闭)。只通知变化,监听方自己去读当前状态。 */
+ setSessionTurnChangeListener(listener: ((sessionId: string) => void) | null): void {
+ this.onSessionTurnChange = listener;
+ }
+
+ private setInTurn(sessionId: string, isRunning: boolean | null): void {
+ const before = this.sessionInTurn.get(sessionId) === true;
+ if (isRunning === null) this.sessionInTurn.delete(sessionId);
+ else this.sessionInTurn.set(sessionId, isRunning);
+ if (before !== (isRunning === true)) {
+ try {
+ this.onSessionTurnChange?.(sessionId);
+ } catch {
+ // 监听方的问题不能影响 turn 记账。
+ }
+ }
+ }
+
isSessionInTurn(sessionId: string): boolean {
return this.sessionInTurn.get(sessionId) === true;
}
@@ -43,7 +62,7 @@ export class SessionTurnActivityTracker {
setSessionInTurn(sessionId: string, isRunning: boolean): void {
if (isRunning) this.clearScheduledSessionTurnKeepalive(sessionId);
- this.sessionInTurn.set(sessionId, isRunning);
+ this.setInTurn(sessionId, isRunning);
this.sessionTurnDispatchBoundary.set(sessionId, isRunning);
this.sessionTurnKeepalive.set(sessionId, isRunning);
this.notifyAnySessionTurnKeepaliveIfChanged();
@@ -51,7 +70,7 @@ export class SessionTurnActivityTracker {
deleteSession(sessionId: string): void {
this.clearScheduledSessionTurnKeepalive(sessionId);
- this.sessionInTurn.delete(sessionId);
+ this.setInTurn(sessionId, null);
this.sessionTurnDispatchBoundary.delete(sessionId);
this.sessionTurnKeepalive.delete(sessionId);
this.notifyAnySessionTurnKeepaliveIfChanged();
@@ -69,7 +88,7 @@ export class SessionTurnActivityTracker {
sessionId: string,
options: { releaseDispatchBoundary: boolean },
): void {
- this.sessionInTurn.set(sessionId, false);
+ this.setInTurn(sessionId, false);
if (options.releaseDispatchBoundary) {
this.sessionTurnDispatchBoundary.set(sessionId, 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 0182cf3f19..c0b9dde557 100644
--- a/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
@@ -57,6 +57,27 @@ describe('parseProviderGroupCommand', () => {
expect(() => parseProviderGroupCommand({ action: 'save', providerId: 'anthropic' })).toThrow();
expect(parseProviderGroupCommand({ action: 'get', providerId: 'anthropic' })).toEqual({ action: 'get', providerId: 'anthropic' });
});
+
+ it('accepts listing this computer’s groups and reading a group on another computer', () => {
+ expect(parseProviderGroupCommand({ action: 'list' })).toEqual({ action: 'list' });
+ expect(parseProviderGroupCommand({ action: 'remote-view', providerId: 'anthropic', deviceId: 'mini' }))
+ .toEqual({ action: 'remote-view', providerId: 'anthropic', deviceId: 'mini' });
+ expect(() => parseProviderGroupCommand({ action: 'remote-view', providerId: 'anthropic' })).toThrow();
+ expect(() => parseProviderGroupCommand({ action: 'remote-view', providerId: 'anthropic', deviceId: 'bad id' })).toThrow();
+ });
+});
+
+describe('executeProviderGroupCommand reads', () => {
+ it('lists local groups without touching the network and forwards remote views', async () => {
+ const d = deps([]);
+ const listGroups = vi.fn(() => ({ anthropic: { strategy: 'least', autoSwitch: true, members: [] } }));
+ const remoteView = vi.fn(async () => ({ providerId: 'anthropic', config: null, members: [] }));
+ Object.assign(d, { listGroups, remoteView });
+ expect(await executeProviderGroupCommand(d, { action: 'list' })).toEqual({ anthropic: expect.any(Object) });
+ expect(d.router.view).not.toHaveBeenCalled();
+ await executeProviderGroupCommand(d, { action: 'remote-view', providerId: 'anthropic', deviceId: 'mini' });
+ expect(remoteView).toHaveBeenCalledWith('mini', 'anthropic');
+ });
});
describe('executeProviderGroupCommand save', () => {
diff --git a/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts b/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts
new file mode 100644
index 0000000000..9d93f5bfb3
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts
@@ -0,0 +1,101 @@
+/**
+ * 向组所在电脑报告经它的组正在运行的任务(provider-groups.md §5):变化时防抖报告、运行期间心跳、
+ * 结束后补报一次空,序号只增。
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { ProviderGroupBinding } from '../bindings';
+import {
+ createProviderGroupLeaseReporter,
+ PROVIDER_GROUP_LEASE_DEBOUNCE_MS,
+ PROVIDER_GROUP_LEASE_HEARTBEAT_MS,
+} from '../leaseReporter';
+
+beforeEach(() => {
+ vi.useFakeTimers();
+});
+
+afterEach(() => {
+ vi.useRealTimers();
+});
+
+function setup() {
+ const bindings: Record<string, ProviderGroupBinding> = {
+ s1: { providerId: 'anthropic', memberKey: 'device:studio:a', groupDeviceId: 'mini', at: 1 },
+ s2: { providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini', at: 1 },
+ s3: { providerId: 'openai', memberKey: 'local', groupDeviceId: 'other', at: 1 },
+ };
+ const running = new Set<string>();
+ const send = vi.fn(async (_owner: string, _seq: number, _entries: unknown[]) => undefined);
+ const reporter = createProviderGroupLeaseReporter({
+ listRemoteBindings: () => bindings,
+ isTurnRunning: (id) => running.has(id),
+ send,
+ now: () => Date.now(),
+ log: { warn: vi.fn() },
+ });
+ return { reporter, running, send, bindings };
+}
+
+describe('provider group lease reporter', () => {
+ it('reports the running tasks per group computer after a short debounce', async () => {
+ const { reporter, running, send } = setup();
+ running.add('s1');
+ reporter.notify('s1');
+ reporter.notify('s1');
+ expect(send).not.toHaveBeenCalled();
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ expect(send).toHaveBeenCalledTimes(1);
+ expect(send).toHaveBeenCalledWith('mini', expect.any(Number), [
+ { sessionId: 's1', providerId: 'anthropic', memberKey: 'device:studio:a' },
+ ]);
+ reporter.dispose();
+ });
+
+ it('sends a heartbeat while tasks run and one empty report once they stop', async () => {
+ const { reporter, running, send } = setup();
+ running.add('s1');
+ reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_HEARTBEAT_MS);
+ expect(send).toHaveBeenCalledTimes(2);
+ running.clear();
+ reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ expect(send).toHaveBeenCalledTimes(3);
+ expect(send).toHaveBeenLastCalledWith('mini', expect.any(Number), []);
+ // 都停了:不再心跳,也不重复报空。
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_HEARTBEAT_MS * 3);
+ reporter.notify('s2');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ expect(send).toHaveBeenCalledTimes(3);
+ reporter.dispose();
+ });
+
+ it('numbers reports so a later one always has a larger sequence, even across restarts', async () => {
+ const { reporter, running, send } = setup();
+ running.add('s1');
+ reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ running.add('s2');
+ reporter.notify('s2');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ const seqs = send.mock.calls.map((call) => call[1] as number);
+ expect(seqs[1]).toBeGreaterThan(seqs[0]);
+ reporter.dispose();
+ const restarted = setup();
+ restarted.running.add('s1');
+ restarted.reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ expect(restarted.send.mock.calls[0][1] as number).toBeGreaterThan(seqs[1]);
+ restarted.reporter.dispose();
+ });
+
+ it('does nothing when no task runs through a group on another computer', async () => {
+ const { reporter, send } = setup();
+ reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_HEARTBEAT_MS);
+ expect(send).not.toHaveBeenCalled();
+ reporter.dispose();
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
new file mode 100644
index 0000000000..56ce4b0c20
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
@@ -0,0 +1,270 @@
+/**
+ * 同账号另一台电脑上的供应商组(provider-groups.md §4「同账号直连」、§6):
+ * - 任务选了组所在电脑的这个供应商:问组所在电脑该用哪台,直接连过去,组员坐标换成本机的位置;
+ * - 组员出问题时由本机换电脑,并把需要冷却的电脑报告给组所在电脑(连不上只自己避开);
+ * - 组所在电脑读不到时绑定不动,确认组没了才解除。
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ProviderGroupConfig, ProviderGroupMember, ProviderGroupView } from '../../../shared/providerGroup';
+import type { ProviderGroupBinding } from '../bindings';
+import type { ProviderGroupDirectory } from '../directory';
+import { createProviderGroupRouter } from '../router';
+import {
+ createProviderGroupService,
+ PROVIDER_GROUP_UNAVAILABLE_ERROR,
+ type ProviderGroupRemoteGroups,
+ type ProviderGroupServiceDeps,
+ type ProviderGroupSessionRow,
+} from '../service';
+
+const MODEL = 'claude-opus-5-5';
+const OWNER = 'mac-mini';
+const ME = 'my-laptop';
+
+function member(key: string, kind: ProviderGroupMember['kind'], agentDeviceId: string | null, providerId: string, label: string): ProviderGroupMember {
+ return { key, kind, agentDeviceId, providerId, label, limit: 4, weight: 1, paused: false };
+}
+
+const OWNER_LOCAL = member('local', 'local', null, 'anthropic', 'Mac Mini');
+const SELF = member(`device:${ME}:anthropic`, 'device', ME, 'anthropic', 'My Laptop');
+const STUDIO = member('device:studio:anthropic-1a2b3c4d', 'device', 'studio', 'anthropic-1a2b3c4d', 'Studio');
+const SHARED = member('share:s1:anthropic', 'share', 'share:s1', 'anthropic', 'Friend PC');
+
+function harness(options: {
+ row?: Partial<ProviderGroupSessionRow>;
+ /** undefined = 组所在电脑读不到;null = 那台没有这个组。 */
+ config?: ProviderGroupConfig | null | undefined;
+ picks?: Array<ProviderGroupMember | 'unavailable' | 'none' | Error>;
+ view?: Partial<Record<string, ProviderGroupView['members'][number]['state']>>;
+} = {}) {
+ const config: ProviderGroupConfig | null | undefined = 'config' in options
+ ? options.config
+ : { strategy: 'least', autoSwitch: true, members: [OWNER_LOCAL, SELF, STUDIO, SHARED] };
+ const picks = [...(options.picks ?? [STUDIO])];
+ const bindings = new Map<string, ProviderGroupBinding>();
+ const directory: ProviderGroupDirectory = {
+ resolveMembers: async () => [],
+ listCandidates: async () => [],
+ readDeviceCatalog: async () => [],
+ invalidate: vi.fn(),
+ };
+ const router = createProviderGroupRouter({
+ directory,
+ readGroup: () => null,
+ listBindings: () => ({}),
+ isTurnRunning: () => false,
+ now: () => 1_000,
+ random: () => 0,
+ });
+ const remote = {
+ readGroup: vi.fn(async () => config),
+ pick: vi.fn(async () => {
+ const next = picks.shift() ?? 'unavailable';
+ if (next instanceof Error) throw next;
+ if (next === 'unavailable' || next === 'none') return { kind: next };
+ const { key, kind, agentDeviceId, providerId } = next;
+ return { kind: 'member' as const, member: { key, kind, agentDeviceId, providerId }, label: next.label! };
+ }),
+ cool: vi.fn(async () => undefined),
+ view: vi.fn(async (): Promise<ProviderGroupView> => ({
+ providerId: 'anthropic',
+ config: config ?? null,
+ members: (config?.members ?? []).map((m) => ({
+ key: m.key,
+ kind: m.kind,
+ label: m.label ?? m.key,
+ state: options.view?.[m.key] ?? 'available',
+ running: 0,
+ limit: m.limit,
+ weight: m.weight,
+ paused: m.paused,
+ })),
+ })),
+ invalidate: vi.fn(),
+ } satisfies ProviderGroupRemoteGroups;
+ const row: ProviderGroupSessionRow = {
+ agentKind: 'claude-code',
+ model: MODEL,
+ providerId: 'anthropic',
+ agentDeviceId: OWNER,
+ remoteHostId: null,
+ sdkSessionId: null,
+ ...options.row,
+ };
+ const deps = {
+ router,
+ directory,
+ readGroup: () => null,
+ remote,
+ localDeviceId: () => ME,
+ readBinding: (id: string) => bindings.get(id) ?? null,
+ writeBinding: vi.fn(async (id: string, binding: { providerId: string; memberKey: string; groupDeviceId?: string | null } | null) => {
+ if (binding) bindings.set(id, { providerId: binding.providerId, memberKey: binding.memberKey, ...(binding.groupDeviceId ? { groupDeviceId: binding.groupDeviceId } : {}), at: 1 });
+ else bindings.delete(id);
+ }),
+ readSessionRow: vi.fn(async () => row),
+ resolveImplicitProvider: vi.fn(async () => 'anthropic'),
+ persistRoute: vi.fn(async (_id: string, route: { agentDeviceId: string | null; providerId: string | null }) => {
+ row.agentDeviceId = route.agentDeviceId;
+ row.providerId = route.providerId;
+ }),
+ hasAssistantHistory: vi.fn(async () => false),
+ isFailoverEligible: vi.fn(async () => true),
+ leaseRecovery: vi.fn((): object | null => ({})),
+ isLeaseCurrent: vi.fn(() => true),
+ rearmContinue: vi.fn((): number | null => 7),
+ cancelContinue: vi.fn(),
+ switchAgentLocation: vi.fn(async (_id: string, route: { agentDeviceId: string | null; providerId: string | null }) => {
+ row.agentDeviceId = route.agentDeviceId;
+ row.providerId = route.providerId;
+ }),
+ isTurnRunning: vi.fn(() => false),
+ continueSession: vi.fn(async () => 'resumed' as const),
+ fallback: vi.fn(),
+ readResetAt: vi.fn((): number | null => 5_000),
+ now: () => 1_000,
+ log: { info: vi.fn(), warn: vi.fn() },
+ } satisfies ProviderGroupServiceDeps;
+ return { service: createProviderGroupService(deps), deps, remote, row, bindings };
+}
+
+async function flush() {
+ for (let i = 0; i < 30; i++) await Promise.resolve();
+}
+
+const START = { sessionId: 's1', agentKind: 'claude-code' as const, model: MODEL };
+
+describe('assigning through a group on another computer', () => {
+ it('asks the group computer and connects straight to the chosen computer', async () => {
+ const h = harness();
+ const context = await h.service.assignBeforeStart(START);
+ expect(h.remote.pick).toHaveBeenCalledWith(OWNER, expect.objectContaining({ sessionId: 's1', providerId: 'anthropic', exclude: [] }));
+ expect(context).toMatchObject({
+ groupDeviceId: OWNER,
+ overrideRoute: true,
+ route: { agentDeviceId: 'studio', providerId: 'anthropic-1a2b3c4d' },
+ });
+ expect(h.deps.persistRoute).toHaveBeenCalledWith('s1', { agentDeviceId: 'studio', providerId: 'anthropic-1a2b3c4d' });
+ expect(h.bindings.get('s1')).toMatchObject({ providerId: 'anthropic', memberKey: STUDIO.key, groupDeviceId: OWNER });
+ });
+
+ it('maps the group computer itself, this computer and shares to the right place', async () => {
+ const cases: Array<[ProviderGroupMember, { agentDeviceId: string | null; providerId: string }]> = [
+ [OWNER_LOCAL, { agentDeviceId: OWNER, providerId: 'anthropic' }],
+ [SELF, { agentDeviceId: null, providerId: 'anthropic' }],
+ [SHARED, { agentDeviceId: 'share:s1', providerId: 'anthropic' }],
+ ];
+ for (const [picked, route] of cases) {
+ const h = harness({ picks: [picked] });
+ const context = await h.service.assignBeforeStart(START);
+ expect(context?.route).toEqual(route);
+ }
+ });
+
+ it('runs straight on the group computer when it cannot answer or has no group', async () => {
+ for (const options of [{ config: undefined }, { config: null }, { picks: ['none' as const] }, { picks: [new Error('link down')] }]) {
+ const h = harness(options);
+ expect(await h.service.assignBeforeStart(START)).toBeNull();
+ expect(h.deps.persistRoute).not.toHaveBeenCalled();
+ expect(h.bindings.size).toBe(0);
+ }
+ });
+
+ it('reports a clear error when no computer in the group can take the task', async () => {
+ const h = harness({ picks: ['unavailable'] });
+ await expect(h.service.assignBeforeStart(START)).rejects.toThrow(PROVIDER_GROUP_UNAVAILABLE_ERROR);
+ });
+
+ it('never moves a task that already ran on the group computer, and leaves shares alone', async () => {
+ for (const row of [{ sdkSessionId: 'native-1' }, { agentDeviceId: 'share:s9' }, { providerId: null }]) {
+ const h = harness({ row });
+ expect(await h.service.assignBeforeStart(START)).toBeNull();
+ expect(h.remote.pick).not.toHaveBeenCalled();
+ }
+ });
+
+ it('keeps the binding while the group computer is unreachable and drops it once the group is gone', async () => {
+ const unreachable = harness({ config: undefined, row: { agentDeviceId: 'studio', providerId: STUDIO.providerId } });
+ unreachable.bindings.set('s1', { providerId: 'anthropic', memberKey: STUDIO.key, groupDeviceId: OWNER, at: 1 });
+ expect(await unreachable.service.assignBeforeStart(START)).toBeNull();
+ expect(unreachable.bindings.has('s1')).toBe(true);
+
+ const gone = harness({ config: null, row: { agentDeviceId: 'studio', providerId: STUDIO.providerId } });
+ gone.bindings.set('s1', { providerId: 'anthropic', memberKey: STUDIO.key, groupDeviceId: OWNER, at: 1 });
+ expect(await gone.service.assignBeforeStart(START)).toBeNull();
+ expect(gone.bindings.has('s1')).toBe(false);
+ });
+
+ it('tries the next computer when the chosen one does not start', async () => {
+ const h = harness({ picks: [STUDIO, SHARED] });
+ const context = await h.service.assignBeforeStart(START);
+ const next = await h.service.nextAfterStartFailure(context!, new Error('[REMOTE_AGENT_DEVICE_UNREACHABLE] gone'));
+ expect(h.remote.pick).toHaveBeenLastCalledWith(OWNER, expect.objectContaining({ exclude: [STUDIO.key] }));
+ // 连不上只由本机自己避开,不替全组冷却那台。
+ expect(h.remote.cool).not.toHaveBeenCalled();
+ expect(next?.route).toEqual({ agentDeviceId: 'share:s1', providerId: 'anthropic' });
+ expect(h.bindings.get('s1')).toMatchObject({ memberKey: SHARED.key, groupDeviceId: OWNER });
+ });
+});
+
+describe('switching computers within a group on another computer', () => {
+ function bound(options: Parameters<typeof harness>[0] = {}) {
+ const h = harness({ row: { agentDeviceId: 'studio', providerId: STUDIO.providerId, sdkSessionId: 'native-1' }, ...options });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: STUDIO.key, groupDeviceId: OWNER, at: 1 });
+ return h;
+ }
+
+ it('reports the usage limit to the group computer, moves the task and continues with names', async () => {
+ const h = bound({ picks: [OWNER_LOCAL] });
+ h.service.onTurnError('s1', { sdkError: 'rate_limit' }, 3);
+ await flush();
+ expect(h.remote.cool).toHaveBeenCalledWith(OWNER, { providerId: 'anthropic', memberKey: STUDIO.key, cause: 'usage-limit', resetAt: 5_000 });
+ expect(h.remote.pick).toHaveBeenCalledWith(OWNER, expect.objectContaining({ exclude: expect.arrayContaining([STUDIO.key]) }));
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledWith('s1', expect.objectContaining({ agentDeviceId: OWNER, providerId: 'anthropic' }), expect.anything());
+ expect(h.deps.continueSession).toHaveBeenCalledWith('s1', 7, expect.objectContaining({
+ agentSwitch: { from: 'Studio', to: 'Mac Mini', cause: 'usage-limit' },
+ }));
+ expect(h.bindings.get('s1')).toMatchObject({ memberKey: 'local', groupDeviceId: OWNER });
+ expect(h.deps.fallback).not.toHaveBeenCalled();
+ });
+
+ it('only avoids an unreachable computer itself instead of cooling it for the whole group', async () => {
+ const h = bound({ picks: [SELF] });
+ h.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
+ await flush();
+ expect(h.remote.cool).not.toHaveBeenCalled();
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledWith('s1', expect.objectContaining({ agentDeviceId: null, providerId: 'anthropic' }), expect.anything());
+ });
+
+ it('hands the error back when the group computer cannot be reached', async () => {
+ const h = bound({ config: undefined });
+ h.service.onTurnError('s1', { sdkError: 'rate_limit' }, 3);
+ await flush();
+ expect(h.deps.fallback).toHaveBeenCalled();
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.bindings.has('s1')).toBe(true);
+ });
+
+ it('stops following the group once the user moved the task elsewhere', async () => {
+ const h = bound({ row: { agentDeviceId: 'elsewhere', providerId: 'openai', sdkSessionId: 'native-1' } });
+ h.service.onTurnError('s1', { sdkError: 'rate_limit' }, 3);
+ await flush();
+ expect(h.bindings.has('s1')).toBe(false);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.deps.fallback).toHaveBeenCalled();
+ });
+
+ it('moves the task before sending when the group computer says its computer is offline', async () => {
+ const h = bound({ view: { [STUDIO.key]: 'offline' }, picks: [SHARED] });
+ await h.service.beforeSend('s1');
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledWith(
+ 's1',
+ expect.objectContaining({ agentDeviceId: 'share:s1', providerId: 'anthropic' }),
+ { beforeSend: true },
+ );
+ const healthy = bound();
+ await healthy.service.beforeSend('s1');
+ expect(healthy.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
new file mode 100644
index 0000000000..70b7736e90
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -0,0 +1,161 @@
+/**
+ * 组所在电脑这一侧(provider-groups.md §4–§6):同账号其他电脑来问该用哪台、报告冷却与运行中的任务;
+ * 目录只给同账号电脑补组摘要。
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
+import {
+ createProviderGroupExternalLoad,
+ PROVIDER_GROUP_LEASE_TTL_MS,
+ PROVIDER_GROUP_PROVISIONAL_MS,
+} from '../externalLoad';
+import {
+ decorateProviderListWithGroups,
+ handleProviderGroupRemote,
+ PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
+ type ProviderGroupRemoteHandlerDeps,
+} from '../remoteHandler';
+import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, PROVIDER_GROUP_FAILURE_COOLDOWN_MS, type ProviderGroupRouter } from '../router';
+
+const MINI: ProviderGroupMember = {
+ key: 'device:mini:anthropic-1a2b3c4d',
+ kind: 'device',
+ agentDeviceId: 'mini',
+ providerId: 'anthropic-1a2b3c4d',
+ label: 'Mini',
+ limit: 4,
+ weight: 1,
+ paused: false,
+};
+const CONFIG: ProviderGroupConfig = {
+ strategy: 'least',
+ autoSwitch: true,
+ members: [{ key: 'local', kind: 'local', agentDeviceId: null, providerId: 'anthropic', limit: 4, weight: 1, paused: false }, MINI],
+};
+
+function deps(overrides: Partial<ProviderGroupRemoteHandlerDeps> = {}) {
+ let now = 10_000;
+ const router = {
+ pick: vi.fn(async () => ({ kind: 'member' as const, member: MINI, label: 'Mini', resolved: [] })),
+ view: vi.fn(async () => ({ providerId: 'anthropic', config: CONFIG, members: [] })),
+ running: vi.fn(() => 0),
+ markCooling: vi.fn(),
+ coolingUntil: vi.fn(() => null),
+ markTried: vi.fn(() => new Set<string>()),
+ triedThisTurn: vi.fn(() => new Set<string>()),
+ resetTurn: vi.fn(),
+ } satisfies ProviderGroupRouter;
+ const externalLoad = createProviderGroupExternalLoad({ now: () => now });
+ const value = {
+ router,
+ externalLoad,
+ readGroup: (id: string) => (id === 'anthropic' ? CONFIG : null),
+ isRemoteAllowed: () => true,
+ now: () => now,
+ ...overrides,
+ } satisfies ProviderGroupRemoteHandlerDeps;
+ return { ...value, router, externalLoad, advance: (ms: number) => { now += ms; } };
+}
+
+const PICK = { action: 'pick', sessionId: 's1', providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: ['local'] };
+
+describe('provider-group:remote', () => {
+ it('picks a computer, honouring what the caller already tried, and holds it briefly', async () => {
+ const d = deps();
+ const result = await handleProviderGroupRemote(d, 'laptop', PICK);
+ expect(d.router.pick).toHaveBeenCalledWith({ providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: new Set(['local']) });
+ expect(result).toEqual({
+ kind: 'member',
+ member: { key: MINI.key, kind: 'device', agentDeviceId: 'mini', providerId: 'anthropic-1a2b3c4d' },
+ label: 'Mini',
+ });
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(1);
+ d.advance(PROVIDER_GROUP_PROVISIONAL_MS + 1);
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(0);
+ });
+
+ it('answers that there is no group for providers without one or no longer open to other computers', async () => {
+ expect(await handleProviderGroupRemote(deps(), 'laptop', { ...PICK, providerId: 'openai' })).toEqual({ kind: 'none' });
+ expect(await handleProviderGroupRemote(deps({ isRemoteAllowed: () => false }), 'laptop', PICK)).toEqual({ kind: 'none' });
+ });
+
+ it('reports that no computer can take the task', async () => {
+ const d = deps();
+ d.router.pick.mockResolvedValueOnce({ kind: 'unavailable', resolved: [] } as never);
+ expect(await handleProviderGroupRemote(d, 'laptop', PICK)).toEqual({ kind: 'unavailable' });
+ });
+
+ it('cools computers for usage limits up to a bounded reset time, and briefly for other causes', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'usage-limit', resetAt: 50_000 });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 50_000);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'usage-limit', resetAt: 10_000 + 365 * 86_400_000 });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 10_000 + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'usage-limit' });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 10_000 + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'auth' });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 10_000 + PROVIDER_GROUP_FAILURE_COOLDOWN_MS);
+ });
+
+ it('refuses to cool computers outside the group and rejects causes it does not cool for', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: 'device:x:y', cause: 'auth' });
+ expect(d.router.markCooling).not.toHaveBeenCalled();
+ await expect(handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'unavailable' }))
+ .rejects.toThrow('[INVALID_PARAMS]');
+ });
+
+ it('counts the running tasks each computer reports and drops stale or out-of-order reports', async () => {
+ const d = deps();
+ const lease = { sessionId: 's1', providerId: 'anthropic', memberKey: MINI.key };
+ await handleProviderGroupRemote(d, 'laptop', { action: 'leases', seq: 5, entries: [lease, { ...lease, sessionId: 's2' }] });
+ await handleProviderGroupRemote(d, 'desktop', { action: 'leases', seq: 1, entries: [{ ...lease, sessionId: 's9' }] });
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(3);
+ // 乱序到达的旧报告不能盖掉新的。
+ await handleProviderGroupRemote(d, 'laptop', { action: 'leases', seq: 4, entries: [] });
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(3);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'leases', seq: 6, entries: [] });
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(1);
+ d.advance(PROVIDER_GROUP_LEASE_TTL_MS + 1);
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(0);
+ });
+
+ it('does not double count a picked task once it is reported', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', PICK);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'leases', seq: 1, entries: [{ sessionId: 's1', providerId: 'anthropic', memberKey: MINI.key }] });
+ expect(d.externalLoad.running('anthropic', MINI.key)).toBe(1);
+ });
+
+ it('rejects malformed requests', async () => {
+ for (const raw of [null, { action: 'nope' }, { ...PICK, agentKind: 'x' }, { ...PICK, sessionId: '../x' }, { action: 'leases', seq: -1, entries: [] }]) {
+ await expect(handleProviderGroupRemote(deps(), 'laptop', raw)).rejects.toThrow('[INVALID_PARAMS]');
+ }
+ });
+});
+
+describe('decorateProviderListWithGroups', () => {
+ it('adds the group summary only to providers that have a group and stay open for remote use', () => {
+ const result = decorateProviderListWithGroups({
+ providers: [
+ { id: 'anthropic', remoteInvocationEnabled: true },
+ { id: 'openai', remoteInvocationEnabled: true, group: { forged: true } },
+ { id: 'anthropic', remoteInvocationEnabled: false },
+ ],
+ other: 1,
+ }, (id) => (id === 'anthropic' ? CONFIG : null)) as { providers: Array<Record<string, unknown>>; other: number };
+ expect(result.other).toBe(1);
+ expect(result.providers[0].group).toEqual({
+ strategy: 'least',
+ autoSwitch: true,
+ members: [
+ { key: 'local', kind: 'local', agentDeviceId: null, providerId: 'anthropic', paused: false },
+ { key: MINI.key, kind: 'device', agentDeviceId: 'mini', providerId: MINI.providerId, label: 'Mini', paused: false },
+ ],
+ });
+ // 只有本机设置能产生组摘要;没开放的不带。
+ expect(result.providers[1]).not.toHaveProperty('group');
+ expect(result.providers[2]).not.toHaveProperty('group');
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/service.test.ts b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
index 4a90b81e88..7f77824733 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -67,6 +67,9 @@ function harness(options: {
async listCandidates() {
return [];
},
+ async readDeviceCatalog() {
+ return [];
+ },
invalidate: vi.fn(),
};
const router = createProviderGroupRouter({
@@ -123,7 +126,7 @@ function harness(options: {
}
async function flush() {
- for (let i = 0; i < 20; i++) await Promise.resolve();
+ for (let i = 0; i < 60; i++) await Promise.resolve();
}
describe('assignBeforeStart', () => {
diff --git a/apps/desktop/src/main/provider-group/__tests__/stores.test.ts b/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
index dc7f829420..531551506b 100644
--- a/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
@@ -92,4 +92,33 @@ describe('provider group bindings', () => {
expect(bindings.readProviderGroupBinding('a')).toBeNull();
expect(bindings.readProviderGroupBinding('c')).not.toBeNull();
});
+
+ it('keeps bindings to a group on another computer in their own file, one group per task', async () => {
+ await bindings.writeProviderGroupBinding('r1', { providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini' }, 7);
+ expect(bindings.readProviderGroupBinding('r1')).toEqual({ providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini', at: 7 });
+ // 本机的组只数本机那份:另一台电脑的组不进本机分配器的统计,也不被本机删组时清掉。
+ expect(bindings.listProviderGroupBindings().r1).toBeUndefined();
+ expect(bindings.listRemoteProviderGroupBindings().r1).toBeDefined();
+ await bindings.pruneProviderGroupBindings('anthropic', null);
+ expect(bindings.readProviderGroupBinding('r1')).not.toBeNull();
+ // 降级后的旧版本只读本机那份,读不到它。
+ const localFile = JSON.parse(fs.readFileSync(path.join(tmpDir, 'provider-group-bindings.json'), 'utf8'));
+ expect(localFile.sessions?.r1).toBeUndefined();
+ // 改归本机的组时另一份里的同一任务一并清掉。
+ await bindings.writeProviderGroupBinding('r1', { providerId: 'anthropic', memberKey: 'local' }, 8);
+ expect(bindings.readProviderGroupBinding('r1')).toEqual({ providerId: 'anthropic', memberKey: 'local', at: 8 });
+ expect(bindings.listRemoteProviderGroupBindings().r1).toBeUndefined();
+ await bindings.writeProviderGroupBinding('r1', null);
+ expect(bindings.readProviderGroupBinding('r1')).toBeNull();
+ });
+
+ it('drops remote bindings without a valid group computer', () => {
+ expect(bindings.__testing.normalizeRemote({
+ sessions: {
+ r1: { providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini', at: 1 },
+ r2: { providerId: 'anthropic', memberKey: 'local' },
+ r3: { providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'bad id' },
+ },
+ })).toEqual({ sessions: { r1: { providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini', at: 1 } } });
+ });
});
diff --git a/apps/desktop/src/main/provider-group/bindings.ts b/apps/desktop/src/main/provider-group/bindings.ts
index acc2714652..ca58baea5e 100644
--- a/apps/desktop/src/main/provider-group/bindings.ts
+++ b/apps/desktop/src/main/provider-group/bindings.ts
@@ -4,6 +4,10 @@
*
* 任务实际运行的位置以任务记录(`sessions.agent_device_id` / `provider_id`)为准;这里只记「它属于
* 哪个组、对应组里哪一项」,不重复保存位置。
+ *
+ * 两份文件:本机的组(`provider-group-bindings.json`)与同账号另一台电脑上的组
+ * (`provider-group-remote-bindings.json`,多记组所在电脑)。分开存放,降级到旧版本时旧版本只读得到
+ * 本机的那份,不会把另一台电脑上的组误当成本机的同名组。
*/
import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
import { desktopMakerLogger } from '../maker-host/logger-adapter.js';
@@ -13,8 +17,10 @@ import { isProviderGroupProviderId } from '../../shared/providerGroup.js';
export interface ProviderGroupBinding {
/** 组所属的供应商(组所在电脑上的供应商 id)。 */
providerId: string;
- /** 组内电脑的键(ProviderGroupMember.key)。 */
+ /** 组内电脑的键(ProviderGroupMember.key,组所在电脑视角)。 */
memberKey: string;
+ /** 组在同账号另一台电脑上:那台的设备 id。本机的组没有这个字段。 */
+ groupDeviceId?: string;
/** 最近一次分配 / 换电脑的时间(unix ms),超出容量时淘汰最旧的。 */
at: number;
}
@@ -25,16 +31,19 @@ interface BindingFile {
const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
const MEMBER_KEY_PATTERN = /^[A-Za-z0-9_.:-]{1,300}$/;
+const DEVICE_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
/** 只需覆盖仍可能继续的任务;超出时淘汰最久没有分配过的绑定。 */
export const MAX_PROVIDER_GROUP_BINDINGS = 4000;
-function normalizeBinding(raw: unknown): ProviderGroupBinding | null {
+function normalizeBinding(raw: unknown, remote: boolean): ProviderGroupBinding | null {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
const value = raw as Record<string, unknown>;
if (!isProviderGroupProviderId(value.providerId)) return null;
if (typeof value.memberKey !== 'string' || !MEMBER_KEY_PATTERN.test(value.memberKey)) return null;
const at = typeof value.at === 'number' && Number.isFinite(value.at) && value.at > 0 ? value.at : 0;
- return { providerId: value.providerId, memberKey: value.memberKey, at };
+ if (!remote) return { providerId: value.providerId, memberKey: value.memberKey, at };
+ if (typeof value.groupDeviceId !== 'string' || !DEVICE_ID_PATTERN.test(value.groupDeviceId)) return null;
+ return { providerId: value.providerId, memberKey: value.memberKey, groupDeviceId: value.groupDeviceId, at };
}
function prune(sessions: Record<string, ProviderGroupBinding>): Record<string, ProviderGroupBinding> {
@@ -44,18 +53,21 @@ function prune(sessions: Record<string, ProviderGroupBinding>): Record<string, P
return Object.fromEntries(entries.slice(0, MAX_PROVIDER_GROUP_BINDINGS));
}
-function normalize(raw: unknown): BindingFile {
+function normalizeFile(raw: unknown, remote: boolean): BindingFile {
const sessions = (raw as Partial<BindingFile> | null)?.sessions;
if (!sessions || typeof sessions !== 'object' || Array.isArray(sessions)) return { sessions: {} };
const out: Record<string, ProviderGroupBinding> = {};
for (const [sessionId, value] of Object.entries(sessions)) {
if (!SESSION_ID_PATTERN.test(sessionId)) continue;
- const binding = normalizeBinding(value);
+ const binding = normalizeBinding(value, remote);
if (binding) out[sessionId] = binding;
}
return { sessions: prune(out) };
}
+const normalize = (raw: unknown) => normalizeFile(raw, false);
+const normalizeRemote = (raw: unknown) => normalizeFile(raw, true);
+
const log = desktopMakerLogger.child('provider-group-bindings');
const store = createOverrideSettingsFile<BindingFile>({
filePath: () => ownerScopedUserDataPath('provider-group-bindings.json'),
@@ -67,36 +79,68 @@ const store = createOverrideSettingsFile<BindingFile>({
maxBytes: 2 * 1024 * 1024,
logLoadedValue: false,
});
+const remoteStore = createOverrideSettingsFile<BindingFile>({
+ filePath: () => ownerScopedUserDataPath('provider-group-remote-bindings.json'),
+ scopeKey: activeOwnerScopeKey,
+ defaults: { sessions: {} },
+ normalize: normalizeRemote,
+ log,
+ label: 'provider-group-remote-bindings',
+ maxBytes: 2 * 1024 * 1024,
+ logLoadedValue: false,
+});
+/** 这个任务的绑定(本机的组或另一台电脑上的组,至多一个)。 */
export function readProviderGroupBinding(sessionId: string): ProviderGroupBinding | null {
if (!SESSION_ID_PATTERN.test(sessionId)) return null;
- return store.read().sessions[sessionId] ?? null;
+ return store.read().sessions[sessionId] ?? remoteStore.read().sessions[sessionId] ?? null;
}
+/** 本机的组的绑定(本机分配器据此统计各组内电脑上正在运行的任务)。 */
export function listProviderGroupBindings(): Record<string, ProviderGroupBinding> {
return store.read().sessions;
}
-export async function writeProviderGroupBinding(
+/** 另一台电脑上的组的绑定(据此向组所在电脑报告正在运行的任务)。 */
+export function listRemoteProviderGroupBindings(): Record<string, ProviderGroupBinding> {
+ return remoteStore.read().sessions;
+}
+
+async function writeIn(
+ target: typeof store,
sessionId: string,
- binding: { providerId: string; memberKey: string } | null,
- now: number = Date.now(),
+ binding: ProviderGroupBinding | null,
): Promise<void> {
- if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('Invalid session id');
- const normalized = binding ? normalizeBinding({ ...binding, at: now }) : null;
- if (binding && !normalized) throw new Error('Invalid provider group binding');
- await store.updateAtomic(({ value }) => {
+ await target.updateAtomic(({ value }) => {
const sessions = { ...value.sessions };
- if (normalized) sessions[sessionId] = normalized;
+ if (binding) sessions[sessionId] = binding;
else if (sessionId in sessions) delete sessions[sessionId];
else return {};
return { sessions: prune(sessions) };
});
}
+/**
+ * 写入(或解除)一个任务的绑定。带 `groupDeviceId` 写进另一台电脑的那份,并清掉本机那份里的同一任务,
+ * 反之亦然:一个任务只属于一个组。
+ */
+export async function writeProviderGroupBinding(
+ sessionId: string,
+ binding: { providerId: string; memberKey: string; groupDeviceId?: string | null } | null,
+ now: number = Date.now(),
+): Promise<void> {
+ if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('Invalid session id');
+ const remote = typeof binding?.groupDeviceId === 'string';
+ const normalized = binding ? normalizeBinding({ ...binding, at: now }, remote) : null;
+ if (binding && !normalized) throw new Error('Invalid provider group binding');
+ await writeIn(remote ? remoteStore : store, sessionId, normalized);
+ await writeIn(remote ? store : remoteStore, sessionId, null);
+}
+
/**
* 组内电脑被移出或整个组被删除后,解除指向它们的任务绑定:这些任务成为普通任务,之后即使同一台电脑
* 重新加入、或重建同一个组,也不会恢复自动换电脑。`keepMemberKeys` 为 null 表示整个组已删除。
+ * 只作用于本机的组。
*/
export async function pruneProviderGroupBindings(
providerId: string,
@@ -115,4 +159,4 @@ export async function pruneProviderGroupBindings(
});
}
-export const __testing = { normalize, prune };
+export const __testing = { normalize, normalizeRemote, prune };
diff --git a/apps/desktop/src/main/provider-group/directory.ts b/apps/desktop/src/main/provider-group/directory.ts
index d6f57b1d80..584b245746 100644
--- a/apps/desktop/src/main/provider-group/directory.ts
+++ b/apps/desktop/src/main/provider-group/directory.ts
@@ -56,6 +56,8 @@ const SHARE_REASON = /^\[REMOTE_AGENT_SHARE_(PAUSED|REMOVED|UNAVAILABLE)\]/;
export interface ProviderGroupDirectory {
resolveMembers(providerId: string, config: ProviderGroupConfig): Promise<ResolvedProviderGroupMember[]>;
listCandidates(providerId: string, config: ProviderGroupConfig | null): Promise<ProviderGroupCandidate[]>;
+ /** 那台电脑允许被远程调用的供应商(与组内电脑状态共用同一份短时缓存);读不到时抛错。 */
+ readDeviceCatalog(agentDeviceId: string): Promise<ProviderView[]>;
/** 忘掉缓存(换账号、组内电脑失败后需要现读)。 */
invalidate(agentDeviceId?: string): void;
}
@@ -216,6 +218,8 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
a.kind === b.kind ? a.label.localeCompare(b.label) : a.kind === 'device' ? -1 : 1);
},
+ readDeviceCatalog: readCatalog,
+
invalidate(agentDeviceId) {
if (agentDeviceId === undefined) {
catalogs.clear();
diff --git a/apps/desktop/src/main/provider-group/externalLoad.ts b/apps/desktop/src/main/provider-group/externalLoad.ts
new file mode 100644
index 0000000000..a21028b9b2
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/externalLoad.ts
@@ -0,0 +1,125 @@
+/**
+ * 经本组分出去、但不在本机任务表里的运行中任务(docs/product-rules/provider-groups.md §5):
+ * 同账号其他电脑经组运行的任务由那台电脑直接连到组内电脑,组所在电脑看不到它们,只能靠那台电脑报告。
+ *
+ * - 报告(lease):每台电脑整体上报它正在运行的经组任务,过期(电脑离开、崩溃)自动作废;`seq` 只增,
+ * 乱序到达的旧报告丢弃,不会盖掉新的。
+ * - 临时占用:刚选中、还没来得及报告的任务先记一会儿,同时开的几个任务不会全落到同一台。
+ *
+ * 只用于分摊负载(并发上限不因满载拒绝消息),不落盘;重启后等各电脑重新报告。
+ */
+import type { ProviderGroupRemoteLease } from '../../shared/providerGroup.js';
+
+/** 报告多久不刷新就作废(那台电脑每 60s 刷新一次)。 */
+export const PROVIDER_GROUP_LEASE_TTL_MS = 150_000;
+/** 选中后、报告到达前的临时占用时长。 */
+export const PROVIDER_GROUP_PROVISIONAL_MS = 30_000;
+/** 防止异常对端无限占内存的边界,远高于实际同账号电脑数。 */
+const MAX_CONTROLLERS = 256;
+const MAX_PROVISIONAL = 4096;
+
+export interface ProviderGroupExternalLoad {
+ /** 这台组内电脑上经本组运行、但不在本机任务表里的任务数。 */
+ running(providerId: string, memberKey: string): number;
+ /** 刚给某台电脑的某个任务选了组内电脑。 */
+ recordPick(controller: string, sessionId: string, providerId: string, memberKey: string): void;
+ /** 某台电脑的整份报告;返回 false = 比已有的旧,被丢弃。 */
+ replaceLeases(controller: string, seq: number, entries: readonly ProviderGroupRemoteLease[]): boolean;
+}
+
+interface LeaseSet {
+ seq: number;
+ at: number;
+ entries: readonly ProviderGroupRemoteLease[];
+}
+
+interface Provisional {
+ controller: string;
+ sessionId: string;
+ providerId: string;
+ memberKey: string;
+ until: number;
+}
+
+export function createProviderGroupExternalLoad(deps: { now(): number }): ProviderGroupExternalLoad {
+ const leases = new Map<string, LeaseSet>();
+ const provisional = new Map<string, Provisional>();
+ const provisionalKey = (controller: string, sessionId: string) => `${controller}\u0000${sessionId}`;
+
+ function liveLeases(controller: string): LeaseSet | null {
+ const set = leases.get(controller);
+ if (!set) return null;
+ if (deps.now() - set.at > PROVIDER_GROUP_LEASE_TTL_MS) {
+ // 过期的报告只作废内容,保留 seq:之后迟到的旧报告仍按序号丢弃。
+ if (set.entries.length) leases.set(controller, { ...set, entries: [] });
+ return null;
+ }
+ return set;
+ }
+
+ function sweepProvisional(now: number): void {
+ for (const [key, entry] of provisional) {
+ if (entry.until <= now) provisional.delete(key);
+ }
+ }
+
+ return {
+ running(providerId, memberKey) {
+ const now = deps.now();
+ sweepProvisional(now);
+ let count = 0;
+ const reported = new Set<string>();
+ for (const controller of leases.keys()) {
+ const set = liveLeases(controller);
+ if (!set) continue;
+ for (const lease of set.entries) {
+ reported.add(provisionalKey(controller, lease.sessionId));
+ if (lease.providerId === providerId && lease.memberKey === memberKey) count++;
+ }
+ }
+ for (const [key, entry] of provisional) {
+ // 已经报告过的任务以报告为准,不重复计数。
+ if (reported.has(key)) continue;
+ if (entry.providerId === providerId && entry.memberKey === memberKey) count++;
+ }
+ return count;
+ },
+
+ recordPick(controller, sessionId, providerId, memberKey) {
+ const now = deps.now();
+ sweepProvisional(now);
+ const key = provisionalKey(controller, sessionId);
+ provisional.delete(key);
+ if (provisional.size >= MAX_PROVISIONAL) {
+ const oldest = provisional.keys().next().value;
+ if (oldest !== undefined) provisional.delete(oldest);
+ }
+ provisional.set(key, { controller, sessionId, providerId, memberKey, until: now + PROVIDER_GROUP_PROVISIONAL_MS });
+ },
+
+ replaceLeases(controller, seq, entries) {
+ const previous = leases.get(controller);
+ if (previous && seq <= previous.seq) return false;
+ if (!previous && leases.size >= MAX_CONTROLLERS) {
+ // 淘汰最久没有报告的一台。
+ let oldestKey: string | null = null;
+ let oldestAt = Infinity;
+ for (const [key, set] of leases) {
+ if (set.at < oldestAt) {
+ oldestAt = set.at;
+ oldestKey = key;
+ }
+ }
+ if (oldestKey !== null) leases.delete(oldestKey);
+ }
+ leases.set(controller, { seq, at: deps.now(), entries: [...entries] });
+ // 报告里已有的任务不再需要临时占用。报告里还没有的保留到过期:这份报告可能早于那次选中。
+ for (const [key, entry] of provisional) {
+ if (entry.controller === controller && entries.some((lease) => lease.sessionId === entry.sessionId)) {
+ provisional.delete(key);
+ }
+ }
+ return true;
+ },
+ };
+}
diff --git a/apps/desktop/src/main/provider-group/ipc.ts b/apps/desktop/src/main/provider-group/ipc.ts
index cff102879c..f6e1bccd12 100644
--- a/apps/desktop/src/main/provider-group/ipc.ts
+++ b/apps/desktop/src/main/provider-group/ipc.ts
@@ -11,17 +11,20 @@ import {
normalizeProviderGroupConfig,
type ProviderGroupCommand,
type ProviderGroupConfig,
+ type ProviderGroupView,
} from '../../shared/providerGroup.js';
+import { tapWindowBroadcast } from '../device-link/broadcast-tap.js';
import { broadcast } from '../device-link/index.js';
import { getDeviceLinkInvokeContext } from '../device-link/invoke-context.js';
import { createLogger } from '../logger.js';
+import { MAKER_PUSH } from '../maker-ipc/channels.js';
import { assertTrustedAppRendererEvent } from '../security/trustedAppRenderer.js';
import { throwIpcError } from '../utils/ipcValidate.js';
import { pruneProviderGroupBindings } from './bindings.js';
import type { ProviderGroupDirectory } from './directory.js';
import type { ProviderGroupRouter } from './router.js';
-import { getProviderGroupDirectory, getProviderGroupRouter } from './runtime.js';
-import { readProviderGroup, writeProviderGroup } from './store.js';
+import { getProviderGroupDirectory, getProviderGroupRemoteClient, getProviderGroupRouter } from './runtime.js';
+import { listProviderGroups, readProviderGroup, writeProviderGroup } from './store.js';
const log = createLogger('provider-group');
@@ -34,12 +37,19 @@ export interface ProviderGroupCommandDeps {
pruneBindings(providerId: string, keep: ReadonlySet<string> | null): Promise<void>;
/** 当前账号:等远端目录期间换了账号时不写入(否则会把上一个账号的组写进新账号)。 */
ownerKey(): string;
+ /** 另一台电脑上某个供应商的组与组内电脑状态(设置页只读展示)。 */
+ remoteView(deviceId: string, providerId: string): Promise<ProviderGroupView>;
+ /** 本机全部组的设置(不读远端,模型列表据此收起本机组里的远程供应商)。 */
+ listGroups(): Record<string, ProviderGroupConfig>;
changed(providerId: string): void;
}
+const REMOTE_DEVICE_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
+
export function parseProviderGroupCommand(raw: unknown): ProviderGroupCommand {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throwIpcError('INVALID_PARAMS', 'command required');
const value = raw as Record<string, unknown>;
+ if (value.action === 'list') return { action: 'list' };
if (!isProviderGroupProviderId(value.providerId)) throwIpcError('INVALID_PARAMS', 'providerId required');
const providerId = value.providerId as string;
switch (value.action) {
@@ -47,6 +57,12 @@ export function parseProviderGroupCommand(raw: unknown): ProviderGroupCommand {
case 'candidates':
case 'delete':
return { action: value.action, providerId };
+ case 'remote-view': {
+ if (typeof value.deviceId !== 'string' || !REMOTE_DEVICE_ID_PATTERN.test(value.deviceId)) {
+ throwIpcError('INVALID_PARAMS', 'deviceId required');
+ }
+ return { action: 'remote-view', providerId, deviceId: value.deviceId as string };
+ }
case 'save': {
if (!value.config || typeof value.config !== 'object') throwIpcError('INVALID_PARAMS', 'config required');
return { action: 'save', providerId, config: value.config as ProviderGroupConfig };
@@ -58,10 +74,13 @@ export function parseProviderGroupCommand(raw: unknown): ProviderGroupCommand {
/** 业务体(依赖注入,单测直接调)。 */
export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps, command: ProviderGroupCommand) {
+ if (command.action === 'list') return deps.listGroups();
const { providerId } = command;
switch (command.action) {
case 'get':
return deps.router.view(providerId);
+ case 'remote-view':
+ return deps.remoteView(command.deviceId, providerId);
case 'candidates':
return deps.directory.listCandidates(providerId, deps.readGroup(providerId));
case 'delete':
@@ -110,14 +129,19 @@ export function registerProviderGroupIpc(): void {
writeGroup: writeProviderGroup,
pruneBindings: pruneProviderGroupBindings,
ownerKey: activeOwnerScopeKey,
+ remoteView: (deviceId, providerId) => getProviderGroupRemoteClient().view(deviceId, providerId),
+ listGroups: listProviderGroups,
changed: (providerId) => {
try {
broadcast(PROVIDER_GROUP_IPC.CHANGED, { providerId });
+ // 同账号其他电脑的模型列表按本机目录里的组摘要收起组内电脑:组变化后让它们重读目录。
+ tapWindowBroadcast(MAKER_PUSH.PROVIDER_CHANGED, {});
} catch (error) {
log.warn('provider group broadcast failed', { error: String(error) });
}
},
};
+
ipcMain.handle(PROVIDER_GROUP_IPC.COMMAND, async (event, raw: unknown) => {
if (getDeviceLinkInvokeContext()) throwIpcError('PERMISSION_DENIED', 'Provider groups are local only');
assertTrustedAppRendererEvent(event);
diff --git a/apps/desktop/src/main/provider-group/leaseReporter.ts b/apps/desktop/src/main/provider-group/leaseReporter.ts
new file mode 100644
index 0000000000..fde79b435e
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/leaseReporter.ts
@@ -0,0 +1,110 @@
+/**
+ * 向组所在电脑报告这台电脑经它的组运行、正在跑的任务(docs/product-rules/provider-groups.md §5):
+ * 任务由这台电脑直接连到组内电脑,组所在电脑看不到,只能靠这里报告,它的「最少占用」与并发上限才算得准。
+ *
+ * - 任务开始 / 结束一轮时防抖后报告;有任务在跑时每分钟再报一次(组所在电脑 150s 收不到就作废);
+ * - 每次报告是这台电脑在那台组上的完整一份,序号只增(按时间生成,重启后仍比之前大);
+ * - 只用于分摊负载,报告失败只记日志,不影响任务。
+ */
+import type { ProviderGroupRemoteLease } from '../../shared/providerGroup.js';
+import type { ProviderGroupBinding } from './bindings.js';
+
+export const PROVIDER_GROUP_LEASE_DEBOUNCE_MS = 1_000;
+export const PROVIDER_GROUP_LEASE_HEARTBEAT_MS = 60_000;
+
+export interface ProviderGroupLeaseReporterDeps {
+ listRemoteBindings(): Record<string, ProviderGroupBinding>;
+ isTurnRunning(sessionId: string): boolean;
+ send(ownerDeviceId: string, seq: number, entries: ProviderGroupRemoteLease[]): Promise<void>;
+ now(): number;
+ log: { warn(message: string, meta?: Record<string, unknown>): void };
+ setTimeout?: (fn: () => void, ms: number) => unknown;
+ clearTimeout?: (handle: unknown) => void;
+}
+
+export interface ProviderGroupLeaseReporter {
+ /** 某个任务开始或结束了一轮(或被关闭)。 */
+ notify(sessionId: string): void;
+ dispose(): void;
+}
+
+export function createProviderGroupLeaseReporter(deps: ProviderGroupLeaseReporterDeps): ProviderGroupLeaseReporter {
+ const schedule = deps.setTimeout ?? ((fn, ms) => {
+ const timer = setTimeout(fn, ms);
+ (timer as { unref?: () => void }).unref?.();
+ return timer;
+ });
+ const cancel = deps.clearTimeout ?? ((handle) => clearTimeout(handle as ReturnType<typeof setTimeout>));
+ /** 上次报给每台组所在电脑的内容(按序列化比较);报过空的就不再重复报空。 */
+ const lastSent = new Map<string, string>();
+ let counter = 0;
+ let debounce: unknown = null;
+ let heartbeat: unknown = null;
+ let disposed = false;
+
+ function nextSeq(): number {
+ counter = (counter + 1) % 1000;
+ return deps.now() * 1000 + counter;
+ }
+
+ function collect(): Map<string, ProviderGroupRemoteLease[]> {
+ const byOwner = new Map<string, ProviderGroupRemoteLease[]>();
+ for (const [sessionId, binding] of Object.entries(deps.listRemoteBindings())) {
+ if (!binding.groupDeviceId) continue;
+ const entries = byOwner.get(binding.groupDeviceId) ?? [];
+ if (deps.isTurnRunning(sessionId)) entries.push({ sessionId, providerId: binding.providerId, memberKey: binding.memberKey });
+ byOwner.set(binding.groupDeviceId, entries);
+ }
+ return byOwner;
+ }
+
+ function flush(force: boolean): void {
+ if (disposed) return;
+ const byOwner = collect();
+ // 之前报过、现在已经没有绑定的组所在电脑:补报一次空,让它立刻放掉。
+ for (const owner of lastSent.keys()) if (!byOwner.has(owner)) byOwner.set(owner, []);
+ let anyRunning = false;
+ for (const [owner, entries] of byOwner) {
+ entries.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+ const serialized = JSON.stringify(entries);
+ if (entries.length) anyRunning = true;
+ const previous = lastSent.get(owner);
+ if (previous === undefined && !entries.length) continue;
+ if (!force && previous === serialized) continue;
+ if (!entries.length) lastSent.delete(owner);
+ else lastSent.set(owner, serialized);
+ void deps.send(owner, nextSeq(), entries).catch((error) => {
+ // 下次心跳或下一次变化时重报:清掉记录,避免以为已经报过。
+ if (entries.length) lastSent.set(owner, '');
+ deps.log.warn('provider group: reporting running tasks failed', {
+ error: error instanceof Error ? error.message : String(error),
+ });
+ });
+ }
+ if (heartbeat !== null) {
+ cancel(heartbeat);
+ heartbeat = null;
+ }
+ if (anyRunning) heartbeat = schedule(() => {
+ heartbeat = null;
+ flush(true);
+ }, PROVIDER_GROUP_LEASE_HEARTBEAT_MS);
+ }
+
+ return {
+ notify() {
+ if (disposed || debounce !== null) return;
+ debounce = schedule(() => {
+ debounce = null;
+ flush(false);
+ }, PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ },
+ dispose() {
+ disposed = true;
+ if (debounce !== null) cancel(debounce);
+ if (heartbeat !== null) cancel(heartbeat);
+ debounce = null;
+ heartbeat = null;
+ },
+ };
+}
diff --git a/apps/desktop/src/main/provider-group/remoteClient.ts b/apps/desktop/src/main/provider-group/remoteClient.ts
new file mode 100644
index 0000000000..664b45927b
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/remoteClient.ts
@@ -0,0 +1,97 @@
+/**
+ * 同账号其他电脑这一侧:经 `provider-group:remote` 问组所在电脑(docs/product-rules/provider-groups.md §4–§6)。
+ *
+ * 组所在电脑是旧版本(`CHANNEL_NOT_ALLOWED`)或这个供应商已经没有组时,`pick` 返回 `none`,调用方照常
+ * 直接在组所在电脑上运行;其他失败原样抛出,由调用方决定(分配阶段按连不上组所在电脑处理)。
+ */
+import { PROVIDER_GROUP_REMOTE_CHANNEL } from '@cindy/device-link';
+
+import {
+ parseProviderGroupRemotePick,
+ parseProviderGroupRemoteView,
+ type ProviderGroupRemoteCoolCause,
+ type ProviderGroupRemoteLease,
+ type ProviderGroupRemotePick,
+ type ProviderGroupView,
+} from '../../shared/providerGroup.js';
+
+export type ProviderGroupRemoteInvoke = (
+ deviceId: string,
+ channel: string,
+ args: unknown[],
+) => Promise<{ ok: boolean; result?: unknown; error?: { code?: string; message?: string } }>;
+
+export interface ProviderGroupRemoteClient {
+ pick(ownerDeviceId: string, input: {
+ sessionId: string;
+ providerId: string;
+ agentKind: 'claude-code' | 'codex' | 'pi';
+ model: string;
+ exclude: readonly string[];
+ }): Promise<ProviderGroupRemotePick>;
+ cool(ownerDeviceId: string, input: {
+ providerId: string;
+ memberKey: string;
+ cause: ProviderGroupRemoteCoolCause;
+ resetAt?: number | null;
+ }): Promise<void>;
+ leases(ownerDeviceId: string, seq: number, entries: readonly ProviderGroupRemoteLease[]): Promise<void>;
+ view(ownerDeviceId: string, providerId: string): Promise<ProviderGroupView>;
+}
+
+/** 组所在电脑没有这个通道(旧版本):当作没有组。 */
+export class ProviderGroupRemoteUnsupportedError extends Error {
+ constructor() {
+ super('[UNSUPPORTED_CAPABILITY] the computer with the provider group does not support it');
+ this.name = 'ProviderGroupRemoteUnsupportedError';
+ }
+}
+
+export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvoke): ProviderGroupRemoteClient {
+ async function call(ownerDeviceId: string, request: Record<string, unknown>): Promise<unknown> {
+ const result = await invoke(ownerDeviceId, PROVIDER_GROUP_REMOTE_CHANNEL, [request]);
+ if (result.ok) return result.result;
+ if (result.error?.code === 'CHANNEL_NOT_ALLOWED') throw new ProviderGroupRemoteUnsupportedError();
+ const message = result.error?.message ?? 'provider group request failed';
+ throw Object.assign(new Error(/^\[[A-Z_]+\]/.test(message) ? message : `[REMOTE_AGENT_UNAVAILABLE] ${message}`), {
+ code: result.error?.code,
+ });
+ }
+
+ return {
+ async pick(ownerDeviceId, input) {
+ try {
+ const raw = await call(ownerDeviceId, {
+ action: 'pick',
+ sessionId: input.sessionId,
+ providerId: input.providerId,
+ agentKind: input.agentKind,
+ model: input.model,
+ exclude: [...input.exclude],
+ });
+ return parseProviderGroupRemotePick(raw, input.providerId);
+ } catch (error) {
+ if (error instanceof ProviderGroupRemoteUnsupportedError) return { kind: 'none' };
+ throw error;
+ }
+ },
+
+ async cool(ownerDeviceId, input) {
+ await call(ownerDeviceId, {
+ action: 'cool',
+ providerId: input.providerId,
+ memberKey: input.memberKey,
+ cause: input.cause,
+ ...(typeof input.resetAt === 'number' ? { resetAt: input.resetAt } : {}),
+ });
+ },
+
+ async leases(ownerDeviceId, seq, entries) {
+ await call(ownerDeviceId, { action: 'leases', seq, entries: entries.map((e) => ({ ...e })) });
+ },
+
+ async view(ownerDeviceId, providerId) {
+ return parseProviderGroupRemoteView(await call(ownerDeviceId, { action: 'view', providerId }), providerId);
+ },
+ };
+}
diff --git a/apps/desktop/src/main/provider-group/remoteHandler.ts b/apps/desktop/src/main/provider-group/remoteHandler.ts
new file mode 100644
index 0000000000..4376484e0f
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/remoteHandler.ts
@@ -0,0 +1,103 @@
+/**
+ * 组所在电脑处理同账号其他电脑的 `provider-group:remote` 请求(docs/product-rules/provider-groups.md §4–§6)。
+ *
+ * 那台电脑上的任务选了本机的这个供应商:先来问该用组里哪台,再自己直接连过去运行;出问题时报告
+ * 需要冷却的电脑,运行期间报告正在跑的任务,让本机的分配看到全组真实的负载。
+ *
+ * 只服务同账号电脑(dispatch 已拒绝受邀者与共享任务访客),且只对仍「允许被远程调用」的供应商提供组:
+ * 没开放的供应商对其他电脑本来就不可见。
+ */
+import {
+ parseProviderGroupRemoteRequest,
+ providerGroupSummaryForWire,
+ type ProviderGroupConfig,
+ type ProviderGroupRemotePick,
+ type ProviderGroupView,
+} from '../../shared/providerGroup.js';
+import type { ProviderGroupExternalLoad } from './externalLoad.js';
+import {
+ PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
+ PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
+ type ProviderGroupRouter,
+} from './router.js';
+
+/** 报告来的重置时刻最多信多远(账号用量上限最长按周重置),避免一台电脑被异常时刻长期冷却。 */
+export const PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS = 8 * 24 * 60 * 60_000;
+
+export interface ProviderGroupRemoteHandlerDeps {
+ router: ProviderGroupRouter;
+ externalLoad: ProviderGroupExternalLoad;
+ readGroup(providerId: string): ProviderGroupConfig | null;
+ /** 这个供应商仍对其他电脑开放(「允许被远程调用」)。 */
+ isRemoteAllowed(providerId: string): boolean;
+ now(): number;
+}
+
+/**
+ * 给同账号电脑的 `maker:provider:list` 补组摘要:只加在仍允许被远程调用、且建了组的供应商上。
+ * 结果里已有的 `group` 一律先去掉,只有本机设置能产生它。
+ */
+export function decorateProviderListWithGroups(
+ result: unknown,
+ readGroup: (providerId: string) => ProviderGroupConfig | null,
+): unknown {
+ if (!result || typeof result !== 'object' || Array.isArray(result)) return result;
+ const value = result as { providers?: unknown };
+ if (!Array.isArray(value.providers)) return result;
+ return {
+ ...value,
+ providers: value.providers.map((provider: unknown) => {
+ if (!provider || typeof provider !== 'object' || Array.isArray(provider)) return provider;
+ const entry = { ...(provider as Record<string, unknown>) };
+ delete entry.group;
+ const config = entry.remoteInvocationEnabled === true && typeof entry.id === 'string' ? readGroup(entry.id) : null;
+ if (config) entry.group = providerGroupSummaryForWire(config);
+ return entry;
+ }),
+ };
+}
+
+export async function handleProviderGroupRemote(
+ deps: ProviderGroupRemoteHandlerDeps,
+ controller: string,
+ raw: unknown,
+): Promise<ProviderGroupRemotePick | ProviderGroupView | Record<string, never>> {
+ const request = parseProviderGroupRemoteRequest(raw);
+ switch (request.action) {
+ case 'pick': {
+ const { providerId } = request;
+ if (!deps.isRemoteAllowed(providerId) || !deps.readGroup(providerId)) return { kind: 'none' };
+ const pick = await deps.router.pick({
+ providerId,
+ agentKind: request.agentKind,
+ model: request.model,
+ exclude: new Set(request.exclude),
+ });
+ if (pick.kind === 'none') return { kind: 'none' };
+ if (pick.kind === 'unavailable') return { kind: 'unavailable' };
+ deps.externalLoad.recordPick(controller, request.sessionId, providerId, pick.member.key);
+ const { key, kind, agentDeviceId, providerId: memberProviderId } = pick.member;
+ return { kind: 'member', member: { key, kind, agentDeviceId, providerId: memberProviderId }, label: pick.label };
+ }
+ case 'cool': {
+ const config = deps.readGroup(request.providerId);
+ if (!config || !config.members.some((m) => m.key === request.memberKey)) return {};
+ const now = deps.now();
+ const until = request.cause === 'usage-limit'
+ ? Math.min(
+ request.resetAt !== undefined && request.resetAt > now ? request.resetAt : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
+ now + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
+ )
+ : now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
+ deps.router.markCooling(request.providerId, request.memberKey, until);
+ return {};
+ }
+ case 'leases':
+ deps.externalLoad.replaceLeases(controller, request.seq, request.entries);
+ return {};
+ case 'view': {
+ if (!deps.isRemoteAllowed(request.providerId)) return { providerId: request.providerId, config: null, members: [] };
+ return deps.router.view(request.providerId);
+ }
+ }
+}
diff --git a/apps/desktop/src/main/provider-group/remoteRegistration.ts b/apps/desktop/src/main/provider-group/remoteRegistration.ts
new file mode 100644
index 0000000000..37607681f5
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/remoteRegistration.ts
@@ -0,0 +1,28 @@
+/**
+ * 把供应商组接到设备互联(docs/product-rules/provider-groups.md §4):同账号其他电脑的
+ * `provider-group:remote` 请求,以及给它们的 `maker:provider:list` 补组摘要。
+ * 只服务同账号电脑,dispatch 已拒绝受邀者与共享任务访客。
+ */
+import { setProviderGroupRemoteHandler } from '../device-link/dispatch.js';
+import { isRemoteProviderInvocationAllowed } from '../maker-host/remote-provider-access-store.js';
+import {
+ decorateProviderListWithGroups,
+ handleProviderGroupRemote,
+ type ProviderGroupRemoteHandlerDeps,
+} from './remoteHandler.js';
+import { getProviderGroupExternalLoad, getProviderGroupRouter } from './runtime.js';
+import { readProviderGroup } from './store.js';
+
+export function registerProviderGroupRemoteHandler(): void {
+ const deps: ProviderGroupRemoteHandlerDeps = {
+ router: getProviderGroupRouter(),
+ externalLoad: getProviderGroupExternalLoad(),
+ readGroup: readProviderGroup,
+ isRemoteAllowed: isRemoteProviderInvocationAllowed,
+ now: () => Date.now(),
+ };
+ setProviderGroupRemoteHandler({
+ handle: (controller, raw) => handleProviderGroupRemote(deps, controller, raw),
+ decorateProviderList: (result) => decorateProviderListWithGroups(result, readProviderGroup),
+ });
+}
diff --git a/apps/desktop/src/main/provider-group/router.ts b/apps/desktop/src/main/provider-group/router.ts
index d4f29edde9..1b811f02d8 100644
--- a/apps/desktop/src/main/provider-group/router.ts
+++ b/apps/desktop/src/main/provider-group/router.ts
@@ -30,6 +30,11 @@ export interface ProviderGroupRouterDeps {
listBindings(): Record<string, ProviderGroupBinding>;
/** 这个任务现在是否正在运行一轮。 */
isTurnRunning(sessionId: string): boolean;
+ /**
+ * 经本组分出去、但不在本机任务表里的运行中任务(同账号其他电脑报来的、刚选中还没报来的)。
+ * 不提供 = 只算本机任务。
+ */
+ externalRunning?(providerId: string, memberKey: string): number;
now(): number;
random(): number;
}
@@ -97,7 +102,7 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
count++;
}
}
- return count;
+ return count + (deps.externalRunning?.(providerId, memberKey) ?? 0);
}
/** 那台能为新会话提供这个模型:停用、已退役、需要付费的都不算(与新建任务、切模型同一准入)。 */
diff --git a/apps/desktop/src/main/provider-group/runtime.ts b/apps/desktop/src/main/provider-group/runtime.ts
index eb8fae6b4f..c85a4b0d0f 100644
--- a/apps/desktop/src/main/provider-group/runtime.ts
+++ b/apps/desktop/src/main/provider-group/runtime.ts
@@ -5,7 +5,10 @@
* 目录缓存、冷却、轮询位置都属于当前账号:换账号后另起一份,旧账号还在路上的远端读取只落进旧的那份,
* 新账号看不到旧账号的电脑与冷却。调用方拿到的是固定的门面,每次调用按当前账号转发。
*/
+import type { ProviderView } from '@cindy/model-providers';
+
import { activeOwnerScopeKey } from '../appSessionState.js';
+import { readProviderGroupSummary } from '../../shared/providerGroup.js';
import { getReceivedShares } from '../device-link/providerShareGuest.js';
import { handleListDevices, defaultDeps as deviceDirectoryDeps } from '../device-link/ipc.js';
import { remoteBackgroundInvoke } from '../device-link/index.js';
@@ -15,13 +18,17 @@ import { getDesktopProviderService } from '../maker-host/createDesktopProviderSe
import { readDeviceProviderViews } from '../remote-agent/controller/deviceCatalog.js';
import { listProviderGroupBindings } from './bindings.js';
import { createProviderGroupDirectory, type ProviderGroupDirectory } from './directory.js';
+import { createProviderGroupExternalLoad, type ProviderGroupExternalLoad } from './externalLoad.js';
+import { createProviderGroupRemoteClient, type ProviderGroupRemoteClient } from './remoteClient.js';
import { createProviderGroupRouter, type ProviderGroupRouter } from './router.js';
+import type { ProviderGroupRemoteGroups } from './service.js';
import { readProviderGroup } from './store.js';
interface OwnerRuntime {
owner: string;
directory: ProviderGroupDirectory;
router: ProviderGroupRouter;
+ externalLoad: ProviderGroupExternalLoad;
}
let current: OwnerRuntime | null = null;
@@ -39,24 +46,34 @@ function runtimeForActiveOwner(): OwnerRuntime {
isMobilePlatform: (platform) => isMobilePlatform(platform),
now: () => Date.now(),
});
+ const externalLoad = createProviderGroupExternalLoad({ now: () => Date.now() });
const router = createProviderGroupRouter({
directory,
readGroup: readProviderGroup,
listBindings: listProviderGroupBindings,
isTurnRunning: (sessionId) => isTurnRunning(sessionId),
+ externalRunning: (providerId, memberKey) => externalLoad.running(providerId, memberKey),
now: () => Date.now(),
random: () => Math.random(),
});
- current = { owner, directory, router };
+ current = { owner, directory, router, externalLoad };
return current;
}
const directoryFacade: ProviderGroupDirectory = {
resolveMembers: (providerId, config) => runtimeForActiveOwner().directory.resolveMembers(providerId, config),
listCandidates: (providerId, config) => runtimeForActiveOwner().directory.listCandidates(providerId, config),
+ readDeviceCatalog: (agentDeviceId) => runtimeForActiveOwner().directory.readDeviceCatalog(agentDeviceId),
invalidate: (agentDeviceId) => runtimeForActiveOwner().directory.invalidate(agentDeviceId),
};
+const externalLoadFacade: ProviderGroupExternalLoad = {
+ running: (providerId, memberKey) => runtimeForActiveOwner().externalLoad.running(providerId, memberKey),
+ recordPick: (controller, sessionId, providerId, memberKey) =>
+ runtimeForActiveOwner().externalLoad.recordPick(controller, sessionId, providerId, memberKey),
+ replaceLeases: (controller, seq, entries) => runtimeForActiveOwner().externalLoad.replaceLeases(controller, seq, entries),
+};
+
const routerFacade: ProviderGroupRouter = {
pick: (input) => runtimeForActiveOwner().router.pick(input),
view: (providerId) => runtimeForActiveOwner().router.view(providerId),
@@ -76,6 +93,42 @@ export function getProviderGroupRouter(): ProviderGroupRouter {
return routerFacade;
}
+export function getProviderGroupExternalLoad(): ProviderGroupExternalLoad {
+ return externalLoadFacade;
+}
+
+let remoteClient: ProviderGroupRemoteClient | null = null;
+
+/** 问其他电脑上的组(无状态,按调用时的账号经设备互联发出)。 */
+export function getProviderGroupRemoteClient(): ProviderGroupRemoteClient {
+ remoteClient ??= createProviderGroupRemoteClient(remoteBackgroundInvoke);
+ return remoteClient;
+}
+
+/**
+ * 任务生命周期用的「另一台电脑上的组」:组设置读那台目录里的组摘要(与组内电脑状态共用同一份短时缓存),
+ * 选电脑、冷却与状态经 `provider-group:remote` 问那台。
+ */
+export function getProviderGroupRemoteGroups(): ProviderGroupRemoteGroups {
+ const client = getProviderGroupRemoteClient();
+ return {
+ async readGroup(ownerDeviceId, providerId) {
+ let views: ProviderView[];
+ try {
+ views = await directoryFacade.readDeviceCatalog(ownerDeviceId);
+ } catch {
+ return undefined;
+ }
+ const view = views.find((candidate) => candidate.id === providerId);
+ return view ? readProviderGroupSummary((view as { group?: unknown }).group, providerId) : null;
+ },
+ pick: (ownerDeviceId, input) => client.pick(ownerDeviceId, input),
+ cool: (ownerDeviceId, input) => client.cool(ownerDeviceId, input),
+ view: (ownerDeviceId, providerId) => client.view(ownerDeviceId, providerId),
+ invalidate: (ownerDeviceId) => directoryFacade.invalidate(ownerDeviceId),
+ };
+}
+
/** register 装配会话表后注入:分配器据此统计「正在运行」。 */
export function setProviderGroupTurnProbe(probe: (sessionId: string) => boolean): void {
isTurnRunning = probe;
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index dab0c8113d..f5df10b01b 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -7,6 +7,11 @@
* 同一轮每台最多试一次,全部失败才交回原有的报错 / 等额度重置流程。
* 3. **发送前**:已归组的任务所在那台现在不能用时,先交接到下一台,这条消息直接发到新电脑。
*
+ * 组可以在本机,也可以在同账号的另一台电脑上(§4「同账号直连」):任务选了另一台电脑的某个供应商、
+ * 而那台把它建成了组时,选哪台由组所在电脑决定,这台电脑直接连到选中的那台运行;那台出问题时由
+ * 这台电脑(任务所在、看得到错误、有对话记录)换电脑,并把需要冷却的电脑报告给组所在电脑。两种组共用
+ * 下面同一套流程,差别只在「组来源」:选电脑、冷却、组员状态问谁,以及组员坐标怎么换成本机的位置。
+ *
* 依赖全部注入,由 maker-ipc/register 装配;这里不直接碰数据库、会话与输入协调器。
*/
import type { AgentKind } from '@cindy/maker-core';
@@ -15,8 +20,15 @@ import {
USAGE_LIMIT_RESET_AUTO_RESUME_REASON,
type AutoResumeInfo,
} from '../../shared/agentInputQueue.js';
-import type { ProviderGroupConfig, ProviderGroupMember } from '../../shared/providerGroup.js';
+import type {
+ ProviderGroupConfig,
+ ProviderGroupMember,
+ ProviderGroupRemoteCoolCause,
+ ProviderGroupRemotePick,
+ ProviderGroupView,
+} from '../../shared/providerGroup.js';
import { providerGroupMemberKey } from '../../shared/providerGroup.js';
+import { isProviderShareAgentDeviceId } from '../../shared/providerShare.js';
import type { InterruptedTurnErrorSignals } from '../maker-ipc/interruptedTurnAutoResume.js';
import type { ProviderGroupBinding } from './bindings.js';
import type { ProviderGroupDirectory } from './directory.js';
@@ -52,10 +64,17 @@ export interface ProviderGroupRoute {
export interface ProviderGroupStartContext {
sessionId: string;
groupProviderId: string;
+ /** 组在另一台电脑上时为那台的设备 id;本机的组为 null。 */
+ groupDeviceId: string | null;
agentKind: AgentKind;
model: string;
member: ProviderGroupMember;
route: ProviderGroupRoute;
+ /**
+ * 调用方要用 route 覆盖启动参数(含改回本机运行)。本机的组只在原本没有指定位置时才改;
+ * 另一台电脑上的组总是覆盖:任务原本指向组所在电脑,选中的可能是任何一台。
+ */
+ overrideRoute: boolean;
/** 任务原本的(本机)来源,换回本机时还原。 */
localProviderId: string | null;
}
@@ -65,12 +84,44 @@ interface Logger {
warn(message: string, meta?: Record<string, unknown>): void;
}
+/** 另一台电脑上的组(经设备互联问组所在电脑)。 */
+export interface ProviderGroupRemoteGroups {
+ /**
+ * 组所在电脑目录里这个供应商的组:读到了返回组或 null(那台没有这个组 / 旧版本),读不到(离线、
+ * 连不上)返回 undefined——读不到时不能当作组已删除去解除绑定。
+ */
+ readGroup(ownerDeviceId: string, providerId: string): Promise<ProviderGroupConfig | null | undefined>;
+ pick(ownerDeviceId: string, input: {
+ sessionId: string;
+ providerId: string;
+ agentKind: 'claude-code' | 'codex' | 'pi';
+ model: string;
+ exclude: readonly string[];
+ }): Promise<ProviderGroupRemotePick>;
+ cool(ownerDeviceId: string, input: {
+ providerId: string;
+ memberKey: string;
+ cause: ProviderGroupRemoteCoolCause;
+ resetAt: number | null;
+ }): Promise<void>;
+ view(ownerDeviceId: string, providerId: string): Promise<ProviderGroupView>;
+ /** 忘掉组所在电脑目录的缓存(组员失败后下次现读)。 */
+ invalidate(ownerDeviceId: string): void;
+}
+
export interface ProviderGroupServiceDeps {
router: ProviderGroupRouter;
directory: ProviderGroupDirectory;
readGroup(providerId: string): ProviderGroupConfig | null;
+ /** 另一台电脑上的组;不提供 = 只处理本机的组。 */
+ remote?: ProviderGroupRemoteGroups;
+ /** 本机设备 id(另一台电脑的组里,本机自己可能也是一台组内电脑)。 */
+ localDeviceId?(): string | null;
readBinding(sessionId: string): ProviderGroupBinding | null;
- writeBinding(sessionId: string, binding: { providerId: string; memberKey: string } | null): Promise<void>;
+ writeBinding(
+ sessionId: string,
+ binding: { providerId: string; memberKey: string; groupDeviceId?: string | null } | null,
+ ): Promise<void>;
readSessionRow(sessionId: string): Promise<ProviderGroupSessionRow | null>;
/** 隐式来源(provider_id 为空)时本机实际会用的来源。 */
resolveImplicitProvider(agentKind: AgentKind, model: string): Promise<string | null>;
@@ -137,36 +188,191 @@ export interface ProviderGroupService {
/** 发送前检查组内电脑状态的上限:读不到就照常发送,不让一台卡住的电脑拖慢每次发送。 */
export const PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS = 3_000;
-function memberRoute(member: ProviderGroupMember, localProviderId: string | null): ProviderGroupRoute {
- return member.kind === 'local'
- ? { agentDeviceId: null, providerId: localProviderId }
- : { agentDeviceId: member.agentDeviceId, providerId: member.providerId };
-}
-
function errorText(error: unknown): string {
return error instanceof Error ? error.message : typeof error === 'string' ? error : '';
}
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T | null> {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ return Promise.race([
+ promise.catch(() => null),
+ new Promise<null>((resolve) => {
+ timer = setTimeout(() => resolve(null), ms);
+ }),
+ ]).finally(() => clearTimeout(timer));
+}
+
+type SourcePick =
+ | { kind: 'none' }
+ | { kind: 'unavailable' }
+ | { kind: 'member'; member: ProviderGroupMember; label: string; labelOf(memberKey: string): string | undefined };
+
+/** 组来源:本机的组,或同账号另一台电脑上的组。 */
+interface GroupSource {
+ /** null = 本机的组。 */
+ ownerDeviceId: string | null;
+ /** 组设置;undefined = 现在读不到(不能据此解除绑定)。 */
+ readGroup(providerId: string): Promise<ProviderGroupConfig | null | undefined>;
+ pick(input: {
+ sessionId: string;
+ providerId: string;
+ config: ProviderGroupConfig;
+ agentKind: AgentKind;
+ model: string;
+ exclude: ReadonlySet<string>;
+ }): Promise<SourcePick>;
+ cool(providerId: string, memberKey: string, cause: ProviderGroupSwitchCause, resetAt: number | null): void;
+ /** 发送前:这台现在该不该换掉;null = 读不到,照常发送。 */
+ shouldMoveAway(providerId: string, config: ProviderGroupConfig, memberKey: string): Promise<{ reason: string } | false | null>;
+ invalidate(member: ProviderGroupMember): void;
+ /** 任务记录里 Agent 的位置对应组里哪一项(组所在电脑视角的键);不对应任何组员返回 null。 */
+ memberKeyOf(groupProviderId: string, row: ProviderGroupSessionRow): Promise<string | null>;
+ /** 组员 → 本机启动参数里的位置。 */
+ routeOf(member: ProviderGroupMember, localProviderId: string | null): ProviderGroupRoute;
+}
+
export function createProviderGroupService(deps: ProviderGroupServiceDeps): ProviderGroupService {
const { router } = deps;
/** 进行中的自动换电脑:用户亲自接手(发消息、重试、换模型)时标记作废。只在换电脑期间登记。 */
const runningSwitches = new Map<string, Set<{ superseded: boolean }>>();
+ function coolUntil(cause: ProviderGroupSwitchCause, resetAt: number | null): number {
+ const now = deps.now();
+ return cause === 'usage-limit'
+ ? (resetAt !== null && resetAt > now ? resetAt : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS)
+ : now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
+ }
+
+ const localSource: GroupSource = {
+ ownerDeviceId: null,
+ async readGroup(providerId) {
+ return deps.readGroup(providerId);
+ },
+ async pick({ providerId, agentKind, model, exclude }) {
+ const pick = await router.pick({ providerId, agentKind, model, exclude });
+ if (pick.kind !== 'member') return { kind: pick.kind };
+ return {
+ kind: 'member',
+ member: pick.member,
+ label: pick.label,
+ labelOf: (key) => pick.resolved.find((r) => r.member.key === key)?.label,
+ };
+ },
+ cool(providerId, memberKey, cause, resetAt) {
+ router.markCooling(providerId, memberKey, coolUntil(cause, resetAt));
+ },
+ async shouldMoveAway(providerId, config, memberKey) {
+ const resolved = await withTimeout(deps.directory.resolveMembers(providerId, config), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
+ const state = resolved?.find((r) => r.member.key === memberKey);
+ if (!state) return null;
+ const cooling = router.coolingUntil(providerId, memberKey) !== null;
+ if (state.state === 'ok' && !cooling) return false;
+ return { reason: cooling ? 'cooling' : state.state };
+ },
+ invalidate(member) {
+ deps.directory.invalidate(member.agentDeviceId ?? undefined);
+ },
+ async memberKeyOf(groupProviderId, row) {
+ if (row.agentDeviceId) {
+ return row.providerId ? providerGroupMemberKey(row.agentDeviceId, row.providerId) : null;
+ }
+ const provider = row.providerId
+ ?? (row.model ? await deps.resolveImplicitProvider(row.agentKind, row.model) : null);
+ return provider === groupProviderId ? providerGroupMemberKey(null, provider) : null;
+ },
+ routeOf(member, localProviderId) {
+ return member.kind === 'local'
+ ? { agentDeviceId: null, providerId: localProviderId }
+ : { agentDeviceId: member.agentDeviceId, providerId: member.providerId };
+ },
+ };
+
+ const remoteSources = new Map<string, GroupSource>();
+
+ function remoteSource(ownerDeviceId: string): GroupSource {
+ const existing = remoteSources.get(ownerDeviceId);
+ if (existing) return existing;
+ const remote = deps.remote!;
+ const self = () => deps.localDeviceId?.() ?? null;
+ const source: GroupSource = {
+ ownerDeviceId,
+ readGroup: (providerId) => remote.readGroup(ownerDeviceId, providerId),
+ async pick({ sessionId, providerId, config, agentKind, model, exclude }) {
+ const pick = await remote.pick(ownerDeviceId, {
+ sessionId,
+ providerId,
+ agentKind: agentKind as 'claude-code' | 'codex' | 'pi',
+ model,
+ exclude: [...exclude],
+ });
+ if (pick.kind !== 'member') return { kind: pick.kind };
+ const labelOf = (key: string) => config.members.find((m) => m.key === key)?.label;
+ // 组设置以组所在电脑为准;本机读到的那份可能稍旧,缺的组员按回包补齐。
+ const member = config.members.find((m) => m.key === pick.member.key)
+ ?? { ...pick.member, limit: 1, weight: 1, paused: false };
+ return { kind: 'member', member, label: pick.label, labelOf };
+ },
+ cool(providerId, memberKey, cause, resetAt) {
+ // 连不上只由发现它的这台电脑自己避开(这一轮已试过),不替全组判断:可能只是这台连不过去。
+ if (cause === 'unavailable') return;
+ void remote.cool(ownerDeviceId, { providerId, memberKey, cause, resetAt }).catch((error) => {
+ deps.log.warn('provider group: reporting a computer to cool down failed', { error: errorText(error) });
+ });
+ },
+ async shouldMoveAway(providerId, _config, memberKey) {
+ const view = await withTimeout(remote.view(ownerDeviceId, providerId), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
+ const state = view?.members.find((m) => m.key === memberKey)?.state;
+ if (!state) return null;
+ return state === 'offline' || state === 'unavailable' || state === 'cooling' ? { reason: state } : false;
+ },
+ invalidate() {
+ remote.invalidate(ownerDeviceId);
+ },
+ async memberKeyOf(groupProviderId, row) {
+ // 本机坐标 → 组所在电脑坐标。
+ if (row.agentDeviceId === ownerDeviceId) {
+ return row.providerId === groupProviderId ? providerGroupMemberKey(null, groupProviderId) : null;
+ }
+ if (row.agentDeviceId) {
+ return row.providerId ? providerGroupMemberKey(row.agentDeviceId, row.providerId) : null;
+ }
+ const me = self();
+ if (!me) return null;
+ const provider = row.providerId
+ ?? (row.model ? await deps.resolveImplicitProvider(row.agentKind, row.model) : null);
+ return provider ? providerGroupMemberKey(me, provider) : null;
+ },
+ routeOf(member) {
+ // 组所在电脑坐标 → 本机启动参数:它自己是组所在电脑;组里的「本机这台」就是这里。
+ if (member.kind === 'local') return { agentDeviceId: ownerDeviceId, providerId: member.providerId };
+ if (member.kind === 'device' && member.agentDeviceId === self()) {
+ return { agentDeviceId: null, providerId: member.providerId };
+ }
+ return { agentDeviceId: member.agentDeviceId, providerId: member.providerId };
+ },
+ };
+ remoteSources.set(ownerDeviceId, source);
+ return source;
+ }
+
+ function sourceFor(groupDeviceId: string | null | undefined): GroupSource | null {
+ if (!groupDeviceId) return localSource;
+ return deps.remote ? remoteSource(groupDeviceId) : null;
+ }
+
+ function bindingFor(source: GroupSource, providerId: string, memberKey: string) {
+ return { providerId, memberKey, ...(source.ownerDeviceId ? { groupDeviceId: source.ownerDeviceId } : {}) };
+ }
+
/** 任务记录里 Agent 实际所在位置对应的组内电脑键;不在组里返回 null。 */
async function actualMemberKey(
+ source: GroupSource,
groupProviderId: string,
config: ProviderGroupConfig,
row: ProviderGroupSessionRow,
): Promise<string | null> {
if (row.remoteHostId) return null;
- let key: string | null;
- if (row.agentDeviceId) {
- key = row.providerId ? providerGroupMemberKey(row.agentDeviceId, row.providerId) : null;
- } else {
- const provider = row.providerId
- ?? (row.model ? await deps.resolveImplicitProvider(row.agentKind, row.model) : null);
- key = provider === groupProviderId ? providerGroupMemberKey(null, provider) : null;
- }
+ const key = await source.memberKeyOf(groupProviderId, row);
return key !== null && config.members.some((m) => m.key === key) ? key : null;
}
@@ -176,39 +382,23 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
*/
async function verifyBinding(
sessionId: string,
+ source: GroupSource,
binding: ProviderGroupBinding,
config: ProviderGroupConfig | null,
row: ProviderGroupSessionRow,
): Promise<ProviderGroupMember | null> {
- const key = config ? await actualMemberKey(binding.providerId, config, row) : null;
+ const key = config ? await actualMemberKey(source, binding.providerId, config, row) : null;
if (key === null) {
await deps.writeBinding(sessionId, null);
return null;
}
if (key !== binding.memberKey) {
- await deps.writeBinding(sessionId, { providerId: binding.providerId, memberKey: key });
+ await deps.writeBinding(sessionId, bindingFor(source, binding.providerId, key));
return null;
}
return config!.members.find((m) => m.key === key) ?? null;
}
- function cool(providerId: string, memberKey: string, cause: ProviderGroupSwitchCause, resetAt: number | null): void {
- const now = deps.now();
- const until = cause === 'usage-limit'
- ? (resetAt !== null && resetAt > now ? resetAt : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS)
- : now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
- router.markCooling(providerId, memberKey, until);
- }
-
- async function pickNext(
- groupProviderId: string,
- agentKind: AgentKind,
- model: string,
- exclude: ReadonlySet<string>,
- ) {
- return router.pick({ providerId: groupProviderId, agentKind, model, exclude });
- }
-
/**
* 交接换电脑时不考虑的组内电脑:这一轮试过的,以及与当前所在同一台电脑上的其他账号——首版的交接只能
* 换电脑,同一台电脑上换账号不会生效(新任务分配不受此限)。
@@ -228,25 +418,41 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
/** 交接失败后以任务记录为准还原绑定(交接可能已改了位置,也可能没有)。 */
async function restoreBindingAfterFailedSwitch(
sessionId: string,
+ source: GroupSource,
groupProviderId: string,
config: ProviderGroupConfig,
): Promise<void> {
const row = await deps.readSessionRow(sessionId);
- const key = row ? await actualMemberKey(groupProviderId, config, row) : null;
- await deps.writeBinding(sessionId, key ? { providerId: groupProviderId, memberKey: key } : null);
+ const key = row ? await actualMemberKey(source, groupProviderId, config, row) : null;
+ await deps.writeBinding(sessionId, key ? bindingFor(source, groupProviderId, key) : null);
+ }
+
+ /** 读到的绑定与组设置(组所在电脑读不到时返回 null,什么都不动)。 */
+ async function loadBound(sessionId: string): Promise<{
+ binding: ProviderGroupBinding;
+ source: GroupSource;
+ config: ProviderGroupConfig | null;
+ } | null> {
+ const binding = deps.readBinding(sessionId);
+ if (!binding) return null;
+ const source = sourceFor(binding.groupDeviceId);
+ if (!source) return null;
+ const config = await source.readGroup(binding.providerId).catch(() => undefined);
+ if (config === undefined) return null;
+ return { binding, source, config };
}
/** true = 已由本机制处理(含它自己交回原有处理);false = 不归它管,调用方照常交回。 */
async function failover(sessionId: string, signals: InterruptedTurnErrorSignals, token: number): Promise<boolean> {
- const binding = deps.readBinding(sessionId);
const cause = classifyProviderGroupSwitchCause(signals);
- if (!binding || !cause) return false;
- const config = deps.readGroup(binding.providerId);
- if (!config?.autoSwitch) return false;
+ if (!cause || !deps.readBinding(sessionId)) return false;
+ const bound = await loadBound(sessionId);
+ if (!bound?.config?.autoSwitch) return false;
+ const { binding, source, config } = bound;
if (!(await deps.isFailoverEligible(sessionId))) return false;
const row = await deps.readSessionRow(sessionId);
if (!row?.model || row.remoteHostId) return false;
- const current = await verifyBinding(sessionId, binding, config, row);
+ const current = await verifyBinding(sessionId, source, binding, config, row);
if (!current) return false;
// 交接会关闭旧会话(关闭撤销限额等待):先取得这次错误的重试入口。用户已接手时什么都不做。
const lease = deps.leaseRecovery(sessionId, token);
@@ -265,7 +471,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
};
try {
await switchUntilSettled({
- sessionId, signals, cause, binding, config, row: { ...row, model: row.model }, current, lease, isCurrent, handBack,
+ sessionId, signals, cause, binding, source, config, row: { ...row, model: row.model }, current, lease, isCurrent, handBack,
});
} catch (error) {
deps.log.warn('provider group: automatic switch failed', { sessionId, error: errorText(error) });
@@ -282,6 +488,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
signals: InterruptedTurnErrorSignals;
cause: ProviderGroupSwitchCause;
binding: ProviderGroupBinding;
+ source: GroupSource;
config: ProviderGroupConfig;
row: ProviderGroupSessionRow & { model: string };
current: ProviderGroupMember;
@@ -289,9 +496,9 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
isCurrent: () => boolean;
handBack: () => void;
}): Promise<void> {
- const { sessionId, signals, cause, binding, config, row, current, lease, isCurrent, handBack } = input;
- cool(binding.providerId, current.key, cause, deps.readResetAt(signals));
- deps.directory.invalidate(current.agentDeviceId ?? undefined);
+ const { sessionId, signals, cause, binding, source, config, row, current, lease, isCurrent, handBack } = input;
+ source.cool(binding.providerId, current.key, cause, deps.readResetAt(signals));
+ source.invalidate(current);
const tried = router.markTried(sessionId, current.key);
// 换回本机时:原本就在本机的保留原来的来源写法(可能是隐式来源),否则用组所属的供应商。
const localProviderId = current.kind === 'local' ? row.providerId : binding.providerId;
@@ -299,21 +506,26 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
for (;;) {
if (!isCurrent()) return;
- const pick = await pickNext(binding.providerId, row.agentKind, row.model, switchExclusion(config, current, tried));
+ const pick = await source.pick({
+ sessionId,
+ providerId: binding.providerId,
+ config,
+ agentKind: row.agentKind,
+ model: row.model,
+ exclude: switchExclusion(config, current, tried),
+ });
// 选电脑期间用户已接手:绑定与任务记录都还没动,直接停下。
if (!isCurrent()) return;
- if (pick.kind !== 'none') {
- fromLabel = pick.resolved.find((r) => r.member.key === current.key)?.label ?? fromLabel;
- }
if (pick.kind !== 'member') {
deps.log.info('provider group: no computer left to switch to', { sessionId, cause, tried: tried.size });
router.resetTurn(sessionId);
handBack();
return;
}
- const route = memberRoute(pick.member, localProviderId);
+ fromLabel = pick.labelOf(current.key) ?? fromLabel;
+ const route = source.routeOf(pick.member, localProviderId);
// 先写绑定再交接:交接会重建会话,分配入口据绑定认出它已归组,不会重新分配。
- await deps.writeBinding(sessionId, { providerId: binding.providerId, memberKey: pick.member.key });
+ await deps.writeBinding(sessionId, bindingFor(source, binding.providerId, pick.member.key));
try {
await deps.switchAgentLocation(sessionId, {
agentKind: row.agentKind,
@@ -322,7 +534,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
agentDeviceId: route.agentDeviceId,
}, { isCurrent });
} catch (error) {
- await restoreBindingAfterFailedSwitch(sessionId, binding.providerId, config);
+ await restoreBindingAfterFailedSwitch(sessionId, source, binding.providerId, config);
// 只有目标电脑本身的问题(连不上、分享暂停、Agent 起不来等)才记到它头上并换下一台;任务在运行、
// 已删除、用户已接手等与目标无关的失败直接结束,不冷却任何电脑。
const targetCause = classifyProviderGroupSwitchCause({ message: errorText(error) });
@@ -337,7 +549,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
error: errorText(error),
});
router.markTried(sessionId, pick.member.key);
- cool(binding.providerId, pick.member.key, targetCause, null);
+ source.cool(binding.providerId, pick.member.key, targetCause, null);
continue;
}
deps.log.info('provider group: switched computer', { sessionId, cause, to: pick.member.key });
@@ -357,33 +569,79 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
}
}
+ /** 已经指向同账号另一台电脑的新任务:那台把这个供应商建成了组时,问它该用哪台。 */
+ async function assignFromRemoteGroup(
+ sessionId: string,
+ row: ProviderGroupSessionRow,
+ agentKind: AgentKind,
+ model: string,
+ ): Promise<ProviderGroupStartContext | null> {
+ const ownerDeviceId = row.agentDeviceId;
+ if (!deps.remote || !ownerDeviceId || isProviderShareAgentDeviceId(ownerDeviceId) || !row.providerId) return null;
+ // 只给从没运行过的任务选电脑;已经在那台运行过的留在那台(原生会话在那里)。
+ if (row.sdkSessionId || (await deps.hasAssistantHistory(sessionId))) return null;
+ const source = remoteSource(ownerDeviceId);
+ const groupProviderId = row.providerId;
+ const config = await source.readGroup(groupProviderId).catch(() => undefined);
+ if (!config) return null;
+ // 问不到组所在电脑(刚断线等):照常直接连它,由那次连接给出原本的报错。
+ const pick = await source.pick({ sessionId, providerId: groupProviderId, config, agentKind, model, exclude: new Set() })
+ .catch((error): SourcePick => {
+ deps.log.warn('provider group: asking the group computer failed', { sessionId, error: errorText(error) });
+ return { kind: 'none' };
+ });
+ if (pick.kind === 'none') return null;
+ if (pick.kind === 'unavailable') {
+ deps.log.warn('provider group: no computer available for a new task', { sessionId, groupProviderId, remote: true });
+ throw new Error(PROVIDER_GROUP_UNAVAILABLE_ERROR);
+ }
+ const route = source.routeOf(pick.member, null);
+ await deps.writeBinding(sessionId, bindingFor(source, groupProviderId, pick.member.key));
+ await deps.persistRoute(sessionId, route);
+ deps.log.info('provider group: assigned a computer', { sessionId, groupProviderId, member: pick.member.key, remote: true });
+ return {
+ sessionId,
+ groupProviderId,
+ groupDeviceId: ownerDeviceId,
+ agentKind,
+ model,
+ member: pick.member,
+ route,
+ overrideRoute: true,
+ localProviderId: null,
+ };
+ }
+
return {
async assignBeforeStart({ sessionId, agentKind, model }) {
const row = await deps.readSessionRow(sessionId);
if (!row || row.remoteHostId) return null;
- const binding = deps.readBinding(sessionId);
- if (binding) {
- const config = deps.readGroup(binding.providerId);
- const current = await verifyBinding(sessionId, binding, config, row).catch((error) => {
+ if (deps.readBinding(sessionId)) {
+ const bound = await loadBound(sessionId).catch(() => null);
+ if (!bound) return null;
+ const { binding, source, config } = bound;
+ const current = await verifyBinding(sessionId, source, binding, config, row).catch((error) => {
deps.log.warn('provider group: binding reconciliation failed', { sessionId, error: errorText(error) });
return null;
});
// 从没运行过的任务(上次全部没能启动、重启应用后再打开等):带上启动上下文,这次启动失败时仍能
// 换组里下一台。已经运行过的任务在原来那台上有原生会话,换电脑要走交接,不在这里换。
if (!current || row.sdkSessionId || (await deps.hasAssistantHistory(sessionId))) return null;
- const localProviderId = current.kind === 'local' ? row.providerId : binding.providerId;
+ const localProviderId = current.kind === 'local' && !source.ownerDeviceId ? row.providerId : binding.providerId;
return {
sessionId,
groupProviderId: binding.providerId,
+ groupDeviceId: source.ownerDeviceId,
agentKind,
model,
member: current,
- route: memberRoute(current, localProviderId),
+ route: source.routeOf(current, localProviderId),
+ overrideRoute: source.ownerDeviceId !== null,
localProviderId,
};
}
- // 已指定 Agent 所在电脑的任务不动。
- if (row.agentDeviceId) return null;
+ // 已指定 Agent 所在电脑的任务:那台把这个供应商建成了组时由那台的组选电脑,否则不动。
+ if (row.agentDeviceId) return assignFromRemoteGroup(sessionId, row, agentKind, model);
const groupProviderId = row.providerId ?? (await deps.resolveImplicitProvider(agentKind, model));
const config = groupProviderId ? deps.readGroup(groupProviderId) : null;
if (!groupProviderId || !config) return null;
@@ -398,23 +656,25 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
}
return null;
}
- const pick = await pickNext(groupProviderId, agentKind, model, new Set());
+ const pick = await localSource.pick({ sessionId, providerId: groupProviderId, config, agentKind, model, exclude: new Set() });
if (pick.kind === 'none') return null;
if (pick.kind === 'unavailable') {
deps.log.warn('provider group: no computer available for a new task', { sessionId, groupProviderId });
throw new Error(PROVIDER_GROUP_UNAVAILABLE_ERROR);
}
- const route = memberRoute(pick.member, row.providerId);
+ const route = localSource.routeOf(pick.member, row.providerId);
await deps.writeBinding(sessionId, { providerId: groupProviderId, memberKey: pick.member.key });
if (route.agentDeviceId !== null) await deps.persistRoute(sessionId, route);
deps.log.info('provider group: assigned a computer', { sessionId, groupProviderId, member: pick.member.key });
return {
sessionId,
groupProviderId,
+ groupDeviceId: null,
agentKind,
model,
member: pick.member,
route,
+ overrideRoute: false,
localProviderId: row.providerId,
};
},
@@ -422,25 +682,34 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
async nextAfterStartFailure(context, error) {
const cause = classifyProviderGroupSwitchCause({ message: errorText(error) })
?? (/not authenticated|login/i.test(errorText(error)) ? 'auth' : null);
- const config = deps.readGroup(context.groupProviderId);
- if (!cause || !config?.autoSwitch) return null;
- cool(context.groupProviderId, context.member.key, cause, null);
- deps.directory.invalidate(context.member.agentDeviceId ?? undefined);
+ const source = sourceFor(context.groupDeviceId);
+ if (!cause || !source) return null;
+ const config = await source.readGroup(context.groupProviderId).catch(() => undefined);
+ if (!config?.autoSwitch) return null;
+ source.cool(context.groupProviderId, context.member.key, cause, null);
+ source.invalidate(context.member);
const tried = router.markTried(context.sessionId, context.member.key);
- const pick = await pickNext(context.groupProviderId, context.agentKind, context.model, tried);
+ const pick = await source.pick({
+ sessionId: context.sessionId,
+ providerId: context.groupProviderId,
+ config,
+ agentKind: context.agentKind,
+ model: context.model,
+ exclude: tried,
+ });
if (pick.kind !== 'member') {
router.resetTurn(context.sessionId);
return null;
}
- const route = memberRoute(pick.member, context.localProviderId);
- await deps.writeBinding(context.sessionId, { providerId: context.groupProviderId, memberKey: pick.member.key });
+ const route = source.routeOf(pick.member, context.localProviderId);
+ await deps.writeBinding(context.sessionId, bindingFor(source, context.groupProviderId, pick.member.key));
await deps.persistRoute(context.sessionId, route);
deps.log.info('provider group: agent did not start; trying the next computer', {
sessionId: context.sessionId,
cause,
to: pick.member.key,
});
- return { ...context, member: pick.member, route };
+ return { ...context, member: pick.member, route, overrideRoute: true };
},
onTurnError(sessionId, signals, token) {
@@ -455,36 +724,34 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
},
async beforeSend(sessionId) {
- const binding = deps.readBinding(sessionId);
- if (!binding || deps.isTurnRunning(sessionId)) return;
- const config = deps.readGroup(binding.providerId);
- if (!config?.autoSwitch) return;
+ if (!deps.readBinding(sessionId) || deps.isTurnRunning(sessionId)) return;
+ const bound = await loadBound(sessionId);
+ if (!bound?.config?.autoSwitch) return;
+ const { binding, source, config } = bound;
if (!(await deps.isFailoverEligible(sessionId))) return;
const row = await deps.readSessionRow(sessionId);
if (!row?.model || row.remoteHostId) return;
- const current = await verifyBinding(sessionId, binding, config, row);
+ const current = await verifyBinding(sessionId, source, binding, config, row);
// 暂停分配只影响新任务,已在那台的任务不挪走。
if (!current || current.paused) return;
- let timer: ReturnType<typeof setTimeout> | undefined;
- const resolved = await Promise.race([
- deps.directory.resolveMembers(binding.providerId, config),
- new Promise<null>((resolve) => {
- timer = setTimeout(() => resolve(null), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
- }),
- ]).finally(() => clearTimeout(timer));
- const state = resolved?.find((r) => r.member.key === current.key);
- if (!state) return;
- const cooling = router.coolingUntil(binding.providerId, current.key) !== null;
- if (state.state === 'ok' && !cooling) return;
+ const verdict = await source.shouldMoveAway(binding.providerId, config, current.key);
+ if (!verdict) return;
const tried = router.markTried(sessionId, current.key);
- const pick = await pickNext(binding.providerId, row.agentKind, row.model, switchExclusion(config, current, tried));
+ const pick = await source.pick({
+ sessionId,
+ providerId: binding.providerId,
+ config,
+ agentKind: row.agentKind,
+ model: row.model,
+ exclude: switchExclusion(config, current, tried),
+ });
if (pick.kind !== 'member') {
router.resetTurn(sessionId);
return;
}
- const localProviderId = current.kind === 'local' ? row.providerId : binding.providerId;
- const route = memberRoute(pick.member, localProviderId);
- await deps.writeBinding(sessionId, { providerId: binding.providerId, memberKey: pick.member.key });
+ const localProviderId = current.kind === 'local' && !source.ownerDeviceId ? row.providerId : binding.providerId;
+ const route = source.routeOf(pick.member, localProviderId);
+ await deps.writeBinding(sessionId, bindingFor(source, binding.providerId, pick.member.key));
try {
await deps.switchAgentLocation(sessionId, {
agentKind: row.agentKind,
@@ -496,10 +763,10 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
sessionId,
from: current.key,
to: pick.member.key,
- reason: cooling ? 'cooling' : state.state,
+ reason: verdict.reason,
});
} catch (error) {
- await restoreBindingAfterFailedSwitch(sessionId, binding.providerId, config);
+ await restoreBindingAfterFailedSwitch(sessionId, source, binding.providerId, config);
deps.log.warn('provider group: moving a task before sending failed', { sessionId, error: errorText(error) });
}
},
diff --git a/apps/desktop/src/main/remote-agent/__tests__/plumbing.test.ts b/apps/desktop/src/main/remote-agent/__tests__/plumbing.test.ts
index f91b43cf10..01e869a65d 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/plumbing.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/plumbing.test.ts
@@ -158,6 +158,11 @@ describe('wire payloads', () => {
});
expect(payload.projectFiles.map((file) => file.path)).toEqual(['AGENTS.md']);
expect(payload.mcpServers).toEqual(['cindy_memory']);
+ expect(payload).not.toHaveProperty('groupAssigned');
+ // 供应商组分配的任务带防转圈标记;只认 true。
+ const base = { sessionId: 's1', options: { model: 'm' }, workspace: { workingDir: '/p', platform: 'darwin' } };
+ expect(decodeOpenPayload({ ...base, groupAssigned: true }).groupAssigned).toBe(true);
+ expect(decodeOpenPayload({ ...base, groupAssigned: 'yes' })).not.toHaveProperty('groupAssigned');
expect(() => decodeOpenPayload({ sessionId: 's', options: { model: 'm' }, workspace: { workingDir: '/p', platform: 'beos' } })).toThrow();
});
diff --git a/apps/desktop/src/main/remote-agent/controller/service.ts b/apps/desktop/src/main/remote-agent/controller/service.ts
index 804e3e7900..cbe0271383 100644
--- a/apps/desktop/src/main/remote-agent/controller/service.ts
+++ b/apps/desktop/src/main/remote-agent/controller/service.ts
@@ -55,6 +55,8 @@ export interface DeviceAgentServiceDeps {
mapEvent?: (kind: AgentKind) => ((event: AgentEvent) => AgentEvent) | undefined;
/** Read 读 PDF 时取文字。 */
extractPdfText?: PdfTextExtractor;
+ /** 这个任务由供应商组分配(本机的组或另一台电脑上的组):打开时告诉那台不要再进入它自己的组。 */
+ isGroupAssigned?(sessionId: string): boolean;
logger: Logger;
}
@@ -128,6 +130,7 @@ export function createDeviceAgentStarter(deps: DeviceAgentServiceDeps) {
poller,
rgPath: deps.rgPath(),
codexPath: () => deps.codexPath?.(),
+ ...(opts.sessionId && deps.isGroupAssigned?.(opts.sessionId) ? { groupAssigned: true } : {}),
prepareMcp: async ({ kind, opts: startOpts, vendorOptions }): Promise<PreparedRemoteMcp> => {
const extra = await deps.prepareMcpBridge(deps.mcpProviders(), deps.logger, {
agentKind: kind,
diff --git a/apps/desktop/src/main/remote-agent/controller/startRemote.ts b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
index b02eaae118..296cbb1e85 100644
--- a/apps/desktop/src/main/remote-agent/controller/startRemote.ts
+++ b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
@@ -67,6 +67,8 @@ export interface StartRemoteAgentDeps {
mapEvent?: (kind: RemoteAgentKind) => ((event: AgentEvent) => AgentEvent) | undefined;
/** 本机 Codex 程序(给对方的 Codex 提供 exec-server 执行环境);缺省时不提供。 */
codexPath?: () => string | undefined;
+ /** 这个任务由供应商组分配到那台:告诉那台直接运行,不再进入它自己的组(防转圈)。 */
+ groupAssigned?: boolean;
newId(): string;
log?: {
info(message: string, meta?: Record<string, unknown>): void;
@@ -263,6 +265,7 @@ export async function startRemoteAgentSession(
ancestorFiles,
personal: collectedPersonal?.personal ?? { files: [] },
mcpServers: [...mcp.servers.keys()],
+ ...(deps.groupAssigned ? { groupAssigned: true } : {}),
};
let startedRaw: Record<string, unknown>;
diff --git a/apps/desktop/src/main/remote-agent/wire.ts b/apps/desktop/src/main/remote-agent/wire.ts
index c6c9fe5e1d..038ab23719 100644
--- a/apps/desktop/src/main/remote-agent/wire.ts
+++ b/apps/desktop/src/main/remote-agent/wire.ts
@@ -143,6 +143,11 @@ export interface RemoteAgentOpenPayload {
sessionId: string;
/** 能力增量:Agent 使用本机虚拟工作区;新控制端在 open 前必须确认对端 caps 支持。 */
virtualWorkspace?: boolean;
+ /**
+ * 这个任务已由供应商组分配到这台(docs/product-rules/provider-groups.md §4 防转圈):直接在这台运行,
+ * 不再进入这台自己的供应商组。可选字段,旧版本解码时丢弃(它本来没有组)。
+ */
+ groupAssigned?: boolean;
options: RemoteAgentWireStartOptions;
workspace: RemoteAgentWireWorkspace;
projectFiles: RemoteAgentWireFile[];
@@ -283,6 +288,7 @@ export function decodeOpenPayload(value: unknown): RemoteAgentOpenPayload {
return {
sessionId,
...(value.virtualWorkspace === true ? { virtualWorkspace: true } : {}),
+ ...(value.groupAssigned === true ? { groupAssigned: true } : {}),
options: decodeStartOptions(value.options),
workspace: decodeWorkspace(value.workspace),
projectFiles,
diff --git a/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx b/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx
index af046a1771..7bb38a9080 100644
--- a/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx
@@ -94,6 +94,8 @@ import {
import { useDevicesProviders } from '@/hooks/useDevicesProviders';
import { RemoteSourceMark } from '@/components/icons/RemoteSourceMark';
import { buildUnifiedRail, remoteAgentProviders } from './unifiedModelSelection';
+import { collectRemoteProviderGroups, remoteProviderEntryKey } from '@/lib/remoteProviderGroups';
+import { useLocalProviderGroups } from '@/features/provider-group/useLocalProviderGroups';
import { modelPriceDiscountLabelValues, modelPriceDetailRows } from '@/lib/modelPriceFormat';
import { resolveModelPricePresentation } from '@/lib/modelPricePresentation';
import {
@@ -1536,12 +1538,47 @@ function ModelSelectorContentView({
[remoteAgentDevices],
);
const remoteDeviceCatalogs = useDevicesProviders(remoteAgentDeviceIds);
+ // 任务所在电脑那一格:本机任务用本机目录与可见性偏好;被控电脑上的任务用被控电脑的目录与它的
+ // 可见性快照(顺序沿用被控端快照,不套本机排序,同远程控制)。
+ const homeDeviceProviders = useDeviceProviders(homeDeviceId);
+ const localProviderGroups = useLocalProviderGroups();
+ // 供应商组(provider-groups.md §10):组里的电脑与分享收起,只列组那一项。组可以在其他电脑上
+ // (看它们目录里的组摘要),也可以是任务所在电脑自己建的(本机任务读本机设置,被控电脑上的任务看那台的
+ // 目录)。当前正在用的那一项不收起。
+ const remoteProviderGroups = useMemo(
+ () => collectRemoteProviderGroups(
+ [
+ ...(remoteAgentDevices ?? []).flatMap((device) => {
+ const catalog = remoteDeviceCatalogs.get(device.deviceId);
+ return catalog ? [{ deviceId: device.deviceId, providers: catalog.providers }] : [];
+ }),
+ ...(homeDeviceId ? [{ deviceId: homeDeviceId, providers: homeDeviceProviders.providers }] : []),
+ ],
+ remoteAgentDeviceId && currentProviderId
+ ? [remoteProviderEntryKey(remoteAgentDeviceId, currentProviderId)]
+ : [],
+ homeDeviceId ? [] : Object.values(localProviderGroups),
+ ),
+ [
+ remoteAgentDevices,
+ remoteDeviceCatalogs,
+ remoteAgentDeviceId,
+ currentProviderId,
+ homeDeviceId,
+ homeDeviceProviders.providers,
+ localProviderGroups,
+ ],
+ );
const remoteAgentGroups = useMemo(() => {
if (!remoteAgentDevices) return [];
return remoteAgentDevices.flatMap((device) => {
const catalog = remoteDeviceCatalogs.get(device.deviceId);
// 只列那台电脑开了「允许被远程调用」的供应商;一个都没开的电脑整段不出现。
- const shared = catalog ? remoteAgentProviders(catalog.providers) : [];
+ const shared = catalog
+ ? remoteAgentProviders(catalog.providers).filter(
+ (provider) => !remoteProviderGroups.hidden.has(remoteProviderEntryKey(device.deviceId, provider.id)),
+ )
+ : [];
if (!catalog || shared.length === 0) return [];
const entries = unifiedModelEntries({
providers: shared,
@@ -1555,11 +1592,8 @@ function ModelSelectorContentView({
? [{ deviceId: device.deviceId, providers: shared, providerIds }]
: [];
});
- }, [remoteAgentDevices, remoteDeviceCatalogs]);
+ }, [remoteAgentDevices, remoteDeviceCatalogs, remoteProviderGroups]);
const hasRemoteAgent = remoteAgent !== undefined;
- // 任务所在电脑那一格:本机任务用本机目录与可见性偏好;被控电脑上的任务用被控电脑的目录与它的
- // 可见性快照(顺序沿用被控端快照,不套本机排序,同远程控制)。
- const homeDeviceProviders = useDeviceProviders(homeDeviceId);
const homeProviders = homeDeviceId ? homeDeviceProviders.providers : localProviders.providers;
const homeModelVisibilityOverrides = homeDeviceProviders.modelVisibilityOverrides;
const remoteAgentLocalRailItems = useMemo(() => {
@@ -1596,12 +1630,18 @@ function ModelSelectorContentView({
const provider = remoteAgentGroups
.find((group) => group.deviceId === targetDeviceId)
?.providers.find((entry) => entry.id === providerId);
- return t('newChat.modelSelector.unified.railRemoteProvider', {
- provider: provider ? providerDisplayName(provider, t) : providerId,
- device: device?.name || targetDeviceId,
- });
+ const grouped = remoteProviderGroups.groups.has(remoteProviderEntryKey(targetDeviceId, providerId));
+ return t(
+ grouped
+ ? 'newChat.modelSelector.unified.railRemoteProviderGroup'
+ : 'newChat.modelSelector.unified.railRemoteProvider',
+ {
+ provider: provider ? providerDisplayName(provider, t) : providerId,
+ device: device?.name || targetDeviceId,
+ },
+ );
},
- [remoteAgentDevices, remoteAgentGroups, t],
+ [remoteAgentDevices, remoteAgentGroups, remoteProviderGroups, t],
);
// 官方默认推荐 → 一次性**种子收藏**(Chris 2026-08-16 裁决,替代列表里的「默认」
diff --git a/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx b/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
index 31ed9361b3..c1c356e702 100644
--- a/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
+++ b/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
@@ -4,6 +4,9 @@
*
* 与本机供应商同在左栏,图标右上角带远程角标(与模型列表同一个 RemoteSourceMark);点开在
* 右栏只读地看它在哪台电脑、开放了哪些模型。修改要到那台电脑上去,这里不提供开关。
+ *
+ * 供应商组(provider-groups.md §10):另一台电脑把某个供应商建成了组时,组里的电脑与分享不再单独
+ * 列出,组所在电脑那一项标成供应商组,详情里只读列出组内电脑与状态。规则与模型列表同一份。
*/
import { useMemo } from 'react';
import { useTranslation } from 'react-i18next';
@@ -14,11 +17,16 @@ import { hasProviderLogo, ProviderLogoMark } from '@/components/icons/ProviderLo
import { RemoteSourceMark } from '@/components/icons/RemoteSourceMark';
import { remoteAgentProviders } from '@/components/new-chat/unifiedModelSelection';
import { Tip } from '@/components/ui/tooltip';
+import { RemoteProviderGroupMembers } from '@/features/provider-group/RemoteProviderGroupMembers';
+import { useLocalProviderGroups } from '@/features/provider-group/useLocalProviderGroups';
import { useControllableDevices } from '@/hooks/useControllableDevices';
import { useDevicesProviders } from '@/hooks/useDevicesProviders';
import { providerDisplayName } from '@/lib/providerDisplayName';
import { providerMonogram } from '@/lib/providerModels';
+import { collectRemoteProviderGroups, remoteProviderEntryKey } from '@/lib/remoteProviderGroups';
import { cn } from '@/lib/utils';
+import { PROVIDER_SHARE_AGENT_DEVICE_PREFIX } from '../../../shared/providerShare';
+import type { ProviderGroupConfig } from '../../../shared/providerGroup';
import { ReadOnlyProviderModelSection, readOnlyProviderModels } from './ReadOnlyProviderModels';
@@ -29,36 +37,73 @@ export interface OwnRemoteProvider {
deviceName: string;
provider: ProviderView;
modelVisibilityOverrides?: Record<string, boolean>;
+ /** 那台电脑把这个供应商建成了供应商组。 */
+ group?: ProviderGroupConfig;
}
export function ownRemoteProviderKey(deviceId: string, providerId: string): string {
- return `${deviceId}\n${providerId}`;
+ return remoteProviderEntryKey(deviceId, providerId);
}
-/** 在线的同账号电脑上可以远程使用的供应商,按电脑、再按那台电脑的供应商顺序排列。 */
-export function useOwnRemoteProviders(): readonly OwnRemoteProvider[] {
+export interface OwnRemoteProviderList {
+ entries: readonly OwnRemoteProvider[];
+ /** 被其他电脑的供应商组收进去的分享(「分享给我的供应商」里不再单独列出)。 */
+ hiddenShareIds: ReadonlySet<string>;
+}
+
+/**
+ * 在线的同账号电脑上可以远程使用的供应商,按电脑、再按那台电脑的供应商顺序排列;被其他电脑的组
+ * 收进去的不再单独列出。
+ */
+export function useOwnRemoteProviderList(): OwnRemoteProviderList {
const devices = useControllableDevices();
const deviceIds = useMemo(() => devices.map((device) => device.deviceId), [devices]);
const catalogs = useDevicesProviders(deviceIds);
- return useMemo(
- () =>
+ // 本机自己建的组:组那一项就是本机的供应商(在上面本机那一段),组里的远程供应商与分享同样收起。
+ const localGroups = useLocalProviderGroups();
+ return useMemo(() => {
+ const groups = collectRemoteProviderGroups(
devices.flatMap((device) => {
const catalog = catalogs.get(device.deviceId);
- if (!catalog) return [];
- return remoteAgentProviders(catalog.providers)
- .filter((provider) => provider.connected && !provider.suspended)
- .map((provider) => ({
- key: ownRemoteProviderKey(device.deviceId, provider.id),
+ return catalog ? [{ deviceId: device.deviceId, providers: catalog.providers }] : [];
+ }),
+ [],
+ Object.values(localGroups),
+ );
+ const entries = devices.flatMap((device) => {
+ const catalog = catalogs.get(device.deviceId);
+ if (!catalog) return [];
+ return remoteAgentProviders(catalog.providers)
+ .filter((provider) => provider.connected && !provider.suspended)
+ .filter((provider) => !groups.hidden.has(remoteProviderEntryKey(device.deviceId, provider.id)))
+ .map((provider): OwnRemoteProvider => {
+ const key = ownRemoteProviderKey(device.deviceId, provider.id);
+ const group = groups.groups.get(key);
+ return {
+ key,
deviceId: device.deviceId,
deviceName: device.name,
provider,
...(catalog.modelVisibilityOverrides !== undefined
? { modelVisibilityOverrides: catalog.modelVisibilityOverrides }
: {}),
- }));
- }),
- [catalogs, devices],
- );
+ ...(group ? { group } : {}),
+ };
+ });
+ });
+ const hiddenShareIds = new Set<string>();
+ for (const key of groups.hidden) {
+ const agentDeviceId = key.slice(0, key.indexOf('\n'));
+ if (agentDeviceId.startsWith(PROVIDER_SHARE_AGENT_DEVICE_PREFIX)) {
+ hiddenShareIds.add(agentDeviceId.slice(PROVIDER_SHARE_AGENT_DEVICE_PREFIX.length));
+ }
+ }
+ return { entries, hiddenShareIds };
+ }, [catalogs, devices, localGroups]);
+}
+
+export function useOwnRemoteProviders(): readonly OwnRemoteProvider[] {
+ return useOwnRemoteProviderList().entries;
}
function RemoteProviderIcon({ provider, size }: { provider: ProviderView; size: number }) {
@@ -89,7 +134,10 @@ export function OwnRemoteProviderRows({
<div data-testid="own-remote-providers" className="flex flex-col gap-0.5">
{entries.map((entry) => {
const name = providerDisplayName(entry.provider, t);
- const label = t('settings.providers.remote.rowLabel', { provider: name, device: entry.deviceName });
+ const label = t(
+ entry.group ? 'settings.providers.remote.rowLabelGroup' : 'settings.providers.remote.rowLabel',
+ { provider: name, device: entry.deviceName },
+ );
const selected = selectedKey === entry.key;
return (
<Tip key={entry.key} text={label} side="right" contentClassName="max-w-[360px] break-words">
@@ -123,9 +171,11 @@ export function OwnRemoteProviderRows({
{name}
</span>
<span className="shrink-0 select-none text-11 tabular-nums" style={{ color: 'var(--text-tertiary)' }}>
- {t('settings.providers.models.modelCount', {
- count: readOnlyProviderModels(entry.provider, entry.modelVisibilityOverrides).length,
- })}
+ {entry.group
+ ? t('settings.providers.remote.groupBadge', { count: entry.group.members.length })
+ : t('settings.providers.models.modelCount', {
+ count: readOnlyProviderModels(entry.provider, entry.modelVisibilityOverrides).length,
+ })}
</span>
<span
aria-hidden="true"
@@ -194,10 +244,16 @@ export function OwnRemoteProviderDetail({ entry }: { entry: OwnRemoteProvider })
style={{ borderColor: 'var(--settings-theme-card-border)' }}
>
<p className="text-13 leading-[1.5]" style={{ color: 'var(--settings-section-desc)' }}>
- {t('settings.providers.remote.detailNote', { device: entry.deviceName })}
+ {t(entry.group ? 'settings.providers.remote.groupNote' : 'settings.providers.remote.detailNote', {
+ device: entry.deviceName,
+ })}
</p>
</div>
+ {entry.group && (
+ <RemoteProviderGroupMembers deviceId={entry.deviceId} providerId={entry.provider.id} config={entry.group} />
+ )}
+
<ReadOnlyProviderModelSection
title={t('settings.providers.remote.modelsTitle')}
models={models}
diff --git a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
index d033b0529f..82ee7d941b 100644
--- a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
@@ -91,7 +91,7 @@ import { OllamaProviderDetail } from './OllamaProviderDetail';
import {
OwnRemoteProviderDetail,
OwnRemoteProviderRows,
- useOwnRemoteProviders,
+ useOwnRemoteProviderList,
} from './OwnRemoteProviders';
import { LlamaCppProviderDetail } from './LlamaCppProviderDetail';
import { MANAGED_LLAMACPP_PROVIDER_ID } from '../../../shared/llamaCpp';
@@ -2424,7 +2424,7 @@ export function ProvidersSection() {
const selectedShare = selectedShareId
? receivedShares.find((share) => share.shareId === selectedShareId) ?? null
: null;
- const ownRemoteProviders = useOwnRemoteProviders();
+ const { entries: ownRemoteProviders, hiddenShareIds: groupedShareIds } = useOwnRemoteProviderList();
const selectedRemote = selectedRemoteKey
? ownRemoteProviders.find((entry) => entry.key === selectedRemoteKey) ?? null
: null;
@@ -3129,6 +3129,7 @@ export function ProvidersSection() {
{/* 分享给我的供应商(受邀者):单独成组,没有分享时不显示。 */}
<ProviderShareReceivedRailGroup
selectedShareId={selectedShare?.shareId ?? null}
+ hiddenShareIds={groupedShareIds}
onSelect={(shareId) => {
setFocusedModel(null);
selectShare(shareId);
diff --git a/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx b/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
index fdb0050e6d..88c1178d06 100644
--- a/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
+++ b/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
@@ -6,6 +6,7 @@ import {
OwnRemoteProviderDetail,
OwnRemoteProviderRows,
ownRemoteProviderKey,
+ useOwnRemoteProviderList,
useOwnRemoteProviders,
type OwnRemoteProvider,
} from '../OwnRemoteProviders';
@@ -76,6 +77,36 @@ describe('useOwnRemoteProviders', () => {
]);
expect(result.current[0].key).toBe(ownRemoteProviderKey('mini-a', 'anthropic'));
});
+
+ it('shows only the group when another computer put providers and shares in a provider group', () => {
+ devices.value = [
+ { deviceId: 'mini-a', name: "Magi's Mac Mini", platform: 'darwin' },
+ { deviceId: 'mini-b', name: 'Studio', platform: 'darwin' },
+ ];
+ catalogs.value = new Map([
+ ['mini-a', {
+ providers: [provider('anthropic', {
+ group: {
+ strategy: 'least',
+ members: [
+ { kind: 'local' },
+ { kind: 'device', agentDeviceId: 'mini-b', providerId: 'anthropic' },
+ { kind: 'share', agentDeviceId: 'share:s1', providerId: 'anthropic' },
+ ],
+ },
+ })],
+ loading: false,
+ error: null,
+ }],
+ ['mini-b', { providers: [provider('anthropic'), provider('openai')], loading: false, error: null }],
+ ]);
+ const { result } = renderHook(() => useOwnRemoteProviderList());
+ expect(result.current.entries.map((entry) => [entry.deviceId, entry.provider.id, entry.group?.members.length ?? 0])).toEqual([
+ ['mini-a', 'anthropic', 3],
+ ['mini-b', 'openai', 0],
+ ]);
+ expect([...result.current.hiddenShareIds]).toEqual(['s1']);
+ });
});
describe('OwnRemoteProviderRows / OwnRemoteProviderDetail', () => {
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index 2bc77ac683..34181c9039 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -337,7 +337,8 @@ function MemberRow({
);
}
-function memberStatusText(
+/** 组内电脑的状态词(本机的组与另一台电脑上的组的只读列表共用)。 */
+export function memberStatusText(
t: ReturnType<typeof useTranslation>['t'],
status: ProviderGroupMemberStatus | undefined,
locale: string,
diff --git a/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx b/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx
new file mode 100644
index 0000000000..16ca6a3432
--- /dev/null
+++ b/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx
@@ -0,0 +1,153 @@
+/**
+ * 另一台电脑上的供应商组,只读(docs/product-rules/provider-groups.md §10):设置页里同账号另一台电脑的
+ * 供应商被建成了组时,详情里列出组内电脑与它们的状态(在线、正在运行几个任务、冷却到何时)。
+ * 组的设置只能在组所在电脑上改。状态没有推送,打开期间定时重读。
+ */
+import { Monitor } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { cn } from '@/lib/utils';
+
+import type {
+ ProviderGroupConfig,
+ ProviderGroupMember,
+ ProviderGroupMemberStatus,
+ ProviderGroupView,
+} from '../../../shared/providerGroup';
+import { memberStatusText } from './ProviderGroupSection';
+
+const REFRESH_INTERVAL_MS = 15_000;
+
+function useRemoteProviderGroupView(deviceId: string, providerId: string) {
+ const [view, setView] = useState<ProviderGroupView | null>(null);
+ const [failed, setFailed] = useState(false);
+ const seq = useRef(0);
+
+ const reload = useCallback(async () => {
+ const current = ++seq.current;
+ try {
+ const next = await window.electronAPI.providerGroup.command({ action: 'remote-view', deviceId, providerId });
+ if (current !== seq.current) return;
+ setView(next);
+ setFailed(false);
+ } catch {
+ if (current !== seq.current) return;
+ setFailed(true);
+ }
+ }, [deviceId, providerId]);
+
+ useEffect(() => {
+ setView(null);
+ setFailed(false);
+ void reload();
+ const timer = window.setInterval(() => void reload(), REFRESH_INTERVAL_MS);
+ return () => {
+ window.clearInterval(timer);
+ seq.current += 1;
+ };
+ }, [reload]);
+
+ return { view, failed };
+}
+
+export function RemoteProviderGroupMembers({
+ deviceId,
+ providerId,
+ config,
+}: {
+ deviceId: string;
+ providerId: string;
+ /** 目录里带的组设置:状态还没读到时先按它列出组内电脑。 */
+ config: ProviderGroupConfig;
+}) {
+ const { t } = useTranslation();
+ const { view, failed } = useRemoteProviderGroupView(deviceId, providerId);
+ const members = view?.config?.members ?? config.members;
+ return (
+ <section
+ data-testid="remote-provider-group-members"
+ className="shrink-0 border-t px-5 py-3"
+ style={{ borderColor: 'var(--settings-theme-card-border)' }}
+ >
+ <h3 className="pb-2 text-13 font-medium" style={{ color: 'var(--settings-section-title)' }}>
+ {t('settings.providers.remote.groupMembersTitle')}
+ </h3>
+ <div className="overflow-hidden rounded-lg border border-[var(--settings-theme-card-border)]">
+ {members.map((member, index) => (
+ <MemberRow
+ key={member.key}
+ member={member}
+ status={view?.members.find((m) => m.key === member.key)}
+ first={index === 0}
+ />
+ ))}
+ </div>
+ {failed && (
+ <p className="mt-2 text-12 leading-[1.5] text-[var(--text-tertiary)]">
+ {t('settings.providers.remote.groupMembersFailed')}
+ </p>
+ )}
+ </section>
+ );
+}
+
+function MemberRow({
+ member,
+ status,
+ first,
+}: {
+ member: ProviderGroupMember;
+ status: ProviderGroupMemberStatus | undefined;
+ first: boolean;
+}) {
+ const { t, i18n } = useTranslation();
+ const label = status?.label ?? member.label ?? member.key;
+ const source = member.kind === 'local'
+ ? t('providerGroup.member.sourceGroupOwner')
+ : member.kind === 'device'
+ ? t('providerGroup.member.sourceDevice')
+ : t('providerGroup.member.sourceShare', { name: status?.ownerName ?? '' });
+ const ready = status?.state === 'available' || status?.state === 'full';
+ const running = status?.running ?? 0;
+ const appendRunning = running > 0 && status != null && status.state !== 'available' && status.state !== 'full';
+ return (
+ <div
+ data-testid="remote-provider-group-member"
+ data-member-state={status?.state ?? 'loading'}
+ className={cn(
+ 'flex items-center gap-3 px-3 py-2.5',
+ !first && 'border-t border-[var(--settings-theme-card-border)]',
+ )}
+ >
+ <span
+ aria-hidden="true"
+ className="inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-[var(--surface-chip)] text-[var(--text-secondary)]"
+ >
+ <Monitor size={14} />
+ </span>
+ <div className={cn('flex min-w-0 flex-1 flex-col gap-0.5', member.paused && 'opacity-60')}>
+ <div className="flex min-w-0 flex-wrap items-baseline gap-2 text-13">
+ <span className="truncate font-medium text-[var(--text-primary)]">{label}</span>
+ <span className="text-12 text-[var(--text-secondary)]">{source}</span>
+ </div>
+ <div className="flex flex-wrap items-center gap-1.5 text-12 text-[var(--text-secondary)]">
+ <span
+ aria-hidden="true"
+ className="h-1.5 w-1.5 shrink-0 rounded-full"
+ style={{ background: ready ? 'var(--remote-status-ready)' : 'var(--remote-status-disconnected)' }}
+ />
+ <span>{memberStatusText(t, status, i18n.language)}</span>
+ {appendRunning && (
+ <>
+ <span aria-hidden="true">·</span>
+ <span className="[font-variant-numeric:tabular-nums]">
+ {t('providerGroup.member.runningCount', { count: running })}
+ </span>
+ </>
+ )}
+ </div>
+ </div>
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts b/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts
new file mode 100644
index 0000000000..2ed25b476e
--- /dev/null
+++ b/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts
@@ -0,0 +1,57 @@
+/**
+ * 本机建的供应商组(只读设置,不读远端):模型列表与设置页据此收起本机组里的远程供应商与分享,
+ * 与其他电脑的组同一条规则(provider-groups.md §10)。组设置变化时 main 广播 CHANGED,重读一次。
+ * 全窗口共用一份,多个组件同时用也只发一次 IPC。
+ */
+import { useEffect, useState } from 'react';
+
+import type { ProviderGroupConfig } from '../../../shared/providerGroup';
+
+type LocalGroups = Readonly<Record<string, ProviderGroupConfig>>;
+
+const EMPTY: LocalGroups = Object.freeze({});
+let snapshot: LocalGroups = EMPTY;
+let loaded: Promise<void> | null = null;
+let offChanged: (() => void) | null = null;
+const listeners = new Set<(groups: LocalGroups) => void>();
+
+function reload(): Promise<void> {
+ const api = window.electronAPI?.providerGroup;
+ if (typeof api?.command !== 'function') return Promise.resolve();
+ loaded = Promise.resolve()
+ .then(() => api.command({ action: 'list' }))
+ .then((groups) => {
+ snapshot = groups ?? EMPTY;
+ for (const listener of listeners) listener(snapshot);
+ })
+ .catch(() => undefined);
+ return loaded;
+}
+
+function subscribe(listener: (groups: LocalGroups) => void): () => void {
+ listeners.add(listener);
+ if (!loaded) void reload();
+ offChanged ??= window.electronAPI?.providerGroup?.onChanged?.(() => void reload()) ?? null;
+ return () => {
+ listeners.delete(listener);
+ };
+}
+
+export function useLocalProviderGroups(): LocalGroups {
+ const [groups, setGroups] = useState<LocalGroups>(snapshot);
+ useEffect(() => {
+ setGroups(snapshot);
+ return subscribe(setGroups);
+ }, []);
+ return groups;
+}
+
+export const __testing = {
+ reset(): void {
+ snapshot = EMPTY;
+ loaded = null;
+ offChanged?.();
+ offChanged = null;
+ listeners.clear();
+ },
+};
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareReceivedRail.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareReceivedRail.tsx
index df93fb1e32..e4c5d8a3d6 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareReceivedRail.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareReceivedRail.tsx
@@ -56,16 +56,24 @@ function StatusDot({ status }: { status: ReceivedStatus }) {
);
}
-/** 左栏的「分享给我的供应商」一组;没有分享时整组不显示。 */
+/**
+ * 左栏的「分享给我的供应商」一组;没有分享时整组不显示。被我另一台电脑的供应商组收进去的分享
+ * 不再单独列出(provider-groups.md §3、§10),正在查看的那一项保留。
+ */
export function ProviderShareReceivedRailGroup({
selectedShareId,
onSelect,
+ hiddenShareIds,
}: {
selectedShareId: string | null;
onSelect: (shareId: string) => void;
+ hiddenShareIds?: ReadonlySet<string>;
}) {
const { t } = useTranslation();
- const { received } = useProviderShareReceived();
+ const { received: all } = useProviderShareReceived();
+ const received = hiddenShareIds?.size
+ ? all.filter((share) => share.shareId === selectedShareId || !hiddenShareIds.has(share.shareId))
+ : all;
if (received.length === 0) return null;
return (
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index 9453154768..7fc8188bf4 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -472,7 +472,8 @@
"description": "It won’t get new tasks. Tasks already running there stay on that computer.",
"lastDescription": "It’s the last computer in the group, so removing it deletes the {{provider}} provider group.",
"confirm": "Remove from Group"
- }
+ },
+ "sourceGroupOwner": "Hosts the group"
},
"deleteConfirm": {
"title": "Delete the {{provider}} provider group?",
@@ -2832,7 +2833,13 @@
"statusReady": "Available",
"detailNote": "The agent runs on {{device}}, using that computer’s sign-in and quota. To use it, choose it in the model list when you start a task. To change this provider, go to Settings → Providers on that computer.",
"modelsTitle": "Available Models",
- "modelsEmpty": "This provider has no models available on that computer yet."
+ "modelsEmpty": "This provider has no models available on that computer yet.",
+ "rowLabelGroup": "{{provider}} · {{device}} · Provider Group",
+ "groupBadge_one": "Provider Group · {{count}} computer",
+ "groupBadge_other": "Provider Group · {{count}} computers",
+ "groupNote": "{{device}} made this provider a provider group. When you start a task with it, {{device}} assigns the task to one of the computers below by its group strategy, and moves it to another one if that computer runs into a problem. To change the group, go to Settings → Providers on {{device}}.",
+ "groupMembersTitle": "Computers in the Group",
+ "groupMembersFailed": "Couldn’t get the status of the computers in the group right now."
},
"genericOAuth": {
"subtitle": "Subscription account",
@@ -9419,7 +9426,8 @@
"effortEndSmart": "Smarter",
"railSameEngine": "{{agent}} only",
"crossEngineWarning": "Switching engines rebuilds context and may lose content",
- "favoritesSyncFailed": "Favorites could not sync. Reopen the picker to retry; the remote computer may need an update."
+ "favoritesSyncFailed": "Favorites could not sync. Reopen the picker to retry; the remote computer may need an update.",
+ "railRemoteProviderGroup": "{{provider}} · {{device}} · Provider Group"
}
},
"permissionSelector": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 394580cb32..c6f2a6836f 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -467,7 +467,8 @@
"description": "新しいセッションは割り当てられなくなります。すでにそこで実行中のセッションはそのパソコンに残ります。",
"lastDescription": "グループ内の最後のパソコンです。外すと {{provider}} のプロバイダーグループは削除されます。",
"confirm": "グループから外す"
- }
+ },
+ "sourceGroupOwner": "グループを作成したパソコン"
},
"deleteConfirm": {
"title": "{{provider}} のプロバイダーグループを削除しますか?",
@@ -2825,7 +2826,12 @@
"statusReady": "利用可能",
"detailNote": "Agent は {{device}} で動き、そのパソコンのログインとクォータを使います。タスクを新規作成するときにモデル一覧で選ぶと使えます。このプロバイダーを変更するには、そのパソコンの「設定 → モデルプロバイダー」を開いてください。",
"modelsTitle": "利用できるモデル",
- "modelsEmpty": "このプロバイダーには、そのパソコンで利用できるモデルがまだありません。"
+ "modelsEmpty": "このプロバイダーには、そのパソコンで利用できるモデルがまだありません。",
+ "rowLabelGroup": "{{provider}} · {{device}} · プロバイダーグループ",
+ "groupBadge_other": "プロバイダーグループ · {{count}} 台のパソコン",
+ "groupNote": "{{device}} はこのプロバイダーをプロバイダーグループにしています。モデル一覧で選んでタスクを新規作成すると、{{device}} がグループの割り当て方式に従って下のいずれかのパソコンにタスクを割り当て、そのパソコンで問題が起きたら別のパソコンに切り替えて続けます。グループを変更するには、{{device}} の「設定 → モデルプロバイダー」を開いてください。",
+ "groupMembersTitle": "グループ内のパソコン",
+ "groupMembersFailed": "グループ内のパソコンの状態を今は取得できません。"
},
"genericOAuth": {
"subtitle": "サブスクリプションアカウント",
@@ -9400,7 +9406,8 @@
"effortEndSmart": "高精度",
"railSameEngine": "{{agent}} のみ",
"crossEngineWarning": "エンジンを切り替えるとコンテキストが再構築され、内容が失われる場合があります",
- "favoritesSyncFailed": "お気に入りを同期できません。選択画面を開き直してください。接続先の更新が必要な場合があります。"
+ "favoritesSyncFailed": "お気に入りを同期できません。選択画面を開き直してください。接続先の更新が必要な場合があります。",
+ "railRemoteProviderGroup": "{{provider}} · {{device}} · プロバイダーグループ"
}
},
"permissionSelector": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index f61dd365a6..89ae70c130 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -467,7 +467,8 @@
"description": "새 세션이 더 이상 배정되지 않습니다. 이미 그 컴퓨터에서 실행 중인 세션은 그대로 남습니다.",
"lastDescription": "그룹의 마지막 컴퓨터입니다. 제외하면 {{provider}} 제공자 그룹이 삭제됩니다.",
"confirm": "그룹에서 제외"
- }
+ },
+ "sourceGroupOwner": "그룹을 만든 컴퓨터"
},
"deleteConfirm": {
"title": "{{provider}} 제공자 그룹을 삭제할까요?",
@@ -2825,7 +2826,12 @@
"statusReady": "사용 가능",
"detailNote": "Agent는 {{device}}에서 실행되며 그 컴퓨터의 로그인과 할당량을 씁니다. 새 작업을 만들 때 모델 목록에서 선택하면 사용할 수 있습니다. 이 제공자를 바꾸려면 그 컴퓨터의 「설정 → 모델 제공자」로 가세요.",
"modelsTitle": "사용 가능한 모델",
- "modelsEmpty": "이 제공자는 그 컴퓨터에서 아직 사용 가능한 모델을 공개하지 않았습니다."
+ "modelsEmpty": "이 제공자는 그 컴퓨터에서 아직 사용 가능한 모델을 공개하지 않았습니다.",
+ "rowLabelGroup": "{{provider}} · {{device}} · 제공자 그룹",
+ "groupBadge_other": "제공자 그룹 · 컴퓨터 {{count}}대",
+ "groupNote": "{{device}}에서 이 제공자를 제공자 그룹으로 만들었습니다. 모델 목록에서 선택해 새 작업을 만들면 {{device}}가 그룹 배정 방식에 따라 아래 컴퓨터 중 한 대에 작업을 배정하고, 그 컴퓨터에 문제가 생기면 다른 컴퓨터로 바꿔 계속합니다. 그룹을 바꾸려면 {{device}}의 「설정 → 모델 제공자」로 가세요.",
+ "groupMembersTitle": "그룹의 컴퓨터",
+ "groupMembersFailed": "지금은 그룹의 컴퓨터 상태를 가져올 수 없습니다."
},
"genericOAuth": {
"subtitle": "구독 계정",
@@ -9400,7 +9406,8 @@
"effortEndSmart": "더 똑똑하게",
"railSameEngine": "{{agent}} 전용",
"crossEngineWarning": "엔진을 전환하면 컨텍스트가 다시 구성되어 내용이 사라질 수 있습니다",
- "favoritesSyncFailed": "즐겨찾기를 동기화할 수 없습니다. 선택 화면을 다시 여세요. 원격 컴퓨터를 업데이트해야 할 수 있습니다."
+ "favoritesSyncFailed": "즐겨찾기를 동기화할 수 없습니다. 선택 화면을 다시 여세요. 원격 컴퓨터를 업데이트해야 할 수 있습니다.",
+ "railRemoteProviderGroup": "{{provider}} · {{device}} · 제공자 그룹"
}
},
"permissionSelector": {
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 1ea7207547..cd817c6d70 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -467,7 +467,8 @@
"description": "之后不再给它分新任务;已经在它上面运行的任务留在那台电脑上。",
"lastDescription": "它是组里最后一台电脑,移出后会删除 {{provider}} 的供应商组。",
"confirm": "移出组"
- }
+ },
+ "sourceGroupOwner": "组所在电脑"
},
"deleteConfirm": {
"title": "删除 {{provider}} 的供应商组?",
@@ -2825,7 +2826,12 @@
"statusReady": "可用",
"detailNote": "Agent 在 {{device}} 上运行,用的是那台电脑的登录和配额。新建任务时在模型列表里选择它就能用;要修改这个供应商,请到那台电脑的「设置 → 模型供应商」。",
"modelsTitle": "可用的模型",
- "modelsEmpty": "这个供应商在那台电脑上还没有开放可用的模型。"
+ "modelsEmpty": "这个供应商在那台电脑上还没有开放可用的模型。",
+ "rowLabelGroup": "{{provider}} · {{device}} · 供应商组",
+ "groupBadge_other": "供应商组 · {{count}} 台电脑",
+ "groupNote": "{{device}} 把这个供应商建成了供应商组。在模型列表里选它新建任务时,{{device}} 会按组策略把任务分给下面的一台电脑运行,那台出问题时自动换一台继续。要修改组,请到 {{device}} 的「设置 → 模型供应商」。",
+ "groupMembersTitle": "组内电脑",
+ "groupMembersFailed": "暂时读不到组内电脑的状态。"
},
"genericOAuth": {
"subtitle": "订阅账号",
@@ -9400,7 +9406,8 @@
"effortEndSmart": "更智能",
"railSameEngine": "仅 {{agent}}",
"crossEngineWarning": "切换引擎会重建上下文,可能丢失内容",
- "favoritesSyncFailed": "收藏未能同步。请重新打开重试;被控电脑可能需要更新。"
+ "favoritesSyncFailed": "收藏未能同步。请重新打开重试;被控电脑可能需要更新。",
+ "railRemoteProviderGroup": "{{provider}} · {{device}} · 供应商组"
}
},
"permissionSelector": {
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 039c4436aa..7d586d1921 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -467,7 +467,8 @@
"description": "之後不再給它分新任務;已經在它上面執行的任務留在那臺電腦上。",
"lastDescription": "它是組裡最後一臺電腦,移出後會刪除 {{provider}} 的供應商組。",
"confirm": "移出組"
- }
+ },
+ "sourceGroupOwner": "組所在電腦"
},
"deleteConfirm": {
"title": "刪除 {{provider}} 的供應商組?",
@@ -2825,7 +2826,12 @@
"statusReady": "可用",
"detailNote": "Agent 在 {{device}} 上執行,使用的是那台電腦的登入和配額。新建任務時在模型列表裡選擇它就能用;要修改這個供應商,請到那台電腦的「設定 → 模型供應商」。",
"modelsTitle": "可用的模型",
- "modelsEmpty": "這個供應商在那台電腦上還沒有開放可用的模型。"
+ "modelsEmpty": "這個供應商在那台電腦上還沒有開放可用的模型。",
+ "rowLabelGroup": "{{provider}} · {{device}} · 供應商組",
+ "groupBadge_other": "供應商組 · {{count}} 台電腦",
+ "groupNote": "{{device}} 把這個供應商建成了供應商組。在模型列表裡選它新建任務時,{{device}} 會依組策略把任務分給下面的一台電腦執行,那台出問題時自動換一台繼續。要修改組,請到 {{device}} 的「設定 → 模型供應商」。",
+ "groupMembersTitle": "組內電腦",
+ "groupMembersFailed": "暫時讀不到組內電腦的狀態。"
},
"genericOAuth": {
"subtitle": "訂閱帳號",
@@ -9399,7 +9405,8 @@
"effortEndSmart": "更聰明",
"railSameEngine": "僅 {{agent}}",
"crossEngineWarning": "切換引擎會重建上下文,可能遺失內容",
- "favoritesSyncFailed": "收藏未能同步。請重新開啟重試;被控電腦可能需要更新。"
+ "favoritesSyncFailed": "收藏未能同步。請重新開啟重試;被控電腦可能需要更新。",
+ "railRemoteProviderGroup": "{{provider}} · {{device}} · 供應商組"
},
"modelListAria": "模型清單"
},
diff --git a/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts b/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts
new file mode 100644
index 0000000000..ff62c5bac3
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts
@@ -0,0 +1,73 @@
+/**
+ * 远程供应商列表里的供应商组(provider-groups.md §10):其他在线电脑的组里的电脑与分享收起,
+ * 组所在电脑那一项标成供应商组。
+ */
+import type { ProviderView } from '@cindy/model-providers';
+import { describe, expect, it } from 'vitest';
+
+import { collectRemoteProviderGroups, remoteProviderEntryKey } from '../remoteProviderGroups';
+
+function provider(id: string, extra: Record<string, unknown> = {}): ProviderView {
+ return { id, name: id, agents: ['claude-code'], connected: true, remoteInvocationEnabled: true, models: {}, routing: {}, ...extra } as unknown as ProviderView;
+}
+
+function group(members: Array<Record<string, unknown>>) {
+ return { strategy: 'least', autoSwitch: true, members: [{ kind: 'local' }, ...members] };
+}
+
+describe('collectRemoteProviderGroups', () => {
+ it('hides the computers and shares in another computer’s group and marks the group entry', () => {
+ const result = collectRemoteProviderGroups([
+ {
+ deviceId: 'mini',
+ providers: [provider('anthropic', {
+ group: group([
+ { kind: 'device', agentDeviceId: 'studio', providerId: 'anthropic-1a2b3c4d' },
+ { kind: 'share', agentDeviceId: 'share:s1', providerId: 'anthropic' },
+ ]),
+ })],
+ },
+ { deviceId: 'studio', providers: [provider('anthropic-1a2b3c4d'), provider('openai')] },
+ ]);
+ expect([...result.hidden].sort()).toEqual([
+ remoteProviderEntryKey('share:s1', 'anthropic'),
+ remoteProviderEntryKey('studio', 'anthropic-1a2b3c4d'),
+ ].sort());
+ expect(result.groups.get(remoteProviderEntryKey('mini', 'anthropic'))?.members).toHaveLength(3);
+ expect(result.hidden.has(remoteProviderEntryKey('studio', 'openai'))).toBe(false);
+ });
+
+ it('keeps both groups when two groups contain each other, and keeps the entry in use', () => {
+ const result = collectRemoteProviderGroups([
+ { deviceId: 'mini', providers: [provider('anthropic', { group: group([{ kind: 'device', agentDeviceId: 'studio', providerId: 'anthropic' }]) })] },
+ { deviceId: 'studio', providers: [provider('anthropic', { group: group([{ kind: 'device', agentDeviceId: 'mini', providerId: 'anthropic' }, { kind: 'device', agentDeviceId: 'laptop', providerId: 'anthropic' }]) })] },
+ ], [remoteProviderEntryKey('laptop', 'anthropic')]);
+ expect(result.hidden.size).toBe(0);
+ expect(result.groups.size).toBe(2);
+ });
+
+ it('also hides the remote members of groups this computer created', () => {
+ const local = {
+ strategy: 'least' as const,
+ autoSwitch: true,
+ members: [
+ { key: 'local', kind: 'local' as const, agentDeviceId: null, providerId: 'anthropic', limit: 4, weight: 1, paused: false },
+ { key: 'device:studio:anthropic', kind: 'device' as const, agentDeviceId: 'studio', providerId: 'anthropic', limit: 4, weight: 1, paused: false },
+ ],
+ };
+ const result = collectRemoteProviderGroups([{ deviceId: 'studio', providers: [provider('anthropic')] }], [], [local]);
+ expect([...result.hidden]).toEqual([remoteProviderEntryKey('studio', 'anthropic')]);
+ expect(result.groups.size).toBe(0);
+ });
+
+ it('ignores groups on providers not open for remote use and malformed summaries', () => {
+ const result = collectRemoteProviderGroups([
+ { deviceId: 'mini', providers: [
+ provider('anthropic', { remoteInvocationEnabled: false, group: group([{ kind: 'device', agentDeviceId: 'studio', providerId: 'a' }]) }),
+ provider('openai', { group: { members: 'nope' } }),
+ ] },
+ ]);
+ expect(result.hidden.size).toBe(0);
+ expect(result.groups.size).toBe(0);
+ });
+});
diff --git a/apps/desktop/src/renderer/lib/remoteProviderGroups.ts b/apps/desktop/src/renderer/lib/remoteProviderGroups.ts
new file mode 100644
index 0000000000..eb4ebbd483
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/remoteProviderGroups.ts
@@ -0,0 +1,65 @@
+/**
+ * 远程供应商列表里的供应商组(docs/product-rules/provider-groups.md §10):同账号另一台电脑把某个供应商
+ * 建成了组,组里的其他电脑与分享就不再单独列出,只列组所在电脑那一项,并标成供应商组。
+ *
+ * 只看列表里此刻在线(调用方传进来)的电脑的目录:组所在电脑离线时它的那一项不在,组员自然重新单独出现。
+ * 规则:
+ * - 本身带组的项不收起(两个组互相包含时两个组都还在);
+ * - 当前任务正在用的那一项保留(调用方经 keep 传入),已直接用某台组员跑过的任务不丢来源;
+ * - 本机自己的供应商不在远程列表里,组里的「本机这台」不影响本机那一栏。
+ */
+import type { ProviderView } from '@cindy/model-providers';
+
+import { readProviderGroupSummary, type ProviderGroupConfig } from '../../shared/providerGroup';
+
+/** 远程列表里一项的键:Agent 所在电脑(含 `share:<id>`) + 那台上的供应商 id。 */
+export function remoteProviderEntryKey(agentDeviceId: string, providerId: string): string {
+ return `${agentDeviceId}\n${providerId}`;
+}
+
+/** 组所在电脑目录里某个供应商带的组摘要;没有组或格式不对返回 null。 */
+export function remoteProviderGroupOf(provider: ProviderView): ProviderGroupConfig | null {
+ return readProviderGroupSummary((provider as { group?: unknown }).group, provider.id);
+}
+
+export interface RemoteProviderGroups {
+ /** 被收起的组员(按 remoteProviderEntryKey)。 */
+ hidden: ReadonlySet<string>;
+ /** 带组的项(按 remoteProviderEntryKey) → 组设置。 */
+ groups: ReadonlyMap<string, ProviderGroupConfig>;
+}
+
+/**
+ * @param catalogs 列表里此刻在线的其他电脑的目录(带组摘要)。
+ * @param keep 当前正在用、不能收起的项。
+ * @param localGroups 任务所在电脑自己建的组(本机任务时是本机的组):它们的组员同样收起,组那一项是
+ * 本机自己的供应商,在本机那一栏,不在远程列表里。
+ */
+export function collectRemoteProviderGroups(
+ catalogs: Iterable<{ deviceId: string; providers: readonly ProviderView[] }>,
+ keep: Iterable<string> = [],
+ localGroups: Iterable<ProviderGroupConfig> = [],
+): RemoteProviderGroups {
+ const groups = new Map<string, ProviderGroupConfig>();
+ const members = new Set<string>();
+ const addMembers = (config: ProviderGroupConfig) => {
+ for (const member of config.members) {
+ // 组里的「组所在电脑自己」就是组那一项本身。
+ if (member.kind === 'local' || !member.agentDeviceId) continue;
+ members.add(remoteProviderEntryKey(member.agentDeviceId, member.providerId));
+ }
+ };
+ for (const { deviceId, providers } of catalogs) {
+ for (const provider of providers) {
+ if (provider.remoteInvocationEnabled !== true) continue;
+ const config = remoteProviderGroupOf(provider);
+ if (!config) continue;
+ groups.set(remoteProviderEntryKey(deviceId, provider.id), config);
+ addMembers(config);
+ }
+ }
+ for (const config of localGroups) addMembers(config);
+ for (const key of groups.keys()) members.delete(key);
+ for (const key of keep) members.delete(key);
+ return { hidden: members, groups };
+}
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index 987c980d98..d19fe505bb 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -127,14 +127,20 @@ export type ProviderGroupCommand =
| { action: 'get'; providerId: string }
| { action: 'candidates'; providerId: string }
| { action: 'save'; providerId: string; config: ProviderGroupConfig }
- | { action: 'delete'; providerId: string };
+ | { action: 'delete'; providerId: string }
+ /** 同账号另一台电脑上这个供应商的组与组内电脑状态(只读)。 */
+ | { action: 'remote-view'; providerId: string; deviceId: string }
+ /** 本机全部组的设置(不读远端)。 */
+ | { action: 'list' };
export type ProviderGroupCommandResult<C extends ProviderGroupCommand> =
- C extends { action: 'get' } ? ProviderGroupView
+ C extends { action: 'list' } ? Record<string, ProviderGroupConfig>
+ : C extends { action: 'get' } ? ProviderGroupView
: C extends { action: 'candidates' } ? ProviderGroupCandidate[]
: C extends { action: 'save' } ? ProviderGroupView
: C extends { action: 'delete' } ? ProviderGroupView
- : never;
+ : C extends { action: 'remote-view' } ? ProviderGroupView
+ : never;
const PROVIDER_ID_PATTERN = /^[a-zA-Z0-9._-]{1,128}$/;
const DEVICE_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
@@ -222,3 +228,205 @@ export function normalizeProviderGroupConfig(raw: unknown, groupProviderId: stri
if (members.length === 0) return null;
return { strategy, autoSwitch: value.autoSwitch !== false, members };
}
+
+// ─── 同账号电脑之间(`maker:provider:list` 的 `group` 字段与 `provider-group:remote` 通道) ─────
+
+/**
+ * 组所在电脑的目录里随组所属供应商带出的组摘要:只给同账号电脑,受邀者与共享任务访客看不到。
+ * 组员的坐标是组所在电脑视角(`local` = 组所在电脑自己)。并发上限与权重只在组所在电脑上生效,不外发。
+ */
+export interface ProviderGroupWireSummary {
+ strategy: ProviderGroupStrategy;
+ autoSwitch: boolean;
+ members: Array<Pick<ProviderGroupMember, 'key' | 'kind' | 'agentDeviceId' | 'providerId' | 'label' | 'paused'>>;
+}
+
+export function providerGroupSummaryForWire(config: ProviderGroupConfig): ProviderGroupWireSummary {
+ return {
+ strategy: config.strategy,
+ autoSwitch: config.autoSwitch,
+ members: config.members.map((m) => ({
+ key: m.key,
+ kind: m.kind,
+ agentDeviceId: m.agentDeviceId,
+ providerId: m.providerId,
+ ...(m.label ? { label: m.label } : {}),
+ paused: m.paused,
+ })),
+ };
+}
+
+/** 读另一台电脑目录里的组摘要;格式不对返回 null(当作没有组)。 */
+export function readProviderGroupSummary(raw: unknown, groupProviderId: string): ProviderGroupConfig | null {
+ return normalizeProviderGroupConfig(raw, groupProviderId);
+}
+
+/** 换电脑的原因里,会让组所在电脑冷却那台的几种(连不上只由发现它的电脑自己避开,不替全组判断)。 */
+export type ProviderGroupRemoteCoolCause = 'usage-limit' | 'auth' | 'overload';
+const REMOTE_COOL_CAUSES: readonly ProviderGroupRemoteCoolCause[] = ['usage-limit', 'auth', 'overload'];
+
+export interface ProviderGroupRemoteLease {
+ sessionId: string;
+ providerId: string;
+ memberKey: string;
+}
+
+export type ProviderGroupRemoteRequest =
+ /** 新任务该用组里哪台;选中即给那台记一个短暂的占用,同时开的几个任务不会全落到同一台。 */
+ | { action: 'pick'; sessionId: string; providerId: string; agentKind: 'claude-code' | 'codex' | 'pi'; model: string; exclude: string[] }
+ /** 那台电脑出了问题(用量上限、登录失效、服务繁忙):组所在电脑冷却它,不再分新任务。 */
+ | { action: 'cool'; providerId: string; memberKey: string; cause: ProviderGroupRemoteCoolCause; resetAt?: number }
+ /** 这台电脑经组运行、正在跑的任务(整体替换上一份;seq 只增,乱序到达的旧份丢弃)。 */
+ | { action: 'leases'; seq: number; entries: ProviderGroupRemoteLease[] }
+ /** 组内电脑的状态(发送前检查、设置页展示)。 */
+ | { action: 'view'; providerId: string };
+
+export type ProviderGroupRemotePick =
+ /** 那个供应商现在没有组(组被删了或旧版本):照常直接在组所在电脑上运行。 */
+ | { kind: 'none' }
+ | { kind: 'member'; member: Pick<ProviderGroupMember, 'key' | 'kind' | 'agentDeviceId' | 'providerId'>; label: string }
+ | { kind: 'unavailable' };
+
+/** 一次最多报告的运行中任务数(每台电脑的任务上限远低于此)。 */
+export const PROVIDER_GROUP_REMOTE_MAX_LEASES = 512;
+const REMOTE_SESSION_ID = /^[A-Za-z0-9_-]{1,128}$/;
+const REMOTE_MEMBER_KEY = /^[A-Za-z0-9_.:-]{1,300}$/;
+const REMOTE_AGENT_KINDS = new Set(['claude-code', 'codex', 'pi']);
+
+function invalidRemote(message: string): never {
+ throw new Error(`[INVALID_PARAMS] ${message}`);
+}
+
+function remoteRecord(raw: unknown): Record<string, unknown> {
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) invalidRemote('provider group request must be an object');
+ return raw as Record<string, unknown>;
+}
+
+function remoteProviderId(value: unknown): string {
+ if (!isProviderGroupProviderId(value)) invalidRemote('invalid provider id');
+ return value;
+}
+
+function remoteMemberKey(value: unknown): string {
+ if (typeof value !== 'string' || !REMOTE_MEMBER_KEY.test(value)) invalidRemote('invalid member key');
+ return value;
+}
+
+function remoteSessionId(value: unknown): string {
+ if (typeof value !== 'string' || !REMOTE_SESSION_ID.test(value)) invalidRemote('invalid session id');
+ return value;
+}
+
+/** 组所在电脑解析同账号电脑发来的请求;不合法抛 `[INVALID_PARAMS]`。 */
+export function parseProviderGroupRemoteRequest(raw: unknown): ProviderGroupRemoteRequest {
+ const value = remoteRecord(raw);
+ switch (value.action) {
+ case 'pick': {
+ const agentKind = value.agentKind;
+ if (typeof agentKind !== 'string' || !REMOTE_AGENT_KINDS.has(agentKind)) invalidRemote('invalid agent');
+ if (typeof value.model !== 'string' || !value.model || value.model.length > 512) invalidRemote('invalid model');
+ const exclude = value.exclude === undefined ? [] : value.exclude;
+ if (!Array.isArray(exclude) || exclude.length > PROVIDER_GROUP_STORAGE_MEMBER_CAP) invalidRemote('invalid exclude');
+ return {
+ action: 'pick',
+ sessionId: remoteSessionId(value.sessionId),
+ providerId: remoteProviderId(value.providerId),
+ agentKind: agentKind as 'claude-code' | 'codex' | 'pi',
+ model: value.model,
+ exclude: exclude.map(remoteMemberKey),
+ };
+ }
+ case 'cool': {
+ const cause = value.cause;
+ if (!REMOTE_COOL_CAUSES.includes(cause as ProviderGroupRemoteCoolCause)) invalidRemote('invalid cause');
+ const resetAt = typeof value.resetAt === 'number' && Number.isFinite(value.resetAt) && value.resetAt > 0
+ ? value.resetAt
+ : undefined;
+ return {
+ action: 'cool',
+ providerId: remoteProviderId(value.providerId),
+ memberKey: remoteMemberKey(value.memberKey),
+ cause: cause as ProviderGroupRemoteCoolCause,
+ ...(resetAt !== undefined ? { resetAt } : {}),
+ };
+ }
+ case 'leases': {
+ if (!Number.isSafeInteger(value.seq) || (value.seq as number) < 0) invalidRemote('invalid seq');
+ if (!Array.isArray(value.entries) || value.entries.length > PROVIDER_GROUP_REMOTE_MAX_LEASES) invalidRemote('invalid leases');
+ return {
+ action: 'leases',
+ seq: value.seq as number,
+ entries: value.entries.map((entry) => {
+ const lease = remoteRecord(entry);
+ return {
+ sessionId: remoteSessionId(lease.sessionId),
+ providerId: remoteProviderId(lease.providerId),
+ memberKey: remoteMemberKey(lease.memberKey),
+ };
+ }),
+ };
+ }
+ case 'view':
+ return { action: 'view', providerId: remoteProviderId(value.providerId) };
+ default:
+ invalidRemote('unknown provider group action');
+ }
+}
+
+/** 同账号电脑读组所在电脑 `pick` 的回包;格式不对按「没有组」处理。 */
+export function parseProviderGroupRemotePick(raw: unknown, groupProviderId: string): ProviderGroupRemotePick {
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { kind: 'none' };
+ const value = raw as Record<string, unknown>;
+ if (value.kind === 'unavailable') return { kind: 'unavailable' };
+ if (value.kind !== 'member') return { kind: 'none' };
+ const member = normalizeMember(value.member, groupProviderId);
+ if (!member) return { kind: 'none' };
+ const label = normalizeLabel(value.label) ?? member.label ?? member.key;
+ return {
+ kind: 'member',
+ member: { key: member.key, kind: member.kind, agentDeviceId: member.agentDeviceId, providerId: member.providerId },
+ label,
+ };
+}
+
+const MEMBER_STATES: readonly ProviderGroupMemberState[] = ['available', 'full', 'paused', 'cooling', 'offline', 'unavailable'];
+const UNAVAILABLE_REASONS: readonly ProviderGroupUnavailableReason[] = ['provider-off', 'disconnected', 'share-paused', 'share-removed'];
+
+/** 同账号电脑读组所在电脑 `view` 的回包(设置页只读展示、发送前检查);坏条目丢弃。 */
+export function parseProviderGroupRemoteView(raw: unknown, groupProviderId: string): ProviderGroupView {
+ const empty: ProviderGroupView = { providerId: groupProviderId, config: null, members: [] };
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return empty;
+ const value = raw as Record<string, unknown>;
+ const config = normalizeProviderGroupConfig(value.config, groupProviderId);
+ if (!config) return empty;
+ const keys = new Set(config.members.map((m) => m.key));
+ const count = (v: unknown, max: number) =>
+ typeof v === 'number' && Number.isFinite(v) ? Math.min(max, Math.max(0, Math.round(v))) : 0;
+ const members = (Array.isArray(value.members) ? value.members : []).flatMap((entry): ProviderGroupMemberStatus[] => {
+ if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return [];
+ const item = entry as Record<string, unknown>;
+ const key = typeof item.key === 'string' && keys.has(item.key) ? item.key : null;
+ const state = MEMBER_STATES.includes(item.state as ProviderGroupMemberState) ? item.state as ProviderGroupMemberState : null;
+ const member = key ? config.members.find((m) => m.key === key)! : null;
+ if (!member || !state) return [];
+ const reason = UNAVAILABLE_REASONS.includes(item.reason as ProviderGroupUnavailableReason)
+ ? item.reason as ProviderGroupUnavailableReason
+ : undefined;
+ const ownerName = normalizeLabel(item.ownerName);
+ const coolingUntil = typeof item.coolingUntil === 'number' && Number.isFinite(item.coolingUntil) ? item.coolingUntil : undefined;
+ return [{
+ key: member.key,
+ kind: member.kind,
+ label: normalizeLabel(item.label) ?? member.label ?? member.key,
+ ...(ownerName ? { ownerName } : {}),
+ state,
+ ...(reason ? { reason } : {}),
+ running: count(item.running, 10_000),
+ limit: member.limit,
+ weight: member.weight,
+ paused: member.paused,
+ ...(coolingUntil !== undefined ? { coolingUntil } : {}),
+ }];
+ });
+ return { providerId: groupProviderId, config, members };
+}
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 079eb1b4cb..8a2e1f02b5 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -703,6 +703,36 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
覆盖 IPC、远程与 Agent 工具入口),不能复制到其他电脑(`task-migration/service.ts`);侧栏照常显示,
任务头标注「来自 X 的协同」,结束后显示「协同已结束」。
+## 供应商组:同账号直连(P2a)
+
+产品规则见 [`provider-groups.md`](../product-rules/provider-groups.md) §4、§5、§6.1、§10。组所在电脑 O 把某个供应商建成组后,
+同账号另一台电脑 C 上选了 O 的这个供应商的新任务:C 问 O 该用哪台,再自己直接连到选中的组内电脑运行。
+
+- **新 invoke channel `provider-group:remote`**(`packages/device-link/src/providerGroup.ts`,进同账号 allowlist),被控端
+ `dispatch.ts` 拦截执行,不落 ipcMain handler;供应商分享受邀者(不在 `PROVIDER_SHARE_CHANNELS`)与共享任务访客一律
+ `CHANNEL_NOT_ALLOWED`。请求 `{ action, ... }`,结构与校验在 `apps/desktop/src/shared/providerGroup.ts`(两端同一份):
+ - `pick { sessionId, providerId, agentKind, model, exclude[] }` → `{ kind: 'member', member: { key, kind, agentDeviceId, providerId }, label }`
+ / `{ kind: 'unavailable' }` / `{ kind: 'none' }`(没有组或供应商没开放远程调用)。组员坐标是 O 视角(`local` = O 自己),C 换算成
+ 本机位置;选中即给那台记 30s 临时占用;
+ - `cool { providerId, memberKey, cause: 'usage-limit' | 'auth' | 'overload', resetAt? }` → O 冷却那台(`resetAt` 最多信 8 天);
+ 连不上不报,只由 C 自己避开;
+ - `leases { seq, entries: [{ sessionId, providerId, memberKey }] }` → 整体替换 C 正在运行的经组任务,`seq` 只增(C 按时间生成,
+ 重启后仍增大),乱序旧包丢弃,150s 不刷新作废;只用于分摊负载;
+ - `view { providerId }` → 组设置与组员状态(`ProviderGroupView`)。
+ 旧 O 回 `CHANNEL_NOT_ALLOWED`:`pick` 按 `none` 处理,任务照旧直接在 O 上运行。
+- **`maker:provider:list` 新增可选字段 `group`**:只对同账号调用方、只加在建了组且「允许被远程调用」的供应商上:
+ `{ strategy, autoSwitch, members: [{ key, kind, agentDeviceId, providerId, label?, paused }] }`(并发上限与权重不外发)。
+ 组摘要列着组内电脑,受邀者与共享任务访客拿不到:分享投影里去掉,`scrubSharedProvider` 再兜一层(分享者电脑、受邀者电脑与
+ 手机各过一遍)。旧控制端与手机不认识就忽略;新控制端据此在模型列表与设置页收起组员(只看在线电脑的目录)。O 改组后经
+ `maker:provider:changed` 推送让同账号电脑重读目录。
+- **远程 Agent open 载荷新增可选 `groupAssigned: true`**(`remote-agent/wire.ts`):任务由供应商组分配到这台(本机的组或另一台的组),
+ 这台直接运行、不再进入它自己的组(防转圈)。旧被控端解码时丢弃(它本来没有组)。
+- **本地数据**:C 上经另一台电脑的组分配的任务绑定存 `provider-group-remote-bindings.json`(按账号,与本机组的
+ `provider-group-bindings.json` 分开,降级后旧版本读不到它,不会误认成本机的同名组)。不改数据库与服务端。
+- 实现:`apps/desktop/src/main/provider-group/`(`remoteHandler.ts`、`remoteClient.ts`、`externalLoad.ts`、`leaseReporter.ts`、
+ `service.ts` 的组来源);回归见同目录 `__tests__/remoteGroup.test.ts`、`remoteHandler.test.ts`、`leaseReporter.test.ts`,
+ `device-link/__tests__/providerShareDispatch.test.ts`(受邀者拒绝与不泄露组摘要)。
+
## 事实来源
| 内容 | 权威来源 |
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index e5cec37d29..da6fdb6ad2 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -1,7 +1,9 @@
# 供应商组:一台电脑把多台电脑上的同一个供应商合成一组
> 产品方案:2026-10-09 用户确认(含自动换电脑、受邀者不提醒、自定义供应商按名称匹配、不设数量上限)。
-> 实现进度见 §12:P1(组设置、组所在电脑自己的任务按组分配与自动换电脑)已实现,P2、P3 未实现。
+> 2026-10-10 用户确认:同账号其他电脑经组使用时**直接连到选中的组内电脑**(不经组所在电脑中转),
+> 分享的人仍经组所在电脑中转;被组收进去的远程供应商与分享,在同账号其他电脑上只显示组那一项。
+> 实现进度见 §12:P1 已实现;P2 同账号直连与模型列表只显示组(P2a)已实现,分享的人经组中转(P2b)未实现;P3 未实现。
> 交互设计稿见 [`docs/design-previews/provider-groups/index.html`](../design-previews/provider-groups/index.html)。
> 读取时机:新增或修改供应商组、组策略、组内电脑的添加与状态、经供应商组的任务分配或转发、
> 供应商组用量与「远程与分享」页之前。
@@ -17,13 +19,13 @@
供应商加进来。之后这个供应商在组所在电脑上的所有使用都按**组策略**选一台**组内电脑**运行:
- 组所在电脑自己的任务;
-- 同账号的其他电脑把组所在电脑的这个供应商当远程供应商使用;
-- 别人通过分享使用组所在电脑分享出去的这个供应商。
+- 同账号的其他电脑把组所在电脑的这个供应商当远程供应商使用(组所在电脑选电脑,那台电脑直接连过去);
+- 别人通过分享使用组所在电脑分享出去的这个供应商(组所在电脑选电脑并转发)。
这样一台现成的 Cindy 就是网关,不需要另外部署服务;登录、界面、分享链接与审批全部复用。
**Agent 始终在被选中的组内电脑上运行**,用那台电脑的 Agent 程序、登录、供应商与网络;
-任务的文件与命令仍在发起任务的电脑上执行。组所在电脑只负责选电脑与转发。
+任务的文件与命令仍在发起任务的电脑上执行。组所在电脑只负责选电脑,对分享的人还负责转发。
## 2. 术语
@@ -59,13 +61,15 @@
把两台电脑上的名称改成一样即可。
- 判断所需的品牌信息取远端供应商目录里已有的去敏字段,不新增协议字段。
- 组内电脑必须与组所在电脑在同一区域(跨区域分享默认关闭,见供应商分享 §8)。
-- 分享关系属于账号:组所在电脑账号收到的分享,在这个账号的其他电脑上仍按普通的「分享给我的供应商」显示和使用;
- 「挂在组里」只是组所在电脑本机的设置。
+- 分享关系属于账号:组所在电脑账号收到的分享,这个账号的其他电脑也能直接用。被组所在电脑加进组之后,
+ 这个账号的其他电脑上不再单独列出它,只列组那一项(与同账号电脑被收进组同一条规则,§10);组所在电脑离线时
+ 它重新单独出现。组设置本身仍只存在组所在电脑本机。
- 组内电脑数量不设上限;每台的并发上限见 §5。
- Orca 协同任务与审查任务对 Agent 位置各有契约,首版不归供应商组分配,照原样在本机运行。
- 组里至少保留一台组内电脑;移除最后一台即删除组。
- **组只是这台电脑上这个供应商的一项设置,不新增账号级的概念。** 同账号的几台电脑可以各自建组、成员也可以重叠,
- 组与组之间互不感知:每个组只管经它发起的任务;直接选某台电脑的远程供应商仍是在那台直接运行,与现在一致。
+ 组与组之间互不感知:每个组只管经它发起的任务;被收进组的电脑在其他电脑的列表里只在组所在电脑离线时单独出现,
+ 这时直接选它仍是在那台直接运行,与现在一致。
重叠不会出错——组内电脑被别的组或别人直接用满、撞到用量上限时,经本组的任务会失败,按 §6.1 直接换下一台,
最多多一次换电脑。界面建议在一台常开的电脑上建组,其他电脑选这个组的入口,但不强制。
@@ -73,23 +77,33 @@
- 判断依据是任务实际使用的供应商连接,不看发起方:§1 列出的三种使用走同一套组策略与绑定规则。
- 组内电脑是本机时,Agent 直接在本机运行,与现在一致。
-- 组内电脑是其他电脑时,组所在电脑作为控制端把任务转发过去:对「我的其他电脑」是同账号远程 Agent;
+- **组所在电脑自己的任务**:组内电脑是其他电脑时,组所在电脑作为控制端连过去:对「我的其他电脑」是同账号远程 Agent;
对分享来的电脑,组所在电脑的账号是那台电脑的受邀者。
-- **防转圈**:经组转发到组内电脑的任务,在那台电脑上直接运行,不再进入那台电脑自己的供应商组。
- 打开任务时带一个可选标记说明「已由供应商组分配」;旧版本不认识这个标记,也是直接运行。
- 该标记属于跨端协议的新增可选字段,实现时按 `docs/dev-rules/protocol-compatibility.md` 登记。
+- **同账号其他电脑(直连,2026-10-10)**:任务所在的电脑先问组所在电脑「该用哪台」(`provider-group:remote` 通道,只给
+ 同账号),再**自己直接连到选中的组内电脑**:选中组所在电脑本身就连组所在电脑,选中任务所在的这台就在本机运行,
+ 选中分享来的电脑就用这个账号收到的那个分享(分享属于账号,§3)。少一次中转;组所在电脑关机不影响已经在跑的任务。
+ 组所在电脑看不到这些任务的内容,任务所在的电脑把正在跑的经组任务报告给它(只用于统计负载),组内电脑出问题时把
+ 需要冷却的电脑报告给它(§5、§6.1)。
+- **分享的人**:连不到组内其他电脑,由组所在电脑选电脑并中转(P2b)。
+- **防转圈**:经组分配到组内电脑的任务,在那台电脑上直接运行,不再进入那台电脑自己的供应商组。
+ 打开任务时带一个可选标记 `groupAssigned` 说明「已由供应商组分配」;旧版本不认识这个标记,也是直接运行。
+ 登记见 `docs/dev-rules/protocol-compatibility.md`「供应商组」。
## 5. 组策略
- **选择方式**:最少占用(默认,选正在运行任务最少的那台)、轮询、按顺序(排在前面的优先,前面的不可用才用后面的)、
按权重。
-- **并发上限**:每台组内电脑单独设置,默认 4,最多 16(远程 Agent 对每个控制端的上限);只统计经本组分到这台的任务。
+- **并发上限**:每台组内电脑单独设置,默认 4,最多 16(远程 Agent 对每个控制端的上限);只统计经本组分到这台的任务,
+ 包括同账号其他电脑经本组直连过去的任务:它们由任务所在的电脑在每一轮开始、结束时报告,运行期间每分钟再报一次,
+ 组所在电脑 150 秒收不到就不再计入;刚选中、还没报告的任务先按占用记 30 秒,同时开的几个任务不会全落到同一台。
- **只分给可用的电脑**:在线;对方仍允许远程控制,且仍对这个供应商允许被远程调用;分享未暂停、未删除;
不在冷却中;提供所选模型;未被设为「暂停分配」。优先分给未达到并发上限的;都满了时分给相对最空的一台,
并发上限只用来分摊,不因满载拒绝消息。
- **冷却**:组内电脑上的任务报用量上限时,这台电脑进入冷却,不再接新任务。重置时刻按
[用量上限自动继续](usage-limit-auto-continue.md) 的口径取(不采用不带时区的钟点);取不到时默认冷却 30 分钟。
冷却不主动迁移这台电脑上正在运行的其他任务;它们自己撞到上限时再按 §6.1 换电脑。
+ 同账号其他电脑直连时撞到用量上限、登录失效或服务繁忙,也报告给组所在电脑冷却那台(报来的重置时刻最多信 8 天);
+ 连不上只由发现它的那台电脑自己在这一轮避开,不替全组判断——可能只是那台电脑自己连不过去。
- 组内电脑的在线状态、分享状态与模型目录定时核对;不可用的电脑在组里标出原因。
- 组里所有电脑都失败才报错,见 §6 自动换电脑。
@@ -146,19 +160,24 @@
Agent 还没开始运行就失败(打开任务阶段)时,在启动入口直接换下一台。代码在 `apps/desktop/src/main/provider-group/`。
- **谁来执行换电脑**:交接要用到任务的对话记录,所以由任务所在的电脑执行。
- 组所在电脑自己的任务:组所在电脑直接换。
- - 同账号其他电脑与分享的人:组所在电脑告诉任务所在的电脑「需要换一台」,那边自动交接后重新打开,
+ - 同账号其他电脑(直连):任务所在的电脑直接看到组内电脑的报错,自己换:把需要冷却的电脑报告给组所在电脑,
+ 再问它下一台(带上这一轮试过的),交接与续跑与组所在电脑自己的任务同一套。组所在电脑读不到时(离线、断线)
+ 不换电脑、绑定不动,交回原有的报错;确认组已删除或这台已不在组里时才解除绑定,任务成为普通的远程 Agent 任务。
+ - 分享的人:组所在电脑告诉任务所在的电脑「需要换一台」,那边自动交接后重新打开,
组所在电脑再为它选新电脑。任务所在的电脑需要更新到支持这个功能的版本;旧版本只会看到原有的报错,
- 可以手动换模型。
+ 可以手动换模型。(P2b)
- **不续接的打开**(第一次运行、交接后的新会话)优先回到原电脑;原电脑不可用或满载时换一台,绑定改到新电脑,
旧电脑上的会话不能再续接。
- **模型**:组对外提供组内电脑模型的并集;新任务只分给提供所选模型的电脑。任务中途换模型时在当前组内电脑上核对,
它不提供该模型时提示换模型,不自动换电脑。
+ 已知差异(P2a):同账号其他电脑的模型列表里,组那一项列的是组所在电脑本机这个供应商的模型,还不是并集。
- 任务详情与任务头部显示实际运行的电脑:「在 {电脑} 上运行 · 由供应商组分配」;受邀者那边不显示(§8)。
## 7. 用量
- **记账位置**:组所在电脑。经这个供应商运行或转发的任务都记账,包括本机、同账号其他电脑与分享的人;
- 组所在电脑选电脑,知道每个任务实际在哪台运行。
+ 组所在电脑选电脑,知道每个任务实际在哪台运行。同账号其他电脑直连时组所在电脑不经手内容,用量要由任务所在的
+ 电脑报告给它(P3 定口径)。
- **两个维度**:
- 按使用方:本机、我的其他电脑(按电脑分开)、分享的人(按人分开);
- 按组内电脑:每台实际运行的用量。
@@ -195,6 +214,8 @@
不再自动换电脑;之后同一台电脑重新加入、或重建同一个组,这些任务也不会恢复自动换电脑。
5. **防转圈**(§4)。
6. 同账号的组内电脑沿用同账号远程 Agent 的信任等级,组不改变它。
+7. **组内电脑的名单只给同账号电脑。** `provider-group:remote` 通道与目录里的组摘要都只给同账号电脑:受邀者与共享任务
+ 访客调用通道一律拒绝,分享出去的目录里去掉组摘要(分享者电脑、受邀者电脑与手机各去一遍)。
## 10. 界面
@@ -219,15 +240,24 @@
供应商不一致(§3 口径)、链接属于自己账号、链接失效时给出对应提示。
- **模型列表**:组所在电脑上供应商项不变;同账号其他电脑上的远程供应商分组标题写
「{供应商} · {组所在电脑} · 供应商组」;受邀者看到的标题不变(「来自 {分享者} 的分享」)。
+- **只显示组**(2026-10-10):同账号其他电脑的模型列表与设置页左栏里,被其他在线电脑的组收进去的远程供应商与
+ 分享不再单独列出,只列组所在电脑那一项;不在任何组里的照常单独显示。规则:
+ - 只看此刻在线、列表里有的电脑的目录:组所在电脑离线时组那一项不在,组员自动重新单独出现;
+ - 本身带组的项不收起(两个组互相包含时两个组都还在);本机自己的供应商照常显示;
+ - 当前任务正在用的那一项不收起,已直接用某台组员跑过的任务不会丢了来源;
+ - 设置页里组那一项行内写「供应商组 · {N} 台电脑」,详情只读列出组内电脑与状态(问组所在电脑,每 15 秒重读),
+ 说明组设置要到组所在电脑上改。
+ - 手机端本期不收起(手机只显示任务实际运行的电脑)。
- Light 与 Dark 两种模式都要实现。
## 11. 与现有规则的关系
- [供应商分享](provider-sharing.md):§4.1 第 3 步的告知不论有没有组都改用 §8 的说法;§1「Agent 在分享者电脑上运行」、
§7.2 管理页、§7.4 用量、§9 安全不变量在有组时按本文调整;实现时同步修订该文。
-- 远程 Agent 协议:新增 §4 的「已由供应商组分配」可选标记,以及 §6.1 的「需要换一台」:任务所在电脑打开任务时
- 声明支持(可选字段),组所在电脑只对声明了的电脑返回这个新错误码。其余沿用现有协议,不改服务端。
- 兼容做法见 §14,实现时按 `docs/dev-rules/protocol-compatibility.md` 登记。
+- 远程 Agent 协议:新增 §4 的「已由供应商组分配」可选标记(`groupAssigned`);同账号直连新增同账号通道
+ `provider-group:remote` 与目录里的组摘要;分享的人的「需要换一台」(P2b):任务所在电脑打开任务时声明支持(可选字段),
+ 组所在电脑只对声明了的电脑发出。其余沿用现有协议,不改服务端。兼容做法见 §14,登记见
+ `docs/dev-rules/protocol-compatibility.md`「供应商组」。
- [跨电脑复制任务](task-device-migration.md) 与已建任务换 Agent 所在电脑:§6.1 的自动换电脑与手动「换一台继续」
都复用现有交接,不新增交接机制。
- [用量上限自动继续](usage-limit-auto-continue.md):冷却的重置时刻口径与之一致;有组时先换电脑,组里所有电脑都失败且其中有
@@ -239,7 +269,8 @@
| 期 | 内容 |
|---|---|
| P1(已实现) | 供应商组设置与「远程与分享」页的组一块;组所在电脑自己的任务按组选电脑(选定后就是普通的本机或远程 Agent 任务)与自动换电脑;组内电脑状态与本次运行内的冷却;换电脑的活动记录(桌面与手机) |
-| P2 | 同账号其他电脑与分享的人经组转发;使用方隔离;防转圈标记;「需要换一台」信号与任务所在电脑的自动交接;申请弹窗的新说法 |
+| P2a(已实现) | 同账号其他电脑经组直连:问组所在电脑选电脑、直接连过去、本机自动换电脑并报告冷却;运行中任务报告给组所在电脑计入负载;防转圈标记;同账号其他电脑的模型列表与设置页只显示组、组项标出供应商组与组内电脑状态 |
+| P2b | 分享的人经组所在电脑中转;使用方隔离;同账号组内电脑接受被中转的受邀者(隔离);「需要换一台」信号与受邀者那边的自动交接;申请弹窗的新说法 |
| P3 | 两个维度的用量;全部失败时逐台列出原因、按全组最早恢复的一台等待;手机端显示实际运行电脑 |
## 13. 验收
@@ -268,9 +299,10 @@
| 角色 | 是旧版本时 |
|---|---|
-| 组所在电脑 | 组只在新版本里存在。降级到旧版本后组不生效,这个供应商回到只在本机运行;经组分到其他电脑的任务在旧版本里不能续接,需要换模型或新开任务 |
+| 组所在电脑 | 组只在新版本里存在。降级到旧版本后组不生效,这个供应商回到只在本机运行;经组分到其他电脑的任务在旧版本里不能续接,需要换模型或新开任务。同账号其他电脑问它时得到 `CHANNEL_NOT_ALLOWED`、目录里也没有组摘要,当作没有组照常直接连它;已经经它的组分到别处的任务留在原处,成为普通的远程 Agent 任务 |
| 组内电脑 | 照常作为普通的同账号远程供应商或分享来的供应商接任务。「已由供应商组分配」标记对它是不认识的字段,解码时丢弃;它本来没有组,也不会转圈 |
-| 同账号其他电脑、分享的人 | 照常使用。打开任务阶段的换电脑由组所在电脑完成,旧版本同样享受;运行中失败时它没有声明支持「需要换一台」,组所在电脑照旧返回原来的错误(如用量上限),用户像现在一样换模型或稍后重试。模型列表与任务头部没有供应商组的标注 |
+| 同账号其他电脑 | 直连由任务所在的电脑执行,旧版本不认识组:选组所在电脑的这个供应商时直接在组所在电脑上运行(没有组),模型列表里组内电脑照常单独显示、没有供应商组的标注 |
+| 分享的人 | 照常使用。打开任务阶段的换电脑由组所在电脑完成,旧版本同样享受;运行中失败时它没有声明支持「需要换一台」,组所在电脑照旧返回原来的错误(如用量上限),用户像现在一样换模型或稍后重试。(P2b) |
| 受邀者申请 | 申请弹窗由受邀者自己的 Cindy 显示,旧版本仍是原来的说法(§8 已知差异) |
- 本地数据:供应商组设置只新增存储,不改已有的供应商、远程调用与分享数据;涉及数据库时按
diff --git a/packages/device-link/src/__tests__/providerShare.test.ts b/packages/device-link/src/__tests__/providerShare.test.ts
index b5ec7c1237..3473a840c7 100644
--- a/packages/device-link/src/__tests__/providerShare.test.ts
+++ b/packages/device-link/src/__tests__/providerShare.test.ts
@@ -144,6 +144,9 @@ describe('provider share identity scrubbing', () => {
};
expect(scrubSharedProvider(provider)).toEqual({ id: 'openai-2', name: 'OpenAI', connected: true });
expect(JSON.stringify(scrubSharedProviderCatalog({ providers: [provider], providerOrder: ['openai-2'] }))).not.toContain('alice');
+ // 供应商组摘要列着组内电脑,只给同账号电脑。
+ expect(scrubSharedProvider({ id: 'anthropic', name: 'Anthropic', group: { members: [{ label: 'Mini' }] } }))
+ .toEqual({ id: 'anthropic', name: 'Anthropic' });
});
it('drops a login name cut short by the 50-character auto-name limit', async () => {
diff --git a/packages/device-link/src/__tests__/remoteAgent.test.ts b/packages/device-link/src/__tests__/remoteAgent.test.ts
index 086291760e..a6fec7b91e 100644
--- a/packages/device-link/src/__tests__/remoteAgent.test.ts
+++ b/packages/device-link/src/__tests__/remoteAgent.test.ts
@@ -1,5 +1,6 @@
import { describe, expect, it } from 'vitest';
import {
+ PROVIDER_GROUP_REMOTE_CHANNEL,
REMOTE_AGENT_CHANNEL,
REMOTE_AGENT_MAX_INLINE_PAYLOAD_CHARS,
REMOTE_AGENT_UPLOAD_CHUNK_BYTES,
@@ -22,6 +23,8 @@ describe('remote agent channel', () => {
// Shared-task guests are refused by the desktop shared-task gate (not in its channel list).
it('is registered on the same-account allowlist', () => {
expect(REMOTE_INVOKE_ALLOWLIST.has(REMOTE_AGENT_CHANNEL)).toBe(true);
+ // 供应商组:同账号电脑问组所在电脑该用哪台(受邀者在 Desktop dispatch 被拒)。
+ expect(REMOTE_INVOKE_ALLOWLIST.has(PROVIDER_GROUP_REMOTE_CHANNEL)).toBe(true);
});
it('parses every op and drops unknown fields', () => {
diff --git a/packages/device-link/src/allowlist.ts b/packages/device-link/src/allowlist.ts
index fe90043e90..e001689595 100644
--- a/packages/device-link/src/allowlist.ts
+++ b/packages/device-link/src/allowlist.ts
@@ -25,6 +25,7 @@
* Renderer 可调用。它由业务 dispatch 拦截,绝不放行通用 UI / shell IPC。
*/
import { FILE_PEER_CHANNEL } from './filePeer.js';
+import { PROVIDER_GROUP_REMOTE_CHANNEL } from './providerGroup.js';
import { REMOTE_AGENT_CHANNEL } from './remoteAgent.js';
import {
ORCA_EXECUTION_DEVICES_CHANNEL,
@@ -346,6 +347,9 @@ const CORE_INVOKE_CHANNELS: readonly string[] = [
// 供应商运行 Agent,文件、命令与 Cindy 工具回到控制端执行。准入同 fs:list-dir 的论证:
// 同账号 + 被控端显式打开远程控制时,控制端本就能驱动被控端的 Agent;不进共享任务白名单。
REMOTE_AGENT_CHANNEL,
+ // 供应商组(被控端 dispatch 拦截执行,不落 ipcMain handler):同账号电脑问组所在电脑该用组里哪台、
+ // 报告运行中的任务与需要冷却的电脑。只给同账号,分享受邀者与共享任务访客在 dispatch 再拒一次。
+ PROVIDER_GROUP_REMOTE_CHANNEL,
// 出方向语音转写(被控端 dispatch 拦截执行,不落 ipcMain handler;复用被控端 ASR 配置)。
DL_VOICE_TRANSCRIBE_CHANNEL,
// 临时 voice credential 同步(被控端 dispatch 拦截执行,不落 ipcMain handler;禁止泛化)。
diff --git a/packages/device-link/src/index.ts b/packages/device-link/src/index.ts
index 56746dbe57..1358761bb8 100644
--- a/packages/device-link/src/index.ts
+++ b/packages/device-link/src/index.ts
@@ -43,6 +43,7 @@ export * from "./providerShareApi.js";
export * from "./providerShareInvitation.js";
export * from "./providerShareCatalog.js";
export * from "./providerShareEnvelope.js";
+export * from "./providerGroup.js";
export * from "./modelFavorites.js";
export * from "./sessionListTransport.js";
export * from './sessionMessageReuse.js';
diff --git a/packages/device-link/src/providerGroup.ts b/packages/device-link/src/providerGroup.ts
new file mode 100644
index 0000000000..365276adec
--- /dev/null
+++ b/packages/device-link/src/providerGroup.ts
@@ -0,0 +1,10 @@
+/**
+ * 供应商组(同账号):组所在电脑把某个供应商的多台电脑合成一组,同账号的其他电脑选这个供应商时,
+ * 先经本通道问组所在电脑「该用哪台」,再自己直接连到那台运行 Agent。
+ * 产品规则见 docs/product-rules/provider-groups.md。
+ *
+ * 只进同账号 allowlist:供应商分享的受邀者与共享任务访客一律拒绝(被控端 dispatch 拦截执行,
+ * 不落 ipcMain handler)。请求与回包的结构由 Desktop 两端共同维护(apps/desktop/src/shared/providerGroup.ts),
+ * 旧版电脑回 `CHANNEL_NOT_ALLOWED`,控制端当作那台没有组。
+ */
+export const PROVIDER_GROUP_REMOTE_CHANNEL = 'provider-group:remote';
diff --git a/packages/device-link/src/providerShareCatalog.ts b/packages/device-link/src/providerShareCatalog.ts
index c0f257db1a..3699c16853 100644
--- a/packages/device-link/src/providerShareCatalog.ts
+++ b/packages/device-link/src/providerShareCatalog.ts
@@ -103,11 +103,13 @@ function accountIdentity(value: unknown): string | undefined {
/**
* 分享出去的一条供应商:去掉分享者的账号身份字段(`subscriptionAccount` / `openAiAccount`,
* 含登录邮箱)并清理名称,地址里的用户名密码与查询参数也去掉;其余展示字段沿用同账号投影。
+ * 供应商组摘要(`group`,列着组内电脑)只给同账号电脑,这里也去掉。
* 分享者电脑、受邀者电脑与手机都各过一遍。
*/
export function scrubSharedProvider<T>(provider: T): T {
if (!provider || typeof provider !== 'object' || Array.isArray(provider)) return provider;
const { subscriptionAccount, openAiAccount, ...fields } = provider as Record<string, unknown>;
+ delete fields.group;
const rest = stripNestedUrlSecrets(fields, 0) as Record<string, unknown>;
if (typeof rest.name === 'string') {
rest.name = scrubProviderShareLabel(rest.name, [accountIdentity(subscriptionAccount), accountIdentity(openAiAccount)],