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(provider-group): 组内电脑连不上时先按退避重试 5 次,恢复了留在原电脑继续,都不行再换

Lizifa58757f32e7
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts
index 581780268b..b26c794785 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts
@@ -13978,7 +13978,7 @@ describe('provider group computer switch hold', () => {
sessionTotal: 0,
};
- async function failWhileSwitching(sid: string, cause: 'usage-limit' | null = 'usage-limit') {
+ async function failWhileSwitching(sid: string, cause: 'usage-limit' | 'unavailable' | null = 'usage-limit') {
const candidate = vi.fn<NonNullable<AgentInputCoordinatorDeps['providerGroupSwitchCandidate']>>(
() => cause,
);
@@ -14070,4 +14070,52 @@ describe('provider group computer switch hold', () => {
// 错误已不是当前状态:结算只清登记,不再弹横幅。
expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(false);
});
+
+ it('shows "reconnecting n/5" while waiting for the original computer, and "switching" once it gives up', async () => {
+ const sid = 'group-hold-reconnect';
+ const { h } = await failWhileSwitching(sid, 'unavailable');
+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;
+ expect(h.coordinator.setProviderGroupSwitchHoldProgress(sid, holdId + 1, { attempt: 1, maxAttempts: 5 })).toBe(false);
+ expect(h.coordinator.setProviderGroupSwitchHoldProgress(sid, holdId, { attempt: 2, maxAttempts: 5 })).toBe(true);
+ // 一次普通的重连:新旧端都显示「重新连接中 2/5」,不带 groupSwitchPending;错误仍不呈现。
+ expect(latestProjection(h.projections).error).toBeNull();
+ expect(latestProjection(h.projections).autoResumePending).toEqual({
+ error: MESSAGE,
+ attempt: 2,
+ maxAttempts: 5,
+ sessionTotal: 0,
+ });
+ expect(h.coordinator.setProviderGroupSwitchHoldProgress(sid, holdId, null)).toBe(true);
+ expect(latestProjection(h.projections).autoResumePending).toMatchObject({
+ attempt: 0,
+ groupSwitchPending: { cause: 'unavailable' },
+ });
+ // 放出来之后不再改。
+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(true);
+ expect(h.coordinator.setProviderGroupSwitchHoldProgress(sid, holdId, { attempt: 3, maxAttempts: 5 })).toBe(false);
+ expect(latestProjection(h.projections).error).toBe(MESSAGE);
+ expect(latestProjection(h.projections).autoResumePending).toBeUndefined();
+ });
+
+ it('shows progress on a message that has not gone out while the group waits before sending', async () => {
+ const h = createHarness();
+ const sid = 'group-send-reconnect';
+ const send = deferred<AgentInputSendResult>();
+ h.sendToAgent.mockImplementationOnce(async () => send.promise);
+ h.coordinator.enqueue(sid, makeItem('q-1', 'hello'));
+ await flush();
+ h.coordinator.setProviderGroupSendReconnect(sid, { attempt: 1, maxAttempts: 5 });
+ expect(latestProjection(h.projections).autoResumePending).toEqual({ attempt: 1, maxAttempts: 5, sessionTotal: 0 });
+ h.coordinator.setProviderGroupSendReconnect(sid, 'switching');
+ expect(latestProjection(h.projections).autoResumePending).toMatchObject({
+ groupSwitchPending: { cause: 'unavailable' },
+ });
+ h.coordinator.setProviderGroupSendReconnect(sid, null);
+ expect(latestProjection(h.projections).autoResumePending).toBeUndefined();
+ // 派出去之后不再挂到这一轮上。
+ send.resolve(sendSuccess());
+ await flush();
+ h.coordinator.setProviderGroupSendReconnect(sid, { attempt: 2, maxAttempts: 5 });
+ expect(latestProjection(h.projections).autoResumePending).toBeUndefined();
+ });
});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts
index e915b6ed98..4591cfc3a7 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts
@@ -3308,6 +3308,31 @@ describe('session-agent-switch handoff injection', () => {
expect(bootstrapOpts.resumeSessionId).toBeUndefined();
});
+ it('发送前的准备期间被停止(如供应商组在等原电脑恢复)→ 不再打开会话,按「派发前取消」返回', async () => {
+ const controller = new AbortController();
+ const getSession = vi.fn((): MakerSendTransactionSession | null => null);
+ const bootstrapSession = vi.fn(async (): Promise<never> => {
+ throw new Error('must not open a session after the send was stopped');
+ });
+ const { deps } = createDeps({
+ getSession,
+ bootstrapSession,
+ applyPendingAgentSwitch: vi.fn(async () => {
+ controller.abort();
+ }),
+ });
+ const transaction = createMakerSendTransaction(deps);
+ const result = await transaction.sendToAgentAccepted(
+ 'session-1',
+ { type: 'user', content: 'hi' },
+ { agentKind: 'claude-code', workingDir: 'C:\Users\admin\AppData\Local\Temp\w' },
+ { signal: controller.signal },
+ );
+ expect(result).toMatchObject({ accepted: false, reason: 'cancelled-before-dispatch' });
+ expect(getSession).not.toHaveBeenCalled();
+ expect(bootstrapSession).not.toHaveBeenCalled();
+ });
+
it('排队 drain 端到端:切换在派发时刻落实(关旧引擎)→ createOpts 按 DB 对齐新引擎 → 交接注入新引擎首条 + scheduler origin 透传', async () => {
// 复刻 coordinator drain 一条排队 scheduler 心跳时对 sendToAgentAccepted 的调用:
// 入队的是裸 prompt(不含交接)+ 旧引擎(claude-code)createOpts。drain 时会话已
diff --git a/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts b/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts
index 182fb65d7d..537dc668fd 100644
--- a/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts
+++ b/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts
@@ -667,6 +667,11 @@ interface ActiveTurn {
* `undefined` 表示当前没有待回滚的采纳。
*/
preContinuationVendorTurnGeneration?: number | null;
+ /**
+ * 供应商组在发送前等原电脑恢复(这条还没派出去,provider-groups.md §6.1):投影的进行中行显示
+ * 「重新连接中 n/5」。挂在这一轮上,轮次结束或换掉即一起消失。
+ */
+ providerGroupReconnect?: AutoResumeInfo;
}
interface PendingCompactRequest {
@@ -766,6 +771,8 @@ interface SessionInputState {
/** 每次登记唯一:host 暂存的 error 行与结算都按它对号,迟到的旧结算不会碰到下一次失败。 */
id: number;
recovery: NonNullable<AgentInputRecovery>;
+ cause: AutoResumeAgentSwitchCause;
+ /** 投影里的进行中行:换电脑时「正在换一台电脑继续」,先等原电脑恢复时「重新连接中 n/5」。 */
info: AutoResumeInfo;
} | null;
recovery: AgentInputRecovery;
@@ -913,6 +920,22 @@ function isUsageLimitWaitLive(state: SessionInputState, token?: number): boolean
return state.usageLimitWait?.resumeAt != null && isUsageLimitCandidateCurrent(state, token);
}
+/**
+ * 换电脑期间进行中行的内容。`error` 只用来让 renderer 认出随后到达的终态 event 是同一次失败的回声(不再点亮
+ * 横幅)。换电脑时次数都给 0(不是重连),旧端按普通的「重新连接中」显示、不带次数;先等原电脑恢复时就是一次
+ * 普通的重连:不带 groupSwitchPending,新旧端都显示「重新连接中 n/5」,展开看原因。
+ */
+function providerGroupSwitchHoldInfo(
+ cause: AutoResumeAgentSwitchCause,
+ error: string | undefined,
+ progress: { attempt: number; maxAttempts: number } | null,
+): AutoResumeInfo {
+ const base = error ? { error } : {};
+ return progress
+ ? { ...base, attempt: progress.attempt, maxAttempts: progress.maxAttempts, sessionTotal: 0 }
+ : { ...base, attempt: 0, maxAttempts: 0, sessionTotal: 0, groupSwitchPending: { cause } };
+}
+
/** 换电脑期间先不呈现的那次错误仍是当前状态:登记时的 recovery 没被换掉、错误仍在、没有别的自愈接管。 */
function isProviderGroupSwitchHoldLive(state: SessionInputState): boolean {
const hold = state.providerGroupSwitchHold;
@@ -4306,9 +4329,9 @@ export class AgentInputCoordinator {
const autoResumePending = state.autoResumePending ?? (
groupSwitchHeld
? state.providerGroupSwitchHold!.info
- : state.activeTurn?.item?.autoResume &&
- state.activeTurn.dispatchLifecycle !== 'dispatched'
- ? state.activeTurn.item.autoResumeInfo
+ : state.activeTurn && state.activeTurn.dispatchLifecycle !== 'dispatched'
+ ? state.activeTurn.providerGroupReconnect ??
+ (state.activeTurn.item?.autoResume ? state.activeTurn.item.autoResumeInfo : undefined)
: undefined
);
const recovery: AgentInputRecovery =
@@ -6571,18 +6594,51 @@ export class AgentInputCoordinator {
state.providerGroupSwitchHold = {
id: ++this.providerGroupSwitchHoldSeq,
recovery: state.recovery!,
- info: {
- // 只用来让 renderer 认出随后到达的终态 event 是同一次失败的回声(不再点亮横幅),行内不显示它。
- ...(message ? { error: message } : {}),
- // 不是重连:次数都给 0,旧端按普通的「重新连接中」显示、不带次数。
- attempt: 0,
- maxAttempts: 0,
- sessionTotal: 0,
- groupSwitchPending: { cause },
- },
+ cause,
+ info: providerGroupSwitchHoldInfo(cause, message, null),
};
}
+ /**
+ * 换电脑这一趟先等原电脑恢复(那台连不上):进行中行改为「重新连接中 attempt/maxAttempts」;传 null 回到
+ * 「正在换一台电脑继续」。只认仍有效的那次登记;返回是否更新了。
+ */
+ setProviderGroupSwitchHoldProgress(
+ sessionId: string,
+ id: number,
+ progress: { attempt: number; maxAttempts: number } | null,
+ ): boolean {
+ const state = this.states.get(sessionId);
+ const hold = state?.providerGroupSwitchHold;
+ if (!state || !hold || hold.id !== id || !isProviderGroupSwitchHoldLive(state)) return false;
+ hold.info = providerGroupSwitchHoldInfo(hold.cause, hold.info.error, progress);
+ this.emit(sessionId);
+ return true;
+ }
+
+ /**
+ * 供应商组在发送前等原电脑恢复(这条还没派出去):进行中行显示「重新连接中 attempt/maxAttempts」,没等到、开始换电脑
+ * 时(`switching`)显示「正在换一台电脑继续」,传 null 撤掉。只挂在还没派发的这一轮上;没有这样的一轮时不做什么。
+ */
+ setProviderGroupSendReconnect(
+ sessionId: string,
+ progress: { attempt: number; maxAttempts: number } | 'switching' | null,
+ ): void {
+ const active = this.states.get(sessionId)?.activeTurn;
+ if (!active || active.dispatchLifecycle === 'dispatched') return;
+ if (!progress && !active.providerGroupReconnect) return;
+ if (progress) {
+ active.providerGroupReconnect = providerGroupSwitchHoldInfo(
+ 'unavailable',
+ undefined,
+ progress === 'switching' ? null : progress,
+ );
+ } else {
+ delete active.providerGroupReconnect;
+ }
+ this.emit(sessionId);
+ }
+
/**
* 这次错误正因供应商组换电脑而先不呈现时返回那次登记的 id(host 据此暂不落 error 行、不弹 Agent Island,
* 并按 id 结算);没有返回 null。
diff --git a/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts b/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts
index 5e6c40a631..fd3e639ac5 100644
--- a/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts
+++ b/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts
@@ -488,9 +488,10 @@ export interface MakerSendTransactionDeps {
* session-agent-switch:turn 运行中登记的切换意图在**发送时刻**执行(先于
* getSession——apply 会 close 旧引擎,随后本事务按 DB 新值 lazy-create 新引擎,
* 交接注入走下面的 pending handoff 通道)。apply 内部自查 turn 空闲,仍在跑则
- * 保留意图本次不动。undefined = 不启用(测试最小 harness)。
+ * 保留意图本次不动。undefined = 不启用(测试最小 harness)。`signal` 是这次发送的取消信号:
+ * 供应商组在这里等原电脑恢复时,发送被停止就不再等、不再换电脑。
*/
- applyPendingAgentSwitch?(sessionId: string): Promise<void>;
+ applyPendingAgentSwitch?(sessionId: string, options?: { signal?: AbortSignal }): Promise<void>;
/**
* 发送前换窗:必须在 getSession 之前。prepare 会关掉不健康的 live handle,
* 随后本事务按空 session 走 lazy-create,避免 peek 之后对已关闭对象 send。
@@ -986,7 +987,20 @@ export function createMakerSendTransaction(deps: MakerSendTransactionDeps): Make
// session-agent-switch:pending 切换在发送时刻生效(用户语义:「消息真正发出
// 去时才切」)。必须在 getSession 之前——apply 会 close 旧引擎的 live session,
// 让下方走 lazy-create 按 DB 新值 spawn 新引擎。
- await deps.applyPendingAgentSwitch?.(sessionId);
+ await deps.applyPendingAgentSwitch?.(
+ sessionId,
+ requestedSendOpts.signal ? { signal: requestedSendOpts.signal } : undefined,
+ );
+ // 发送前的准备期间就被停止(如供应商组正在等原电脑恢复):不再打开会话、不再派发,与 Session 在派发前
+ // 收到取消是同一个结果,由调用方按「派发前取消」收尾。
+ if (requestedSendOpts.signal?.aborted) {
+ return toCompatibleMakerSendResult(
+ toDesktopSessionDispatchOutcome(
+ { accepted: false, reason: 'cancelled-before-dispatch' },
+ { source: 'maker-ipc', context: `SEND/${sessionId}/before-session` },
+ ),
+ );
+ }
await deps.prepareUnhealthySession?.(sessionId);
let sess = deps.getSession(sessionId);
// Maker keeps a failed Session registered until its real handle cleanup
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index e3294c28b5..cef34acedc 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -9717,6 +9717,11 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
await withSendToSessionLock(sessionId, run);
},
isTurnRunning: (sessionId) => maker.getSession(sessionId)?.isTurnRunning() ?? false,
+ // 没有开着的会话(或已出错)时这次发送要重新打开 Agent 所在电脑上的会话:发送前现读那台的状态。
+ hasLiveSession: (sessionId) => {
+ const live = maker.getSession(sessionId);
+ return live?.getStatus() === 'active';
+ },
// 分享来的供应商被分享者建成了组:组所在电脑发来「需要换一台」时自动交接(provider-groups.md §6.1)。
guestSwitch: getProviderGroupGuestSwitch(),
continueSession: async (sessionId, token, info) =>
@@ -15472,14 +15477,20 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 调用方自报;与手机说明同层(只进 wire 消息)。
isCindyMakeSession: async (sessionId) =>
(await readSessionSource(sessionId)) === CINDY_MAKE_SESSION_SOURCE,
- applyPendingAgentSwitch: async (sessionId) => {
+ applyPendingAgentSwitch: async (sessionId, options) => {
await applyPendingAgentSwitchIfIdle(agentSwitchDeps, sessionId);
- // 已归组的任务所在那台现在不能用时,先换到组里下一台再发(失败不影响这次发送)。
- await providerGroupService?.beforeSend(sessionId).catch((error) => {
+ // 已归组的任务所在那台现在不能用时,先换到组里下一台再发(失败不影响这次发送);离线时先等它恢复,
+ // 等的时候进行中行显示「重新连接中 n/5」。
+ await providerGroupService?.beforeSend(sessionId, {
+ ...(options?.signal ? { signal: options.signal } : {}),
+ progress: (state) => agentInputCoordinatorHolder?.setProviderGroupSendReconnect(sessionId, state),
+ }).catch((error) => {
log.warn('provider group: pre-send check failed', {
sessionId,
error: error instanceof Error ? error.message : String(error),
});
+ }).finally(() => {
+ agentInputCoordinatorHolder?.setProviderGroupSendReconnect(sessionId, null);
});
},
prepareUnhealthySession: (sessionId) =>
@@ -16653,15 +16664,30 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
let hooks: ProviderGroupTurnErrorHooks | undefined;
let holdTimer: ReturnType<typeof setTimeout> | undefined;
if (holdId !== null) {
+ // 久久没有结局时到点放出来。每次重试、开始换电脑时重新计时:等原电脑恢复本身就可能要一两分钟,
+ // 不让等的时间吃掉换电脑的时间(到点放出会把协同 Worker 的异常终止回报给 Lead)。
+ const armHoldTimer = () => {
+ clearTimeout(holdTimer);
+ holdTimer = setTimeout(
+ () => releaseProviderGroupHeld(sessionId, holdId),
+ PROVIDER_GROUP_SWITCH_HOLD_MAX_MS,
+ );
+ };
// 协同 Worker 的终态与 error 行按同一次登记结算:换成了不回报这次异常终止,没换成才回报给 Lead。
hooks = {
beforeFallback: () => releaseProviderGroupHeld(sessionId, holdId),
resumed: () => discardProviderGroupHeld(sessionId, holdId),
+ // 先等原电脑恢复时进行中行显示「重新连接中 n/5」,开始换电脑时改回「正在换一台电脑继续」。
+ reconnecting: (attempt, maxAttempts) => {
+ armHoldTimer();
+ inputCoordinator.setProviderGroupSwitchHoldProgress(sessionId, holdId, { attempt, maxAttempts });
+ },
+ switching: () => {
+ armHoldTimer();
+ inputCoordinator.setProviderGroupSwitchHoldProgress(sessionId, holdId, null);
+ },
};
- holdTimer = setTimeout(
- () => releaseProviderGroupHeld(sessionId, holdId),
- PROVIDER_GROUP_SWITCH_HOLD_MAX_MS,
- );
+ armHoldTimer();
}
void providerGroupService
.onTurnError(sessionId, signals, candidateToken, hooks)
diff --git a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
index ab9f105990..d5420818a3 100644
--- a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
@@ -227,3 +227,55 @@ describe('resolveMembers', () => {
expect(d.readDeviceProviders).toHaveBeenCalledTimes(2);
});
});
+
+describe('probe (waiting for a computer to come back, §6.1)', () => {
+ it('tells apart a computer that cannot be reached from one whose provider cannot be used', async () => {
+ const directory = createProviderGroupDirectory(deps());
+ expect(await directory.probe('mini', 'anthropic-1a2b3c4d')).toBe('ok');
+ expect(await directory.probe('off', 'anthropic')).toBe('offline');
+ expect(await directory.probe('mini', 'gone')).toBe('unavailable');
+ expect(await directory.probe('share:s1', 'anthropic')).toBe('ok');
+ expect(await directory.probe('share:s2', 'anthropic')).toBe('unavailable');
+ });
+
+ it('does not wait for a computer that is online but turned off remote control', async () => {
+ const directory = createProviderGroupDirectory(deps({
+ listDevices: async () => [device('mini', { remoteControlEnabled: false })],
+ }));
+ expect(await directory.probe('mini', 'anthropic-1a2b3c4d')).toBe('unavailable');
+ });
+
+ it('reads a shared computer directly instead of trusting the periodically refreshed online flag', async () => {
+ const directory = createProviderGroupDirectory(deps({
+ listReceivedShares: () => [share('s1', { hostOnline: false })],
+ }));
+ // 快照还说离线,其实已经能读到那台的目录:按恢复算。
+ expect(await directory.probe('share:s1', 'anthropic')).toBe('ok');
+ // 真读不到时仍是离线。
+ const unreachable = createProviderGroupDirectory(deps({
+ listReceivedShares: () => [share('s1', { hostOnline: false })],
+ readDeviceProviders: async () => {
+ throw new Error('unreachable');
+ },
+ }));
+ expect(await unreachable.probe('share:s1', 'anthropic')).toBe('offline');
+ });
+
+ it('reads the current state instead of the cached one', async () => {
+ let miniOnline = true;
+ const d = deps({ listDevices: async () => [device('self', { isSelf: true }), device('mini', { online: miniOnline })] });
+ const directory = createProviderGroupDirectory(d);
+ const config: ProviderGroupConfig = {
+ strategy: 'least',
+ autoSwitch: true,
+ members: [{ key: 'device:mini:anthropic-1a2b3c4d', kind: 'device', agentDeviceId: 'mini', providerId: 'anthropic-1a2b3c4d', limit: 4, weight: 1, paused: false }],
+ };
+ await directory.resolveMembers('anthropic', config);
+ miniOnline = false;
+ expect(await directory.probe('mini', 'anthropic-1a2b3c4d')).toBe('offline');
+ miniOnline = true;
+ expect(await directory.probe('mini', 'anthropic-1a2b3c4d')).toBe('ok');
+ // 那台的目录也现读,不用短时缓存。
+ expect(d.readDeviceProviders).toHaveBeenCalledTimes(2);
+ });
+});
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 ed40ca48cc..61a11fd05c 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
@@ -8,12 +8,13 @@ import { describe, expect, it, vi } from 'vitest';
import type { ProviderGroupConfig, ProviderGroupMember, ProviderGroupView } from '../../../shared/providerGroup';
import type { ProviderGroupBinding, ProviderGroupRef } from '../bindings';
-import type { ProviderGroupDirectory } from '../directory';
+import type { ProviderGroupDirectory, ResolvedMemberState } from '../directory';
import { createProviderGroupRouter } from '../router';
import {
createProviderGroupService,
PROVIDER_GROUP_ADOPT_TIMEOUT_MS,
PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS,
+ PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS,
PROVIDER_GROUP_UNAVAILABLE_ERROR,
type ProviderGroupRemoteGroups,
type ProviderGroupServiceDeps,
@@ -47,10 +48,13 @@ function harness(options: {
const bindings = new Map<string, ProviderGroupBinding>();
/** 因组内电脑被移出或组被删除而解除过的任务 → 那个组。 */
const released = new Map<string, ProviderGroupRef>();
+ // 现读那台的状态(等它恢复时用):默认一直连不上,单测按需逐次指定。
+ const probe = vi.fn(async (_agentDeviceId: string, _providerId: string): Promise<ResolvedMemberState> => 'offline');
const directory: ProviderGroupDirectory = {
resolveMembers: async () => [],
listCandidates: async () => [],
readDeviceCatalog: async () => [],
+ probe,
memberLabel: (m) => m.label ?? m.key,
invalidate: vi.fn(),
};
@@ -136,9 +140,11 @@ function harness(options: {
fallback: vi.fn(),
readResetAt: vi.fn((): number | null => 5_000),
now: () => 1_000,
+ // 等原电脑恢复时的退避不真等。
+ sleep: vi.fn(async (_ms: number) => {}),
log: { info: vi.fn(), warn: vi.fn() },
} satisfies ProviderGroupServiceDeps;
- return { service: createProviderGroupService(deps), deps, remote, row, bindings, released };
+ return { service: createProviderGroupService(deps), deps, remote, row, bindings, released, probe };
}
async function flush() {
@@ -299,12 +305,63 @@ describe('switching computers within a group on another computer', () => {
it('only avoids an unreachable computer itself instead of cooling it for the whole group', async () => {
const h = bound({ picks: [SELF] });
- h.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
- await flush();
+ await h.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
+ // 先等它恢复:本机现读那台(组内电脑坐标照本机的写法),重试用完才换。
+ expect(h.probe).toHaveBeenCalledWith('studio', STUDIO.providerId);
+ expect(h.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
expect(h.remote.cool).not.toHaveBeenCalled();
expect(h.deps.switchAgentLocation).toHaveBeenCalledWith('s1', expect.objectContaining({ agentDeviceId: null, providerId: 'anthropic' }), expect.anything());
});
+ it('continues on the same computer when it comes back, without asking the group computer for another', async () => {
+ const h = bound({ picks: [SELF] });
+ h.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ await h.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
+ expect(h.remote.pick).not.toHaveBeenCalled();
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.bindings.get('s1')).toMatchObject({ memberKey: STUDIO.key, groupDeviceId: OWNER });
+ expect(h.deps.continueSession).toHaveBeenCalledWith('s1', 7, expect.objectContaining({
+ agentReconnect: { computer: 'Studio' },
+ }));
+ });
+
+ it('still waits for its own computer when the group computer cannot be read, but cannot switch', async () => {
+ // 常见是任务就跑在组所在电脑上、它自己断了:组读不到,只按任务记录里的位置等它恢复。
+ const back = bound({ config: undefined });
+ back.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ await back.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
+ expect(back.probe).toHaveBeenCalledWith('studio', STUDIO.providerId);
+ expect(back.deps.continueSession).toHaveBeenCalledWith('s1', 7, expect.objectContaining({
+ agentReconnect: { computer: '' },
+ }));
+ expect(back.deps.fallback).not.toHaveBeenCalled();
+ expect(back.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(back.bindings.has('s1')).toBe(true);
+
+ // 等不到:换不了电脑,交回原有处理。
+ const gone = bound({ config: undefined });
+ await gone.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
+ expect(gone.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ expect(gone.deps.fallback).toHaveBeenCalledTimes(1);
+ expect(gone.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+
+ it('waits before sending for its own computer when the group computer cannot be read and the session must be reopened', async () => {
+ const reopen = bound({ config: undefined });
+ Object.assign(reopen.deps, { hasLiveSession: () => false });
+ const progress = vi.fn();
+ await reopen.service.beforeSend('s1', { progress });
+ expect(reopen.probe).toHaveBeenCalledWith('studio', STUDIO.providerId);
+ expect(progress).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ expect(progress).not.toHaveBeenCalledWith('switching');
+ expect(reopen.deps.switchAgentLocation).not.toHaveBeenCalled();
+
+ // 会话还开着:照常发送,不现读。
+ const live = bound({ config: undefined });
+ await live.service.beforeSend('s1');
+ expect(live.probe).not.toHaveBeenCalled();
+ });
+
it('hands the error back when the group computer cannot be reached', async () => {
const h = bound({ config: undefined });
h.service.onTurnError('s1', { sdkError: 'rate_limit' }, 3);
@@ -377,6 +434,9 @@ describe('switching computers within a group on another computer', () => {
it('moves the task before sending when the group computer says its computer is offline', async () => {
const h = bound({ view: { [STUDIO.key]: 'offline' }, picks: [SHARED] });
await h.service.beforeSend('s1');
+ // 现读一次仍离线,等满重试次数才换。
+ expect(h.probe).toHaveBeenCalledWith('studio', STUDIO.providerId);
+ expect(h.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
expect(h.deps.switchAgentLocation).toHaveBeenCalledWith(
's1',
expect.objectContaining({ agentDeviceId: 'share:s1', providerId: 'anthropic' }),
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 00389e3004..bda34d3d9d 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -175,6 +175,7 @@ describe('provider-group:remote', () => {
},
listCandidates: async () => [],
readDeviceCatalog: async () => [],
+ probe: async () => 'ok' as const,
memberLabel: (m) => m.label ?? m.key,
invalidate: vi.fn(),
};
diff --git a/apps/desktop/src/main/provider-group/__tests__/router.test.ts b/apps/desktop/src/main/provider-group/__tests__/router.test.ts
index 2392270bd2..68a3e89d40 100644
--- a/apps/desktop/src/main/provider-group/__tests__/router.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/router.test.ts
@@ -49,6 +49,9 @@ function harness(reported: Record<string, number>, bindings: Record<string, Prov
async readDeviceCatalog() {
return [];
},
+ async probe() {
+ return 'ok' as const;
+ },
memberLabel: (m) => m.key,
invalidate: () => undefined,
};
diff --git a/apps/desktop/src/main/provider-group/__tests__/service.test.ts b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
index 1668de608d..621ae4bbb1 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -9,11 +9,12 @@ import { describe, expect, it, vi } from 'vitest';
import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
import type { ProviderGroupBinding, ProviderGroupRef } from '../bindings';
-import type { ProviderGroupDirectory, ResolvedProviderGroupMember } from '../directory';
+import type { ProviderGroupDirectory, ResolvedMemberState, ResolvedProviderGroupMember } from '../directory';
import { createProviderGroupGuestSwitch, PROVIDER_GROUP_SWITCH_OFFER_TTL_MS } from '../guestSwitch';
import { createProviderGroupRouter, PROVIDER_GROUP_DEFAULT_COOLDOWN_MS } from '../router';
import {
createProviderGroupService,
+ PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS,
PROVIDER_GROUP_SUPERSEDED_ERROR,
PROVIDER_GROUP_UNAVAILABLE_ERROR,
type ProviderGroupServiceDeps,
@@ -61,6 +62,11 @@ function harness(options: {
const bindings = new Map<string, ProviderGroupBinding>();
/** 因组内电脑被移出或组被删除而解除过的任务 → 那个组。 */
const released = new Map<string, ProviderGroupRef>();
+ // 现读那台的状态:默认与组内电脑状态同一份离线名单,单测按需逐次指定。
+ const probe = vi.fn(async (agentDeviceId: string, providerId: string): Promise<ResolvedMemberState> => {
+ const found = config.members.find((m) => m.agentDeviceId === agentDeviceId && m.providerId === providerId);
+ return found && offline.has(found.key) ? 'offline' : 'ok';
+ });
const directory: ProviderGroupDirectory = {
async resolveMembers(_providerId, current) {
return current.members.map((m): ResolvedProviderGroupMember => offline.has(m.key)
@@ -73,6 +79,7 @@ function harness(options: {
async readDeviceCatalog() {
return [];
},
+ probe,
memberLabel: (m) => m.label ?? m.key,
invalidate: vi.fn(),
};
@@ -126,14 +133,17 @@ function harness(options: {
row.providerId = route.providerId;
}),
isTurnRunning: vi.fn(() => false),
+ hasLiveSession: vi.fn((_id: string) => true),
continueSession: vi.fn(async () => 'resumed' as const),
fallback: vi.fn(),
readResetAt: vi.fn(() => null),
now: () => now,
+ // 等原电脑恢复时的退避不真等。
+ sleep: vi.fn(async (_ms: number) => {}),
log: { info: vi.fn(), warn: vi.fn() },
} satisfies ProviderGroupServiceDeps;
const service = createProviderGroupService(deps);
- return { service, deps, row, bindings, released, router, config, offline, advance: (ms: number) => { now += ms; } };
+ return { service, deps, row, bindings, released, router, config, offline, probe, advance: (ms: number) => { now += ms; } };
}
async function flush() {
@@ -550,11 +560,166 @@ describe('onTurnError (automatic switch)', () => {
});
});
+describe('waiting for a computer that cannot be reached before switching (§6.1)', () => {
+ const UNREACHABLE = { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] unreachable' };
+
+ function onMini() {
+ const h = harness({ members: [MINI, LOCAL], row: { agentDeviceId: 'mini', providerId: MINI.providerId } });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ const hooks = { reconnecting: vi.fn(), switching: vi.fn(), resumed: vi.fn(), beforeFallback: vi.fn() };
+ return { ...h, hooks };
+ }
+
+ it('retries with backoff and continues on the same computer once it is back', async () => {
+ const h = onMini();
+ h.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ await h.service.onTurnError('s1', UNREACHABLE, 7, h.hooks);
+ expect(h.hooks.reconnecting.mock.calls).toEqual([
+ [1, PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS],
+ [2, PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS],
+ ]);
+ // 退避:第二次比第一次等得久。
+ const [first, second] = h.deps.sleep.mock.calls.map(([ms]) => ms);
+ expect(second).toBeGreaterThan(first!);
+ // 不交接、不冷却、绑定不动,在原电脑续跑,活动记录写「已重新连上」。
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.bindings.get('s1')?.memberKey).toBe(MINI.key);
+ expect(h.router.coolingUntil('anthropic', MINI.key)).toBeNull();
+ expect(h.deps.continueSession).toHaveBeenCalledWith('s1', 99, expect.objectContaining({
+ agentReconnect: { computer: MINI.key },
+ }));
+ expect(h.hooks.resumed).toHaveBeenCalledTimes(1);
+ expect(h.hooks.switching).not.toHaveBeenCalled();
+ expect(h.deps.fallback).not.toHaveBeenCalled();
+ });
+
+ it('switches to the next computer after five failed retries, and says so before switching', async () => {
+ const h = onMini();
+ h.probe.mockResolvedValue('offline');
+ await h.service.onTurnError('s1', UNREACHABLE, 7, h.hooks);
+ expect(h.hooks.reconnecting).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ expect(h.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ expect(h.hooks.switching).toHaveBeenCalledTimes(1);
+ expect(h.hooks.switching.mock.invocationCallOrder[0]).toBeGreaterThan(
+ h.hooks.reconnecting.mock.invocationCallOrder.at(-1)!,
+ );
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledWith(
+ 's1',
+ expect.objectContaining({ agentDeviceId: null, providerId: 'anthropic' }),
+ expect.anything(),
+ );
+ expect(h.deps.continueSession).toHaveBeenCalledWith('s1', 99, expect.objectContaining({
+ agentSwitch: expect.objectContaining({ to: 'local-name', cause: 'unavailable' }),
+ }));
+ expect(h.hooks.resumed).toHaveBeenCalledTimes(1);
+ });
+
+ it('switches right away when the computer answers but the failure was not about the connection, or its provider cannot be used', async () => {
+ // 远程那边没能启动 Agent 等:那台连得上,问题不在连接。
+ const notConnection = { message: '[REMOTE_AGENT_UNAVAILABLE] the agent could not start' };
+ for (const [signals, state] of [[notConnection, 'ok'], [UNREACHABLE, 'unavailable']] as const) {
+ const h = onMini();
+ h.probe.mockResolvedValue(state);
+ await h.service.onTurnError('s1', signals, 7, h.hooks);
+ expect(h.probe).toHaveBeenCalledTimes(1);
+ expect(h.deps.sleep).not.toHaveBeenCalled();
+ expect(h.hooks.reconnecting).not.toHaveBeenCalled();
+ expect(h.hooks.switching).not.toHaveBeenCalled();
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ }
+ });
+
+ it('counts a dropped connection that is already back as one retry and continues on the same computer', async () => {
+ for (const signals of [UNREACHABLE, { reason: 'remote_agent_closed', message: 'remote agent closed' }]) {
+ const h = onMini();
+ h.probe.mockResolvedValue('ok');
+ await h.service.onTurnError('s1', signals, 7, h.hooks);
+ expect(h.deps.sleep).not.toHaveBeenCalled();
+ expect(h.hooks.reconnecting.mock.calls).toEqual([[1, PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS]]);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.deps.continueSession).toHaveBeenCalledWith('s1', 99, expect.objectContaining({
+ agentReconnect: { computer: MINI.key },
+ }));
+ }
+ // 反复断:这一轮的次数用完就换,不会一直在原电脑上重来。
+ const flapping = onMini();
+ flapping.probe.mockResolvedValue('ok');
+ for (let token = 1; token <= PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS + 1; token++) {
+ await flapping.service.onTurnError('s1', UNREACHABLE, token, flapping.hooks);
+ }
+ expect(flapping.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ const reconnects = (flapping.deps.continueSession.mock.calls as unknown[][])
+ .filter((call) => (call[2] as { agentReconnect?: unknown } | undefined)?.agentReconnect !== undefined);
+ expect(reconnects).toHaveLength(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ });
+
+ it('does not wait for this computer, or for failures that are not about reaching a computer', async () => {
+ const local = harness();
+ local.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ await local.service.onTurnError('s1', { message: '[REMOTE_AGENT_UNAVAILABLE] gone' }, 1);
+ expect(local.probe).not.toHaveBeenCalled();
+ expect(local.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+
+ const limited = onMini();
+ await limited.service.onTurnError('s1', { sdkError: 'rate_limit' }, 1, limited.hooks);
+ expect(limited.probe).not.toHaveBeenCalled();
+ expect(limited.hooks.reconnecting).not.toHaveBeenCalled();
+ expect(limited.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ });
+
+ it('stops waiting once the user takes over: no switch, no continue, no hand back', async () => {
+ const h = onMini();
+ h.probe.mockResolvedValue('offline');
+ h.deps.sleep.mockImplementationOnce(async () => {
+ h.service.noteUserAction('s1');
+ });
+ await h.service.onTurnError('s1', UNREACHABLE, 7, h.hooks);
+ expect(h.hooks.reconnecting).toHaveBeenCalledTimes(1);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.deps.continueSession).not.toHaveBeenCalled();
+ expect(h.deps.fallback).not.toHaveBeenCalled();
+ expect(h.hooks.beforeFallback).not.toHaveBeenCalled();
+ });
+
+ it('counts retries per round, so a computer that keeps dropping cannot hold the task forever', async () => {
+ const h = onMini();
+ h.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ await h.service.onTurnError('s1', UNREACHABLE, 7, h.hooks);
+ // 同一轮里又掉线:接着上次的次数,用完就换。
+ h.hooks.reconnecting.mockClear();
+ h.probe.mockResolvedValue('offline');
+ await h.service.onTurnError('s1', UNREACHABLE, 8, h.hooks);
+ expect(h.hooks.reconnecting.mock.calls.map(([attempt]) => attempt)).toEqual([3, 4, 5]);
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ });
+
+ it('starts counting again after the user takes over', async () => {
+ const h = onMini();
+ h.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ await h.service.onTurnError('s1', UNREACHABLE, 7, h.hooks);
+ h.service.noteUserAction('s1');
+ h.hooks.reconnecting.mockClear();
+ h.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ await h.service.onTurnError('s1', UNREACHABLE, 8, h.hooks);
+ expect(h.hooks.reconnecting.mock.calls.map(([attempt]) => attempt)).toEqual([1, 2]);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+});
+
describe('beforeSend', () => {
- it('moves a task off a computer that went offline before sending, without an extra continue', async () => {
+ it('moves a task off a computer that stays offline before sending, without an extra continue', async () => {
const h = harness({ offline: [MINI.key], row: { agentDeviceId: 'mini', providerId: 'anthropic-1a2b3c4d', sdkSessionId: 'native' } });
h.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
- await h.service.beforeSend('s1');
+ const progress = vi.fn();
+ await h.service.beforeSend('s1', { progress });
+ // 先等它恢复:重试用完才换,换之前告诉调用方。
+ expect(progress.mock.calls.map(([state]) => state)).toEqual([
+ ...Array.from({ length: PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS }, (_, i) => ({
+ attempt: i + 1,
+ maxAttempts: PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS,
+ })),
+ 'switching',
+ ]);
expect(h.deps.switchAgentLocation).toHaveBeenCalledWith(
's1',
{ agentKind: 'claude-code', model: MODEL, providerId: 'anthropic', agentDeviceId: null },
@@ -564,6 +729,87 @@ describe('beforeSend', () => {
expect(h.deps.continueSession).not.toHaveBeenCalled();
});
+ it('waits for an offline computer before sending and sends there once it is back', async () => {
+ const h = harness({ offline: [MINI.key], row: { agentDeviceId: 'mini', providerId: MINI.providerId, sdkSessionId: 'native' } });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ // 现读一次仍离线 → 第 1 次重试后仍离线 → 第 2 次重试后恢复。
+ h.probe.mockResolvedValueOnce('offline').mockResolvedValueOnce('offline').mockResolvedValueOnce('ok');
+ const progress = vi.fn();
+ await h.service.beforeSend('s1', { progress });
+ expect(progress.mock.calls).toEqual([
+ [{ attempt: 1, maxAttempts: PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS }],
+ [{ attempt: 2, maxAttempts: PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS }],
+ ]);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.bindings.get('s1')?.memberKey).toBe(MINI.key);
+ });
+
+ it('sends right away when a computer shown as offline has already come back', async () => {
+ const h = harness({ offline: [MINI.key], row: { agentDeviceId: 'mini', providerId: MINI.providerId, sdkSessionId: 'native' } });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ h.probe.mockResolvedValue('ok');
+ const progress = vi.fn();
+ await h.service.beforeSend('s1', { progress });
+ expect(h.probe).toHaveBeenCalledTimes(1);
+ expect(progress).not.toHaveBeenCalled();
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+
+ it('checks the computer freshly when the send has to reopen the session there', async () => {
+ const options = { members: [MINI, LOCAL], row: { agentDeviceId: 'mini', providerId: MINI.providerId, sdkSessionId: 'native' } };
+ const reopen = harness(options);
+ reopen.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ reopen.deps.hasLiveSession.mockReturnValue(false);
+ reopen.probe.mockResolvedValue('offline');
+ await reopen.service.beforeSend('s1');
+ expect(reopen.probe).toHaveBeenCalledWith('mini', MINI.providerId);
+ expect(reopen.deps.switchAgentLocation).toHaveBeenCalledWith(
+ 's1',
+ expect.objectContaining({ agentDeviceId: null }),
+ { beforeSend: true },
+ );
+
+ // 会话还开着:信缓存的状态,不现读。
+ const live = harness(options);
+ live.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ await live.service.beforeSend('s1');
+ expect(live.probe).not.toHaveBeenCalled();
+ expect(live.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+
+ it('stops waiting without moving the task when the send is stopped', async () => {
+ const h = harness({ offline: [MINI.key], members: [MINI, LOCAL], row: { agentDeviceId: 'mini', providerId: MINI.providerId } });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ const controller = new AbortController();
+ h.deps.sleep.mockImplementationOnce(async () => {
+ controller.abort();
+ });
+ const progress = vi.fn();
+ await h.service.beforeSend('s1', { signal: controller.signal, progress });
+ expect(progress).toHaveBeenCalledTimes(1);
+ expect(progress).not.toHaveBeenCalledWith('switching');
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.bindings.get('s1')?.memberKey).toBe(MINI.key);
+ });
+
+ it('stops at once when the send is stopped in the middle of a backoff wait', async () => {
+ const h = harness({ offline: [MINI.key], members: [MINI, LOCAL], row: { agentDeviceId: 'mini', providerId: MINI.providerId } });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: MINI.key, at: 1 });
+ const controller = new AbortController();
+ // 退避等很久(不结束):停止要立刻生效,不等到这次退避结束。
+ h.deps.sleep.mockImplementation(() => new Promise<void>(() => undefined));
+ const done = vi.fn();
+ void h.service.beforeSend('s1', { signal: controller.signal }).then(done);
+ await flush();
+ expect(h.deps.sleep).toHaveBeenCalledTimes(1);
+ expect(done).not.toHaveBeenCalled();
+ controller.abort();
+ await flush();
+ expect(done).toHaveBeenCalledTimes(1);
+ expect(h.probe).toHaveBeenCalledTimes(1);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ });
+
it('moves a task off a computer that is cooling down', async () => {
const h = harness({ row: { sdkSessionId: 'native' } });
h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
diff --git a/apps/desktop/src/main/provider-group/__tests__/switchCause.test.ts b/apps/desktop/src/main/provider-group/__tests__/switchCause.test.ts
index fbdff64cf1..efdd448588 100644
--- a/apps/desktop/src/main/provider-group/__tests__/switchCause.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/switchCause.test.ts
@@ -3,7 +3,7 @@
*/
import { describe, expect, it } from 'vitest';
-import { classifyProviderGroupSwitchCause } from '../switchCause';
+import { classifyProviderGroupSwitchCause, isProviderGroupConnectionLoss } from '../switchCause';
describe('classifyProviderGroupSwitchCause', () => {
it('switches on usage limits, quota and billing depletion', () => {
@@ -35,3 +35,20 @@ describe('classifyProviderGroupSwitchCause', () => {
expect(classifyProviderGroupSwitchCause(undefined)).toBeNull();
});
});
+
+describe('isProviderGroupConnectionLoss', () => {
+ it('recognises failures that only say the connection to that computer dropped', () => {
+ expect(isProviderGroupConnectionLoss({ reason: 'remote_agent_closed' })).toBe(true);
+ expect(isProviderGroupConnectionLoss({ message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] unreachable' })).toBe(true);
+ expect(isProviderGroupConnectionLoss({ message: '[REMOTE_AGENT_EXPIRED] session expired' })).toBe(true);
+ expect(isProviderGroupConnectionLoss({ message: '[REMOTE_AGENT_NOT_FOUND] no such session' })).toBe(true);
+ });
+
+ it('does not treat a reachable computer that refuses or cannot run the task as a dropped connection', () => {
+ expect(isProviderGroupConnectionLoss({ message: '[REMOTE_AGENT_UNAVAILABLE] the agent could not start' })).toBe(false);
+ expect(isProviderGroupConnectionLoss({ message: '[REMOTE_AGENT_PROVIDER_NOT_ALLOWED] not allowed' })).toBe(false);
+ expect(isProviderGroupConnectionLoss({ message: '[REMOTE_AGENT_SHARE_PAUSED] paused' })).toBe(false);
+ expect(isProviderGroupConnectionLoss({ sdkError: 'rate_limit' })).toBe(false);
+ expect(isProviderGroupConnectionLoss(undefined)).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/directory.ts b/apps/desktop/src/main/provider-group/directory.ts
index 951538526e..c00839dfac 100644
--- a/apps/desktop/src/main/provider-group/directory.ts
+++ b/apps/desktop/src/main/provider-group/directory.ts
@@ -66,6 +66,11 @@ export interface ProviderGroupDirectory {
listCandidates(providerId: string, config: ProviderGroupConfig | null): Promise<ProviderGroupCandidate[]>;
/** 那台电脑允许被远程调用的供应商(与组内电脑状态共用同一份短时缓存);读不到时抛错。 */
readDeviceCatalog(agentDeviceId: string): Promise<ProviderView[]>;
+ /**
+ * 本机现在连不连得上那台电脑上的这个供应商:不用缓存,现读设备列表与那台的目录(同账号电脑、分享来的电脑;
+ * `agentDeviceId` 用任务记录里的写法)。自动换电脑前等那台恢复时用。
+ */
+ probe(agentDeviceId: string, providerId: string): Promise<ResolvedMemberState>;
/**
* 组员给人看的名字(换电脑的活动记录用):分享来的电脑只用分享者的昵称,不用电脑名
* (provider-sharing.md §6),读不到这条分享时为空;其余沿用加入时的快照。
@@ -139,7 +144,11 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
return reportedRunning === null ? resolved : { ...resolved, reportedRunning };
}
- async function resolveShare(member: ProviderGroupMember): Promise<ResolvedProviderGroupMember> {
+ async function resolveShare(
+ member: ProviderGroupMember,
+ /** 不信分享列表里定时刷新的 hostOnline 快照,照样去读那台的目录(等它恢复时用)。 */
+ options?: { readThroughOffline?: boolean },
+ ): Promise<ResolvedProviderGroupMember> {
const agentDeviceId = member.agentDeviceId!;
const shareId = agentDeviceId.slice(PROVIDER_SHARE_AGENT_DEVICE_PREFIX.length);
const share = deps.listReceivedShares().find((s) => s.shareId === shareId);
@@ -149,7 +158,7 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
const ownerName = share.owner.displayName;
const label = ownerName;
if (share.status === 'paused') return { member, label, ownerName, state: 'unavailable', reason: 'share-paused' };
- if (!share.hostOnline) return { member, label, ownerName, state: 'offline' };
+ if (!share.hostOnline && !options?.readThroughOffline) return { member, label, ownerName, state: 'offline' };
let views: ProviderView[];
try {
views = await readCatalog(agentDeviceId);
@@ -241,6 +250,28 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
readDeviceCatalog: readCatalog,
+ async probe(agentDeviceId, providerId) {
+ catalogs.delete(agentDeviceId);
+ const share = isProviderShareAgentDeviceId(agentDeviceId);
+ const member: ProviderGroupMember = {
+ key: providerGroupMemberKey(agentDeviceId, providerId),
+ kind: share ? 'share' : 'device',
+ agentDeviceId,
+ providerId,
+ limit: 1,
+ weight: 1,
+ paused: false,
+ };
+ // 分享来的电脑:hostOnline 是定时刷新的快照,等它恢复时不只看它,直接读那台的目录。
+ if (share) return (await resolveShare(member, { readThroughOffline: true })).state;
+ devices = null;
+ const deviceList = await readDevices().catch(() => null);
+ const device = deviceList?.find((d) => d.deviceId === agentDeviceId);
+ // 在线却关了远程控制或远程调用:是有意的设置,不是断线,不用等它恢复。
+ if (device?.online && !isControllable(device)) return 'unavailable';
+ return (await resolveDevice(member, deviceList)).state;
+ },
+
memberLabel(member) {
if (member.kind !== 'share') return member.label ?? member.key;
const shareId = member.agentDeviceId?.slice(PROVIDER_SHARE_AGENT_DEVICE_PREFIX.length) ?? '';
diff --git a/apps/desktop/src/main/provider-group/runtime.ts b/apps/desktop/src/main/provider-group/runtime.ts
index 537829368e..29219c53ba 100644
--- a/apps/desktop/src/main/provider-group/runtime.ts
+++ b/apps/desktop/src/main/provider-group/runtime.ts
@@ -66,6 +66,7 @@ const directoryFacade: ProviderGroupDirectory = {
resolveMembers: (providerId, config) => runtimeForActiveOwner().directory.resolveMembers(providerId, config),
listCandidates: (providerId, config) => runtimeForActiveOwner().directory.listCandidates(providerId, config),
readDeviceCatalog: (agentDeviceId) => runtimeForActiveOwner().directory.readDeviceCatalog(agentDeviceId),
+ probe: (agentDeviceId, providerId) => runtimeForActiveOwner().directory.probe(agentDeviceId, providerId),
memberLabel: (member) => runtimeForActiveOwner().directory.memberLabel(member),
invalidate: (agentDeviceId) => runtimeForActiveOwner().directory.invalidate(agentDeviceId),
};
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index 756b500b48..0d875a90e2 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -4,8 +4,10 @@
* 1. **分配**:新任务第一次启动 Agent 前(bootstrapSession),按组策略选一台组内电脑,把选择写回
* 任务记录与绑定;Agent 还没开始运行就失败(连不上、登录失效、启动失败)时直接换下一台。
* 2. **自动换电脑**:运行中因那台电脑的原因失败(终态错误)时,交接到组里下一台并继续这一轮;
- * 同一轮每台最多试一次,全部失败才交回原有的报错 / 等额度重置流程。
- * 3. **发送前**:已归组的任务所在那台现在不能用时,先交接到下一台,这条消息直接发到新电脑。
+ * 同一轮每台最多试一次,全部失败才交回原有的报错 / 等额度重置流程。那台是连不上(离线、断线)时先等它
+ * 恢复:按退避最多重试 5 次,恢复了就留在原电脑继续,都不行再换。别的电脑上的组读不到(常见是任务就在组所在
+ * 电脑上、它自己断了)时换不了电脑,只等任务所在那台恢复。
+ * 3. **发送前**:已归组的任务所在那台现在不能用时,先交接到下一台,这条消息直接发到新电脑;离线时同样先等。
*
* 没归过组、但正用着组那一项的老任务(建组前就在用,或运行过之后才换到组那一项)在启动 Agent 前纳入组,
* 不挪动它;当时没纳入的(一直开着、或启动时问不到组所在电脑)出错时再补上,然后照常换电脑。
@@ -32,16 +34,24 @@ import type {
} from '../../shared/providerGroup.js';
import { providerGroupMemberKey } from '../../shared/providerGroup.js';
import { isProviderShareAgentDeviceId } from '../../shared/providerShare.js';
-import type { InterruptedTurnErrorSignals } from '../maker-ipc/interruptedTurnAutoResume.js';
+import {
+ interruptedTurnResumeDelayMs,
+ type InterruptedTurnErrorSignals,
+} from '../maker-ipc/interruptedTurnAutoResume.js';
import type { ProviderGroupBinding, ProviderGroupRef } from './bindings.js';
import type { ProviderGroupDirectory } from './directory.js';
import type { ProviderGroupGuestSwitch } from './guestSwitch.js';
import {
PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
+ PROVIDER_GROUP_TURN_WINDOW_MS,
type ProviderGroupRouter,
} from './router.js';
-import { classifyProviderGroupSwitchCause, type ProviderGroupSwitchCause } from './switchCause.js';
+import {
+ classifyProviderGroupSwitchCause,
+ isProviderGroupConnectionLoss,
+ type ProviderGroupSwitchCause,
+} from './switchCause.js';
/** 换电脑途中用户已接手:交接在改动之前停下(不是目标电脑的问题)。 */
export const PROVIDER_GROUP_SUPERSEDED_ERROR = 'provider group: superseded by user action';
@@ -169,6 +179,11 @@ export interface ProviderGroupServiceDeps {
guestSwitch?: Pick<ProviderGroupGuestSwitch, 'hasOffer' | 'claim' | 'release' | 'drop'>;
/** 这个任务现在是否正在运行一轮。 */
isTurnRunning(sessionId: string): boolean;
+ /**
+ * 这个任务现在有没有开着、能直接发的会话;false = 这次发送要重新打开 Agent 所在电脑上的会话。
+ * 不提供 = 不知道(发送前只看缓存的组内电脑状态)。
+ */
+ hasLiveSession?(sessionId: string): boolean;
continueSession(
sessionId: string,
token: number,
@@ -179,6 +194,8 @@ export interface ProviderGroupServiceDeps {
/** 报错里的重置时刻(unix ms)。 */
readResetAt(signals: InterruptedTurnErrorSignals): number | null;
now(): number;
+ /** 等原电脑恢复时两次重试之间的等待;不提供用定时器。 */
+ sleep?(ms: number): Promise<void>;
log: Logger;
}
@@ -213,24 +230,45 @@ export interface ProviderGroupService {
): Promise<void>;
/**
* 发送前:已归组的任务所在那台现在不能用(离线、分享暂停、供应商关掉、冷却中)时,先交接到组里下一台,
- * 这条消息直接发到新电脑。读不到状态或没有下一台时不动,照常发送。
+ * 这条消息直接发到新电脑。离线时先等它恢复(与运行中失败同一套重试),恢复了照常发到原电脑。
+ * 读不到状态或没有下一台时不动,照常发送。
*/
- beforeSend(sessionId: string): Promise<void>;
+ beforeSend(sessionId: string, options?: ProviderGroupBeforeSendOptions): Promise<void>;
/** 用户亲自接手:这一轮重新从头试。 */
noteUserAction(sessionId: string): void;
}
+export interface ProviderGroupBeforeSendOptions {
+ /** 这次发送被停止或取消:等原电脑恢复时就此停下,不再换电脑。 */
+ signal?: AbortSignal;
+ /** 等原电脑恢复的进度(第几次重试);`switching` = 没等到,开始换电脑。 */
+ progress?(state: { attempt: number; maxAttempts: number } | 'switching'): void;
+}
+
/** 一次终态错误的处理结局(调用方据此结算换电脑期间先不呈现的那次错误)。 */
export interface ProviderGroupTurnErrorHooks {
/** 不换了,马上交回原有处理(报错与额度重置后自动继续):先把错误放出来。 */
beforeFallback?(): void;
- /** 已换到另一台电脑并续上了这一轮。 */
+ /** 已换到另一台电脑(或原电脑恢复后在原电脑)续上了这一轮。 */
resumed?(): void;
+ /** 原电脑连不上,先等它恢复:开始第 attempt 次重试(从 1 起)。 */
+ reconnecting?(attempt: number, maxAttempts: number): void;
+ /** 等过原电脑但没等到,开始换电脑。 */
+ switching?(): void;
}
/** 发送前检查组内电脑状态的上限:读不到就照常发送,不让一台卡住的电脑拖慢每次发送。 */
export const PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS = 3_000;
+/**
+ * 那台连不上时,换电脑前先等它恢复:同一轮每台最多重试几次。两次之间的等待与中断自愈相同
+ * (约 3、6、12、20、20 秒,合计约一分钟)。
+ */
+export const PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS = 5;
+
+/** 现读那台状态的上限:读不到按连不上算。 */
+export const PROVIDER_GROUP_PROBE_TIMEOUT_MS = 10_000;
+
/** 纳入老任务时问组所在电脑的上限:读不到就照常启动 / 交回原有处理,出错时再补。 */
export const PROVIDER_GROUP_ADOPT_TIMEOUT_MS = 3_000;
@@ -277,10 +315,139 @@ interface GroupSource {
routeOf(member: ProviderGroupMember, localProviderId: string | null): ProviderGroupRoute;
}
+/**
+ * 等原电脑恢复的结局:`reachable` 现读一次就连得上(不是连不上的问题,没等);`back` 等过之后恢复了;
+ * `gone` 那台本身不能用了(供应商关掉、登录失效、分享暂停等)或重试用完;`stopped` 等的途中用户接手。
+ */
+type ReturnOutcome = 'reachable' | 'back' | 'gone' | 'stopped';
+
export function createProviderGroupService(deps: ProviderGroupServiceDeps): ProviderGroupService {
const { router } = deps;
/** 进行中的自动换电脑:用户亲自接手(发消息、重试、换模型)时标记作废。只在换电脑期间登记。 */
const runningSwitches = new Map<string, Set<{ superseded: boolean }>>();
+ /**
+ * 这一轮等过原电脑几次:每台各算,运行中失败与发送前共用一份,那台反复掉线也不会无休止地等下去。
+ * 用户接手即重新计;距上一次重试超过一轮的时限(30 分钟)也重新计。
+ */
+ const reconnects = new Map<string, { memberKey: string; used: number; at: number }>();
+ const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+
+ /** 等 `promise`,但发送被停止时立刻返回 undefined(不再干等退避或一次慢的现读)。 */
+ function untilAborted<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T | undefined> {
+ if (!signal) return promise;
+ if (signal.aborted) return Promise.resolve(undefined);
+ return new Promise<T | undefined>((resolve, reject) => {
+ const onAbort = () => resolve(undefined);
+ signal.addEventListener('abort', onAbort, { once: true });
+ promise.then(
+ (value) => {
+ signal.removeEventListener('abort', onAbort);
+ resolve(value);
+ },
+ (error: unknown) => {
+ signal.removeEventListener('abort', onAbort);
+ reject(error);
+ },
+ );
+ });
+ }
+
+ /** 记一次等原电脑的重试,返回这是第几次;这一轮已用完返回 null。 */
+ function nextReconnectAttempt(sessionId: string, memberKey: string): number | null {
+ const now = deps.now();
+ const previous = reconnects.get(sessionId);
+ const used = previous && previous.memberKey === memberKey && now - previous.at <= PROVIDER_GROUP_TURN_WINDOW_MS
+ ? previous.used
+ : 0;
+ if (used >= PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS) return null;
+ reconnects.set(sessionId, { memberKey, used: used + 1, at: now });
+ return used + 1;
+ }
+
+ /**
+ * 那台连不上(离线、断线)时先等它恢复,不急着换电脑(§6.1):现读一次,确实连不上才等;按退避最多重试 5 次,
+ * 每次现读那台的状态。本机这台没有「连不上」,直接 `gone`。`onAttempt` 在每次重试开始等之前调用。
+ */
+ async function awaitReturn(
+ sessionId: string,
+ route: ProviderGroupRoute,
+ memberKey: string,
+ isCurrent: () => boolean,
+ onAttempt?: (attempt: number) => void,
+ options?: {
+ /** 调用方刚现读过、确认连不上,不再读第一次。 */
+ knownOffline?: boolean;
+ /**
+ * 这次失败只是连接断了:现读第一次就已连得上,也算一次重试、留在原电脑继续(断线刚好已恢复),
+ * 不当成「问题不在连接」直接换。次数照算,那台反复断也只这 5 次。
+ */
+ connectionLost?: boolean;
+ /** 发送被停止:退避与现读都立刻停下。 */
+ signal?: AbortSignal;
+ },
+ ): Promise<ReturnOutcome> {
+ const { agentDeviceId, providerId } = route;
+ if (!agentDeviceId || !providerId) return 'gone';
+ const signal = options?.signal;
+ const current = () => isCurrent() && signal?.aborted !== true;
+ const probe = async () =>
+ (await untilAborted(
+ withTimeout(deps.directory.probe(agentDeviceId, providerId), PROVIDER_GROUP_PROBE_TIMEOUT_MS),
+ signal,
+ )) ?? 'offline';
+ if (!options?.knownOffline) {
+ const first = await probe();
+ if (!current()) return 'stopped';
+ if (first === 'unavailable') return 'gone';
+ if (first === 'ok') {
+ if (!options?.connectionLost) return 'reachable';
+ const attempt = nextReconnectAttempt(sessionId, memberKey);
+ if (attempt === null) return 'gone';
+ onAttempt?.(attempt);
+ deps.log.info('provider group: the connection is already back', { sessionId, member: memberKey, attempt });
+ return 'back';
+ }
+ }
+ for (;;) {
+ if (!current()) return 'stopped';
+ const attempt = nextReconnectAttempt(sessionId, memberKey);
+ if (attempt === null) {
+ deps.log.info('provider group: the computer did not come back; switching', { sessionId, member: memberKey });
+ return 'gone';
+ }
+ onAttempt?.(attempt);
+ await untilAborted(sleep(interruptedTurnResumeDelayMs(attempt)), signal);
+ if (!current()) return 'stopped';
+ const state = await probe();
+ if (!current()) return 'stopped';
+ if (state === 'ok') {
+ deps.log.info('provider group: the computer came back', { sessionId, member: memberKey, attempt });
+ return 'back';
+ }
+ if (state === 'unavailable') return 'gone';
+ }
+ }
+
+ /** 这一轮结束(放弃换电脑、用户接手):下一轮重新从头试、重新等。 */
+ function resetRound(sessionId: string): void {
+ router.resetTurn(sessionId);
+ reconnects.delete(sessionId);
+ }
+
+ /** 登记一段进行中的自动处理:用户亲自接手(发消息、重试、换模型)时 `superseded` 被置为 true。 */
+ function trackRun(sessionId: string): { run: { superseded: boolean }; done(): void } {
+ const run = { superseded: false };
+ const runs = runningSwitches.get(sessionId) ?? new Set();
+ runs.add(run);
+ runningSwitches.set(sessionId, runs);
+ return {
+ run,
+ done() {
+ runs.delete(run);
+ if (runs.size === 0 && runningSwitches.get(sessionId) === runs) runningSwitches.delete(sessionId);
+ },
+ };
+ }
function coolUntil(cause: ProviderGroupSwitchCause, resetAt: number | null): number {
const now = deps.now();
@@ -576,10 +743,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
hooks: ProviderGroupTurnErrorHooks | undefined,
body: (isCurrent: () => boolean, handBack: () => void) => Promise<void>,
): Promise<void> {
- const run = { superseded: false };
- const runs = runningSwitches.get(sessionId) ?? new Set();
- runs.add(run);
- runningSwitches.set(sessionId, runs);
+ const { run, done } = trackRun(sessionId);
const isCurrent = () => !run.superseded && deps.isLeaseCurrent(sessionId, lease);
const handBack = () => {
if (!isCurrent()) return;
@@ -593,8 +757,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
deps.log.warn('provider group: automatic switch failed', { sessionId, error: errorText(error) });
handBack();
} finally {
- runs.delete(run);
- if (runs.size === 0 && runningSwitches.get(sessionId) === runs) runningSwitches.delete(sessionId);
+ done();
}
}
@@ -611,7 +774,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return guestFailover(sessionId, signals, token, cause, hooks);
}
const bound = await loadBound(sessionId);
- if (!bound) return false;
+ if (!bound) return cause === 'unavailable' ? reconnectWithoutGroup(sessionId, signals, token, hooks) : false;
const { binding, source, config } = bound;
if (!config) {
await releaseDeletedGroup(sessionId, groupOf(source, binding.providerId));
@@ -627,12 +790,127 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
const lease = deps.leaseRecovery(sessionId, token);
if (!lease) return true;
const boundRow = { ...row, model: row.model };
- await withSwitchRun(sessionId, signals, token, lease, hooks, (isCurrent, handBack) => switchUntilSettled({
- sessionId, signals, cause, binding, source, config, row: boundRow, current, lease, isCurrent, handBack, hooks,
- }));
+ await withSwitchRun(sessionId, signals, token, lease, hooks, async (isCurrent, handBack) => {
+ // 连不上先等那台恢复:恢复了留在原电脑继续这一轮(不交接),等不到再换。
+ if (cause === 'unavailable') {
+ let waited = false;
+ const route = source.routeOf(current, row.providerId);
+ const outcome = await awaitReturn(sessionId, route, current.key, isCurrent, (attempt) => {
+ waited = true;
+ hooks?.reconnecting?.(attempt, PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ }, { connectionLost: isProviderGroupConnectionLoss(signals) });
+ if (outcome === 'stopped') return;
+ if (outcome === 'back') {
+ await continueOnSameComputer(sessionId, deps.directory.memberLabel(current), lease, isCurrent, hooks);
+ return;
+ }
+ if (waited) hooks?.switching?.();
+ }
+ await switchUntilSettled({
+ sessionId, signals, cause, binding, source, config, row: boundRow, current, lease, isCurrent, handBack, hooks,
+ });
+ });
return true;
}
+ /**
+ * 原电脑等回来了:留在原电脑继续这一轮,不交接;活动记录写「已重新连上 {电脑},继续运行」(`computer` 为空时写
+ * 「原来的电脑」)。
+ */
+ async function continueOnSameComputer(
+ sessionId: string,
+ computer: string,
+ lease: object,
+ isCurrent: () => boolean,
+ hooks: ProviderGroupTurnErrorHooks | undefined,
+ ): Promise<void> {
+ if (!isCurrent()) return;
+ const continueToken = deps.rearmContinue(sessionId, lease, deps.now());
+ if (continueToken === null) return;
+ const outcome = await deps.continueSession(sessionId, continueToken, {
+ reason: USAGE_LIMIT_RESET_AUTO_RESUME_REASON,
+ attempt: 1,
+ maxAttempts: 1,
+ sessionTotal: 0,
+ agentReconnect: { computer },
+ });
+ if (outcome === 'resumed') hooks?.resumed?.();
+ else deps.cancelContinue(sessionId, continueToken);
+ }
+
+ /**
+ * 别的电脑上的组读不到(常见是任务就跑在组所在电脑上、它自己断了):换不了电脑,但仍先等任务所在那台恢复(§6.1)。
+ * 恢复了在原电脑继续,等不到交回原有处理。位置取任务记录里的写法,不需要组设置。
+ */
+ async function reconnectWithoutGroup(
+ sessionId: string,
+ signals: InterruptedTurnErrorSignals,
+ token: number,
+ hooks: ProviderGroupTurnErrorHooks | undefined,
+ ): Promise<boolean> {
+ const binding = deps.readBinding(sessionId);
+ if (!binding?.groupDeviceId || !deps.remote) return false;
+ if (!(await deps.isFailoverEligible(sessionId))) return false;
+ const row = await deps.readSessionRow(sessionId);
+ if (!row?.model || row.remoteHostId || !row.agentDeviceId || !row.providerId) return false;
+ const route = { agentDeviceId: row.agentDeviceId, providerId: row.providerId };
+ const lease = deps.leaseRecovery(sessionId, token);
+ if (!lease) return true;
+ await withSwitchRun(sessionId, signals, token, lease, hooks, async (isCurrent, handBack) => {
+ const outcome = await awaitReturn(sessionId, route, binding.memberKey, isCurrent, (attempt) => {
+ hooks?.reconnecting?.(attempt, PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
+ }, { connectionLost: isProviderGroupConnectionLoss(signals) });
+ if (outcome === 'stopped') return;
+ if (outcome === 'back') {
+ await continueOnSameComputer(sessionId, '', lease, isCurrent, hooks);
+ return;
+ }
+ deps.log.info('provider group: the group computer cannot be read; handing back', { sessionId });
+ handBack();
+ });
+ return true;
+ }
+
+ /** 发送前等那台恢复(这条还没派出去):进度交给调用方显示;发送被停止或用户接手时停下。 */
+ async function waitBeforeSend(
+ sessionId: string,
+ route: ProviderGroupRoute,
+ memberKey: string,
+ knownOffline: boolean,
+ options: ProviderGroupBeforeSendOptions | undefined,
+ ): Promise<ReturnOutcome> {
+ const { run, done } = trackRun(sessionId);
+ try {
+ return await awaitReturn(sessionId, route, memberKey, () => !run.superseded, (attempt) => {
+ options?.progress?.({ attempt, maxAttempts: PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS });
+ }, { knownOffline, ...(options?.signal ? { signal: options.signal } : {}) });
+ } finally {
+ done();
+ }
+ }
+
+ /**
+ * 发送前读不到别的电脑上的组:换不了电脑,但这次要重新打开任务所在那台上的会话时,仍现读那台,离线先等它恢复,
+ * 免得一打开就报错。位置取任务记录里的写法。
+ */
+ async function waitBeforeSendWithoutGroup(
+ sessionId: string,
+ options: ProviderGroupBeforeSendOptions | undefined,
+ ): Promise<void> {
+ const binding = deps.readBinding(sessionId);
+ if (!binding?.groupDeviceId || !deps.remote || deps.hasLiveSession?.(sessionId) !== false) return;
+ if (!(await deps.isFailoverEligible(sessionId))) return;
+ const row = await deps.readSessionRow(sessionId).catch(() => null);
+ if (!row?.agentDeviceId || !row.providerId || row.remoteHostId) return;
+ await waitBeforeSend(
+ sessionId,
+ { agentDeviceId: row.agentDeviceId, providerId: row.providerId },
+ binding.memberKey,
+ false,
+ options,
+ );
+ }
+
/**
* 分享的人这边(§6.1):任务用的是分享来的供应商,分享者把它建成了组,实际运行的电脑由组所在电脑选,本机不知道
* 是哪台。那台因电脑本身的原因失败时,组所在电脑先发来「需要换一台」凭证;本机交接(新建会话并带上交接上下文)
@@ -728,7 +1006,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
if (!isCurrent()) return;
if (pick.kind !== 'member') {
deps.log.info('provider group: no computer left to switch to', { sessionId, cause, tried: tried.size });
- router.resetTurn(sessionId);
+ resetRound(sessionId);
handBack();
return;
}
@@ -915,7 +1193,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
exclude: tried,
});
if (pick.kind !== 'member') {
- router.resetTurn(context.sessionId);
+ resetRound(context.sessionId);
return null;
}
const route = source.routeOf(pick.member, context.localProviderId);
@@ -954,11 +1232,14 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
deps.fallback(sessionId, signals, token);
},
- async beforeSend(sessionId) {
+ async beforeSend(sessionId, options) {
if (!deps.readBinding(sessionId) || deps.isTurnRunning(sessionId)) return;
// 读组设置也算进发送前检查的上限:组所在电脑断线或不响应时保留绑定、照常发送,不等默认的请求超时。
const bound = await withTimeout(loadBound(sessionId), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
- if (!bound) return;
+ if (!bound) {
+ await waitBeforeSendWithoutGroup(sessionId, options);
+ return;
+ }
const { binding, source, config } = bound;
if (!config) {
await releaseDeletedGroup(sessionId, groupOf(source, binding.providerId));
@@ -971,8 +1252,30 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
const current = await verifyBinding(sessionId, source, binding, config, row);
// 暂停分配只影响新任务,已在那台的任务不挪走。
if (!current || current.paused) return;
- const verdict = await source.shouldMoveAway(binding.providerId, config, current.key);
- if (!verdict) return;
+ const cached = await source.shouldMoveAway(binding.providerId, config, current.key);
+ if (cached === null) return;
+ let reason = cached ? cached.reason : null;
+ const currentRoute = source.routeOf(current, row.providerId);
+ const { agentDeviceId, providerId } = currentRoute;
+ // 离线的先现读一次(状态可能刚恢复);看着能用、但这次要重新打开那台电脑上的会话时也不信缓存,现读一次:
+ // 连不上的话要到打开会话时才报错。
+ const checkFresh = Boolean(agentDeviceId && providerId)
+ && (reason === 'offline' || (reason === null && deps.hasLiveSession?.(sessionId) === false));
+ if (checkFresh) {
+ const fresh = (await untilAborted(
+ withTimeout(deps.directory.probe(agentDeviceId!, providerId!), PROVIDER_GROUP_PROBE_TIMEOUT_MS),
+ options?.signal,
+ )) ?? 'offline';
+ if (options?.signal?.aborted) return;
+ reason = fresh === 'ok' ? null : fresh;
+ }
+ if (reason === null) return;
+ // 离线先等它恢复(与运行中失败共用这一轮的重试次数):恢复了照常发到原电脑,等不到再换。
+ if (reason === 'offline') {
+ const outcome = await waitBeforeSend(sessionId, currentRoute, current.key, checkFresh, options);
+ if (outcome !== 'gone') return;
+ options?.progress?.('switching');
+ }
const tried = router.markTried(sessionId, current.key);
const pick = await source.pick({
sessionId,
@@ -1000,7 +1303,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
sessionId,
from: current.key,
to: pick.member.key,
- reason: verdict.reason,
+ reason,
});
} catch (error) {
await restoreBindingAfterFailedSwitch(sessionId, source, binding.providerId, config);
@@ -1010,7 +1313,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
noteUserAction(sessionId) {
for (const run of runningSwitches.get(sessionId) ?? []) run.superseded = true;
- router.resetTurn(sessionId);
+ resetRound(sessionId);
deps.guestSwitch?.drop(sessionId);
},
};
diff --git a/apps/desktop/src/main/provider-group/switchCause.ts b/apps/desktop/src/main/provider-group/switchCause.ts
index 636f984f81..5290322d66 100644
--- a/apps/desktop/src/main/provider-group/switchCause.ts
+++ b/apps/desktop/src/main/provider-group/switchCause.ts
@@ -40,3 +40,16 @@ export function classifyProviderGroupSwitchCause(
}
return null;
}
+
+/** 只说明连接断了的远程错误(那台本身没问题,断线、远程 Cindy 重启后会话没了)。 */
+const REMOTE_CONNECTION_LOST = /\[REMOTE_AGENT_(?:DEVICE_UNREACHABLE|EXPIRED|NOT_FOUND)\]/;
+
+/**
+ * 这次失败只是和那台的连接断了:等它恢复时,现读第一次就已连得上,也算一次重试、留在原电脑继续(断线刚好已恢复),
+ * 不急着换电脑。其余「连不上」(远程调用被关、分享暂停、Agent 没能启动等)现读连得上说明问题不在连接,直接换。
+ */
+export function isProviderGroupConnectionLoss(signals: InterruptedTurnErrorSignals | null | undefined): boolean {
+ if (!signals) return false;
+ const message = typeof signals.message === 'string' ? signals.message : '';
+ return signals.reason === 'remote_agent_closed' || REMOTE_CONNECTION_LOST.test(message);
+}
diff --git a/apps/desktop/src/renderer/__tests__/autoResumePresentation.test.ts b/apps/desktop/src/renderer/__tests__/autoResumePresentation.test.ts
index 458f209867..3ec33ec94c 100644
--- a/apps/desktop/src/renderer/__tests__/autoResumePresentation.test.ts
+++ b/apps/desktop/src/renderer/__tests__/autoResumePresentation.test.ts
@@ -141,4 +141,13 @@ describe('provider group switch presentation', () => {
expect(readAutoResumeInfo({ reason: 'usage-limit-reset', groupSwitch: { cause: 'other' } }))
.toEqual({ usageLimitReset: true });
});
+
+ it('reads a reconnect to the original computer, with or without its name', () => {
+ expect(readAutoResumeInfo({ reason: 'usage-limit-reset', agentReconnect: { computer: 'Mac mini' } }))
+ .toEqual({ usageLimitReset: true, agentReconnect: { computer: 'Mac mini' } });
+ expect(readAutoResumeInfo({ reason: 'usage-limit-reset', agentReconnect: {} }))
+ .toEqual({ usageLimitReset: true, agentReconnect: { computer: '' } });
+ expect(readAutoResumeInfo({ reason: 'usage-limit-reset', agentReconnect: 'Mac mini' }))
+ .toEqual({ usageLimitReset: true });
+ });
});
diff --git a/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx b/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx
index 117661c1ac..4d57ef2d81 100644
--- a/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx
@@ -133,6 +133,32 @@ describe('SystemCard auto-resume 行', () => {
expect(screen.queryByText('chat.systemCard.autoResumePending.label')).toBeNull();
});
+ it('供应商组等回原电脑后在原电脑继续 → 「已重新连上 {电脑},继续运行」,读不到名称时不写电脑名', () => {
+ const { unmount } = render(
+ <SystemCard
+ cardType="auto-resume"
+ data={{
+ reason: 'usage-limit-reset',
+ attempt: 1,
+ maxAttempts: 1,
+ sessionTotal: 0,
+ agentReconnect: { computer: 'Mac mini' },
+ }}
+ />,
+ );
+ expect(
+ screen.getByText('chat.systemCard.autoResume.agentReconnect.named({"computer":"Mac mini"})'),
+ ).toBeTruthy();
+ unmount();
+ render(
+ <SystemCard
+ cardType="auto-resume"
+ data={{ reason: 'usage-limit-reset', attempt: 1, maxAttempts: 1, sessionTotal: 0, agentReconnect: {} }}
+ />,
+ );
+ expect(screen.getByText('chat.systemCard.autoResume.agentReconnect.unnamed')).toBeTruthy();
+ });
+
it('已回填时 inFlight 不参与:终态优先,仍定格 ✓ / ✗', () => {
render(
<SystemCard
diff --git a/apps/desktop/src/renderer/components/chat/SystemCard.tsx b/apps/desktop/src/renderer/components/chat/SystemCard.tsx
index 6a9d4234eb..6478617489 100644
--- a/apps/desktop/src/renderer/components/chat/SystemCard.tsx
+++ b/apps/desktop/src/renderer/components/chat/SystemCard.tsx
@@ -970,6 +970,10 @@ function AutoResumeActionRow({
from: info.agentSwitch.from,
to: info.agentSwitch.to,
})
+ : info.agentReconnect
+ ? info.agentReconnect.computer
+ ? t('chat.systemCard.autoResume.agentReconnect.named', { computer: info.agentReconnect.computer })
+ : t('chat.systemCard.autoResume.agentReconnect.unnamed')
: info.groupSwitch
? t('chat.systemCard.autoResume.groupSwitch')
: usageLimitReset
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index 0df4766794..e1d431a503 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -10573,6 +10573,10 @@
"unavailable": "Couldn’t reach {{from}}; continued on {{to}}",
"overload": "{{from}} was overloaded; continued on {{to}}"
},
+ "agentReconnect": {
+ "named": "Reconnected to {{computer}}; continued there",
+ "unnamed": "Reconnected to the original computer; continued there"
+ },
"groupSwitch": "Continued on another computer automatically"
},
"autoResumeSeparator": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 7abff5a418..2136c8930b 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -10550,6 +10550,10 @@
"unavailable": "{{from}} に接続できないため、{{to}} で続行しました",
"overload": "{{from}} のサービスが混雑しているため、{{to}} で続行しました"
},
+ "agentReconnect": {
+ "named": "{{computer}} に再接続し、続行しました",
+ "unnamed": "元のパソコンに再接続し、続行しました"
+ },
"groupSwitch": "別のパソコンに自動で切り替えて続行しました"
},
"autoResumeSeparator": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index b8cb6106bd..0657a2a895 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -10550,6 +10550,10 @@
"unavailable": "{{from}}에 연결할 수 없어 {{to}}에서 이어서 진행했습니다",
"overload": "{{from}}의 서비스가 혼잡해 {{to}}에서 이어서 진행했습니다"
},
+ "agentReconnect": {
+ "named": "{{computer}}에 다시 연결되어 이어서 진행했습니다",
+ "unnamed": "원래 컴퓨터에 다시 연결되어 이어서 진행했습니다"
+ },
"groupSwitch": "다른 컴퓨터로 자동 전환해 이어서 진행했습니다"
},
"autoResumeSeparator": {
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index 120d9b891f..35b658ff5c 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -10550,6 +10550,10 @@
"unavailable": "{{from}} 连不上,已换到 {{to}} 继续",
"overload": "{{from}} 的服务繁忙,已换到 {{to}} 继续"
},
+ "agentReconnect": {
+ "named": "已重新连上 {{computer}},继续运行",
+ "unnamed": "已重新连上原来的电脑,继续运行"
+ },
"groupSwitch": "已自动换一台电脑继续"
},
"autoResumeSeparator": {
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
index 97a1505a69..bd41eaf9e9 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -10549,6 +10549,10 @@
"unavailable": "{{from}} 連不上,已換到 {{to}} 繼續",
"overload": "{{from}} 的服務繁忙,已換到 {{to}} 繼續"
},
+ "agentReconnect": {
+ "named": "已重新連上 {{computer}},繼續執行",
+ "unnamed": "已重新連上原本的電腦,繼續執行"
+ },
"groupSwitch": "已自動換一台電腦繼續"
},
"autoResumeSeparator": {
diff --git a/apps/desktop/src/renderer/lib/autoResumePresentation.ts b/apps/desktop/src/renderer/lib/autoResumePresentation.ts
index cf69d147db..07521947d3 100644
--- a/apps/desktop/src/renderer/lib/autoResumePresentation.ts
+++ b/apps/desktop/src/renderer/lib/autoResumePresentation.ts
@@ -1,5 +1,6 @@
import {
USAGE_LIMIT_RESET_AUTO_RESUME_REASON,
+ type AutoResumeAgentReconnect,
type AutoResumeAgentSwitch,
type AutoResumeAgentSwitchCause,
type AutoResumeGroupSwitch,
@@ -11,6 +12,8 @@ export interface AutoResumeCardInfo {
usageLimitReset?: boolean;
/** 供应商组自动换电脑后继续(与 usageLimitReset 同时出现)。 */
agentSwitch?: AutoResumeAgentSwitch;
+ /** 供应商组等原电脑恢复后在原电脑继续(与 usageLimitReset 同时出现)。 */
+ agentReconnect?: AutoResumeAgentReconnect;
/** 分享者的供应商组替分享的人换了一台电脑后继续(不知道是哪台,不显示电脑名称)。 */
groupSwitch?: AutoResumeGroupSwitch;
/** 进行中:供应商组正在为这次失败换电脑(错误先不呈现)。 */
@@ -40,6 +43,9 @@ export function readAutoResumeInfo(data?: Record<string, unknown>): AutoResumeCa
return {
...(data?.reason === USAGE_LIMIT_RESET_AUTO_RESUME_REASON ? { usageLimitReset: true } : {}),
...(readAgentSwitch(data?.agentSwitch) ? { agentSwitch: readAgentSwitch(data?.agentSwitch)! } : {}),
+ ...(readAgentReconnect(data?.agentReconnect)
+ ? { agentReconnect: readAgentReconnect(data?.agentReconnect)! }
+ : {}),
...(readGroupSwitch(data?.groupSwitch) ? { groupSwitch: readGroupSwitch(data?.groupSwitch)! } : {}),
...(readGroupSwitch(data?.groupSwitchPending)
? { groupSwitchPending: readGroupSwitch(data?.groupSwitchPending)! }
@@ -64,6 +70,12 @@ function readAgentSwitch(value: unknown): AutoResumeAgentSwitch | null {
return { from: from.slice(0, 128), to: to.slice(0, 128), cause: cause as AutoResumeAgentSwitchCause };
}
+function readAgentReconnect(value: unknown): AutoResumeAgentReconnect | null {
+ if (!value || typeof value !== 'object') return null;
+ const { computer } = value as Record<string, unknown>;
+ return { computer: typeof computer === 'string' ? computer.slice(0, 128) : '' };
+}
+
function readGroupSwitch(value: unknown): AutoResumeGroupSwitch | null {
if (!value || typeof value !== 'object') return null;
const { cause } = value as Record<string, unknown>;
diff --git a/apps/desktop/src/shared/agentInputQueue.ts b/apps/desktop/src/shared/agentInputQueue.ts
index 90a501f8a0..868e5cbac1 100644
--- a/apps/desktop/src/shared/agentInputQueue.ts
+++ b/apps/desktop/src/shared/agentInputQueue.ts
@@ -209,6 +209,12 @@ export interface AutoResumeInfo {
* 后的续跑同一条路径):活动行据此显示「{from} {原因},已换到 {to} 继续」。旧端忽略该字段。
*/
agentSwitch?: AutoResumeAgentSwitch;
+ /**
+ * 供应商组里任务所在的那台连不上,等它恢复后留在原电脑继续(reason 同样为 USAGE_LIMIT_RESET_AUTO_RESUME_REASON):
+ * 活动行显示「{computer} 已重新连上,继续运行」,读不到名称时不写电脑名。旧端忽略该字段,显示成「用量已恢复,
+ * 已自动继续」(与 agentSwitch 相同)。
+ */
+ agentReconnect?: AutoResumeAgentReconnect;
/**
* 分享的人这边的自动换电脑(分享者的供应商组替它换了一台,本机不知道是哪台):活动行显示「已自动换一台
* 电脑继续」,不出现电脑名称(docs/product-rules/provider-groups.md §8)。旧端忽略该字段。
@@ -236,6 +242,11 @@ export interface AutoResumeAgentSwitch {
cause: AutoResumeAgentSwitchCause;
}
+export interface AutoResumeAgentReconnect {
+ /** 重新连上的那台电脑的显示名;读不到时为空。 */
+ computer: string;
+}
+
/** 账号额度重置后自动继续时 `AutoResumeInfo.reason` 的取值(活动行据此换文案)。 */
export const USAGE_LIMIT_RESET_AUTO_RESUME_REASON = 'usage-limit-reset';
diff --git a/apps/mobile/src/__tests__/autoResumePresentation.test.ts b/apps/mobile/src/__tests__/autoResumePresentation.test.ts
index c6835e73fb..a508c13b84 100644
--- a/apps/mobile/src/__tests__/autoResumePresentation.test.ts
+++ b/apps/mobile/src/__tests__/autoResumePresentation.test.ts
@@ -111,4 +111,13 @@ describe('provider group computer switch', () => {
expect(readMobileAutoResumeInfo({ reason: 'usage-limit-reset', groupSwitch: {} }))
.toEqual({ usageLimitReset: true });
});
+
+ it('reads a reconnect to the original computer, with or without its name', () => {
+ expect(readMobileAutoResumeInfo({ reason: 'usage-limit-reset', agentReconnect: { computer: 'Mac mini' } }))
+ .toEqual({ usageLimitReset: true, agentReconnect: { computer: 'Mac mini' } });
+ expect(readMobileAutoResumeInfo({ reason: 'usage-limit-reset', agentReconnect: {} }))
+ .toEqual({ usageLimitReset: true, agentReconnect: { computer: '' } });
+ expect(readMobileAutoResumeInfo({ reason: 'usage-limit-reset', agentReconnect: 'Mac mini' }))
+ .toEqual({ usageLimitReset: true });
+ });
});
diff --git a/apps/mobile/src/i18n/locales/en/message.json b/apps/mobile/src/i18n/locales/en/message.json
index 91623593c7..0b66fbb3b0 100644
--- a/apps/mobile/src/i18n/locales/en/message.json
+++ b/apps/mobile/src/i18n/locales/en/message.json
@@ -273,6 +273,10 @@
"unavailable": "Couldn’t reach {{from}}; continued on {{to}}",
"overload": "{{from}} was overloaded; continued on {{to}}"
},
+ "agentReconnect": {
+ "named": "Reconnected to {{computer}}; continued there",
+ "unnamed": "Reconnected to the original computer; continued there"
+ },
"groupSwitch": "Continued on another computer automatically"
},
"modelLabel": "Model",
diff --git a/apps/mobile/src/i18n/locales/ja/message.json b/apps/mobile/src/i18n/locales/ja/message.json
index fd473b8c29..82cd310872 100644
--- a/apps/mobile/src/i18n/locales/ja/message.json
+++ b/apps/mobile/src/i18n/locales/ja/message.json
@@ -273,6 +273,10 @@
"unavailable": "{{from}} に接続できないため、{{to}} で続行しました",
"overload": "{{from}} のサービスが混雑しているため、{{to}} で続行しました"
},
+ "agentReconnect": {
+ "named": "{{computer}} に再接続し、続行しました",
+ "unnamed": "元のパソコンに再接続し、続行しました"
+ },
"groupSwitch": "別のパソコンに自動で切り替えて続行しました"
},
"modelLabel": "モデル",
diff --git a/apps/mobile/src/i18n/locales/ko/message.json b/apps/mobile/src/i18n/locales/ko/message.json
index b70464ce92..2e4e1ab189 100644
--- a/apps/mobile/src/i18n/locales/ko/message.json
+++ b/apps/mobile/src/i18n/locales/ko/message.json
@@ -273,6 +273,10 @@
"unavailable": "{{from}}에 연결할 수 없어 {{to}}에서 이어서 진행했습니다",
"overload": "{{from}}의 서비스가 혼잡해 {{to}}에서 이어서 진행했습니다"
},
+ "agentReconnect": {
+ "named": "{{computer}}에 다시 연결되어 이어서 진행했습니다",
+ "unnamed": "원래 컴퓨터에 다시 연결되어 이어서 진행했습니다"
+ },
"groupSwitch": "다른 컴퓨터로 자동 전환해 이어서 진행했습니다"
},
"modelLabel": "모델",
diff --git a/apps/mobile/src/i18n/locales/zh-CN/message.json b/apps/mobile/src/i18n/locales/zh-CN/message.json
index 37389b501e..7d7df206f8 100644
--- a/apps/mobile/src/i18n/locales/zh-CN/message.json
+++ b/apps/mobile/src/i18n/locales/zh-CN/message.json
@@ -273,6 +273,10 @@
"unavailable": "{{from}} 连不上,已换到 {{to}} 继续",
"overload": "{{from}} 的服务繁忙,已换到 {{to}} 继续"
},
+ "agentReconnect": {
+ "named": "已重新连上 {{computer}},继续运行",
+ "unnamed": "已重新连上原来的电脑,继续运行"
+ },
"groupSwitch": "已自动换一台电脑继续"
},
"modelLabel": "模型",
diff --git a/apps/mobile/src/i18n/locales/zh-TW/message.json b/apps/mobile/src/i18n/locales/zh-TW/message.json
index 22b93ee13c..1ed97cb059 100644
--- a/apps/mobile/src/i18n/locales/zh-TW/message.json
+++ b/apps/mobile/src/i18n/locales/zh-TW/message.json
@@ -273,6 +273,10 @@
"unavailable": "{{from}} 連不上,已換到 {{to}} 繼續",
"overload": "{{from}} 的服務繁忙,已換到 {{to}} 繼續"
},
+ "agentReconnect": {
+ "named": "已重新連上 {{computer}},繼續執行",
+ "unnamed": "已重新連上原本的電腦,繼續執行"
+ },
"groupSwitch": "已自動換一台電腦繼續"
},
"modelLabel": "模型",
diff --git a/apps/mobile/src/session/MessageRenderer.tsx b/apps/mobile/src/session/MessageRenderer.tsx
index 5de7204565..14f69a5802 100644
--- a/apps/mobile/src/session/MessageRenderer.tsx
+++ b/apps/mobile/src/session/MessageRenderer.tsx
@@ -5330,6 +5330,10 @@ function MobileAutoResumeActionRow({
from: info.agentSwitch.from,
to: info.agentSwitch.to,
})
+ : info.agentReconnect
+ ? info.agentReconnect.computer
+ ? t('message.systemCard.autoResume.agentReconnect.named', { computer: info.agentReconnect.computer })
+ : t('message.systemCard.autoResume.agentReconnect.unnamed')
: info.groupSwitch
? t('message.systemCard.autoResume.groupSwitch')
: info.usageLimitReset
diff --git a/apps/mobile/src/session/autoResumePresentation.ts b/apps/mobile/src/session/autoResumePresentation.ts
index 545ea4a485..bcf35aeba3 100644
--- a/apps/mobile/src/session/autoResumePresentation.ts
+++ b/apps/mobile/src/session/autoResumePresentation.ts
@@ -22,6 +22,17 @@ function readAgentSwitch(value: unknown): MobileAutoResumeAgentSwitch | undefine
return { from: from.slice(0, 128), to: to.slice(0, 128), cause: cause as MobileAutoResumeAgentSwitchCause };
}
+/** 对齐桌面 AutoResumeAgentReconnect:供应商组等原电脑恢复后在原电脑继续(读不到名称时为空)。 */
+export interface MobileAutoResumeAgentReconnect {
+ computer: string;
+}
+
+function readAgentReconnect(value: unknown): MobileAutoResumeAgentReconnect | undefined {
+ if (!value || typeof value !== 'object') return undefined;
+ const { computer } = value as Record<string, unknown>;
+ return { computer: typeof computer === 'string' ? computer.slice(0, 128) : '' };
+}
+
/** 对齐桌面 AutoResumeGroupSwitch:分享者的供应商组替分享的人换了一台电脑(不显示电脑名称)。 */
export interface MobileAutoResumeGroupSwitch {
cause: MobileAutoResumeAgentSwitchCause;
@@ -39,6 +50,8 @@ export interface MobileAutoResumeInfo {
usageLimitReset?: boolean;
/** 供应商组自动换电脑后继续(与 usageLimitReset 同时出现)。 */
agentSwitch?: MobileAutoResumeAgentSwitch;
+ /** 供应商组等原电脑恢复后在原电脑继续(与 usageLimitReset 同时出现)。 */
+ agentReconnect?: MobileAutoResumeAgentReconnect;
/** 分享的人这边的自动换电脑:活动行写「已自动换一台电脑继续」。 */
groupSwitch?: MobileAutoResumeGroupSwitch;
/** 进行中:供应商组正在为这次失败换电脑,错误先不呈现,写「正在换一台电脑继续」。 */
@@ -68,11 +81,13 @@ export function readMobileAutoResumeInfo(data?: Record<string, unknown>): Mobile
const maxAttempts = usageLimitReset ? undefined : number(data?.maxAttempts);
const sessionTotal = usageLimitReset ? undefined : number(data?.sessionTotal);
const agentSwitch = readAgentSwitch(data?.agentSwitch);
+ const agentReconnect = readAgentReconnect(data?.agentReconnect);
const groupSwitch = readGroupSwitch(data?.groupSwitch);
const groupSwitchPending = readGroupSwitch(data?.groupSwitchPending);
return {
...(usageLimitReset ? { usageLimitReset: true } : {}),
...(agentSwitch ? { agentSwitch } : {}),
+ ...(agentReconnect ? { agentReconnect } : {}),
...(groupSwitch ? { groupSwitch } : {}),
...(groupSwitchPending ? { groupSwitchPending } : {}),
// 正在换电脑时错误先不呈现:行内不带原始错误。
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 90eed9a64b..164382988c 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -113,6 +113,12 @@ Claude Code 终态 error 事件可带 `usageResetAt`(unix ms)。服务端无
并且不论哪种 Agent 都不再用这次终态 event 点亮横幅。换成了投影直接进入续跑;没换成投影恢复带 `error`。旧客户端忽略该
字段,按普通「重新连接中」显示(不带次数);旧 Desktop 控制端对 Claude Code / Pi 仍会被终态 event 短暂点亮横幅,
下一份投影即收回。只改投影内容,不新增 invoke 或推送通道,服务端无需改动。
+连不上先等它恢复(2026-10-11):等原电脑恢复期间,`autoResumePending` 是一次普通的重连进度(`attempt` 1–5、
+`maxAttempts` 5、`sessionTotal` 0,不带 `groupSwitchPending`),新旧端都显示「重新连接中 n/5」;发送前等的时候同样挂在
+还没派出的这一轮上(不带 `error`)。开始换电脑时回到上面的 `groupSwitchPending`。恢复后在原电脑续跑,续跑记录的
+`autoResumeInfo` 新增可选字段 `agentReconnect: { computer }`(读不到名称时为空串),新 Desktop 与 Mobile 显示
+「已重新连上 {电脑},继续运行」;旧客户端忽略该字段,显示「用量已恢复,已自动继续」(与 `agentSwitch` 相同)。
+同样只改投影与记录内容,服务端无需改动。
## Agent 跨设备历史发现与搜索
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index 2dc0719020..6cdb5cd66d 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -8,6 +8,7 @@
> 统计(含自己用的、不经组的与替分享的人跑的),见 §5。
> 2026-10-10 用户确认:**换电脑期间不报错**——组里还能换时不出错误卡、红色横幅与红点,只显示「正在换一台电脑继续」;
> 组里都不能用才报错,见 §6.1。
+> 2026-10-11 用户要求:任务所在那台**连不上时先等它恢复**——按退避重试 5 次,恢复了留在原电脑继续,都不行再换电脑,见 §6.1。
> 实现进度见 §12:P1 已实现;P2 全部已实现:同账号直连与模型列表只显示组(P2a)、分享的人经组中转与启动阶段换电脑(P2b)、
> 分享的人运行中换电脑与申请弹窗新说法(P2c);P3 未实现。
> 交互设计稿见 [`docs/design-previews/provider-groups/index.html`](../design-previews/provider-groups/index.html)。
@@ -179,6 +180,22 @@
下一台:新建会话并带上交接上下文,然后继续这一轮——这一轮还没有产出就重发原消息,已经有产出就发续跑指令,
与 [用量上限自动继续](usage-limit-auto-continue.md) 的续跑口径一致。消息流里显示一行活动记录
「{原电脑} {原因},已换到 {新电脑} 继续」(受邀者那边写「已自动换一台电脑继续」,§8),不计为用户发送。
+ - **连不上先等它恢复**(2026-10-11):那台是连不上(离线、断线)时先不换:现读一次那台的状态,确实连不上才等,
+ 按退避(约 3、6、12、20、20 秒,与中断自愈相同)最多重试 5 次,每次现读。恢复了就留在原电脑继续这一轮(不交接、
+ 不冷却,活动记录写「已重新连上 {电脑},继续运行」,读不到名称时写「原来的电脑」);5 次都不行才按上面的方式换到下一台。
+ 等的期间错误同样先不呈现,消息流与输入框状态显示「重新连接中 n/5」,开始换电脑时改为「正在换一台电脑继续」。
+ - 只是连接断了(断线、远程 Cindy 重启后会话没了)而现读第一次就已连得上:断线刚好已恢复,也算一次重试、留在原电脑
+ 继续;同一轮次数照算,那台反复断也只这 5 次,用完就换。
+ - 不等、直接换的情况:现读连得上但问题不在连接(如那台 Agent 起不来);那台本身不能用(供应商关掉、关闭了远程控制或
+ 远程调用、分享暂停或删除等);本机这台;用量上限、登录失效、过载等不是连不上的原因。
+ - 次数按一轮、按电脑计,自动续跑与运行中失败共用;用户亲自发消息、重试、换模型即开始新的一轮,重新计。
+ - 发送前:已归组的任务所在那台显示离线、或这次发送要重新打开那台上的会话(会话没开着或不在运行态)时,现读一次那台的
+ 状态;离线就同样先等(消息还没发出,进行中行显示「重新连接中 n/5」),恢复了照常发到原电脑,等不到再换到下一台
+ 再发。用户停止这次发送时立刻停下:不再等、不再换,也不再去打开那台上的会话。
+ - 别的电脑上的组读不到(常见是任务就跑在组所在电脑上、它自己断了):换不了电脑,但仍按任务记录里的位置先等那台恢复,
+ 恢复了在原电脑继续(活动记录写「原来的电脑」),等不到照原有方式报错;发送前同理。
+ - 已经发出却在那台上没确认收到的消息(如请求超时)不自动重发:可能已经在跑,重发会让同一条消息执行两次,照原有方式报错。
+ - 下面「换电脑久久没有结局(3 分钟)先把错误放出来」的计时不吃掉等它恢复的时间:每次重试、开始换电脑时重新计时。
- **换电脑期间不报错**(2026-10-10):这次失败会先试着换电脑时(已归组、自动换电脑开着、组里还有别的电脑;
受邀者那边是收到了「需要换一台」凭证),失败那一刻就不呈现:没有红色横幅、不写错误卡、不亮红点、Agent Island 不提醒,
消息流末尾只有一行「正在换一台电脑继续」,输入框上方的状态同样这样写。换成了,历史里只留上面那行换电脑的活动记录