Skip to content

armgit / cindy

Public Imported from GitHub
0

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

fix(desktop): 供应商组第二期——处理自动审查意见

Lizi37d99f2ed259
diff --git a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
index d60b2fe2f6..6a32deba89 100644
--- a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
@@ -8,7 +8,7 @@ import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/p
import { createProviderGroupExternalLoad } from '../externalLoad';
import { createProviderGroupGuestRelay, PROVIDER_GROUP_GUEST_INCAPABLE_MS } from '../guestRelay';
import { PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS } from '../remoteHandler';
-import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, type ProviderGroupRouter } from '../router';
+import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, type ProviderGroupPickInput, type ProviderGroupRouter } from '../router';
function member(key: string, kind: ProviderGroupMember['kind'], agentDeviceId: string | null, providerId: string): ProviderGroupMember {
return { key, kind, agentDeviceId, providerId, limit: 4, weight: 1, paused: false };
@@ -19,11 +19,13 @@ const MINI = member('device:mini:anthropic-2', 'device', 'mini', 'anthropic-2');
const FRIEND = member('share:s1:anthropic', 'share', 'share:s1', 'anthropic');
const CONFIG: ProviderGroupConfig = { strategy: 'order', autoSwitch: true, members: [LOCAL, MINI, FRIEND] };
-function setup(picks: ProviderGroupMember[]) {
+function setup(picks: ProviderGroupMember[], config: ProviderGroupConfig = CONFIG) {
let now = 1_000;
+ let current = true;
const router = {
- pick: vi.fn(async ({ exclude }: { exclude?: ReadonlySet<string> }) => {
+ pick: vi.fn(async ({ exclude, onPicked }: ProviderGroupPickInput) => {
const next = picks.find((m) => !exclude?.has(m.key));
+ if (next) onPicked?.(next.key);
return next ? { kind: 'member' as const, member: next, label: next.key, resolved: [] } : { kind: 'unavailable' as const, resolved: [] };
}),
view: vi.fn(),
@@ -37,14 +39,20 @@ function setup(picks: ProviderGroupMember[]) {
const externalLoad = createProviderGroupExternalLoad({ now: () => now });
const invoke = vi.fn(async () => ({}));
const relay = createProviderGroupGuestRelay({
- router,
- readGroup: (id) => (id === 'anthropic' ? CONFIG : null),
- externalLoad,
+ scope: () => ({ router, externalLoad, isCurrent: () => current }),
+ readGroup: (id) => (id === 'anthropic' ? config : null),
connect: () => ({ invoke, poller: {} as never }),
now: () => now,
log: { warn: vi.fn() },
});
- return { relay, router, externalLoad, invoke, advance: (ms: number) => { now += ms; } };
+ return {
+ relay,
+ router,
+ externalLoad,
+ invoke,
+ advance: (ms: number) => { now += ms; },
+ switchAccount: () => { current = false; },
+ };
}
const PLAN = { kind: 'claude-code' as const, model: 'opus', providerId: 'anthropic', exclude: new Set<string>() };
@@ -103,10 +111,10 @@ describe('provider group guest relay planner', () => {
it('cools until the reported reset time, trusting it at most 8 days', () => {
const router = { markCooling: vi.fn() } as unknown as ProviderGroupRouter & { markCooling: ReturnType<typeof vi.fn> };
let resetAt = 1_000 + 3 * 60 * 60_000;
+ const externalLoad = createProviderGroupExternalLoad({ now: () => 1_000 });
const relay = createProviderGroupGuestRelay({
- router,
+ scope: () => ({ router, externalLoad, isCurrent: () => true }),
readGroup: () => CONFIG,
- externalLoad: createProviderGroupExternalLoad({ now: () => 1_000 }),
connect: () => ({ invoke: vi.fn(), poller: {} as never }),
readResetAt: () => resetAt,
now: () => 1_000,
@@ -120,6 +128,37 @@ describe('provider group guest relay planner', () => {
expect(router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 1_000 + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS);
});
+ it('still cools the computer but offers no switch when the group has automatic switching turned off', () => {
+ const env = setup([MINI], { ...CONFIG, autoSwitch: false });
+ const mini = { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true };
+ expect(env.relay.noteRunFailure('anthropic', mini, { usageLimit: true, message: 'usage limit' })).toBe(false);
+ expect(env.router.markCooling).toHaveBeenCalledWith('anthropic', MINI.key, expect.any(Number));
+ });
+
+ it('counts the picked computer in the same step it is picked, when asked to', async () => {
+ const env = setup([MINI, LOCAL]);
+ const relayed = await env.relay.plan({ ...PLAN, reserve: true });
+ expect(env.externalLoad.running('anthropic', MINI.key)).toBe(1);
+ expect(relayed).toMatchObject({ kind: 'member', memberKey: MINI.key, load: expect.anything() });
+ const local = await env.relay.plan({ ...PLAN, exclude: new Set([MINI.key]), reserve: true });
+ expect(local).toMatchObject({ kind: 'local', load: expect.anything() });
+ expect(env.externalLoad.running('anthropic', LOCAL.key)).toBe(1);
+ // 只是问问有没有能接的电脑时不预占。
+ await env.relay.plan(PLAN);
+ expect(env.externalLoad.running('anthropic', MINI.key)).toBe(1);
+ });
+
+ it('drops a pick made for the previous account', async () => {
+ const env = setup([MINI]);
+ env.router.pick.mockImplementationOnce(async (input: ProviderGroupPickInput) => {
+ env.switchAccount();
+ input.onPicked?.(MINI.key);
+ return { kind: 'member' as const, member: MINI, label: MINI.key, resolved: [] };
+ });
+ expect(await env.relay.plan({ ...PLAN, reserve: true })).toEqual({ kind: 'unavailable' });
+ expect(env.externalLoad.running('anthropic', MINI.key)).toBe(0);
+ });
+
it('counts relayed tasks while they run and asks computers to forget a shared user', async () => {
const env = setup([MINI]);
const load = env.relay.trackRun('anthropic', MINI.key);
diff --git a/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts b/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts
index 33fdc008d0..9887103ffe 100644
--- a/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts
@@ -43,4 +43,25 @@ describe('provider group guest switch tokens', () => {
now += PROVIDER_GROUP_SWITCH_ARMED_TTL_MS + 1;
expect(tokens.takeForOpen('s1')).toBeUndefined();
});
+
+ it('drops a token already armed for the next open when the user takes over during the handoff', () => {
+ const tokens = createProviderGroupGuestSwitch(() => 0);
+ tokens.offer('s1', 'token-a');
+ expect(tokens.claim('s1')).toBe(true);
+ tokens.drop('s1');
+ expect(tokens.takeForOpen('s1')).toBeUndefined();
+ });
+
+ it('marks the next send after the user takes over as a new round, only for tasks that got tokens', () => {
+ const tokens = createProviderGroupGuestSwitch(() => 0);
+ tokens.drop('plain');
+ expect(tokens.takeNewRound('plain')).toBe(false);
+
+ tokens.offer('s1', 'token-a');
+ expect(tokens.claim('s1')).toBe(true);
+ expect(tokens.takeNewRound('s1')).toBe(false);
+ tokens.drop('s1');
+ expect(tokens.takeNewRound('s1')).toBe(true);
+ expect(tokens.takeNewRound('s1')).toBe(false);
+ });
});
diff --git a/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts b/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts
index 9d93f5bfb3..43976cf3f8 100644
--- a/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/leaseReporter.test.ts
@@ -9,6 +9,7 @@ import {
createProviderGroupLeaseReporter,
PROVIDER_GROUP_LEASE_DEBOUNCE_MS,
PROVIDER_GROUP_LEASE_HEARTBEAT_MS,
+ PROVIDER_GROUP_LEASE_RETRY_MS,
} from '../leaseReporter';
beforeEach(() => {
@@ -91,6 +92,27 @@ describe('provider group lease reporter', () => {
restarted.reporter.dispose();
});
+ it('retries the final empty report when it fails, even with no heartbeat running', async () => {
+ const { reporter, running, send } = setup();
+ running.add('s1');
+ reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ expect(send).toHaveBeenCalledTimes(1);
+ running.clear();
+ send.mockRejectedValueOnce(new Error('offline'));
+ reporter.notify('s1');
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_DEBOUNCE_MS);
+ expect(send).toHaveBeenCalledTimes(2);
+ expect(send).toHaveBeenLastCalledWith('mini', expect.any(Number), []);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_RETRY_MS);
+ expect(send).toHaveBeenCalledTimes(3);
+ expect(send).toHaveBeenLastCalledWith('mini', expect.any(Number), []);
+ // 补报成功后不再重复。
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_LEASE_HEARTBEAT_MS * 2);
+ expect(send).toHaveBeenCalledTimes(3);
+ reporter.dispose();
+ });
+
it('does nothing when no task runs through a group on another computer', async () => {
const { reporter, send } = setup();
reporter.notify('s1');
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
index 56ce4b0c20..c15dc35be0 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
@@ -12,6 +12,7 @@ import type { ProviderGroupDirectory } from '../directory';
import { createProviderGroupRouter } from '../router';
import {
createProviderGroupService,
+ PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS,
PROVIDER_GROUP_UNAVAILABLE_ERROR,
type ProviderGroupRemoteGroups,
type ProviderGroupServiceDeps,
@@ -246,6 +247,36 @@ describe('switching computers within a group on another computer', () => {
expect(h.bindings.has('s1')).toBe(true);
});
+ it('releases the task as soon as the group computer confirms the group was deleted', async () => {
+ const failing = bound({ config: null });
+ failing.service.onTurnError('s1', { sdkError: 'rate_limit' }, 3);
+ await flush();
+ expect(failing.bindings.has('s1')).toBe(false);
+ expect(failing.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(failing.deps.fallback).toHaveBeenCalled();
+
+ const sending = bound({ config: null });
+ await sending.service.beforeSend('s1');
+ expect(sending.bindings.has('s1')).toBe(false);
+ expect(sending.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+
+ it('sends as usual without waiting when the group computer does not answer in time', async () => {
+ vi.useFakeTimers();
+ try {
+ const h = bound();
+ h.remote.readGroup.mockImplementation(() => new Promise(() => undefined));
+ const done = vi.fn();
+ void h.service.beforeSend('s1').then(done);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
+ expect(done).toHaveBeenCalled();
+ expect(h.bindings.has('s1')).toBe(true);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
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);
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
index 70b7736e90..ecac355af1 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -16,7 +16,14 @@ import {
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';
+import type { ProviderGroupDirectory } from '../directory';
+import {
+ createProviderGroupRouter,
+ PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
+ PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
+ type ProviderGroupPickInput,
+ type ProviderGroupRouter,
+} from '../router';
const MINI: ProviderGroupMember = {
key: 'device:mini:anthropic-1a2b3c4d',
@@ -36,8 +43,13 @@ const CONFIG: ProviderGroupConfig = {
function deps(overrides: Partial<ProviderGroupRemoteHandlerDeps> = {}) {
let now = 10_000;
+ let ownerCurrent = true;
+ const externalLoad = createProviderGroupExternalLoad({ now: () => now });
const router = {
- pick: vi.fn(async () => ({ kind: 'member' as const, member: MINI, label: 'Mini', resolved: [] })),
+ pick: vi.fn(async (input: ProviderGroupPickInput) => {
+ input.onPicked?.(MINI.key);
+ return { 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(),
@@ -46,16 +58,20 @@ function deps(overrides: Partial<ProviderGroupRemoteHandlerDeps> = {}) {
triedThisTurn: vi.fn(() => new Set<string>()),
resetTurn: vi.fn(),
} satisfies ProviderGroupRouter;
- const externalLoad = createProviderGroupExternalLoad({ now: () => now });
const value = {
- router,
- externalLoad,
+ scope: () => ({ router, externalLoad, isCurrent: () => ownerCurrent }),
readGroup: (id: string) => (id === 'anthropic' ? CONFIG : null),
isRemoteAllowed: () => true,
now: () => now,
...overrides,
} satisfies ProviderGroupRemoteHandlerDeps;
- return { ...value, router, externalLoad, advance: (ms: number) => { now += ms; } };
+ return {
+ ...value,
+ router,
+ externalLoad,
+ advance: (ms: number) => { now += ms; },
+ switchAccount: () => { ownerCurrent = false; },
+ };
}
const PICK = { action: 'pick', sessionId: 's1', providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: ['local'] };
@@ -64,7 +80,9 @@ 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(d.router.pick).toHaveBeenCalledWith(expect.objectContaining({
+ 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' },
@@ -128,6 +146,68 @@ describe('provider-group:remote', () => {
expect(d.externalLoad.running('anthropic', MINI.key)).toBe(1);
});
+ it('spreads requests that arrive together instead of sending them all to the same computer', async () => {
+ const now = 10_000;
+ const externalLoad = createProviderGroupExternalLoad({ now: () => now });
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [MINI, { ...MINI, key: 'device:studio:anthropic', agentDeviceId: 'studio', providerId: 'anthropic', label: 'Studio' }] };
+ let release!: () => void;
+ const gate = new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ const directory: ProviderGroupDirectory = {
+ // 两个请求都在等目录时,读负载与选电脑要在目录回来后的同一步里完成。
+ resolveMembers: async (_providerId, cfg) => {
+ await gate;
+ return cfg.members.map((m) => ({
+ member: m,
+ label: m.label ?? m.key,
+ state: 'ok' as const,
+ view: {
+ id: m.providerId,
+ name: m.providerId,
+ agents: ['claude-code'],
+ connected: true,
+ models: { 'claude-code': [{ id: 'opus', name: 'opus', efforts: [], defaultEffort: null }] },
+ routing: { 'claude-code': {} },
+ } as never,
+ }));
+ },
+ listCandidates: async () => [],
+ readDeviceCatalog: async () => [],
+ invalidate: vi.fn(),
+ };
+ const router = createProviderGroupRouter({
+ directory,
+ readGroup: () => config,
+ listBindings: () => ({}),
+ isTurnRunning: () => false,
+ externalRunning: (p, m) => externalLoad.running(p, m),
+ now: () => now,
+ random: () => 0,
+ });
+ const d = {
+ scope: () => ({ router, externalLoad, isCurrent: () => true }),
+ readGroup: () => config,
+ isRemoteAllowed: () => true,
+ now: () => now,
+ } satisfies ProviderGroupRemoteHandlerDeps;
+ const first = handleProviderGroupRemote(d, 'laptop', { ...PICK, exclude: [] });
+ const second = handleProviderGroupRemote(d, 'desktop', { ...PICK, sessionId: 's2', exclude: [] });
+ release();
+ const picked = (await Promise.all([first, second])).map((r) => (r as { member?: { key: string } }).member?.key);
+ expect(new Set(picked).size).toBe(2);
+ });
+
+ it('drops a pick when the account changed while it waited for the directory', async () => {
+ const d = deps();
+ d.router.pick.mockImplementationOnce(async (input: ProviderGroupPickInput) => {
+ d.switchAccount();
+ input.onPicked?.(MINI.key);
+ return { kind: 'member' as const, member: MINI, label: 'Mini', resolved: [] };
+ });
+ expect(await handleProviderGroupRemote(d, 'laptop', PICK)).toEqual({ kind: 'none' });
+ });
+
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]');
diff --git a/apps/desktop/src/main/provider-group/__tests__/runtime.test.ts b/apps/desktop/src/main/provider-group/__tests__/runtime.test.ts
index d7642f4721..f06a8f153b 100644
--- a/apps/desktop/src/main/provider-group/__tests__/runtime.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/runtime.test.ts
@@ -18,7 +18,7 @@ vi.mock('../../remote-agent/controller/deviceCatalog.js', () => ({ readDevicePro
vi.mock('../bindings.js', () => ({ listProviderGroupBindings: () => ({}) }));
vi.mock('../store.js', () => ({ readProviderGroup: () => null }));
-const { getProviderGroupDirectory, getProviderGroupRouter } = await import('../runtime.js');
+const { getProviderGroupDirectory, getProviderGroupOwnerScope, getProviderGroupRouter } = await import('../runtime.js');
describe('provider group runtime', () => {
it('keeps cooling and round state per account behind stable handles', () => {
@@ -34,4 +34,16 @@ describe('provider group runtime', () => {
expect(router.coolingUntil('anthropic', 'local')).toBeNull();
expect(router.triedThisTurn('s1').size).toBe(0);
});
+
+ it('keeps an assignment on the account it started with, even after switching accounts', () => {
+ owner = 'owner-c';
+ const scope = getProviderGroupOwnerScope();
+ expect(scope.isCurrent()).toBe(true);
+ owner = 'owner-d';
+ expect(scope.isCurrent()).toBe(false);
+ // 换账号之后才记上的占用落在 owner-c 那份里,owner-d 看不到。
+ scope.externalLoad.recordPick('laptop', 's1', 'anthropic', 'local');
+ expect(scope.externalLoad.running('anthropic', 'local')).toBe(1);
+ expect(getProviderGroupOwnerScope().externalLoad.running('anthropic', 'local')).toBe(0);
+ });
});
diff --git a/apps/desktop/src/main/provider-group/externalLoad.ts b/apps/desktop/src/main/provider-group/externalLoad.ts
index 725d8e758a..a62d4594f2 100644
--- a/apps/desktop/src/main/provider-group/externalLoad.ts
+++ b/apps/desktop/src/main/provider-group/externalLoad.ts
@@ -18,6 +18,12 @@ export const PROVIDER_GROUP_PROVISIONAL_MS = 30_000;
const MAX_CONTROLLERS = 256;
const MAX_PROVISIONAL = 4096;
+/** 计入某台组内电脑负载的一个任务(按它是否正在运行一轮);任务结束时 release。 */
+export interface ProviderGroupLoadHandle {
+ setRunning(running: boolean): void;
+ release(): void;
+}
+
export interface ProviderGroupExternalLoad {
/** 这台组内电脑上经本组运行、但不在本机任务表里的任务数。 */
running(providerId: string, memberKey: string): number;
@@ -26,9 +32,10 @@ export interface ProviderGroupExternalLoad {
/** 某台电脑的整份报告;返回 false = 比已有的旧,被丢弃。 */
replaceLeases(controller: string, seq: number, entries: readonly ProviderGroupRemoteLease[]): boolean;
/**
- * 本机替受邀者中转到这台组内电脑的任务(本机能看到它是否在运行一轮):任务结束时 release。
+ * 本机替受邀者运行的任务(中转到这台组内电脑,或组选中本机这一台;本机能看到它是否在运行一轮):
+ * 任务结束时 release。
*/
- trackRelay(providerId: string, memberKey: string): { setRunning(running: boolean): void; release(): void };
+ trackRelay(providerId: string, memberKey: string): ProviderGroupLoadHandle;
}
interface LeaseSet {
diff --git a/apps/desktop/src/main/provider-group/guestRelay.ts b/apps/desktop/src/main/provider-group/guestRelay.ts
index 81a6f5c988..eb23bf69be 100644
--- a/apps/desktop/src/main/provider-group/guestRelay.ts
+++ b/apps/desktop/src/main/provider-group/guestRelay.ts
@@ -11,24 +11,20 @@ import type { AgentKind } from '@cindy/maker-core';
import type { ProviderGroupConfig } from '../../shared/providerGroup.js';
import type { RelayRunFailure } from '../remote-agent/host/groupRelay.js';
-import type { GroupRelayMember, RemoteAgentGroupRelayDeps } from '../remote-agent/host/runHost.js';
+import type { GroupRelayLoad, GroupRelayMember, RemoteAgentGroupRelayDeps } from '../remote-agent/host/runHost.js';
import type { RemoteAgentInvoke, RemoteAgentPoller } from '../remote-agent/controller/runClient.js';
-import type { ProviderGroupExternalLoad } from './externalLoad.js';
import { PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS } from './remoteHandler.js';
-import {
- PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
- PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
- type ProviderGroupRouter,
-} from './router.js';
+import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, PROVIDER_GROUP_FAILURE_COOLDOWN_MS } from './router.js';
+import type { ProviderGroupOwnerScope } from './runtime.js';
import { classifyProviderGroupSwitchCause } from './switchCause.js';
/** 同账号电脑不支持接受受邀者任务时,多久内不再试它。 */
export const PROVIDER_GROUP_GUEST_INCAPABLE_MS = 10 * 60_000;
export interface ProviderGroupGuestRelayDeps {
- router: ProviderGroupRouter;
+ /** 当前账号的分配器与负载(每次选电脑开头取一次)。 */
+ scope(): ProviderGroupOwnerScope;
readGroup(providerId: string): ProviderGroupConfig | null;
- externalLoad: ProviderGroupExternalLoad;
connect(agentDeviceId: string): { invoke: RemoteAgentInvoke; poller: RemoteAgentPoller };
/** 组内电脑报错里的用量重置时刻(unix ms);不提供时用量上限一律按默认时长冷却。 */
readResetAt?(failure: RelayRunFailure): number | null;
@@ -55,24 +51,39 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
}
return {
- async plan({ kind, model, providerId, exclude }) {
+ async plan({ kind, model, providerId, exclude, reserve }) {
const config = deps.readGroup(providerId);
if (!config) return null;
const skip = new Set(exclude);
for (const member of config.members) {
if (member.kind === 'device' && member.agentDeviceId && isIncapable(member.agentDeviceId)) skip.add(member.key);
}
- const pick = await deps.router.pick({ providerId, agentKind: kind as AgentKind, model, exclude: skip });
+ const scope = deps.scope();
+ let load: GroupRelayLoad | undefined;
+ const pick = await scope.router.pick({
+ providerId,
+ agentKind: kind as AgentKind,
+ model,
+ exclude: skip,
+ // 选中的同一步就计入那台的负载:同时来的几个受邀者任务不会读到同一份负载、全落到同一台。
+ ...(reserve ? { onPicked: (memberKey: string) => { load = scope.externalLoad.trackRelay(providerId, memberKey); } } : {}),
+ });
+ // 选电脑期间换了账号:这是上一个账号的组,不再交给它的电脑。
+ if (!scope.isCurrent()) {
+ load?.release();
+ return { kind: 'unavailable' };
+ }
if (pick.kind === 'none') return null;
if (pick.kind === 'unavailable') return { kind: 'unavailable' };
const { member } = pick;
- if (member.kind === 'local' || !member.agentDeviceId) return { kind: 'local' };
+ if (member.kind === 'local' || !member.agentDeviceId) return { kind: 'local', ...(load ? { load } : {}) };
return {
kind: 'member',
memberKey: member.key,
agentDeviceId: member.agentDeviceId,
providerId: member.providerId,
sameAccount: member.kind === 'device',
+ ...(load ? { load } : {}),
};
},
@@ -88,7 +99,7 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
const cause = classifyProviderGroupSwitchCause({ message });
if (!cause) return;
const now = deps.now();
- deps.router.markCooling(
+ deps.scope().router.markCooling(
providerId,
member.memberKey,
now + (cause === 'usage-limit' ? PROVIDER_GROUP_DEFAULT_COOLDOWN_MS : PROVIDER_GROUP_FAILURE_COOLDOWN_MS),
@@ -97,7 +108,8 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
noteRunFailure(providerId, member: GroupRelayMember, failure) {
// 没有组,或那台已被移出组:已经在它上面的任务成为普通的远程 Agent 任务,不再自动换电脑(§9 #4)。
- if (!deps.readGroup(providerId)?.members.some((m) => m.key === member.memberKey)) return false;
+ const config = deps.readGroup(providerId);
+ if (!config?.members.some((m) => m.key === member.memberKey)) return false;
const cause = classifyProviderGroupSwitchCause(failure);
if (!cause) return false;
const now = deps.now();
@@ -108,11 +120,12 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
? Math.min(resetAt, now + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS)
: now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS)
: now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
- deps.router.markCooling(providerId, member.memberKey, until);
- return true;
+ deps.scope().router.markCooling(providerId, member.memberKey, until);
+ // 冷却照常(之后的新任务避开它);组设置里关掉了自动换电脑时不发凭证,受邀者照现有方式看到错误(§6.1)。
+ return config.autoSwitch;
},
- trackRun: (providerId, memberKey) => deps.externalLoad.trackRelay(providerId, memberKey),
+ trackRun: (providerId, memberKey) => deps.scope().externalLoad.trackRelay(providerId, memberKey),
async forget(agentDeviceId, relay) {
await deps.connect(agentDeviceId).invoke([{ op: 'forget', relay }]);
diff --git a/apps/desktop/src/main/provider-group/guestSwitch.ts b/apps/desktop/src/main/provider-group/guestSwitch.ts
index c8bfd31bd7..2da2b527b1 100644
--- a/apps/desktop/src/main/provider-group/guestSwitch.ts
+++ b/apps/desktop/src/main/provider-group/guestSwitch.ts
@@ -6,12 +6,17 @@
* (新建会话并带上交接上下文)后重新打开,打开时带回凭证,组所在电脑再为它换一台。
*
* 只有持有组所在电脑发来的凭证才换:分享被暂停、删除、撤权等是分享本身的问题,不会触发换电脑。
+ *
+ * 用户亲自接手(发消息、重试、换模型)即开始新的一轮:本机在接手后的那次发送里告诉组所在电脑,它清掉这个任务
+ * 这一轮已经换下来的电脑(§6.1「一轮的边界」)。
*/
/** 凭证到达后多久内的那次错误才算数(凭证紧挨在错误前面送达,这里只防陈旧凭证误用)。 */
export const PROVIDER_GROUP_SWITCH_OFFER_TTL_MS = 2 * 60_000;
/** 交接后等重新打开带走凭证的时限(与组所在电脑那边的有效期一致)。 */
export const PROVIDER_GROUP_SWITCH_ARMED_TTL_MS = 10 * 60_000;
+/** 记住多少个收到过凭证的任务(只有它们需要告诉组所在电脑「开始新的一轮」)。 */
+const MAX_TRACKED_SESSIONS = 512;
export interface ProviderGroupGuestSwitch {
/** 组所在电脑发来凭证(任务的事件流里)。 */
@@ -22,8 +27,13 @@ export interface ProviderGroupGuestSwitch {
takeForOpen(sessionId: string): string | undefined;
/** 交接没成:作废登记给下一次打开的凭证。 */
release(sessionId: string): void;
- /** 用户亲自接手(发消息、重试、换模型):作废还没用上的凭证。 */
+ /**
+ * 用户亲自接手(发消息、重试、换模型):作废还没用上的凭证(含交接途中已登记、等重新打开带走的),
+ * 并记下接下来的发送开始新的一轮。
+ */
drop(sessionId: string): void;
+ /** 这次发送要不要告诉组所在电脑开始新的一轮(取走即用掉)。 */
+ takeNewRound(sessionId: string): boolean;
}
let shared: ProviderGroupGuestSwitch | null = null;
@@ -37,10 +47,20 @@ export function getProviderGroupGuestSwitch(): ProviderGroupGuestSwitch {
export function createProviderGroupGuestSwitch(now: () => number = Date.now): ProviderGroupGuestSwitch {
const offered = new Map<string, { token: string; at: number }>();
const armed = new Map<string, { token: string; at: number }>();
+ /** 收到过凭证的任务:组所在电脑那边可能记着它这一轮换下来的电脑。 */
+ const seen = new Set<string>();
+ const newRound = new Set<string>();
return {
offer(sessionId, token) {
offered.set(sessionId, { token, at: now() });
+ seen.delete(sessionId);
+ seen.add(sessionId);
+ if (seen.size > MAX_TRACKED_SESSIONS) {
+ const oldest = seen.values().next().value as string;
+ seen.delete(oldest);
+ newRound.delete(oldest);
+ }
},
claim(sessionId) {
@@ -64,6 +84,13 @@ export function createProviderGroupGuestSwitch(now: () => number = Date.now): Pr
drop(sessionId) {
offered.delete(sessionId);
+ // 交接途中用户接手:重新打开时不再带凭证,组所在电脑不会替它换电脑。
+ armed.delete(sessionId);
+ if (seen.has(sessionId)) newRound.add(sessionId);
+ },
+
+ takeNewRound(sessionId) {
+ return newRound.delete(sessionId);
},
};
}
diff --git a/apps/desktop/src/main/provider-group/leaseReporter.ts b/apps/desktop/src/main/provider-group/leaseReporter.ts
index fde79b435e..96f84dbcbb 100644
--- a/apps/desktop/src/main/provider-group/leaseReporter.ts
+++ b/apps/desktop/src/main/provider-group/leaseReporter.ts
@@ -4,13 +4,15 @@
*
* - 任务开始 / 结束一轮时防抖后报告;有任务在跑时每分钟再报一次(组所在电脑 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 const PROVIDER_GROUP_LEASE_RETRY_MS = 15_000;
export interface ProviderGroupLeaseReporterDeps {
listRemoteBindings(): Record<string, ProviderGroupBinding>;
@@ -74,8 +76,15 @@ export function createProviderGroupLeaseReporter(deps: ProviderGroupLeaseReporte
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, '');
+ // 下次心跳或下一次变化时重报:记成「没报上」(与任何内容都不同),避免以为已经报过。结束时的空报告
+ // 也要重报——那时没有任务在跑、没有心跳,组所在电脑会把已结束的任务多算到 150 秒,所以另排一次重试。
+ lastSent.set(owner, '');
+ if (!disposed && heartbeat === null) {
+ heartbeat = schedule(() => {
+ heartbeat = null;
+ flush(false);
+ }, PROVIDER_GROUP_LEASE_RETRY_MS);
+ }
deps.log.warn('provider group: reporting running tasks failed', {
error: error instanceof Error ? error.message : String(error),
});
diff --git a/apps/desktop/src/main/provider-group/remoteHandler.ts b/apps/desktop/src/main/provider-group/remoteHandler.ts
index 4376484e0f..21a7fba621 100644
--- a/apps/desktop/src/main/provider-group/remoteHandler.ts
+++ b/apps/desktop/src/main/provider-group/remoteHandler.ts
@@ -14,19 +14,15 @@ import {
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';
+import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, PROVIDER_GROUP_FAILURE_COOLDOWN_MS } from './router.js';
+import type { ProviderGroupOwnerScope } from './runtime.js';
/** 报告来的重置时刻最多信多远(账号用量上限最长按周重置),避免一台电脑被异常时刻长期冷却。 */
export const PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS = 8 * 24 * 60 * 60_000;
export interface ProviderGroupRemoteHandlerDeps {
- router: ProviderGroupRouter;
- externalLoad: ProviderGroupExternalLoad;
+ /** 当前账号的分配器与负载(每个请求开头取一次,整个请求都用这一份)。 */
+ scope(): ProviderGroupOwnerScope;
readGroup(providerId: string): ProviderGroupConfig | null;
/** 这个供应商仍对其他电脑开放(「允许被远程调用」)。 */
isRemoteAllowed(providerId: string): boolean;
@@ -63,19 +59,22 @@ export async function handleProviderGroupRemote(
raw: unknown,
): Promise<ProviderGroupRemotePick | ProviderGroupView | Record<string, never>> {
const request = parseProviderGroupRemoteRequest(raw);
+ const scope = deps.scope();
switch (request.action) {
case 'pick': {
const { providerId } = request;
if (!deps.isRemoteAllowed(providerId) || !deps.readGroup(providerId)) return { kind: 'none' };
- const pick = await deps.router.pick({
+ const pick = await scope.router.pick({
providerId,
agentKind: request.agentKind,
model: request.model,
exclude: new Set(request.exclude),
+ // 选中的同一步记上临时占用:同时来的几个请求不会读到同一份负载、全落到同一台。
+ onPicked: (memberKey) => scope.externalLoad.recordPick(controller, request.sessionId, providerId, memberKey),
});
- if (pick.kind === 'none') return { kind: 'none' };
+ // 等目录期间换了账号:这是上一个账号的组(占用也记在上一个账号那份里,随它作废),不作数。
+ if (!scope.isCurrent() || 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 };
}
@@ -89,15 +88,15 @@ export async function handleProviderGroupRemote(
now + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
)
: now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
- deps.router.markCooling(request.providerId, request.memberKey, until);
+ scope.router.markCooling(request.providerId, request.memberKey, until);
return {};
}
case 'leases':
- deps.externalLoad.replaceLeases(controller, request.seq, request.entries);
+ scope.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);
+ return scope.router.view(request.providerId);
}
}
}
diff --git a/apps/desktop/src/main/provider-group/remoteRegistration.ts b/apps/desktop/src/main/provider-group/remoteRegistration.ts
index 37607681f5..528326d540 100644
--- a/apps/desktop/src/main/provider-group/remoteRegistration.ts
+++ b/apps/desktop/src/main/provider-group/remoteRegistration.ts
@@ -10,13 +10,12 @@ import {
handleProviderGroupRemote,
type ProviderGroupRemoteHandlerDeps,
} from './remoteHandler.js';
-import { getProviderGroupExternalLoad, getProviderGroupRouter } from './runtime.js';
+import { getProviderGroupOwnerScope } from './runtime.js';
import { readProviderGroup } from './store.js';
export function registerProviderGroupRemoteHandler(): void {
const deps: ProviderGroupRemoteHandlerDeps = {
- router: getProviderGroupRouter(),
- externalLoad: getProviderGroupExternalLoad(),
+ scope: getProviderGroupOwnerScope,
readGroup: readProviderGroup,
isRemoteAllowed: isRemoteProviderInvocationAllowed,
now: () => Date.now(),
diff --git a/apps/desktop/src/main/provider-group/router.ts b/apps/desktop/src/main/provider-group/router.ts
index 1b811f02d8..6ff4e3a85a 100644
--- a/apps/desktop/src/main/provider-group/router.ts
+++ b/apps/desktop/src/main/provider-group/router.ts
@@ -44,6 +44,11 @@ export interface ProviderGroupPickInput {
agentKind: AgentKind;
model: string;
exclude?: ReadonlySet<string>;
+ /**
+ * 选中后在同一步(读负载与选电脑之间没有等待)调用,用来立即记上占用:同时来的几个请求各自读到前一个的
+ * 占用,不会全落到同一台。
+ */
+ onPicked?(memberKey: string): void;
}
export type ProviderGroupPickResult =
@@ -133,6 +138,7 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
});
if (!key) return { kind: 'unavailable', resolved };
lastPicked.set(input.providerId, key);
+ input.onPicked?.(key);
const chosen = resolved.find((r) => r.member.key === key)!;
return { kind: 'member', member: chosen.member, label: chosen.label, resolved };
},
diff --git a/apps/desktop/src/main/provider-group/runtime.ts b/apps/desktop/src/main/provider-group/runtime.ts
index 70650de365..25b671f588 100644
--- a/apps/desktop/src/main/provider-group/runtime.ts
+++ b/apps/desktop/src/main/provider-group/runtime.ts
@@ -67,13 +67,6 @@ const directoryFacade: ProviderGroupDirectory = {
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),
- trackRelay: (providerId, memberKey) => runtimeForActiveOwner().externalLoad.trackRelay(providerId, memberKey),
-};
const routerFacade: ProviderGroupRouter = {
pick: (input) => runtimeForActiveOwner().router.pick(input),
@@ -94,8 +87,23 @@ export function getProviderGroupRouter(): ProviderGroupRouter {
return routerFacade;
}
-export function getProviderGroupExternalLoad(): ProviderGroupExternalLoad {
- return externalLoadFacade;
+/**
+ * 一次分配用的当前账号运行期(不经按调用时账号转发的门面):选电脑要等目录,等待期间换了账号时,记占用仍
+ * 落在这次分配所属账号的那份里,不会记进新账号;`isCurrent()` 为 false 时调用方丢弃这次结果。
+ */
+export interface ProviderGroupOwnerScope {
+ router: ProviderGroupRouter;
+ externalLoad: ProviderGroupExternalLoad;
+ isCurrent(): boolean;
+}
+
+export function getProviderGroupOwnerScope(): ProviderGroupOwnerScope {
+ const runtime = runtimeForActiveOwner();
+ return {
+ router: runtime.router,
+ externalLoad: runtime.externalLoad,
+ isCurrent: () => activeOwnerScopeKey() === runtime.owner,
+ };
}
let remoteClient: ProviderGroupRemoteClient | null = null;
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index e627e3376a..690af1d183 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -448,6 +448,15 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return { binding, source, config };
}
+ /**
+ * 组所在电脑确认组已删除(读到了、没有这个组)时立即解除绑定,任务成为普通的(远程)任务——之后重建同一个组也不会
+ * 恢复自动换电脑(§9.4)。读不到(undefined)的情况 loadBound 已经挡掉,绑定不动。
+ */
+ async function releaseDeletedGroup(sessionId: string): Promise<void> {
+ await deps.writeBinding(sessionId, null);
+ deps.log.info('provider group: group no longer exists; released the task', { sessionId });
+ }
+
/**
* 登记一次进行中的换电脑:用户在途中接手(重试、发消息、换模型)或那次错误已不是当前状态时,之后的每一步都停手。
* `handBack` 在不再换电脑时交回原有的报错与额度重置后自动继续;之前的交接若已关掉旧会话,换一个对当前状态
@@ -487,8 +496,13 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
if (!cause) return false;
if (!deps.readBinding(sessionId)) return guestFailover(sessionId, signals, token, cause);
const bound = await loadBound(sessionId);
- if (!bound?.config?.autoSwitch) return false;
+ if (!bound) return false;
const { binding, source, config } = bound;
+ if (!config) {
+ await releaseDeletedGroup(sessionId);
+ return false;
+ }
+ if (!config.autoSwitch) return false;
if (!(await deps.isFailoverEligible(sessionId))) return false;
const row = await deps.readSessionRow(sessionId);
if (!row?.model || row.remoteHostId) return false;
@@ -802,9 +816,15 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
async beforeSend(sessionId) {
if (!deps.readBinding(sessionId) || deps.isTurnRunning(sessionId)) return;
- const bound = await loadBound(sessionId);
- if (!bound?.config?.autoSwitch) return;
+ // 读组设置也算进发送前检查的上限:组所在电脑断线或不响应时保留绑定、照常发送,不等默认的请求超时。
+ const bound = await withTimeout(loadBound(sessionId), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
+ if (!bound) return;
const { binding, source, config } = bound;
+ if (!config) {
+ await releaseDeletedGroup(sessionId);
+ return;
+ }
+ if (!config.autoSwitch) return;
if (!(await deps.isFailoverEligible(sessionId))) return;
const row = await deps.readSessionRow(sessionId);
if (!row?.model || row.remoteHostId) return;
diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
index f672b1c47a..38f7e65db3 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
@@ -10,6 +10,7 @@ import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
+import { REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER } from '@cindy/device-link';
import type { AgentEvent, AgentSessionHandle } from '@cindy/maker-core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -39,6 +40,8 @@ interface Started {
emit(event: AgentEvent): void;
/** 这台上是否正在运行一轮(写进状态)。 */
running: boolean;
+ /** 这台上的 Agent 事件流意外结束(进程退出等)。 */
+ end(): void;
}
function fakeAgentHost(name: string, started: Started[], options: {
@@ -46,12 +49,18 @@ function fakeAgentHost(name: string, started: Started[], options: {
guestRelayCapable?: boolean;
purge?: (hostSessionIds: readonly string[], nativeIds: readonly string[]) => Promise<void>;
groupRelay?: RemoteAgentGroupRelayDeps;
+ /** 这台的 Agent 启动失败(启动前受邀者目录已经建好)。 */
+ failStart?: boolean;
+ /** 这台的 Agent 一启动就结束。 */
+ endImmediately?: boolean;
}) {
return createRemoteAgentHost({
isAgentAvailable: () => true,
startHosted: async (input) => {
+ if (options.failStart) throw new Error('the agent could not start');
const queue: AgentEvent[] = [];
let wake: (() => void) | null = null;
+ let ended = false;
const record: Started = {
input,
sends: [],
@@ -61,6 +70,11 @@ function fakeAgentHost(name: string, started: Started[], options: {
wake?.();
wake = null;
},
+ end() {
+ ended = true;
+ wake?.();
+ wake = null;
+ },
};
started.push(record);
const handle: AgentSessionHandle = {
@@ -77,7 +91,9 @@ function fakeAgentHost(name: string, started: Started[], options: {
events: () => ({
[Symbol.asyncIterator]: (): AsyncIterator<AgentEvent> => ({
next: async () => {
- while (queue.length === 0) await new Promise<void>((resolve) => { wake = resolve; });
+ if (options.endImmediately) return { value: undefined as unknown as AgentEvent, done: true };
+ while (queue.length === 0 && !ended) await new Promise<void>((resolve) => { wake = resolve; });
+ if (queue.length === 0) return { value: undefined as unknown as AgentEvent, done: true };
return { value: queue.shift()!, done: false };
},
}),
@@ -135,6 +151,10 @@ function setup(options: {
plans?: GroupRelayPlan[];
miniCapable?: boolean;
switchWorthy?: (failure: RelayRunFailure) => boolean;
+ /** mini 这台的 Agent 表现。 */
+ mini?: { failStart?: boolean; endImmediately?: boolean };
+ /** 截住组所在电脑发给组内电脑的请求(模拟回包丢失、应答慢)。 */
+ intercept?: (agentDeviceId: string, request: Record<string, unknown>, forward: () => Promise<unknown>) => Promise<unknown>;
} = {}) {
const memberStarted: Record<string, Started[]> = { mini: [], studio: [] };
const members = {
@@ -142,11 +162,16 @@ function setup(options: {
trust: () => 'owner',
guestRelayCapable: options.miniCapable ?? true,
purge: async () => undefined,
+ ...options.mini,
}),
studio: fakeAgentHost('studio', memberStarted.studio, { trust: () => 'owner', purge: async () => undefined }),
};
- const memberInvoke = (agentDeviceId: string) => async (args: unknown[]) =>
- jsonRoundTrip(await members[agentDeviceId as keyof typeof members].handle(OWNER_DEVICE, jsonRoundTrip(args[0])));
+ const memberInvoke = (agentDeviceId: string) => async (args: unknown[]) => {
+ const request = jsonRoundTrip(args[0]) as Record<string, unknown>;
+ // 不在组里的设备 id(模拟连不上的电脑)在这里抛错。
+ const forward = async () => jsonRoundTrip(await members[agentDeviceId as keyof typeof members].handle(OWNER_DEVICE, request));
+ return options.intercept ? options.intercept(agentDeviceId, request, forward) : forward();
+ };
const pollers = new Map<string, RemoteAgentPoller>();
const plans = [...(options.plans ?? [{ kind: 'member', ...MEMBER_MINI }])];
const relay = {
@@ -210,7 +235,7 @@ async function openAsGuest(env: ReturnType<typeof setup>, guest: string, payload
}, () => `22222222-2222-4222-8222-${String(++counter + runSeq * 100).padStart(12, '0')}`);
let closedReason: string | null = null;
const started = await client.open('claude-code', payload);
- return { client, started, stream, isClosed: () => closedReason !== null };
+ return { client, started, stream, isClosed: () => closedReason !== null, closedReason: () => closedReason };
}
const USAGE_LIMIT_ERROR: AgentEvent = {
@@ -339,6 +364,158 @@ describe('provider group relay for shared users', () => {
});
});
+describe('provider group relay: starting, load and cleanup', () => {
+ it('tries every computer in the group before giving up, however many there are', async () => {
+ const unreachable = Array.from({ length: 9 }, (_, i): GroupRelayPlan => ({
+ kind: 'member',
+ memberKey: `device:off${i}:anthropic`,
+ agentDeviceId: `off${i}`,
+ providerId: 'anthropic',
+ sameAccount: true,
+ }));
+ const env = setup({ plans: [...unreachable, { kind: 'member', ...MEMBER_STUDIO }] });
+ const { client } = await openAsGuest(env, GUEST_A, openPayload(SESSION));
+ expect(env.relay.noteStartFailure).toHaveBeenCalledTimes(9);
+ expect(env.memberStarted.studio).toHaveLength(1);
+ await client.close('close', 'navigation');
+ });
+
+ it('counts the load from the moment it picks, including tasks the group runs on this computer', async () => {
+ const localLoad = { setRunning: vi.fn(), release: vi.fn() };
+ const memberLoad = { setRunning: vi.fn(), release: vi.fn() };
+ const env = setup({ plans: [{ kind: 'local', load: localLoad }, { kind: 'member', ...MEMBER_MINI, load: memberLoad }] });
+ const local = await openAsGuest(env, GUEST_A, openPayload(SESSION));
+ expect(env.relay.plan).toHaveBeenLastCalledWith(expect.objectContaining({ reserve: true }));
+ expect(env.ownerStarted).toHaveLength(1);
+ env.ownerStarted[0].emit({ type: 'text', data: { text: 'hi' } } as AgentEvent);
+ await waitFor(() => localLoad.setRunning.mock.calls.length > 0);
+ await local.client.close('close', 'navigation');
+ await waitFor(() => localLoad.release.mock.calls.length > 0);
+
+ const relayed = await openAsGuest(env, GUEST_A, openPayload('task-2'));
+ // 选中时预占的负载直接交给中转任务,不再另记一份。
+ expect(env.relay.trackRun).not.toHaveBeenCalled();
+ await relayed.client.close('close', 'navigation');
+ await waitFor(() => memberLoad.release.mock.calls.length > 0);
+ });
+
+ it('remembers a computer it handed the task to even if the agent failed to start there', async () => {
+ const env = setup({ mini: { failStart: true }, plans: [{ kind: 'member', ...MEMBER_MINI }, { kind: 'member', ...MEMBER_STUDIO }] });
+ const { client } = await openAsGuest(env, GUEST_A, openPayload(SESSION));
+ expect(env.memberStarted.studio).toHaveLength(1);
+ await client.close('close', 'navigation');
+ await env.owner.purgeControllers((controller) => controller === GUEST_A);
+ await waitFor(() => env.relay.forget.mock.calls.length >= 2);
+ expect(env.relay.forget).toHaveBeenCalledWith('mini', relayKeyFor(GUEST_A));
+ expect(env.relay.forget).toHaveBeenCalledWith('studio', relayKeyFor(GUEST_A));
+ });
+
+ it('keeps the computers it could not reach when deleting a shared user, and asks them again later', async () => {
+ const env = setup();
+ const { client } = await openAsGuest(env, GUEST_A, openPayload(SESSION));
+ await client.close('close', 'navigation');
+ const index = (): Record<string, { forgetPending?: string[]; nativeIds: string[] }> => {
+ try {
+ return JSON.parse(fs.readFileSync(path.join(root, 'owner', 'guest-sessions.json'), 'utf8'));
+ } catch {
+ return {};
+ }
+ };
+ env.relay.forget.mockRejectedValueOnce(new Error('DEVICE_OFFLINE'));
+ await env.owner.purgeControllers((controller) => controller === GUEST_A);
+ await waitFor(() => env.relay.forget.mock.calls.length === 1);
+ await waitFor(() => Object.values(index()).some((record) => record.forgetPending?.includes('mini')));
+ // 本机这边已经清掉,只留下还要通知的那台。
+ expect(Object.values(index()).every((record) => record.nativeIds.length === 0)).toBe(true);
+
+ await env.owner.purgeControllers((controller) => controller === GUEST_A);
+ await waitFor(() => env.relay.forget.mock.calls.length === 2);
+ await waitFor(() => Object.keys(index()).length === 0);
+ });
+
+ it('does not let a shared user get more tasks by filling in its own relay key', async () => {
+ const started: Started[] = [];
+ const host = fakeAgentHost('solo', started, { trust: () => 'guest' });
+ const open = (i: number) => host.handle(GUEST_A, {
+ op: 'open',
+ runId: runId(),
+ agentKind: 'claude-code',
+ payload: { json: openPayload(`t${i}`, { relay: `r${i}` }) },
+ });
+ for (let i = 0; i < REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER; i += 1) await open(i);
+ await expect(open(99)).rejects.toThrow(/REMOTE_AGENT_BUSY/);
+ await host.abortAll();
+ });
+
+ it('does not start the task on the computer when it ended while the computer was being checked', async () => {
+ let releaseCaps!: () => void;
+ const capsGate = new Promise<void>((resolve) => {
+ releaseCaps = resolve;
+ });
+ let capsAsked!: () => void;
+ const asked = new Promise<void>((resolve) => {
+ capsAsked = resolve;
+ });
+ const env = setup({
+ intercept: async (_device, request, forward) => {
+ if (request.op === 'caps') {
+ capsAsked();
+ await capsGate;
+ }
+ return forward();
+ },
+ });
+ const id = runId();
+ await env.owner.handle(GUEST_A, { op: 'open', runId: id, agentKind: 'claude-code', payload: { json: openPayload(SESSION) } });
+ await asked;
+ await env.owner.handle(GUEST_A, { op: 'close', runId: id, mode: 'close', reason: 'navigation' });
+ releaseCaps();
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ expect(env.memberStarted.mini).toHaveLength(0);
+ expect(env.members.mini.runCount()).toBe(0);
+ });
+
+ it('passes on the end of a task that finished on the computer right after starting', async () => {
+ // 那台的任务启动又结束了才放行拉取:启动与结束在同一次拉取里一起带回。
+ const holder: { env?: ReturnType<typeof setup> } = {};
+ holder.env = setup({
+ mini: { endImmediately: true },
+ intercept: async (_device, request, forward) => {
+ if (request.op === 'poll') {
+ await waitFor(() => holder.env!.memberStarted.mini.length === 1 && holder.env!.members.mini.runCount() === 0);
+ }
+ return forward();
+ },
+ });
+ const guest = await openAsGuest(holder.env, GUEST_A, openPayload(SESSION));
+ await waitFor(() => guest.isClosed());
+ });
+
+ it('closes the task on the computer when the answer to opening it was lost, then tries the next one', async () => {
+ let lostRunId: unknown;
+ const closed: unknown[] = [];
+ const env = setup({
+ plans: [{ kind: 'member', ...MEMBER_MINI }, { kind: 'member', ...MEMBER_STUDIO }],
+ intercept: async (device, request, forward) => {
+ const result = await forward();
+ if (device === 'mini' && request.op === 'close') closed.push(request.runId);
+ if (device === 'mini' && request.op === 'open' && lostRunId === undefined) {
+ // 那台已经收下了打开,回包在路上丢了。
+ lostRunId = request.runId;
+ throw Object.assign(new Error('request timed out'), { code: 'INVOKE_TIMEOUT' });
+ }
+ return result;
+ },
+ });
+ const { client } = await openAsGuest(env, GUEST_A, openPayload(SESSION));
+ expect(env.memberStarted.studio).toHaveLength(1);
+ // 换下一台之前已经用同一个任务 id 请那台关掉,那台上没有留下没人管的任务。
+ expect(closed).toContain(lostRunId);
+ await waitFor(() => env.members.mini.runCount() === 0);
+ await client.close('close', 'navigation');
+ });
+});
+
describe('provider group "switch to another computer" for shared users', () => {
it('sends the switch token before the error, and the reopened task avoids the failed computer', async () => {
const env = setup({
@@ -447,6 +624,25 @@ describe('provider group "switch to another computer" for shared users', () => {
await reopened.client.close('close', 'navigation');
});
+ it('offers another computer when the agent on the group computer itself ends in the middle of a turn', async () => {
+ const env = setup({ plans: [{ kind: 'local' }, { kind: 'member', ...MEMBER_MINI }] });
+ const guest = await openAsGuest(env, GUEST_A, openPayload(SESSION, { acceptsGroupSwitch: true }));
+ const record = env.ownerStarted[0];
+ record.running = true;
+ record.emit({ type: 'text', data: { text: 'working' } } as AgentEvent);
+ await waitFor(() => guest.stream.some((item) => item.t === 'state' && item.state.turnRunning === true));
+ // 本机的 Agent 进程退出:事件流没有 done 就结束了。
+ record.end();
+ await waitFor(() => guest.isClosed());
+ expect(switchTokenIn(guest.stream)).toMatch(/^[A-Za-z0-9_-]{16,64}$/);
+ expect(guest.closedReason()).toBe('error');
+ expect(env.relay.noteRunFailure).toHaveBeenCalledWith(
+ 'shared-provider',
+ expect.objectContaining({ memberKey: 'local' }),
+ expect.objectContaining({ reason: 'remote_agent_closed' }),
+ );
+ });
+
it('offers another computer when the computer’s task ends unexpectedly in the middle of a turn', async () => {
const env = setup({ plans: [{ kind: 'member', ...MEMBER_MINI }, { kind: 'member', ...MEMBER_STUDIO }] });
const guest = await openAsGuest(env, GUEST_A, openPayload(SESSION, { acceptsGroupSwitch: true }));
@@ -472,6 +668,7 @@ describe('provider group "switch to another computer" for shared users', () => {
{ kind: 'member', ...MEMBER_STUDIO },
{ kind: 'member', ...MEMBER_STUDIO },
{ kind: 'unavailable' },
+ { kind: 'member', ...MEMBER_MINI },
],
});
const first = await openAsGuest(env, GUEST_A, openPayload(SESSION, { acceptsGroupSwitch: true }));
@@ -488,6 +685,12 @@ describe('provider group "switch to another computer" for shared users', () => {
exclude: new Set([MEMBER_MINI.memberKey, MEMBER_STUDIO.memberKey]),
}));
expect(switchTokenIn(second.stream)).toBeUndefined();
+
+ // 用户亲自重试开始新的一轮:已经恢复的那台又能接手。
+ await second.client.call('send', [{ content: 'try again', attachments: [] }, { groupNewRound: true }]);
+ env.memberStarted.studio[0].emit(USAGE_LIMIT_ERROR);
+ await waitFor(() => switchTokenIn(second.stream) !== undefined);
+ expect(env.relay.plan).toHaveBeenLastCalledWith(expect.objectContaining({ exclude: new Set([MEMBER_STUDIO.memberKey]) }));
await second.client.close('close', 'navigation');
});
});
diff --git a/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts b/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts
index 8740bff171..73b3d870f1 100644
--- a/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts
+++ b/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts
@@ -187,6 +187,8 @@ export interface RemoteHandleDeps {
onVendorOptions?: (patch: Record<string, unknown>) => void;
/** 句柄关闭后释放本机资源(执行器、MCP 身份等)。 */
dispose(): Promise<void>;
+ /** 供应商组(分享的人):这次发送要不要告诉对方开始新的一轮(用户亲自接手过)。 */
+ takeGroupNewRound?(): boolean;
}
export interface RemoteAgentHandleController {
@@ -221,6 +223,7 @@ export function createRemoteAgentHandle(deps: RemoteHandleDeps): RemoteAgentHand
async function sendLike(method: 'send' | 'steer', message: UserMessage, opts?: SendOptions): Promise<void> {
const encoded = await encodeSendOptions(opts, readImage);
+ if (method === 'send' && deps.takeGroupNewRound?.()) encoded.wire.groupNewRound = true;
const wireMessage = await encodeUserMessage(message, readImage);
const projectMessage = (wire: typeof wireMessage) => {
if (typeof wire.content === 'string') wire.content = deps.workspace.mapTextForAgent(wire.content);
diff --git a/apps/desktop/src/main/remote-agent/controller/runClient.ts b/apps/desktop/src/main/remote-agent/controller/runClient.ts
index 3f26146954..7626eb9657 100644
--- a/apps/desktop/src/main/remote-agent/controller/runClient.ts
+++ b/apps/desktop/src/main/remote-agent/controller/runClient.ts
@@ -110,9 +110,14 @@ export class RemoteAgentRunClient implements PolledRun {
return { uploadId, chunks, bytes: gz.length };
}
- /** 打开任务:等对方启动 Agent 成功(返回会话描述)或失败(抛出对方的错误)。 */
+ /**
+ * 打开任务:等对方启动 Agent 成功(返回会话描述)或失败(抛出对方的错误)。已关闭的连接不能再打开:本机这边的
+ * 任务已经结束(撤权、用户关闭),再打开会在对方留下一个没人拉取、没人关闭的任务。
+ */
async open(agentKind: RemoteAgentKind, openPayload: unknown): Promise<Record<string, unknown>> {
+ if (this.closed) throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
const payload = await this.payload(openPayload);
+ if (this.closed) throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
const started = new Promise<Record<string, unknown>>((resolve, reject) => {
this.started = { resolve, reject };
});
@@ -122,6 +127,12 @@ export class RemoteAgentRunClient implements PolledRun {
this.started = null;
throw error;
}
+ if (this.closed) {
+ // 打开途中本机关掉了这个任务:对方可能先收到关闭(那时还没有这个任务)再收到打开,补发一次关闭。
+ void started.catch(() => undefined);
+ void this.invoke([{ op: 'close', runId: this.runId, mode: 'close', reason: 'navigation' }]).catch(() => undefined);
+ throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
+ }
this.registered = true;
this.poller.register(this);
return started;
diff --git a/apps/desktop/src/main/remote-agent/controller/service.ts b/apps/desktop/src/main/remote-agent/controller/service.ts
index 36268d0c89..85c683ff44 100644
--- a/apps/desktop/src/main/remote-agent/controller/service.ts
+++ b/apps/desktop/src/main/remote-agent/controller/service.ts
@@ -64,6 +64,8 @@ export interface DeviceAgentServiceDeps {
groupSwitch?: {
takeForOpen(sessionId: string): string | undefined;
offer(sessionId: string, token: string): void;
+ /** 用户亲自接手后的这次发送开始新的一轮(取走即用掉)。 */
+ takeNewRound?(sessionId: string): boolean;
};
logger: Logger;
}
@@ -162,6 +164,7 @@ export function createDeviceAgentStarter(deps: DeviceAgentServiceDeps) {
groupSwitch: {
...(switchToken ? { token: switchToken } : {}),
offer: (token: string) => groupSwitch.offer(sessionId, token),
+ takeNewRound: () => groupSwitch.takeNewRound?.(sessionId) ?? false,
},
}
: {}),
diff --git a/apps/desktop/src/main/remote-agent/controller/startRemote.ts b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
index acf3cc90a2..91f08f70d2 100644
--- a/apps/desktop/src/main/remote-agent/controller/startRemote.ts
+++ b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
@@ -78,9 +78,10 @@ export interface StartRemoteAgentDeps {
groupAssigned?: boolean;
/**
* 供应商组「需要换一台」(分享的人,docs/product-rules/provider-groups.md §6.1):提供即在打开时声明支持。
- * `token` 是交接后重新打开时带回的凭证;对方发来新凭证时交给 `offer`。
+ * `token` 是交接后重新打开时带回的凭证;对方发来新凭证时交给 `offer`;`takeNewRound` 为 true 的那次发送告诉
+ * 对方开始新的一轮(用户亲自接手过)。
*/
- groupSwitch?: { token?: string; offer(token: string): void };
+ groupSwitch?: { token?: string; offer(token: string): void; takeNewRound?(): boolean };
newId(): string;
log?: {
info(message: string, meta?: Record<string, unknown>): void;
@@ -327,6 +328,7 @@ export async function startRemoteAgentSession(
onInvalidResumeSession: opts.onInvalidResumeSession,
mapEvent: deps.mapEvent?.(kind),
newId: deps.newId,
+ ...(deps.groupSwitch?.takeNewRound ? { takeGroupNewRound: deps.groupSwitch.takeNewRound } : {}),
onPermissionMode: (mode) => {
permissionMode = mode as typeof permissionMode;
executor.setGateMode(executorGateModeFor(permissionMode, planMode));
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index c3a754b284..057a336fb2 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -50,6 +50,7 @@ import { createGuestUsageMeter, type GuestUsageSample } from './guestUsage';
import {
GROUP_SWITCH_STATE_KEY,
newGroupSwitchToken,
+ RELAY_UNAVAILABLE_ERROR,
relayConnId,
relayErrorForGuest,
relayErrorInfoFrom,
@@ -90,16 +91,18 @@ export const REMOTE_AGENT_HOST_IDLE_MS = 3 * 60_000;
/** 结束后保留一段时间供控制端读完收尾事件。 */
export const REMOTE_AGENT_HOST_RETAIN_MS = 60_000;
/**
- * 供应商组的组所在电脑替多个受邀者中转过来时,同一个控制端在本机的任务按受邀者(relay)各算
- * REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER;这个控制端合计不超过这里。
+ * 供应商组的组所在电脑(同账号控制端)替多个受邀者中转过来时,它在本机的任务按受邀者(relay)各算
+ * REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER;这个控制端合计不超过这里。受邀者控制端填的 relay 不放宽额度。
*/
export const REMOTE_AGENT_MAX_RELAYED_RUNS_PER_CONTROLLER = REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER * 4;
-/** 受邀者的任务交给组内电脑时,启动阶段最多换几台。 */
-const MAX_RELAY_START_ATTEMPTS = 8;
/** 「需要换一台」凭证多久内有效(受邀者那边交接通常几秒内完成,重开时带回)。 */
export const GROUP_SWITCH_TOKEN_TTL_MS = 10 * 60_000;
/** 距上一次换电脑超过这么久算新的一轮(与供应商组本机任务的一轮同一口径)。 */
const GROUP_SWITCH_ROUND_MS = 30 * 60_000;
+/** 打开的结果不明(超时、断链)时,换下一台之前最多等多久请那台关掉同一个任务。 */
+const RELAY_CLOSE_WAIT_MS = 5_000;
+/** 删除受邀者时没通知到的组内电脑(离线等),多久后再试一次。 */
+const FORGET_RETRY_MS = 10 * 60_000;
/** 那台上的任务以这些原因结束是正常收尾,不算失败。 */
const NORMAL_RELAY_CLOSE_REASONS = new Set(['closed', 'detached', 'ended', 'superseded']);
const UPLOAD_IDLE_MS = 2 * 60_000;
@@ -221,27 +224,42 @@ function localGroupMember(providerId: string): GroupRelayMember {
return { memberKey: PROVIDER_GROUP_LOCAL_MEMBER_KEY, agentDeviceId: '', providerId, sameAccount: false };
}
+/** 计入某台组内电脑负载的一个受邀者任务(按它是否正在运行一轮);任务结束时 release。 */
+export interface GroupRelayLoad {
+ setRunning(running: boolean): void;
+ release(): void;
+}
+
export type GroupRelayPlan =
- /** 组里选中了本机。 */
- | { kind: 'local' }
- | ({ kind: 'member' } & GroupRelayMember)
+ /** 组里选中了本机。`load`:要求预占时已计入本机这一台的负载。 */
+ | { kind: 'local'; load?: GroupRelayLoad }
+ | ({ kind: 'member'; load?: GroupRelayLoad } & GroupRelayMember)
/** 组里没有能接这个任务的电脑。 */
| { kind: 'unavailable' };
export interface RemoteAgentGroupRelayDeps {
- /** 受邀者的新任务该交给谁;这个供应商没有组返回 null(照常在本机运行)。 */
- plan(input: { kind: RemoteAgentKind; model: string; providerId: string; exclude: ReadonlySet<string> }): Promise<GroupRelayPlan | null>;
+ /**
+ * 受邀者的新任务该交给谁;这个供应商没有组返回 null(照常在本机运行)。`reserve`:选中的同一步就计入那台的负载
+ * (返回的 `load`),同时来的几个任务不会全落到同一台;只是问问有没有能接的电脑时不预占。
+ */
+ plan(input: {
+ kind: RemoteAgentKind;
+ model: string;
+ providerId: string;
+ exclude: ReadonlySet<string>;
+ reserve?: boolean;
+ }): Promise<GroupRelayPlan | null>;
/** 经设备互联连某台组内电脑的远程 Agent 通道(与本机作为控制端共用拉取器)。 */
connect(agentDeviceId: string): { invoke: RemoteAgentInvoke; poller: RemoteAgentPoller };
/** 那台在启动阶段没能接下任务(连不上、登录失效等):按组的口径冷却。 */
noteStartFailure(providerId: string, member: GroupRelayMember, error: unknown): void;
/**
- * 那台上的任务运行中失败(终态错误,或一轮进行中任务意外结束):问题出在那台电脑本身时按组的口径冷却它并
- * 返回 true(可以换一台);用户停止、上下文超限等换到哪台都一样的失败返回 false。
+ * 那台上的任务运行中失败(终态错误,或一轮进行中任务意外结束):问题出在那台电脑本身时按组的口径冷却它,组设置
+ * 允许自动换电脑时返回 true(可以换一台);用户停止、上下文超限等换到哪台都一样的失败返回 false。
*/
noteRunFailure(providerId: string, member: GroupRelayMember, failure: RelayRunFailure): boolean;
/** 计入那台组内电脑的负载(按它是否正在运行一轮)。 */
- trackRun(providerId: string, memberKey: string): { setRunning(running: boolean): void; release(): void };
+ trackRun(providerId: string, memberKey: string): GroupRelayLoad;
/** 删掉受邀者后,请接过它任务的组内电脑清掉留下的会话记录与目录。 */
forget(agentDeviceId: string, relay: string): Promise<void>;
}
@@ -259,7 +277,7 @@ interface RelayBackend {
/** 推帧按任务串行,保证 Codex exec-server 帧的顺序。 */
pushChain: Promise<void>;
model?: string;
- load: { setRunning(running: boolean): void; release(): void };
+ load: GroupRelayLoad;
}
interface Upload {
@@ -316,6 +334,10 @@ interface Run {
* 运行中失败时可以发凭证。
*/
acceptsGroupSwitch?: boolean;
+ /** 本机是组所在电脑、组选中了本机这一台来运行受邀者的任务:计入本机这一台的负载。 */
+ groupLoad?: GroupRelayLoad;
+ /** 本机 Agent 上一次报来的「正在运行一轮」。 */
+ turnRunning?: boolean;
}
/** 控制端真实路径 → 影子目录里逐级镜像的目录名(去掉本机文件系统不允许的字符)。 */
@@ -477,6 +499,15 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
* (会话记录在那里);那台被移出组后也照样回到那台。
*/
members?: Record<string, GroupRelayMember>;
+ /**
+ * 本机是组所在电脑:交过这个受邀者任务的组内电脑(发打开之前先记)。那台在启动 Agent 之前就会建受邀者目录与
+ * 会话记录,启动失败、还没有原生会话 id 时也要能在删除受邀者时请它清掉。
+ */
+ relayDevices?: string[];
+ /**
+ * 受邀者已删除、本机的数据已清掉,只剩这几台组内电脑还没通知到(当时离线等):之后每次清理时再试。
+ */
+ forgetPending?: string[];
}
const guestIndexFile = path.join(deps.runsRoot, 'guest-sessions.json');
const guestDigest = (scope: string) => createHash('sha256').update(scope).digest('hex').slice(0, 32);
@@ -503,12 +534,16 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const list = (value: unknown) => (Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []);
if (typeof record?.controller !== 'string') continue;
const members = readRelayMembers(record.members);
+ const relayDevices = list(record.relayDevices);
+ const forgetPending = list(record.forgetPending);
map.set(digest, {
controller: record.controller,
...(typeof record.relay === 'string' ? { relay: record.relay } : {}),
hostSessionIds: list(record?.hostSessionIds),
nativeIds: list(record?.nativeIds),
...(members ? { members } : {}),
+ ...(relayDevices.length ? { relayDevices } : {}),
+ ...(forgetPending.length ? { forgetPending } : {}),
});
}
return map;
@@ -539,7 +574,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const map = await loadGuestIndex();
const digest = guestDigest(guestScopeOf(controller, relay));
const record = map.get(digest) ?? { controller, ...(relay ? { relay } : {}), hostSessionIds: [], nativeIds: [] };
- let changed = !map.has(digest);
+ let changed = !map.has(digest) || reviveForgottenRecord(record);
if (!record.hostSessionIds.includes(hostSessionId)) {
record.hostSessionIds.push(hostSessionId);
changed = true;
@@ -559,6 +594,36 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
await persistGuestIndex(map);
}
+ /**
+ * 同一个受邀者作用域又用起来了,而上次删除时还有组内电脑没通知到:这些电脑并回「交过任务的电脑」,下次删除时
+ * 一起清,不单独再去清(否则会清掉它刚在那台留下的新数据)。返回记录是否有变。
+ */
+ function reviveForgottenRecord(record: GuestSessionRecord): boolean {
+ if (!record.forgetPending?.length) return false;
+ record.relayDevices = [...new Set([...(record.relayDevices ?? []), ...record.forgetPending])];
+ delete record.forgetPending;
+ return true;
+ }
+
+ /** 本机是组所在电脑:发打开之前先记下要交给哪台组内电脑(见 GuestSessionRecord.relayDevices)。 */
+ async function recordRelayDevice(controller: string, hostSessionId: string, agentDeviceId: string): Promise<void> {
+ const map = await loadGuestIndex();
+ const digest = guestDigest(controller);
+ const record = map.get(digest) ?? { controller, hostSessionIds: [], nativeIds: [] };
+ let changed = !map.has(digest) || reviveForgottenRecord(record);
+ if (!record.hostSessionIds.includes(hostSessionId)) {
+ record.hostSessionIds.push(hostSessionId);
+ changed = true;
+ }
+ if (!record.relayDevices?.includes(agentDeviceId)) {
+ record.relayDevices = [...(record.relayDevices ?? []), agentDeviceId];
+ changed = true;
+ }
+ if (!changed) return;
+ map.set(digest, record);
+ await persistGuestIndex(map);
+ }
+
async function guestOwnsSession(controller: string, relay: string | undefined, nativeId: string): Promise<boolean> {
const map = await loadGuestIndex();
return map.get(guestDigest(guestScopeOf(controller, relay)))?.nativeIds.includes(nativeId) ?? false;
@@ -653,6 +718,10 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
function emitState(run: Run): void {
if (!run.handle || run.closing) return;
const state = snapshotHandleState(run.handle);
+ if (typeof state.turnRunning === 'boolean') {
+ run.turnRunning = state.turnRunning;
+ run.groupLoad?.setRunning(state.turnRunning);
+ }
const serialized = JSON.stringify(state);
if (serialized === run.lastState) return;
run.lastState = serialized;
@@ -942,9 +1011,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
async function pumpEvents(run: Run, handle: AgentSessionHandle): Promise<void> {
/** 供应商组:本机这一台上这一轮出过终态错误。 */
let groupTurnFailed = false;
+ let lastEventType: string | undefined;
+ let streamError: unknown;
+ let streamFailed = false;
try {
for await (const event of handle.events()) {
if (run.closing) break;
+ lastEventType = event.type;
if (run.trust === 'guest') meterGuestUsage(run, handle.model, event);
if (run.acceptsGroupSwitch) {
// 受邀者的任务按组分到了本机这一台:本机运行中失败时同样可以换一台(凭证排在错误前面)。
@@ -963,11 +1036,32 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
append(run, { t: 'event', event });
emitState(run);
}
- await finishRun(run, 'ended', 'navigation', false);
} catch (error) {
- append(run, { t: 'closed', reason: 'error', error: remoteAgentErrorInfo(error) });
+ streamFailed = true;
+ streamError = error;
+ }
+ // 受邀者的任务按组分到了本机这一台、一轮进行中本机的 Agent 意外结束(进程退出、事件流中断):与组内电脑上的
+ // 任务意外结束一样可以换一台——凭证排在收尾前面,收尾按出错处理,受邀者那边才会把这一轮当作失败。
+ const midTurn = run.turnRunning === true && lastEventType !== 'done';
+ if (run.acceptsGroupSwitch && !run.closing && midTurn && !groupTurnFailed) {
+ const info = streamFailed ? remoteAgentErrorInfo(streamError) : RELAY_UNAVAILABLE_ERROR;
+ const token = await groupSwitchOfferFor(run, localGroupMember(run.providerId!), {
+ reason: 'remote_agent_closed',
+ message: info.message,
+ }, handle.model).catch(() => null);
+ if (!run.closing) {
+ if (token) append(run, { t: 'state', state: { [GROUP_SWITCH_STATE_KEY]: token } });
+ append(run, { t: 'closed', reason: 'error', error: info });
+ await finishRun(run, 'error', 'navigation', false, true);
+ return;
+ }
+ }
+ if (streamFailed) {
+ append(run, { t: 'closed', reason: 'error', error: remoteAgentErrorInfo(streamError) });
await finishRun(run, 'error', 'navigation', false, true);
+ return;
}
+ await finishRun(run, 'ended', 'navigation', false);
}
function meterGuestUsage(run: Run, model: string | undefined, event: AgentEvent): void {
@@ -1037,6 +1131,18 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
return issueGroupSwitchToken(run, exclude);
}
+ /**
+ * 受邀者亲自接手(发消息、重试、换模型)后的这次发送:这个任务这一轮已经换下来的电脑清零(§6.1「一轮的边界」),
+ * 之前因故换下、现在已恢复的电脑又能接手。标记只在本机读,去掉后再交给 Agent 或转给组内电脑。
+ */
+ function takeGroupNewRound(run: Run, method: RemoteAgentMethod, args: unknown[]): unknown[] {
+ const opts = args[1];
+ if (method !== 'send' || !opts || typeof opts !== 'object' || Array.isArray(opts) || !('groupNewRound' in opts)) return args;
+ const { groupNewRound, ...rest } = opts as Record<string, unknown>;
+ if (groupNewRound === true && run.hostSessionId) groupSwitchRounds.delete(key(run.controller, run.hostSessionId));
+ return [args[0], rest, ...args.slice(2)];
+ }
+
/** 那台上一轮的结果:正常结束则这个任务的换电脑记录重新从头算。 */
function noteGroupSwitchTurnEnded(run: Run, failed: boolean): void {
if (!failed && run.hostSessionId) groupSwitchRounds.delete(key(run.controller, run.hostSessionId));
@@ -1068,26 +1174,33 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
/**
- * 启动中转任务。全新任务在那台没接下(还没开始运行)时换组里下一台,受邀者无感;续接只能回到原来那台。
- * 组里选回本机时改在本机运行。
+ * 启动中转任务。全新任务在那台没接下(还没开始运行)时换组里下一台,受邀者无感;每台最多试一次,组里能接的
+ * 都试过才报错(组的电脑数不设上限)。续接只能回到原来那台。组里选回本机时改在本机运行。
*/
async function startRelay(
run: Run,
payload: RemoteAgentOpenPayload,
first: GroupRelayMember,
- /** `avoid`:「需要换一台」后重新打开时,这一轮已经换下来的组内电脑,启动阶段换台也不回到它们。 */
- options: { fresh: boolean; avoid?: readonly string[] },
+ /**
+ * `avoid`:「需要换一台」后重新打开时,这一轮已经换下来的组内电脑,启动阶段换台也不回到它们。
+ * `load`:选第一台时已经预占的负载。
+ */
+ options: { fresh: boolean; avoid?: readonly string[]; load?: GroupRelayLoad },
): Promise<void> {
const relayDeps = deps.groupRelay!;
const groupProviderId = run.providerId!;
const tried = new Set<string>(options.avoid ?? []);
let member: GroupRelayMember | null = first;
+ /** 选这台时已经计入它的负载(没有则开始这一次尝试时再计)。 */
+ let reserved: GroupRelayLoad | undefined = options.load;
let lastError: unknown = null;
- for (let attempt = 1; member && attempt <= MAX_RELAY_START_ATTEMPTS && !run.closing; attempt += 1) {
+ // 换下来的都记进 tried、不会再选到,组里选不出新的就停。
+ for (let attempt = 1; member && !run.closing; attempt += 1) {
const current: GroupRelayMember = member;
member = null;
const connection = relayDeps.connect(current.agentDeviceId);
- const load = relayDeps.trackRun(groupProviderId, current.memberKey);
+ const load = reserved ?? relayDeps.trackRun(groupProviderId, current.memberKey);
+ reserved = undefined;
const backend: RelayBackend = {
client: undefined as unknown as RemoteAgentRunClient,
member: current,
@@ -1123,6 +1236,28 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
for (const fn of queue) fn();
});
};
+ /** 那台上的任务开始运行之后结束了:这个任务也结束。 */
+ const relayClosed = (reason: string, error?: RemoteAgentErrorInfo) => {
+ const finish = () => {
+ if (run.closing) return;
+ run.log.append({ t: 'closed', reason, ...(error ? { error: relayErrorForGuest(error) } : {}) });
+ void finishRun(run, reason, 'navigation', false, true);
+ };
+ // 一轮进行中那台的任务意外结束(离线、崩溃等):与终态错误一样可以换一台。
+ const unexpected = backend.turnRunning && !NORMAL_RELAY_CLOSE_REASONS.has(reason);
+ if (unexpected && !held) {
+ holdForGroupSwitch({ reason: 'remote_agent_closed', ...(error?.message ? { message: error.message } : {}) }, finish);
+ return;
+ }
+ emit(finish);
+ };
+ /**
+ * 还没报启动成功那台就结束了:同一次拉取可能同时带回启动与结束(很快结束的任务),先记下,打开返回后再按
+ * 运行中结束处理;启动失败时由下面的 catch 处理(可能换下一台)。
+ */
+ let closedEarly: { reason: string; error?: RemoteAgentErrorInfo } | null = null;
+ /** 打开已经发出(那台可能已经建了目录、启动了 Agent)。 */
+ let openSent = false;
backend.client = new RemoteAgentRunClient(randomUUID(), connection.poller, {
onEvent: (event) => {
if (run.closing || run.relay !== backend) return;
@@ -1175,20 +1310,12 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
});
},
onClosed: (reason, error) => {
- // 启动阶段的收尾由下面的 catch 处理(可能换下一台);开始运行之后那台结束了,这个任务也结束。
- if (run.relay !== backend || run.closing || !backend.started) return;
- const finish = () => {
- if (run.closing) return;
- run.log.append({ t: 'closed', reason, ...(error ? { error: relayErrorForGuest(error) } : {}) });
- void finishRun(run, reason, 'navigation', false, true);
- };
- // 一轮进行中那台的任务意外结束(离线、崩溃等):与终态错误一样可以换一台。
- const unexpected = backend.turnRunning && !NORMAL_RELAY_CLOSE_REASONS.has(reason);
- if (unexpected && !held) {
- holdForGroupSwitch({ reason: 'remote_agent_closed', ...(error?.message ? { message: error.message } : {}) }, finish);
+ if (run.relay !== backend || run.closing) return;
+ if (!backend.started) {
+ closedEarly = { reason, ...(error ? { error } : {}) };
return;
}
- emit(finish);
+ relayClosed(reason, error);
},
}, randomUUID, deps.log);
run.relay = backend;
@@ -1197,6 +1324,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (caps.virtualWorkspace !== true || (current.sameAccount && caps.guestRelay !== true)) {
throw new Error('[REMOTE_AGENT_PEER_TOO_OLD] the computer in the provider group cannot take shared tasks yet');
}
+ // 等 caps 期间任务已经结束(撤权、受邀者关闭):不再打开(收尾已经放掉了这次尝试的负载)。
+ if (run.closing) return;
+ // 发打开之前先记下这台:它在启动 Agent 之前就会建受邀者目录与会话记录,启动失败、还没有原生会话 id
+ // 时,删除受邀者也要能请它清掉。
+ if (run.hostSessionId) await recordRelayDevice(run.controller, run.hostSessionId, current.agentDeviceId);
+ if (run.closing) return;
+ openSent = true;
const started = await backend.client.open(run.kind, relayedOpenPayload(run, payload, current));
if (run.closing) {
await backend.client.close('close', 'navigation').catch(() => undefined);
@@ -1207,10 +1341,23 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const nativeIds = [started.id, started.requestSessionId].map((id) => (typeof id === 'string' ? id : undefined));
if (run.hostSessionId) await recordGuestSession(run.controller, undefined, run.hostSessionId, nativeIds, current);
deps.log?.info('remote agent run relayed to the provider group', { runId: run.id, member: current.memberKey });
+ const early = closedEarly as { reason: string; error?: RemoteAgentErrorInfo } | null;
+ if (early && run.relay === backend) relayClosed(early.reason, early.error);
return;
} catch (error) {
lastError = error;
run.relay = undefined;
+ if (openSent && !backend.client.isClosed) {
+ // 打开的结果不明(超时、断链)时那台可能已经启动了 Agent:换下一台之前先用同一个任务 id 请它关掉;
+ // 关不到时,那台上没人拉取的任务也会在空闲超时后自行结束(删除受邀者时按上面记下的这台清理)。
+ await Promise.race([
+ backend.client.close('close', 'navigation').catch(() => undefined),
+ new Promise<void>((resolve) => {
+ const timer = setTimeout(resolve, RELAY_CLOSE_WAIT_MS);
+ (timer as { unref?: () => void }).unref?.();
+ }),
+ ]);
+ }
backend.client.abandon('start-failed');
load.release();
// 这次尝试里受邀者那边已经打开的连接全部关掉,下一次尝试的连接编号不同。
@@ -1228,14 +1375,23 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
model: payload.options.model,
providerId: groupProviderId,
exclude: tried,
+ reserve: true,
}).catch(() => null);
- if (next?.kind === 'local' && deps.isAgentAvailable(run.kind)) {
+ if (next?.kind === 'local' && deps.isAgentAvailable(run.kind) && !run.closing) {
+ if (next.load) run.groupLoad = next.load;
await startRun(run, payload);
return;
}
- if (next?.kind === 'member') member = next;
+ if (next?.kind === 'member') {
+ const { memberKey, agentDeviceId, providerId, sameAccount } = next;
+ member = { memberKey, agentDeviceId, providerId, sameAccount };
+ reserved = next.load;
+ } else if (next?.kind === 'local') {
+ next.load?.release();
+ }
}
}
+ reserved?.release();
if (run.closing) return;
append(run, { t: 'start-failed', error: relayErrorInfoFrom(lastError ?? new Error('[REMOTE_AGENT_UNAVAILABLE] no computer can run this task right now')) });
await finishRun(run, 'start-failed', 'navigation', false);
@@ -1245,7 +1401,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
async function relayCall(run: Run, relay: RelayBackend, callId: string, method: RemoteAgentMethod, payload: RemoteAgentPayload): Promise<void> {
try {
const raw = await resolvePayload(run.controller, payload);
- const args = Array.isArray(raw) ? raw : [];
+ const args = takeGroupNewRound(run, method, Array.isArray(raw) ? raw : []);
let callArgs: unknown[] = args;
if (method === 'setVendorOptions') callArgs = [sanitizeGuestVendorOptions(args[0])];
if (method === 'setExtraDirs') {
@@ -1315,6 +1471,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
relay.load.release();
}
+ run.groupLoad?.release();
// Agent 已关:撤销受邀者的出站登记,之后这条任务的请求一律被本机 proxy 拒绝。
run.guestRoute?.release();
run.guestRoute = undefined;
@@ -1365,7 +1522,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
try {
if (!handle) fail('REMOTE_AGENT_UNAVAILABLE', 'agent has not started');
const raw = await resolvePayload(run.controller, payload);
- const args = Array.isArray(raw) ? raw : [];
+ const args = takeGroupNewRound(run, method, Array.isArray(raw) ? raw : []);
const target = (handle as unknown as Record<string, unknown>)[method];
if (typeof target !== 'function') fail('REMOTE_AGENT_UNSUPPORTED', `${method} is not supported by this agent`);
let callArgs: unknown[] = args;
@@ -1521,15 +1678,20 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
await Promise.all(targets.map((target) => (
fsp.rm(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }).catch(() => undefined)
)));
+ if (!records.length) return;
+ // 接过这些受邀者任务的组内电脑(含启动失败、还没有原生会话 id 的):先记成待通知再逐台通知,通知到才划掉,
+ // 当时离线的之后再试——不能因为一次没通知到就丢了「要通知哪台」。
+ let forgets = false;
for (const [, record] of records) {
- const devices = new Set(Object.values(record.members ?? {}).map((member) => member.agentDeviceId));
- for (const agentDeviceId of devices) {
- void deps.groupRelay?.forget(agentDeviceId, relayKeyFor(record.controller)).catch((error) => {
- deps.log?.warn('remote agent: asking a provider group computer to forget a shared user failed', { error: String(error) });
- });
- }
+ const devices = new Set([
+ ...Object.values(record.members ?? {}).map((member) => member.agentDeviceId),
+ ...(record.relayDevices ?? []),
+ ...(record.forgetPending ?? []),
+ ]);
+ if (!devices.size || !deps.groupRelay) continue;
+ record.forgetPending = [...devices];
+ forgets = true;
}
- if (!records.length) return;
try {
await deps.purgeHostedTranscripts?.(
records.flatMap(([, record]) => record.hostSessionIds),
@@ -1538,10 +1700,99 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
} catch (error) {
// 留着登记,下次清理重试。
deps.log?.warn('remote agent transcript purge failed', { error: String(error) });
+ if (forgets) {
+ await persistGuestIndex(map);
+ void retryPendingForgets();
+ }
return;
}
- for (const [digest] of records) map.delete(digest);
+ for (const [digest, record] of records) {
+ // 本机这边清完了,只留下还没通知到的组内电脑。
+ if (record.forgetPending?.length) {
+ map.set(digest, {
+ controller: record.controller,
+ ...(record.relay ? { relay: record.relay } : {}),
+ hostSessionIds: [],
+ nativeIds: [],
+ forgetPending: record.forgetPending,
+ });
+ } else {
+ map.delete(digest);
+ }
+ }
await persistGuestIndex(map);
+ if (forgets) void retryPendingForgets();
+ }
+
+ let forgetRetryTimer: ReturnType<typeof setTimeout> | null = null;
+ let forgetRetrying: Promise<void> | null = null;
+ let forgetRetryAgain = false;
+ let disposed = false;
+
+ /**
+ * 逐台请组内电脑忘掉已删除的受邀者(见 GuestSessionRecord.forgetPending):通知到的划掉,都通知到的登记删掉;
+ * 还有没通知到的,过一阵再试。同一个受邀者作用域期间又用起来时(待通知的已并回交过任务的电脑)不再动它。
+ */
+ function retryPendingForgets(): Promise<void> {
+ if (forgetRetrying) {
+ forgetRetryAgain = true;
+ return forgetRetrying;
+ }
+ if (forgetRetryTimer) {
+ clearTimeout(forgetRetryTimer);
+ forgetRetryTimer = null;
+ }
+ forgetRetrying = (async () => {
+ const relayDeps = deps.groupRelay;
+ const map = await loadGuestIndex();
+ if (!relayDeps) return;
+ let changed = false;
+ for (const [digest, record] of [...map]) {
+ for (const agentDeviceId of [...(record.forgetPending ?? [])]) {
+ if (disposed || map.get(digest) !== record || !record.forgetPending?.includes(agentDeviceId)) continue;
+ try {
+ await relayDeps.forget(agentDeviceId, relayKeyFor(record.controller));
+ } catch (error) {
+ deps.log?.warn('remote agent: asking a provider group computer to forget a shared user failed', { error: String(error) });
+ continue;
+ }
+ if (map.get(digest) !== record || !record.forgetPending?.includes(agentDeviceId)) continue;
+ record.forgetPending = record.forgetPending.filter((id) => id !== agentDeviceId);
+ changed = true;
+ }
+ if (map.get(digest) === record && record.forgetPending && !record.forgetPending.length) {
+ delete record.forgetPending;
+ const empty = !record.hostSessionIds.length && !record.nativeIds.length && !record.members && !record.relayDevices?.length;
+ if (empty) map.delete(digest);
+ }
+ }
+ if (changed) await persistGuestIndex(map);
+ })().catch((error) => {
+ deps.log?.warn('remote agent: retrying provider group forget failed', { error: String(error) });
+ }).finally(() => {
+ forgetRetrying = null;
+ if (disposed) return;
+ if (forgetRetryAgain) {
+ forgetRetryAgain = false;
+ void retryPendingForgets();
+ return;
+ }
+ void scheduleForgetRetry();
+ });
+ return forgetRetrying;
+ }
+
+ /** 还有没通知到的组内电脑时,过一阵再试。 */
+ async function scheduleForgetRetry(): Promise<void> {
+ if (disposed || forgetRetryTimer || forgetRetrying || !deps.groupRelay) return;
+ const map = await loadGuestIndex();
+ if (disposed || forgetRetryTimer || forgetRetrying) return;
+ if (![...map.values()].some((record) => record.forgetPending?.length)) return;
+ forgetRetryTimer = setTimeout(() => {
+ forgetRetryTimer = null;
+ void retryPendingForgets();
+ }, FORGET_RETRY_MS);
+ (forgetRetryTimer as { unref?: () => void }).unref?.();
}
/** 组所在电脑请本机忘掉它替某个受邀者中转过来的任务(只清调用方自己的 relay)。 */
@@ -1618,10 +1869,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (relayKey && guestUnsupported) {
fail('REMOTE_AGENT_UNSUPPORTED', `${request.agentKind} is not available to shared users on this computer`);
}
- // 运行数按受邀者作用域各算一份;同一控制端替多个受邀者中转时另有合计上限。
+ // 运行数按受邀者作用域各算一份;同一控制端替多个受邀者中转时另有合计上限。只有同账号控制端(组所在电脑)
+ // 的 relay 才各算一份:受邀者自己填的 relay 只把它的数据分开存放,不能用来绕开它的运行数上限。
const active = [...runs.values()].filter((run) => run.controller === controller && run.closedAt === undefined);
const scope = guestScopeOf(controller, relayKey);
- const scoped = active.filter((run) => guestScopeOf(run.controller, run.relayKey) === scope).length;
+ const scoped = controllerTrust === 'guest'
+ ? active.length
+ : active.filter((run) => guestScopeOf(run.controller, run.relayKey) === scope).length;
if (scoped >= REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER || active.length >= REMOTE_AGENT_MAX_RELAYED_RUNS_PER_CONTROLLER) {
fail('REMOTE_AGENT_BUSY', 'too many tasks are running from this computer');
}
@@ -1655,11 +1909,15 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
let relayTo: GroupRelayMember | null = null;
/** 受邀者因「需要换一台」交接后重新打开:这一轮已经换下来的组内电脑(凭证只认这个受邀者的这个任务)。 */
let avoid: string[] = [];
+ /** 选电脑的同一步已计入那台(或本机这一台)的负载,交给任务;任务没建起来时放掉。 */
+ let reserved: GroupRelayLoad | undefined;
const groupRouted = controllerTrust === 'guest' && !relayKey && !payload.groupAssigned && !!deps.groupRelay && !!providerId;
if (groupRouted && deps.groupRelay && providerId) {
const resumeId = payload.options.resumeSessionId;
if (resumeId) {
relayTo = await relayMemberOf(controller, resumeId);
+ // 在本机运行过的会话接着在本机运行:计入本机这一台的负载。
+ if (!relayTo) reserved = deps.groupRelay.trackRun(providerId, PROVIDER_GROUP_LOCAL_MEMBER_KEY);
} else {
avoid = takeGroupSwitchToken(
controller,
@@ -1671,8 +1929,10 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
model: payload.options.model,
providerId,
exclude: new Set(avoid),
+ reserve: true,
});
if (plan?.kind === 'unavailable') fail('REMOTE_AGENT_UNAVAILABLE', 'no computer can run this task right now');
+ if (plan?.kind === 'member' || plan?.kind === 'local') reserved = plan.load;
if (plan?.kind === 'member') {
const { memberKey, agentDeviceId, providerId: memberProviderId, sameAccount } = plan;
relayTo = { memberKey, agentDeviceId, providerId: memberProviderId, sameAccount };
@@ -1680,10 +1940,14 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
}
if (!relayTo && !deps.isAgentAvailable(request.agentKind)) {
+ reserved?.release();
fail('REMOTE_AGENT_UNSUPPORTED', `${request.agentKind} is not available on this computer`);
}
// 上面有等待:同一个 runId 的重发可能已经先登记了。
- if (runs.has(key(controller, request.runId))) return {};
+ if (runs.has(key(controller, request.runId))) {
+ reserved?.release();
+ return {};
+ }
const run: Run = {
id: request.runId,
controller,
@@ -1702,6 +1966,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
pushParts: new Map(),
...(providerId ? { providerId } : {}),
...(groupRouted && payload.acceptsGroupSwitch === true ? { acceptsGroupSwitch: true } : {}),
+ ...(reserved && !relayTo ? { groupLoad: reserved } : {}),
};
runs.set(key(controller, request.runId), run);
ensureSweep();
@@ -1710,9 +1975,11 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const member = relayTo;
// 先登记再中转:中转中途失败时,分享删除也能找到并清理(含通知那台组内电脑)。
run.hostSessionId = hostSessionIdFor(controller, payload.sessionId);
+ const load = reserved;
void recordGuestSession(controller, undefined, run.hostSessionId, [])
- .then(() => startRelay(run, payload, member, { fresh: !payload.options.resumeSessionId, avoid }))
+ .then(() => startRelay(run, payload, member, { fresh: !payload.options.resumeSessionId, avoid, ...(load ? { load } : {}) }))
.catch(async (error) => {
+ load?.release();
append(run, { t: 'start-failed', error: relayErrorInfoFrom(error) });
await finishRun(run, 'start-failed', 'navigation', false);
});
@@ -1800,6 +2067,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
}
+ // 上次运行时删除受邀者、还没通知到的组内电脑:过一阵再试。
+ void scheduleForgetRetry();
+
return {
handle,
/** 远程控制关闭 / 退出时结束全部任务。 */
@@ -1830,6 +2100,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
dispose(): void {
if (sweepTimer) clearInterval(sweepTimer);
sweepTimer = null;
+ disposed = true;
+ if (forgetRetryTimer) clearTimeout(forgetRetryTimer);
+ forgetRetryTimer = null;
// 退出前尽力收尾:影子工作目录含同步过去的项目与个人说明,不能留到下次启动。
for (const run of runs.values()) void finishRun(run, 'aborted', 'app-quit').then(() => disposeRun(run));
},
diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.ts
index 6a55e206d7..36831700a7 100644
--- a/apps/desktop/src/main/remote-agent/host/service.ts
+++ b/apps/desktop/src/main/remote-agent/host/service.ts
@@ -18,7 +18,7 @@ import { setRemoteAgentHandler } from '../../device-link/dispatch.js';
import { remoteBackgroundInvoke } from '../../device-link/index.js';
import { providerShareGuestAccess } from '../../device-link/providerShareHost.js';
import { createProviderGroupGuestRelay } from '../../provider-group/guestRelay.js';
-import { getProviderGroupExternalLoad, getProviderGroupRouter } from '../../provider-group/runtime.js';
+import { getProviderGroupOwnerScope } from '../../provider-group/runtime.js';
import { readProviderGroup } from '../../provider-group/store.js';
import { remoteAgentPollerFor } from '../controller/service';
import { getProviderShareUsageStore, installProviderShareUsageStore } from '../../device-link/providerShareUsageStore.js';
@@ -153,9 +153,8 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
},
// 供应商组(本机是组所在电脑):受邀者的任务按组分给组内电脑,本机中转(provider-groups.md §4)。
groupRelay: createProviderGroupGuestRelay({
- router: getProviderGroupRouter(),
+ scope: getProviderGroupOwnerScope,
readGroup: readProviderGroup,
- externalLoad: getProviderGroupExternalLoad(),
connect: (agentDeviceId) => {
const poller = remoteAgentPollerFor(agentDeviceId, remoteBackgroundInvoke, log);
return { invoke: poller.invoke, poller };
diff --git a/apps/desktop/src/main/remote-agent/wire.ts b/apps/desktop/src/main/remote-agent/wire.ts
index 0f24e82839..f9e0100074 100644
--- a/apps/desktop/src/main/remote-agent/wire.ts
+++ b/apps/desktop/src/main/remote-agent/wire.ts
@@ -479,6 +479,11 @@ export interface RemoteAgentWireSendOptions {
toolsDisabled?: boolean;
transcriptCallback?: boolean;
turnPolicy?: WireTurnPolicy;
+ /**
+ * 供应商组(分享的人,provider-groups.md §6.1):用户亲自接手(发消息、重试、换模型)后的这次发送,组所在电脑据此
+ * 清掉这个任务这一轮已经换下来的电脑。只有组所在电脑读它,不转给组内电脑;旧版本不认识,忽略。
+ */
+ groupNewRound?: true;
cindy?: {
/** autoReviewReferences is optional and additive; older peers drop it and review without it. */
mainOwned?: { origin: TurnPermissionOrigin; rawChannelText?: string; autoReviewReferences?: unknown };
diff --git a/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx b/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
index c1c356e702..2233c14570 100644
--- a/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
+++ b/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
@@ -74,7 +74,10 @@ export function useOwnRemoteProviderList(): OwnRemoteProviderList {
const catalog = catalogs.get(device.deviceId);
if (!catalog) return [];
return remoteAgentProviders(catalog.providers)
- .filter((provider) => provider.connected && !provider.suspended)
+ // 带组的项照常列出:组所在电脑自己的这个供应商掉登录或被停用时,组仍按组员分配,组员也仍收在组里,
+ // 不能让组和组员一起从设置里消失。
+ .filter((provider) => (provider.connected && !provider.suspended)
+ || groups.groups.has(remoteProviderEntryKey(device.deviceId, provider.id)))
.filter((provider) => !groups.hidden.has(remoteProviderEntryKey(device.deviceId, provider.id)))
.map((provider): OwnRemoteProvider => {
const key = ownRemoteProviderKey(device.deviceId, provider.id);
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 88c1178d06..dcf36fc5c5 100644
--- a/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
+++ b/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
@@ -107,6 +107,28 @@ describe('useOwnRemoteProviders', () => {
]);
expect([...result.current.hiddenShareIds]).toEqual(['s1']);
});
+
+ it('keeps the group listed when the group computer’s own provider is logged out or paused', () => {
+ devices.value = [
+ { deviceId: 'mini-a', name: "Magi's Mac Mini", platform: 'darwin' },
+ { deviceId: 'mini-b', name: 'Studio', platform: 'darwin' },
+ ];
+ const group = {
+ strategy: 'least',
+ members: [{ kind: 'local' }, { kind: 'device', agentDeviceId: 'mini-b', providerId: 'anthropic' }],
+ };
+ for (const state of [{ connected: false }, { suspended: true }]) {
+ catalogs.value = new Map([
+ ['mini-a', { providers: [provider('anthropic', { ...state, group })], loading: false, error: null }],
+ ['mini-b', { providers: [provider('anthropic')], loading: false, error: null }],
+ ]);
+ const { result, unmount } = renderHook(() => useOwnRemoteProviderList());
+ expect(result.current.entries.map((entry) => [entry.deviceId, entry.provider.id, entry.group?.members.length ?? 0])).toEqual([
+ ['mini-a', 'anthropic', 2],
+ ]);
+ unmount();
+ }
+ });
});
describe('OwnRemoteProviderRows / OwnRemoteProviderDetail', () => {
diff --git a/apps/desktop/src/renderer/features/provider-group/__tests__/useLocalProviderGroups.test.tsx b/apps/desktop/src/renderer/features/provider-group/__tests__/useLocalProviderGroups.test.tsx
new file mode 100644
index 0000000000..f40cfb6fe3
--- /dev/null
+++ b/apps/desktop/src/renderer/features/provider-group/__tests__/useLocalProviderGroups.test.tsx
@@ -0,0 +1,94 @@
+// @vitest-environment jsdom
+/**
+ * 本机供应商组快照按账号隔离:换账号后不沿用旧账号的组,旧账号迟到的读取结果丢弃。
+ */
+import { act, cleanup, renderHook, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { __testing as ownerTesting, setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import type { ProviderGroupConfig } from '../../../../shared/providerGroup';
+import { __testing, useLocalProviderGroups } from '../useLocalProviderGroups';
+
+function group(label: string): Record<string, ProviderGroupConfig> {
+ return { anthropic: { members: [{ key: 'local', label }] } as unknown as ProviderGroupConfig };
+}
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((r) => {
+ resolve = r;
+ });
+ return { promise, resolve };
+}
+
+let command: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+ __testing.reset();
+ ownerTesting.reset();
+ setDataOwnerGeneration('owner-a', 1);
+ command = vi.fn();
+ Object.assign(window, { electronAPI: { providerGroup: { command, onChanged: () => () => undefined } } });
+});
+
+afterEach(() => {
+ cleanup();
+ __testing.reset();
+ ownerTesting.reset();
+});
+
+describe('useLocalProviderGroups', () => {
+ it('drops the previous account groups after switching accounts and reads the new account', async () => {
+ command.mockResolvedValueOnce(group('A'));
+ const first = renderHook(() => useLocalProviderGroups());
+ await waitFor(() => expect(first.result.current.anthropic?.members[0].label).toBe('A'));
+ first.unmount();
+
+ const forB = deferred<Record<string, ProviderGroupConfig>>();
+ command.mockReturnValueOnce(forB.promise);
+ setDataOwnerGeneration('owner-b', 2);
+ const second = renderHook(() => useLocalProviderGroups());
+ expect(second.result.current).toEqual({});
+ await act(async () => {
+ forB.resolve(group('B'));
+ await forB.promise;
+ });
+ await waitFor(() => expect(second.result.current.anthropic?.members[0].label).toBe('B'));
+ expect(command).toHaveBeenCalledTimes(2);
+ });
+
+ it('ignores a late answer that belongs to the previous account', async () => {
+ const forA = deferred<Record<string, ProviderGroupConfig>>();
+ command.mockReturnValueOnce(forA.promise);
+ const first = renderHook(() => useLocalProviderGroups());
+ first.unmount();
+
+ command.mockResolvedValueOnce(group('B'));
+ setDataOwnerGeneration('owner-b', 2);
+ const second = renderHook(() => useLocalProviderGroups());
+ await waitFor(() => expect(second.result.current.anthropic?.members[0].label).toBe('B'));
+ await act(async () => {
+ forA.resolve(group('A'));
+ await forA.promise;
+ });
+ expect(second.result.current.anthropic?.members[0].label).toBe('B');
+ });
+
+ it('keeps showing the groups while re-reading after a same-account refresh', async () => {
+ command.mockResolvedValueOnce(group('A'));
+ const first = renderHook(() => useLocalProviderGroups());
+ await waitFor(() => expect(first.result.current.anthropic?.members[0].label).toBe('A'));
+ first.unmount();
+
+ const again = deferred<Record<string, ProviderGroupConfig>>();
+ command.mockReturnValueOnce(again.promise);
+ setDataOwnerGeneration('owner-a', 2);
+ const second = renderHook(() => useLocalProviderGroups());
+ expect(second.result.current.anthropic?.members[0].label).toBe('A');
+ await act(async () => {
+ again.resolve(group('A2'));
+ await again.promise;
+ });
+ await waitFor(() => expect(second.result.current.anthropic?.members[0].label).toBe('A2'));
+ });
+});
diff --git a/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts b/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts
index 2ed25b476e..ff474d4edb 100644
--- a/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts
+++ b/apps/desktop/src/renderer/features/provider-group/useLocalProviderGroups.ts
@@ -2,54 +2,92 @@
* 本机建的供应商组(只读设置,不读远端):模型列表与设置页据此收起本机组里的远程供应商与分享,
* 与其他电脑的组同一条规则(provider-groups.md §10)。组设置变化时 main 广播 CHANGED,重读一次。
* 全窗口共用一份,多个组件同时用也只发一次 IPC。
+ *
+ * 组设置属于当前账号:快照按账号代次存,换账号后清空重读,旧账号还在路上的结果直接丢弃——否则新账号的
+ * 模型列表会按旧账号的组收起供应商。
*/
import { useEffect, useState } from 'react';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+ type DataOwnerGeneration,
+} from '@/contexts/dataOwnerGeneration';
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;
+
+interface GroupsState {
+ owner: DataOwnerGeneration | null;
+ snapshot: LocalGroups;
+ loaded: Promise<void> | null;
+ /** 每次重读或换账号加一,只认最后一次读取的结果。 */
+ revision: number;
+}
+
+const state: GroupsState = { owner: null, snapshot: EMPTY, loaded: null, revision: 0 };
let offChanged: (() => void) | null = null;
const listeners = new Set<(groups: LocalGroups) => void>();
-function reload(): Promise<void> {
+function sameOwner(a: DataOwnerGeneration | null, b: DataOwnerGeneration): boolean {
+ return a?.dataOwnerId === b.dataOwnerId && a.generation === b.generation;
+}
+
+function stateFor(owner: DataOwnerGeneration): GroupsState {
+ if (!sameOwner(state.owner, owner)) {
+ // 同一账号只是代次变了(内部修复):保留快照免得组员闪出来,只重读一次;换了账号才清空。
+ if (state.owner?.dataOwnerId !== owner.dataOwnerId) state.snapshot = EMPTY;
+ state.owner = owner;
+ state.loaded = null;
+ state.revision += 1;
+ }
+ return state;
+}
+
+function reload(owner: DataOwnerGeneration): Promise<void> {
const api = window.electronAPI?.providerGroup;
if (typeof api?.command !== 'function') return Promise.resolve();
- loaded = Promise.resolve()
+ stateFor(owner);
+ const revision = ++state.revision;
+ state.loaded = Promise.resolve()
.then(() => api.command({ action: 'list' }))
.then((groups) => {
- snapshot = groups ?? EMPTY;
- for (const listener of listeners) listener(snapshot);
+ if (revision !== state.revision || !sameOwner(state.owner, owner) || !isDataOwnerGenerationCurrent(owner)) return;
+ state.snapshot = groups ?? EMPTY;
+ for (const listener of listeners) listener(state.snapshot);
})
.catch(() => undefined);
- return loaded;
+ return state.loaded;
}
-function subscribe(listener: (groups: LocalGroups) => void): () => void {
+function subscribe(owner: DataOwnerGeneration, listener: (groups: LocalGroups) => void): () => void {
listeners.add(listener);
- if (!loaded) void reload();
- offChanged ??= window.electronAPI?.providerGroup?.onChanged?.(() => void reload()) ?? null;
+ if (!stateFor(owner).loaded) void reload(owner);
+ offChanged ??= window.electronAPI?.providerGroup?.onChanged?.(() => void reload(getDataOwnerGeneration())) ?? null;
return () => {
listeners.delete(listener);
};
}
export function useLocalProviderGroups(): LocalGroups {
- const [groups, setGroups] = useState<LocalGroups>(snapshot);
+ const owner = getDataOwnerGeneration();
+ const source = stateFor(owner);
+ const [view, setView] = useState(() => ({ owner, groups: source.snapshot }));
useEffect(() => {
- setGroups(snapshot);
- return subscribe(setGroups);
- }, []);
- return groups;
+ setView({ owner, groups: source.snapshot });
+ return subscribe(owner, (groups) => setView({ owner, groups }));
+ }, [owner, source]);
+ return view.owner === owner ? view.groups : source.snapshot;
}
export const __testing = {
reset(): void {
- snapshot = EMPTY;
- loaded = null;
+ state.owner = null;
+ state.snapshot = EMPTY;
+ state.loaded = null;
+ state.revision = 0;
offChanged?.();
offChanged = null;
listeners.clear();
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 9dbaddc7fb..5d43ab1303 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -742,7 +742,9 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
- **open 载荷新增可选 `relay`**(`remote-agent/wire.ts`,`REMOTE_AGENT_RELAY_KEY_PATTERN`,16–64 位 `[A-Za-z0-9_-]`):O 为受邀者取的
不透明键(按受邀者派生,不含分享与成员信息)。M 收到带 `relay` 的 open 一律按受邀者隔离运行(即使控制端是同账号的 O):
- 受邀者目录、会话索引、续接校验与运行数按(控制端, relay)分开;同一控制端按受邀者各 16 个、合计 64 个任务。O 同时带
+ 受邀者目录、会话索引、续接校验与运行数按(控制端, relay)分开;同一控制端按受邀者各 16 个、合计 64 个任务。只有同账号
+ 控制端的 `relay` 才各算一份运行数:受邀者控制端自己填的 `relay` 只把它的数据分开存放,运行数仍按这个受邀者合计 16 个,
+ 不能借此放宽额度(分享来的 M 上 O 本身就是受邀者,O 替各受邀者中转的任务在那台合计 16 个)。O 同时带
`groupAssigned`,并把 `sessionId` 换成按(受邀者, 任务 id)派生的 id、`providerId` 换成 M 上的供应商。旧 M 丢弃这个字段,
所以 O 只把受邀者任务交给 caps 声明了 `guestRelay` 的同账号 M;分享来的 M 本来就把 O 当受邀者隔离,不要求这个能力。
- **caps 新增可选 `guestRelay: true`**(`RemoteAgentCaps`):被控端能按受邀者隔离运行(供应商级授权与受邀者出站边界都已接上)。
@@ -750,6 +752,9 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
只作用于调用方自己的 relay。旧 M 回 `REMOTE_AGENT_INVALID`(它从没接过被中转的任务)。
- O 不信任 G 带来的 `relay` / `groupAssigned`:受邀者的这两个字段只会让任务按普通受邀者在 O 本机隔离运行,不能借此逃出
受邀者隔离;O 的组路由只用 O 自己的组设置与记录。
+- `forget` 的通知名单从 O 发出 open 那一刻起记(含启动失败、还没有原生会话 id 的 M);没通知到的 M 持久记在 O 的受邀者
+ 会话索引(`forgetPending`)里,之后自动重发。open 的结果不明(超时、断链)时 O 先用同一个 runId 发 `close` 再换下一台;
+ 这些都只用已有的 op。
- 中转不解码消息与附件、不落盘(载荷原样按同一 callId 转给 M);推帧按任务串行;M 报出的路径类错误(分享暂停、远程调用
关闭、连不上、太忙等)转给 G 时统一成 `REMOTE_AGENT_UNAVAILABLE`。
- **控制端拉取器修正**(与本节同批,`remote-agent/controller/poller.ts`):一个 poll 带回数据后,若有任务没被仍在途的 poll
@@ -763,7 +768,7 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
产品规则见 [`provider-groups.md`](../product-rules/provider-groups.md) §6.1「谁来执行换电脑 · 分享的人」。上一节的中转任务在组内
电脑 M 上因那台本身的原因失败时,交接要用到对话记录,只能由受邀者 G 执行;组所在电脑 O 只负责告诉 G「需要换一台」并在
-G 重新打开时换一台。G 与 O 之间新增三项可选内容,O 与 M 之间不变:
+G 重新打开时换一台。G 与 O 之间新增四项可选内容,O 与 M 之间不变:
- **open 载荷新增可选 `acceptsGroupSwitch: true`**(`remote-agent/wire.ts`,只认 `true`):G 声明认识下面的凭证状态。新 G 打开
远程 Agent 任务时一律声明;O 只在中转任务上使用。旧 O 丢弃这个字段。
@@ -776,6 +781,10 @@ G 重新打开时换一台。G 与 O 之间新增三项可选内容,O 与 M
这个任务(按 O 侧的 `hostSessionId`)且未过期(10 分钟)的凭证,用一次即作废;有效时选电脑避开这一轮已经换下来的组内电脑,
无效时按普通新任务选。凭证只影响选哪台,不扩大任何权限;它与 `relay` / `groupAssigned` 一样不转给 M。
- 同一轮每台组内电脑最多换一次(O 按(受邀者, 任务)记录);那台上一轮正常结束或距上次换电脑超过 30 分钟算新的一轮。
+- **send 选项新增可选 `groupNewRound: true`**(`RemoteAgentWireSendOptions`,只认 `true`):G 上的用户亲自接手(发消息、重试、
+ 换模型)后、且这个任务收到过凭证时,下一次 `send` 带上它,O 据此清掉这个任务这一轮已经换下来的电脑,也算新的一轮。
+ O 读完即去掉,不交给 Agent、不转给 M;旧 O 丢弃这个字段(手动重试仍沿用旧的一轮,直到正常结束或 30 分钟)。它只影响
+ 这个受邀者自己这个任务的换电脑记录,不扩大任何权限。组设置关掉了自动换电脑时 O 照常冷却出问题的那台,但不发凭证。
- G 只在持有凭证时才换电脑:分享暂停、删除、撤权等来自 O 本身的错误没有凭证,照旧交回原有处理。
- 不改 relay、服务器与数据库。实现:`remote-agent/host/runHost.ts`(暂存与发凭证、校验凭证)、`host/groupRelay.ts`、
`provider-group/guestRelay.ts`(运行中失败的冷却)、`provider-group/guestSwitch.ts` 与 `provider-group/service.ts`(G 侧凭证与
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index d2e7378e4b..e461002b81 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -97,10 +97,12 @@
用同一个任务 id 不会撞车。组所在电脑在同一台组内电脑上按受邀者各算 16 个任务、合计不超过 64 个。
- **续接**只回到当初运行这个会话的那台(组所在电脑记着「哪个会话在哪台」,那台被移出组后也回到那台),不在别处重试;
受邀者不能凭 id 接回别的受邀者的会话。
- - **启动阶段**(新任务还没开始运行)那台接不下时直接换组里下一台,受邀者无感,旧版本受邀者也享受;每次尝试的
- WebSocket 连接编号不同,换台时关掉上一次尝试的连接。
+ - **启动阶段**(新任务还没开始运行)那台接不下时直接换组里下一台,受邀者无感,旧版本受邀者也享受;每台最多试一次,
+ 组里能接的都试过才报错(组的电脑数不设上限)。每次尝试的 WebSocket 连接编号不同,换台时关掉上一次尝试的连接;
+ 打开的结果不明(超时、断链)时,先请那台关掉同一个任务再换下一台(关不到时那台没人拉取的任务也会在空闲超时后结束)。
- 删除受邀者(分享删除)时,组所在电脑请接过它任务的组内电脑清掉它留下的会话记录与目录(`forget`);组内电脑只清
- 调用方自己的那个受邀者。那台当时离线则这次清不掉(已知限制:等下次组所在电脑清理时再试)。
+ 调用方自己的那个受邀者。「接过任务」从发出打开那一刻算起,启动失败、还没有会话的那台也会通知。当时没通知到的
+ (离线等)记在组所在电脑上,之后自动再通知(约每 10 分钟一次,重启后继续),通知到才划掉。
- **防转圈**:经组分配到组内电脑的任务,在那台电脑上直接运行,不再进入那台电脑自己的供应商组。
打开任务时带一个可选标记 `groupAssigned` 说明「已由供应商组分配」;旧版本不认识这个标记,也是直接运行。
登记见 `docs/dev-rules/protocol-compatibility.md`「供应商组」。