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): 换电脑期间不报错,组里都不能用才报错;自动续跑后收掉过期红点

Lizi882ffebcd4a3
diff --git a/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts b/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts
index d1a5b2c5d0..71338ddf1d 100644
--- a/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts
+++ b/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts
@@ -97,6 +97,8 @@ import {
flushOrphanToolResults,
isSuccessfulCodexDoneEventData,
onTurnErrorEvent,
+ captureDeferredTurnError,
+ persistDeferredTurnError,
reserveTurnErrorPersistId,
releaseReservedTurnErrorPersistId,
whenTurnErrorPersisted,
@@ -3444,6 +3446,72 @@ describe('onTurnErrorEvent — terminal error 持久化', () => {
expect(createMessage).toHaveBeenCalledTimes(1);
});
+ describe('延后补落(供应商组换电脑期间先暂存的 error 行)', () => {
+ it('按出错的时刻排序,不排到之后的消息后面', async () => {
+ // 结算时才写:用户在这期间发的新消息必须仍排在它后面。
+ const occurredAt = Date.parse('2026-10-11T08:00:00.000Z');
+ const nowSpy = vi.spyOn(Date, 'now');
+ nowSpy.mockReturnValue(occurredAt);
+ const row = captureDeferredTurnError(SESSION, { message: '换电脑没成', reason: 'usage_limit' }, { uuid: 'failed-turn' });
+ nowSpy.mockReturnValue(occurredAt + 60_000);
+ try {
+ persistDeferredTurnError(SESSION, row!);
+ await flushWrites();
+ } finally {
+ nowSpy.mockRestore();
+ }
+ expect(createMessage).toHaveBeenCalledWith(
+ SESSION,
+ expect.objectContaining({
+ role: 'error',
+ content: { message: '换电脑没成', reason: 'usage_limit' },
+ agentMeta: { uuid: 'failed-turn' },
+ createdAt: occurredAt + 1,
+ }),
+ expect.objectContaining({ shouldBroadcast: expect.any(Function) }),
+ );
+ });
+
+ it('不碰补落时正在进行的那一轮:不 flush 在飞正文,那一轮同样的错误照常落库', async () => {
+ // 失败那一轮:暂存。
+ noteTurnStarted(SESSION);
+ const row = captureDeferredTurnError(SESSION, { message: 'Remote computer is offline' }, null);
+ resetTurnPersistState(SESSION);
+ // 用户中途接手:新的一轮正在输出。
+ noteTurnStarted(SESSION);
+ onAssistantTextEvent(SESSION, { text: 'half a reply', isFinal: false }, null);
+ // 换电脑那一趟结束,补落旧的那条 error 行。
+ persistDeferredTurnError(SESSION, row!);
+ await flushWrites();
+ // 只写了那条 error 行:新一轮输出到一半的正文没有被提前落库(否则重载后会拆成两行)。
+ expect(vi.mocked(createMessage).mock.calls.map(([, body]) => (body as { role: string }).role)).toEqual(['error']);
+ // 新的一轮随后同样连不上:它自己的 error 行不被当成重复,在飞正文这时才随它落库。
+ expect(onTurnErrorEvent(SESSION, { message: 'Remote computer is offline' })).toBeTruthy();
+ await flushWrites();
+ const roles = vi.mocked(createMessage).mock.calls.map(([, body]) => (body as { role: string }).role);
+ expect(roles).toEqual(['error', 'assistant', 'error']);
+ });
+
+ it('旧会话关闭清掉按会话的状态之后照样能补落', async () => {
+ noteTurnStarted(SESSION);
+ const row = captureDeferredTurnError(SESSION, { message: 'agent stopped' }, null);
+ // 交接会关闭旧会话。
+ clearSessionPersistState(SESSION);
+ persistDeferredTurnError(SESSION, row!);
+ await flushWrites();
+ expect(createMessage).toHaveBeenCalledWith(
+ SESSION,
+ expect.objectContaining({ role: 'error', content: { message: 'agent stopped' } }),
+ expect.anything(),
+ );
+ });
+
+ it('没有错误文案时不取行', () => {
+ expect(captureDeferredTurnError(SESSION, { reason: 'turn-failed' })).toBeNull();
+ expect(captureDeferredTurnError(SESSION, null)).toBeNull();
+ });
+ });
+
it('/clear 在 error 事件之前发生时,createdAt 被 cap 在 clear 边界之下(不出现在清空后的会话中)', async () => {
// 场景:turn 在 /clear 之前启动,/clear 后 terminal error 才到达。
// noteTurnStarted 记录 turn 开始时刻(< clearBoundaryTs),使 onTurnErrorEvent
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 4c351f82f1..581780268b 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
@@ -1001,6 +1001,7 @@ function unsupportedChatBridgeImageError(feature = "input content part 'input_im
function createHarness(opts?: {
getRecoveryContextSnapshot?: (sessionId: string, userClientId: string) => Promise<RecoveryContextSnapshot>;
+ providerGroupSwitchCandidate?: AgentInputCoordinatorDeps['providerGroupSwitchCandidate'];
}) {
let running = false;
let liveRunningOverride: boolean | null | 'unknown' = null;
@@ -1199,6 +1200,9 @@ function createHarness(opts?: {
isResumableTurnErrorCandidate,
onResumableTurnErrorDiscarded,
onUsageLimitedTurnError,
+ ...(opts?.providerGroupSwitchCandidate
+ ? { providerGroupSwitchCandidate: opts.providerGroupSwitchCandidate }
+ : {}),
noteSessionClearBoundary,
resolveSessionReferences,
refreshAgentReferencesBeforeDispatch,
@@ -13963,3 +13967,107 @@ describe('usage-limit wait (ordinary tasks)', () => {
expect(h.coordinator.cancelUsageLimitWait(sid, candidate).usageLimitWait).toBeNull();
});
});
+
+describe('provider group computer switch hold', () => {
+ const LIMIT_SIGNALS = { sdkError: 'rate_limit', usageResetAt: 5_000_000 };
+ const MESSAGE = "You've hit your session limit";
+ const INFO = {
+ reason: USAGE_LIMIT_RESET_AUTO_RESUME_REASON,
+ attempt: 1,
+ maxAttempts: 1,
+ sessionTotal: 0,
+ };
+
+ async function failWhileSwitching(sid: string, cause: 'usage-limit' | null = 'usage-limit') {
+ const candidate = vi.fn<NonNullable<AgentInputCoordinatorDeps['providerGroupSwitchCandidate']>>(
+ () => cause,
+ );
+ const h = createHarness({ providerGroupSwitchCandidate: candidate });
+ h.setHasAssistantProgressAfter(async () => true);
+ h.coordinator.enqueue(sid, makeItem('q-first', 'original long task'));
+ await flush();
+ h.setRunning(false);
+ h.coordinator.onTurnEvent(sid, 'error', MESSAGE, LIMIT_SIGNALS);
+ await flush();
+ const token = h.onUsageLimitedTurnError.mock.calls.at(-1)?.[3] as number;
+ return { h, candidate, token };
+ }
+
+ it('shows "switching computer" instead of the error while the group tries the next computer', async () => {
+ const sid = 'group-hold';
+ const { h, candidate } = await failWhileSwitching(sid);
+ expect(candidate).toHaveBeenCalledWith(
+ sid,
+ expect.objectContaining({ message: MESSAGE, ...LIMIT_SIGNALS }),
+ expect.objectContaining({ clientId: 'q-first' }),
+ );
+ // 登记先于第一次投影:一帧红横幅都不出。
+ expect(h.projections.every((projection) => projection.error === null)).toBe(true);
+ const projection = latestProjection(h.projections);
+ expect(projection.autoResumePending).toMatchObject({
+ error: MESSAGE,
+ groupSwitchPending: { cause: 'usage-limit' },
+ });
+ expect(projection.usageLimitWait).toBeNull();
+ // 重试入口与限额候选仍绑定这次错误,换电脑的交接照常拿得到句柄。
+ expect(projection.recovery?.kind).toBe('active-turn');
+ expect(h.onUsageLimitedTurnError).toHaveBeenCalledTimes(1);
+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toEqual(expect.any(Number));
+ });
+
+ it('surfaces the error once the switch gives up', async () => {
+ const sid = 'group-hold-release';
+ const { h, token } = await failWhileSwitching(sid);
+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;
+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId + 1)).toBe(false);
+ expect(latestProjection(h.projections).error).toBeNull();
+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(true);
+ const projection = latestProjection(h.projections);
+ expect(projection.error).toBe(MESSAGE);
+ expect(projection.autoResumePending).toBeUndefined();
+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();
+ // 交回额度重置后自动继续:仍能挂上等待。
+ expect(h.coordinator.armUsageLimitWait(sid, token, 9_000_000)).toBe(true);
+ expect(latestProjection(h.projections).usageLimitWait).toEqual({ resumeAt: 9_000_000 });
+ });
+
+ it('never shows the error when the task continues on another computer', async () => {
+ const sid = 'group-hold-resumed';
+ const { h, token } = await failWhileSwitching(sid);
+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;
+ const lease = h.coordinator.leaseUsageLimitRecovery(sid, token);
+ expect(lease).not.toBeNull();
+ // 交接关闭旧会话,再凭句柄挂上续跑。
+ h.coordinator.onSessionClosed(sid);
+ const continueToken = h.coordinator.rearmUsageLimitWait(sid, lease!, 1);
+ expect(continueToken).toEqual(expect.any(Number));
+ expect(latestProjection(h.projections).error).toBeNull();
+ expect(await h.coordinator.continueAfterUsageLimitReset(sid, continueToken!, INFO)).toBe('resumed');
+ await flush();
+ expect(h.sendToAgent).toHaveBeenCalledTimes(2);
+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();
+ // 迟到的结算碰不到已续上的这一轮。
+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(false);
+ expect(h.projections.every((projection) => projection.error === null)).toBe(true);
+ });
+
+ it('keeps the normal error when the group will not switch', async () => {
+ const sid = 'group-hold-none';
+ const { h } = await failWhileSwitching(sid, null);
+ expect(latestProjection(h.projections).error).toBe(MESSAGE);
+ expect(latestProjection(h.projections).autoResumePending).toBeUndefined();
+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();
+ });
+
+ it('ends the hold when the user takes over', async () => {
+ const sid = 'group-hold-user';
+ const { h } = await failWhileSwitching(sid);
+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;
+ h.coordinator.enqueue(sid, makeItem('q-second', 'do something else'));
+ await flush();
+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();
+ expect(latestProjection(h.projections).autoResumePending?.groupSwitchPending).toBeUndefined();
+ // 错误已不是当前状态:结算只清登记,不再弹横幅。
+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
index d74347089c..4b0a5be2bf 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
@@ -311,6 +311,7 @@ function harness() {
onExternalTurnSettled: vi.fn(),
isAutoResumePending: vi.fn(() => false),
isAutoResumeDeferred: vi.fn(() => false),
+ getProviderGroupSwitchHoldId: vi.fn((): number | null => null),
getAutoResumeAttemptToken: vi.fn(() => 5),
getAutoResumeDeferredOwner: vi.fn(() => null),
},
@@ -757,6 +758,36 @@ describe('production Session event pipeline', () => {
},
);
+ it('holds the error row while a provider group switches computers instead of writing it', async () => {
+ const h = harness();
+ const stashProviderGroupHeldError = vi.fn(() => true);
+ (h.deps as { stashProviderGroupHeldError?: unknown }).stashProviderGroupHeldError = stashProviderGroupHeldError;
+ h.deps.agentInputCoordinatorHolder.getProviderGroupSwitchHoldId.mockReturnValue(3);
+ const agentMeta = { uuid: 'failed-turn-uuid' };
+ h.emit(event('error', { message: "You've hit your session limit", sdkError: 'rate_limit' }, { agentMeta } as Partial<AgentEvent>));
+ expect(effects.fn('reserveTurnErrorPersistId')).not.toHaveBeenCalled();
+ expect(effects.fn('onTurnErrorEvent')).not.toHaveBeenCalled();
+ // 带上失败那一轮的身份:补落时不再读当时正在进行的那一轮。
+ expect(stashProviderGroupHeldError).toHaveBeenCalledWith(
+ 'task',
+ 3,
+ expect.objectContaining({ message: "You've hit your session limit" }),
+ agentMeta,
+ );
+ // 补落发生在 turn 状态重置之后:先存一份 turn 开始时刻。
+ expect(effects.fn('saveTurnStartedAtForDeferred')).toHaveBeenCalledTimes(1);
+ await h.dispose();
+ });
+
+ it('writes a different error that arrives while a switch is held as usual', async () => {
+ const h = harness();
+ (h.deps as { stashProviderGroupHeldError?: unknown }).stashProviderGroupHeldError = vi.fn(() => false);
+ h.deps.agentInputCoordinatorHolder.getProviderGroupSwitchHoldId.mockReturnValue(3);
+ h.emit(event('error', { message: 'Something else broke', sdkError: 'api_error' }));
+ expect(effects.fn('onTurnErrorEvent')).toHaveBeenCalledTimes(1);
+ await h.dispose();
+ });
+
it('keeps deferred error and its paired done out of Orca terminal handling and preserves the failure seal', async () => {
const h = harness();
h.deps.agentInputCoordinatorHolder.isAutoResumeDeferred.mockReturnValue(true);
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 d9a6ea8458..182fb65d7d 100644
--- a/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts
+++ b/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts
@@ -60,6 +60,7 @@ import type {
AgentInputRecovery,
AgentInputSessionReferenceContext,
AgentInputToolLoopDetails,
+ AutoResumeAgentSwitchCause,
AutoResumeInfo,
RecoveryCheckpoint,
} from '../../shared/agentInputQueue.js';
@@ -428,6 +429,17 @@ export interface AgentInputCoordinatorDeps {
/** 绑定本次错误 recovery 的令牌;`armUsageLimitWait` 只认这个令牌。 */
candidateToken: number,
) => void;
+ /**
+ * **纯判定**:这条将交给 `onUsageLimitedTurnError` 的错误会不会先由供应商组试着换电脑
+ * (docs/product-rules/provider-groups.md §6.1)。返回换电脑的原因时,这次错误照常成为当前状态
+ * (重试入口、限额等待候选都绑定它),只是先不呈现:投影里不带 error,改带「正在换一台电脑继续」,
+ * 直到 host 调 `releaseProviderGroupSwitchHold`,或续跑 / 用户接手换掉了这次错误。
+ */
+ providerGroupSwitchCandidate?: (
+ sessionId: string,
+ signals: InterruptedTurnErrorSignals,
+ item: AgentInputQueuedMessage,
+ ) => AutoResumeAgentSwitchCause | null;
/**
* **纯判定**:这条 terminal error 有没有可能被自愈接管(`isInterruptedTurnError`)。
* 不消耗额度、不排期、无副作用。
@@ -745,6 +757,17 @@ interface SessionInputState {
token: number;
recovery: NonNullable<AgentInputRecovery>;
} | null;
+ /**
+ * 供应商组正在为这次错误换电脑(docs/product-rules/provider-groups.md §6.1):错误仍是当前状态,
+ * 重试入口与限额等待候选照旧绑定它,只是投影里先不呈现(换成了就不出现,组里都不行才出来)。
+ * 绑定登记时的 recovery:续跑、用户接手、清空换掉 recovery 即自然失效,不需要在每个入口单独撤。
+ */
+ providerGroupSwitchHold: {
+ /** 每次登记唯一:host 暂存的 error 行与结算都按它对号,迟到的旧结算不会碰到下一次失败。 */
+ id: number;
+ recovery: NonNullable<AgentInputRecovery>;
+ info: AutoResumeInfo;
+ } | null;
recovery: AgentInputRecovery;
drainScheduled: boolean;
drainWakeupGeneration: number;
@@ -848,6 +871,7 @@ function createInitialInputState(
autoResumePending: null,
autoResumeAttemptToken: null,
usageLimitWait: null,
+ providerGroupSwitchHold: null,
recovery: null,
drainScheduled: false,
drainWakeupGeneration: 0,
@@ -889,6 +913,17 @@ function isUsageLimitWaitLive(state: SessionInputState, token?: number): boolean
return state.usageLimitWait?.resumeAt != null && isUsageLimitCandidateCurrent(state, token);
}
+/** 换电脑期间先不呈现的那次错误仍是当前状态:登记时的 recovery 没被换掉、错误仍在、没有别的自愈接管。 */
+function isProviderGroupSwitchHoldLive(state: SessionInputState): boolean {
+ const hold = state.providerGroupSwitchHold;
+ return (
+ hold !== null &&
+ hold.recovery === state.recovery &&
+ state.error !== null &&
+ state.autoResumePending === null
+ );
+}
+
function readSessionInstanceId(identity: object | null | undefined): string | null {
if (!identity || typeof identity !== 'object') return null;
const id = (identity as { instanceId?: unknown }).instanceId;
@@ -1142,6 +1177,7 @@ export class AgentInputCoordinator {
private readonly states = new Map<string, SessionInputState>();
/** 账号限额等待计划的单调令牌(跨会话唯一,迟到的 host 定时器据此失效)。 */
private usageLimitWaitSeq = 0;
+ private providerGroupSwitchHoldSeq = 0;
private readonly steerAbortControllers = new Map<string, Map<string, AbortController>>();
/**
* Stop clears visible steer markers before the provider promise necessarily settles. Retain
@@ -3870,6 +3906,10 @@ export class AgentInputCoordinator {
return;
}
}
+ // 供应商组会先试着换电脑时,在 emit 之前登记先不呈现:不让用户先看到一帧红横幅。
+ if (!takeover && outcome === 'kept' && active.item) {
+ this.holdForProviderGroupSwitch(sessionId, state, active.item, message, signals);
+ }
this.emit(sessionId);
if (!takeover && outcome === 'kept' && active.item) {
this.notifyUsageLimitedTurnError(sessionId, active.item, message, signals);
@@ -4257,14 +4297,19 @@ export class AgentInputCoordinator {
private toProjection(sessionId: string, state: SessionInputState): AgentInputProjection {
const pendingQueue = state.pendingQueue.map((item) => this.toProjectedItem(item));
+ // 供应商组正在换电脑:错误先不呈现(没有红横幅、没有限额倒计时),聊天流里只有「正在换一台电脑继续」。
+ const groupSwitchHeld = isProviderGroupSwitchHoldLive(state);
+ const error = groupSwitchHeld ? null : state.error;
// Draining removes the queue row before asynchronous preparation starts.
// Keep the existing recovery projection until dispatch settles; derive it
// from the active owner so cancellation/failure cannot leave a stale flag.
const autoResumePending = state.autoResumePending ?? (
- state.activeTurn?.item?.autoResume &&
- state.activeTurn.dispatchLifecycle !== 'dispatched'
- ? state.activeTurn.item.autoResumeInfo
- : undefined
+ groupSwitchHeld
+ ? state.providerGroupSwitchHold!.info
+ : state.activeTurn?.item?.autoResume &&
+ state.activeTurn.dispatchLifecycle !== 'dispatched'
+ ? state.activeTurn.item.autoResumeInfo
+ : undefined
);
const recovery: AgentInputRecovery =
state.recovery?.kind === 'active-turn'
@@ -4289,12 +4334,12 @@ export class AgentInputCoordinator {
queueInteractionLocks: [...state.queueInteractionLocks],
queueEditLocks: [...state.queueEditLocks],
queueAbortPending: state.queueAbortPending,
- error: state.error,
- ...(state.error && state.errorReason ? { errorReason: state.errorReason } : {}),
- ...(state.error && state.toolLoop ? { toolLoop: state.toolLoop } : {}),
+ error,
+ ...(error && state.errorReason ? { errorReason: state.errorReason } : {}),
+ ...(error && state.toolLoop ? { toolLoop: state.toolLoop } : {}),
recovery,
...(autoResumePending ? { autoResumePending } : {}),
- usageLimitWait: isUsageLimitWaitLive(state)
+ usageLimitWait: !groupSwitchHeld && isUsageLimitWaitLive(state)
? { resumeAt: state.usageLimitWait!.resumeAt! }
: null,
errorRetryText: projectionRetryText(state.pendingQueue, state.recovery),
@@ -6466,33 +6511,101 @@ export class AgentInputCoordinator {
}
}
+ /** 这次终态错误会不会真的交给 `onUsageLimitedTurnError`(与 notifyUsageLimitedTurnError 同一判据)。 */
+ private willNotifyUsageLimitedTurnError(
+ state: SessionInputState,
+ item: AgentInputQueuedMessage,
+ ): boolean {
+ // scheduler origin(含复用它的 Slack / X / Telegram Hook 消息)终态失败时本就不留
+ // recovery、由各自 runner 收尾,没有可续的入口。共享任务访客的回合也不自动续:
+ // 授权可能在等待期间被撤销,数小时后替访客重发原指令不安全,交给房主手动处理。
+ return Boolean(
+ this.deps.onUsageLimitedTurnError &&
+ !isSchedulerOriginItem(item) &&
+ !item.sharedTaskAuthor &&
+ state.recovery?.kind === 'active-turn' &&
+ state.error !== null,
+ );
+ }
+
private notifyUsageLimitedTurnError(
sessionId: string,
item: AgentInputQueuedMessage,
message?: string,
signals?: Omit<InterruptedTurnErrorSignals, 'message'>,
): void {
- // scheduler origin(含复用它的 Slack / X / Telegram Hook 消息)终态失败时本就不留
- // recovery、由各自 runner 收尾,没有可续的入口。共享任务访客的回合也不自动续:
- // 授权可能在等待期间被撤销,数小时后替访客重发原指令不安全,交给房主手动处理。
- if (
- !this.deps.onUsageLimitedTurnError ||
- isSchedulerOriginItem(item) ||
- item.sharedTaskAuthor
- ) {
- return;
- }
const state = this.states.get(sessionId);
- if (!state || state.recovery?.kind !== 'active-turn' || state.error === null) return;
+ if (!state || !this.willNotifyUsageLimitedTurnError(state, item)) return;
const token = ++this.usageLimitWaitSeq;
- state.usageLimitWait = { resumeAt: null, token, recovery: state.recovery };
+ state.usageLimitWait = { resumeAt: null, token, recovery: state.recovery! };
try {
- this.deps.onUsageLimitedTurnError(sessionId, { ...(signals ?? {}), message }, item, token);
+ this.deps.onUsageLimitedTurnError!(sessionId, { ...(signals ?? {}), message }, item, token);
} catch (err) {
log.warn('onUsageLimitedTurnError failed', { sessionId, error: errorMessage(err) });
+ // 没人接手这次错误了:先不呈现的要立刻放出来。
+ this.releaseProviderGroupSwitchHold(sessionId);
}
}
+ /**
+ * 终态错误交给 `onUsageLimitedTurnError` 之前(emit 之前):供应商组会先试着换电脑时登记先不呈现。
+ * 只在确实会回调时登记,否则没有人放出来。
+ */
+ private holdForProviderGroupSwitch(
+ sessionId: string,
+ state: SessionInputState,
+ item: AgentInputQueuedMessage,
+ message?: string,
+ signals?: Omit<InterruptedTurnErrorSignals, 'message'>,
+ ): void {
+ state.providerGroupSwitchHold = null;
+ const candidate = this.deps.providerGroupSwitchCandidate;
+ if (!candidate || !this.willNotifyUsageLimitedTurnError(state, item)) return;
+ let cause: AutoResumeAgentSwitchCause | null = null;
+ try {
+ cause = candidate(sessionId, { ...(signals ?? {}), message }, item);
+ } catch (err) {
+ log.warn('providerGroupSwitchCandidate failed', { sessionId, error: errorMessage(err) });
+ }
+ if (!cause) return;
+ state.providerGroupSwitchHold = {
+ id: ++this.providerGroupSwitchHoldSeq,
+ recovery: state.recovery!,
+ info: {
+ // 只用来让 renderer 认出随后到达的终态 event 是同一次失败的回声(不再点亮横幅),行内不显示它。
+ ...(message ? { error: message } : {}),
+ // 不是重连:次数都给 0,旧端按普通的「重新连接中」显示、不带次数。
+ attempt: 0,
+ maxAttempts: 0,
+ sessionTotal: 0,
+ groupSwitchPending: { cause },
+ },
+ };
+ }
+
+ /**
+ * 这次错误正因供应商组换电脑而先不呈现时返回那次登记的 id(host 据此暂不落 error 行、不弹 Agent Island,
+ * 并按 id 结算);没有返回 null。
+ */
+ getProviderGroupSwitchHoldId(sessionId: string): number | null {
+ const state = this.states.get(sessionId);
+ return state && isProviderGroupSwitchHoldLive(state) ? state.providerGroupSwitchHold!.id : null;
+ }
+
+ /**
+ * 换电脑这一趟结束(没换成、交回原有处理,或已不再需要):撤掉那次先不呈现的登记(不传 id 时撤当前的)。
+ * 错误仍是当前状态时投影随即带出红横幅,返回 true;已被续跑或用户接手换掉时只清登记,返回 false。
+ */
+ releaseProviderGroupSwitchHold(sessionId: string, id?: number): boolean {
+ const state = this.states.get(sessionId);
+ const hold = state?.providerGroupSwitchHold;
+ if (!state || !hold || (id !== undefined && hold.id !== id)) return false;
+ const live = isProviderGroupSwitchHoldLive(state);
+ state.providerGroupSwitchHold = null;
+ if (live) this.emit(sessionId);
+ return live;
+ }
+
/**
* 普通任务撞上账号限额后挂等待计划:错误与手动重试照常保留,到 `resumeAt` 仍无人处理时
* host 调 `continueAfterUsageLimitReset`。只认终态错误时下发的候选令牌、且那次错误的
@@ -6940,16 +7053,27 @@ export class AgentInputCoordinator {
return;
}
}
- this.emit(sessionId);
- if (
+ const notifyUsageLimited =
!deferredTakeover &&
outcome === 'kept' &&
active.item &&
- terminalEvent.supersededByUser !== true
- ) {
+ terminalEvent.supersededByUser !== true;
+ // 与 onTurnEvent 的 persisted 分支对称。这条时序下横幅在持久化期间已经出现过、error 行也已落库,
+ // 这里至少让换电脑期间不再挂着横幅。
+ if (notifyUsageLimited) {
+ this.holdForProviderGroupSwitch(
+ sessionId,
+ state,
+ active.item!,
+ terminalEvent.message,
+ terminalEvent.signals,
+ );
+ }
+ this.emit(sessionId);
+ if (notifyUsageLimited) {
this.notifyUsageLimitedTurnError(
sessionId,
- active.item,
+ active.item!,
terminalEvent.message,
terminalEvent.signals,
);
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index d12b5a86e2..5ffecd957e 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -52,7 +52,10 @@ import {
type ProviderGroupService,
type ProviderGroupSessionRow,
type ProviderGroupStartContext,
+ type ProviderGroupTurnErrorHooks,
} from '../provider-group/service.js';
+import { createProviderGroupHeldTurnErrors } from '../provider-group/heldTurnErrors.js';
+import { classifyProviderGroupSwitchCause } from '../provider-group/switchCause.js';
import { listProviderGroups, readProviderGroup } from '../provider-group/store.js';
import {
isRemoteProviderInvocationAllowed,
@@ -640,6 +643,7 @@ import {
} from '../maker-host/session-storage.js';
import { libraryExtraDirSyncTargets } from './libraryExtraDirSyncTargets.js';
import {
+ captureDeferredTurnError,
clearSessionPersistState,
clearSessionThinkingSnapshots,
consumeLastAssistantPersistId,
@@ -660,10 +664,12 @@ import {
sealAssistantBlockForLateFinal,
markAutoResumeOutcome,
onTurnErrorEvent,
+ persistDeferredTurnError,
prepareSyntheticToolEventForBroadcast,
redactToolInputForUntrustedBoundary,
resetTurnPersistState,
saveTurnStartedAtForDeferred,
+ type DeferredTurnErrorRow,
} from '../messagePersistBroadcaster.js';
import { ensureCcManagerInstalledOrInstall } from '../remote-ssh/cc-manager-install.js';
import {
@@ -1620,6 +1626,33 @@ const autoResumeBookkeeping = new AutoResumeBookkeeping({
log: (message, fields) => log.debug(message, fields),
});
+/**
+ * 供应商组自动换电脑期间先不呈现的那次失败(provider-group/heldTurnErrors.ts):error 行暂存在这里,换成了丢掉,
+ * 没换成补落并放出横幅与 Agent Island 提醒。
+ */
+const providerGroupHeldErrors = createProviderGroupHeldTurnErrors<DeferredTurnErrorRow>({
+ // 暂存那一刻(仍在失败那一轮里)取好补落要用的一切;补落只写这一行,不碰那时正在进行的一轮,
+ // 按出错的时刻排序:换电脑途中用户发了新消息,补落的错误卡仍排在那条消息之前。
+ capture: (sessionId, data, agentMeta) =>
+ captureDeferredTurnError(
+ sessionId,
+ data as { message?: unknown; reason?: unknown; sdkError?: unknown; toolLoop?: unknown } | null,
+ (agentMeta ?? null) as AgentMeta | null,
+ ),
+ persist: (sessionId, row) => {
+ persistDeferredTurnError(sessionId, row);
+ },
+ surface: (sessionId, detail) => surfaceSuppressedAutoResumeErrorInAgentIsland(sessionId, detail),
+ // holder 是可变绑定,必须懒读。
+ releaseHold: (sessionId, holdId) =>
+ agentInputCoordinatorHolder?.releaseProviderGroupSwitchHold(sessionId, holdId) ?? false,
+ ownerKey: () => activeOwnerScopeKey(),
+ log: (message, meta) => log.info(message, meta),
+});
+
+/** 换电脑这一趟久久没有结局(交接卡住等)时不再瞒着:先把错误放出来,换成了照常续跑。 */
+const PROVIDER_GROUP_SWITCH_HOLD_MAX_MS = 3 * 60_000;
+
/**
* Continuation-only auto-retry is scheduled against the current runtime
* Session, but stall abort recovery, terminal-error drain, or a Codex
@@ -4308,9 +4341,11 @@ function handleAgentIslandEventAfterBroadcast(
return;
}
const terminalError = event.type === 'error' && isTerminalTurnErrorEvent(event);
+ // 供应商组正在为这次失败换电脑:与中断自愈同样先不提醒,没换成时由 providerGroupHeldErrors 补上。
const autoResumePendingOrDeferred =
agentInputCoordinatorHolder?.isAutoResumePending(session.id) === true ||
- agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id) === true;
+ agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id) === true ||
+ (agentInputCoordinatorHolder?.getProviderGroupSwitchHoldId(session.id) ?? null) !== null;
const autoResumeOwnsError =
autoResumePendingOrDeferred ||
autoResumeBookkeeping.shouldSuppressAgentIslandError(session.id);
@@ -5191,6 +5226,8 @@ const sessionEventDependencies: SessionEventDependencies = {
get autoResumeBookkeeping() {
return autoResumeBookkeeping;
},
+ stashProviderGroupHeldError: (sessionId, holdId, data, agentMeta) =>
+ providerGroupHeldErrors.stash(sessionId, holdId, data, agentMeta),
get pendingFailedTurnAssistantPersistId() {
return pendingFailedTurnAssistantPersistId;
},
@@ -16498,10 +16535,45 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 两处必须同判据 —— 否则会出现"按住了却永远不接管"或"没按住却接管"的错配。
isResumableTurnErrorCandidate: canRecoverTurn,
// 被按住的 error 最终没接管 → 只补落 error 行(横幅 coordinator 自己设)。
+ // 纯判定:供应商组会先试着换电脑时,这次错误先不呈现(provider-groups.md §6.1)。
+ providerGroupSwitchCandidate: (sessionId, signals) =>
+ providerGroupService?.mayHandleTurnError(sessionId, signals)
+ ? classifyProviderGroupSwitchCause(signals)
+ : null,
onUsageLimitedTurnError: (sessionId, signals, _item, candidateToken) => {
// 供应商组分配的任务先试自动换电脑,不换时由它交回额度重置后自动继续。
- if (providerGroupService) providerGroupService.onTurnError(sessionId, signals, candidateToken);
- else usageLimitAutoResume.onTurnError(sessionId, signals, candidateToken);
+ if (!providerGroupService) {
+ usageLimitAutoResume.onTurnError(sessionId, signals, candidateToken);
+ return;
+ }
+ // 先不呈现的那次错误:换成了丢掉,不换了先放出来再交回原有处理;一直没有结局时到点放出来。
+ const holdId = inputCoordinator.getProviderGroupSwitchHoldId(sessionId);
+ let hooks: ProviderGroupTurnErrorHooks | undefined;
+ let holdTimer: ReturnType<typeof setTimeout> | undefined;
+ if (holdId !== null) {
+ hooks = {
+ beforeFallback: () => providerGroupHeldErrors.release(sessionId, holdId),
+ resumed: () => providerGroupHeldErrors.discard(sessionId, holdId),
+ };
+ holdTimer = setTimeout(
+ () => providerGroupHeldErrors.release(sessionId, holdId),
+ PROVIDER_GROUP_SWITCH_HOLD_MAX_MS,
+ );
+ }
+ void providerGroupService
+ .onTurnError(sessionId, signals, candidateToken, hooks)
+ .catch((error: unknown) => {
+ log.warn('provider group: handling a failed turn did not complete', {
+ sessionId,
+ error: error instanceof Error ? error.message : String(error),
+ });
+ })
+ .finally(() => {
+ if (holdId === null) return;
+ clearTimeout(holdTimer);
+ // 用户中途接手、错误已被新的一轮换掉等:补落 error 行,错误已不是当前状态时不再呈现。
+ providerGroupHeldErrors.release(sessionId, holdId);
+ });
},
onResumableTurnErrorDiscarded: (
sessionId: string,
diff --git a/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts b/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts
index 68bb22599f..41392094ee 100644
--- a/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts
@@ -23,7 +23,10 @@ export interface DeliverSessionEventDeps {
readonly orcaTeamServiceForEvents: Pick<OrcaTeamService, 'captureWorkerTerminalTurn'> | null;
readonly agentInputCoordinatorHolder: Pick<
AgentInputCoordinator,
- 'onExternalTurnSettled' | 'isAutoResumePending' | 'isAutoResumeDeferred'
+ | 'onExternalTurnSettled'
+ | 'isAutoResumePending'
+ | 'isAutoResumeDeferred'
+ | 'getProviderGroupSwitchHoldId'
> | null;
readonly overflowSuppressedBroadcasts: Map<
string,
@@ -97,6 +100,12 @@ export function deliverSessionEvent(
event.type === 'error' &&
isTerminalTurnErrorEvent(event) &&
(isContextOverflowErrorData(event.data) || isOversizedHistoryErrorData(event.data));
+ // 供应商组正在为这次失败换电脑:error 行先不落库(暂存,换成了就丢掉),同样不预留 persistId。
+ // 协调器在 prepare 阶段同步登记,结算都是异步的,这里与 terminal 阶段看到的是同一次登记。
+ const providerGroupHoldId =
+ event.type === 'error' && isTerminalTurnErrorEvent(event)
+ ? (deps.agentInputCoordinatorHolder?.getProviderGroupSwitchHoldId(session.id) ?? null)
+ : null;
if (
event.type === 'error' &&
isTerminalTurnErrorEvent(event) &&
@@ -104,7 +113,8 @@ export function deliverSessionEvent(
!isRemoteAuthRetry &&
!isGatewayProxyTokenRecovery &&
!autoResumeWouldSuppressPersist &&
- !suppressOverflowBroadcast
+ !suppressOverflowBroadcast &&
+ providerGroupHoldId === null
) {
persistId = reserveTurnErrorPersistId(
session.id,
@@ -172,7 +182,7 @@ export function deliverSessionEvent(
if (isTerminalTurnErrorEvent(event)) {
deps.gitSnapshotCoordinator?.onTurnAbort(session.id);
}
- return { persistId, workerTerminalCapture };
+ return { persistId, workerTerminalCapture, providerGroupHoldId };
}
export type SessionDeliveryResult = ReturnType<typeof deliverSessionEvent>;
diff --git a/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts b/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts
index edca4e3966..617e08a4e9 100644
--- a/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts
@@ -79,6 +79,17 @@ export interface FinishSessionTerminalEventDeps {
| 'consumeFailedTurnCompletionTail'
| 'hasSuppressedError'
>;
+ /**
+ * 供应商组正在为这次失败换电脑(协调器登记了先不呈现):error 行改为暂存,换成了就丢掉,没换成再补落
+ * (provider-group/heldTurnErrors.ts)。返回 false = 不是被暂存的那次失败,照常落库。
+ * `agentMeta` 是失败那一轮的事件身份:补落时不再读当时正在进行的那一轮。
+ */
+ readonly stashProviderGroupHeldError?: (
+ sessionId: string,
+ holdId: number,
+ data: unknown,
+ agentMeta: unknown,
+ ) => boolean;
readonly productTurnUsageTargetTracker: Pick<
ProductTurnUsageTargetTracker,
'remember' | 'finish'
@@ -136,7 +147,7 @@ export function finishSessionTerminalEvent(
isRemoteAuthRetry,
isGatewayProxyTokenRecovery,
} = prepared;
- const { persistId, workerTerminalCapture } = delivery;
+ const { persistId, workerTerminalCapture, providerGroupHoldId } = delivery;
const terminalOwner =
event.type === 'done' || isTerminalTurnErrorEvent(event)
? captureProductTurnFailureOwner(session, event, eventAgentMeta)
@@ -347,16 +358,25 @@ export function finishSessionTerminalEvent(
!isGatewayProxyTokenRecovery &&
!autoResumeSuppressesPersist
) {
- onTurnErrorEvent(
- session.id,
- attributedEvent.data as {
- message?: unknown;
- reason?: unknown;
- sdkError?: unknown;
- } | null,
- eventAgentMeta,
- persistId,
- );
+ // 供应商组正在为这次失败换电脑:先不落库,换成了就丢掉,没换成再补落。登记期间到达的另一条不同错误
+ // 不归这次暂存,照常落库。
+ if (
+ providerGroupHoldId !== null &&
+ deps.stashProviderGroupHeldError?.(session.id, providerGroupHoldId, attributedEvent.data, eventAgentMeta) === true
+ ) {
+ if (persistId) releaseReservedTurnErrorPersistId(session.id, persistId);
+ } else {
+ onTurnErrorEvent(
+ session.id,
+ attributedEvent.data as {
+ message?: unknown;
+ reason?: unknown;
+ sdkError?: unknown;
+ } | null,
+ eventAgentMeta,
+ persistId,
+ );
+ }
} else if (persistId) {
releaseReservedTurnErrorPersistId(session.id, persistId);
}
@@ -391,10 +411,13 @@ export function finishSessionTerminalEvent(
// renderer 会稍后调 persistTurnErrorDeferred IPC。在 resetTurnPersistState 清掉
// _turnStartedAtBySession 之前保存一份,让 deferred 路径能正确做 /clear 竞态 cap。
// 自愈压住 error 行时同理:补落发生在 resetTurnPersistState 之后(退避 3–20 秒,
- // 或决策推迟的那一小段),不先存一份会让 /clear 竞态 cap 判错。
+ // 或决策推迟的那一小段),不先存一份会让 /clear 竞态 cap 判错。供应商组换电脑暂存 error 行时同理。
if (
event.type === 'error' &&
- (isRemoteAuthRetry || isGatewayProxyTokenRecovery || autoResumeSuppressesPersist)
+ (isRemoteAuthRetry ||
+ isGatewayProxyTokenRecovery ||
+ autoResumeSuppressesPersist ||
+ providerGroupHoldId !== null)
) {
saveTurnStartedAtForDeferred(session.id);
}
diff --git a/apps/desktop/src/main/messagePersistBroadcaster.ts b/apps/desktop/src/main/messagePersistBroadcaster.ts
index a7338aae65..2be06612c2 100644
--- a/apps/desktop/src/main/messagePersistBroadcaster.ts
+++ b/apps/desktop/src/main/messagePersistBroadcaster.ts
@@ -2667,6 +2667,24 @@ export function onTurnErrorEvent(
// 避免 Date.now() 落在 /clear 之后导致 error 行在清空后的历史中浮现。
const blockCreatedAt = assistantBlocks.get(sessionId)?.createdAt;
flushAssistantBlock(sessionId, agentMeta);
+ enqueueTurnErrorRow(sessionId, persistId, {
+ content: buildTurnErrorContent(sessionId, data, message),
+ agentMeta: agentMeta ?? lastAgentMetaBySession.get(sessionId) ?? null,
+ agentKind: getSessionDbAgentKind(sessionId) ?? undefined,
+ orderedAt: capturedAt,
+ turnStartedAt: turnStartedAtSnapshot,
+ blockCreatedAt,
+ });
+ notePersistedMessage(sessionId, 'error', persistId);
+ return persistId;
+}
+
+/** error 行 content:{ message, reason?, sdkError?, toolLoop?, providerId? },在入队前同步取值。 */
+function buildTurnErrorContent(
+ sessionId: string,
+ data: { reason?: unknown; sdkError?: unknown; toolLoop?: unknown } | null | undefined,
+ message: string,
+): Record<string, unknown> {
const content: Record<string, unknown> = { message };
if (typeof data?.reason === 'string' && data.reason) content.reason = data.reason;
if (typeof data?.sdkError === 'string' && data.sdkError) {
@@ -2682,8 +2700,24 @@ export function onTurnErrorEvent(
// 余额分类(fail-closed),与 live 路径「显式 providerId 才分类」同一判据。
const providerIdAtError = getSessionProvider(sessionId);
if (providerIdAtError) content.providerId = providerIdAtError;
- const meta = agentMeta ?? lastAgentMetaBySession.get(sessionId) ?? null;
- const dbAgentKindSnapshot = getSessionDbAgentKind(sessionId) ?? undefined;
+ return content;
+}
+
+/** 入队写一条 error 行。除 blockCreatedAt 外的字段都是调用方在入队前同步取好的快照。 */
+function enqueueTurnErrorRow(
+ sessionId: string,
+ persistId: string,
+ row: {
+ content: Record<string, unknown>;
+ agentMeta: AgentMeta | null;
+ agentKind: 'cc' | 'codex' | 'pi' | undefined;
+ /** 行的排序时间上界(通常是错误到达的时刻)。 */
+ orderedAt: number;
+ turnStartedAt: number;
+ blockCreatedAt?: number;
+ },
+): void {
+ const { content, agentMeta: meta, agentKind: dbAgentKindSnapshot, orderedAt, turnStartedAt, blockCreatedAt } = row;
enqueueTurnErrorWrite(sessionId, persistId, async (ownerScope) => {
// 两个分支统一 +1:保证 error.createdAt 严格晚于本轮所有已入库行。
// 注意:register.ts 在 flushAssistantBlock 之后调本函数,blockCreatedAt
@@ -2691,25 +2725,24 @@ export function onTurnErrorEvent(
// 返回本轮最后入库行的 createdAt,与 error 行同值会让 mobile 排序不可控
// (mobile 无 rowid tie-breaker,同 createdAt 依赖 server 响应原始顺序)。
// 统一 +1 确保 error 行始终排在本轮所有正文/工具行之后。
- // Math.min(..., capturedAt):把异步查询结果的上界锁定在 onTurnErrorEvent 调用时刻,
- // 防止写队列延迟消费时(用户已 /clear 并发了新消息)取到 post-clear 时间戳,
- // 使 error.createdAt > clearedAt 从而出现在清空后的新会话历史里。
+ // Math.min(..., orderedAt):把异步查询结果的上界锁定在 onTurnErrorEvent 调用时刻(延后补落时是错误
+ // 实际发生的时刻),防止写队列延迟消费时(用户已 /clear 或发了新消息)取到之后的时间戳,
+ // 使 error.createdAt > clearedAt 从而出现在清空后的新会话历史里,或排到用户新消息之后。
const rawLatestTs =
blockCreatedAt != null
? blockCreatedAt
: await latestMessageCreatedAt(sessionId);
- const latestTs = rawLatestTs != null ? Math.min(rawLatestTs, capturedAt) : capturedAt;
+ const latestTs = rawLatestTs != null ? Math.min(rawLatestTs, orderedAt) : orderedAt;
// /clear 边界 cap:防止 pre-clear 旧 turn 的 error 行在清空后的新会话中浮现。
- // 用 turnStartedAtSnapshot(入队前同步捕获,不受 resetTurnPersistState 影响)
+ // 用 turnStartedAt(入队前同步捕获,不受 resetTurnPersistState 影响)
// 判定 "stale pre-clear turn",而非 rawLatestTs(异步查询,write queue 延迟消费时可能返回
// post-clear 新消息时间戳,导致误判竞态:旧 turn error 在 /clear 后且用户已发新消息后才入队,
// rawLatestTs > clearBoundary → 跳过 cap → error.createdAt > clearedAt → 串入新会话)。
- // turnStartedAtSnapshot <= clearBoundary:turn 在 /clear 之前启动 → stale → cap。
- // turnStartedAtSnapshot > clearBoundary:turn 在 /clear 之后启动 → 新 turn → 不 cap。
+ // turnStartedAt <= clearBoundary:turn 在 /clear 之前启动 → stale → cap。
+ // turnStartedAt > clearBoundary:turn 在 /clear 之后启动 → 新 turn → 不 cap。
// 无 noteTurnStarted:回退到 capturedAt 作保守锚,行为等价于
// "error 事件到达时刻" 作 stale 判定(边缘 case,如 status:isRunning=true 未发的 agent)。
const clearBoundary = clearBoundaryBySession.get(sessionId);
- const turnStartedAt = turnStartedAtSnapshot;
const createdAt =
clearBoundary != null && turnStartedAt <= clearBoundary
? Math.min(latestTs + 1, clearBoundary)
@@ -2748,7 +2781,61 @@ export function onTurnErrorEvent(
broadcastTap.tapWindowBroadcast('local-db:session:error-persisted', payload, ownerStamp);
}
});
- notePersistedMessage(sessionId, 'error', persistId);
+}
+
+/**
+ * 延后补落的 error 行(供应商组换电脑期间先暂存,provider-group/heldTurnErrors.ts):错误发生那一刻取好写库要用的
+ * 一切——内容(含错误来源 provider)、agentMeta、agentKind、turn 开始时刻与出错时刻。
+ *
+ * 补落发生在之后任意时刻:那时任务可能已开始新的一轮(用户中途接手),旧会话也可能已在交接时关闭、按会话的
+ * 持久化状态已清空,所以补落不能再读任何按会话的「当前一轮」状态。
+ */
+export interface DeferredTurnErrorRow {
+ content: Record<string, unknown>;
+ agentMeta: AgentMeta | null;
+ agentKind: 'cc' | 'codex' | 'pi' | undefined;
+ turnStartedAt: number;
+ occurredAt: number;
+}
+
+/** 在失败那一轮里(错误到达时)同步调用,取好补落要用的 error 行;没有错误文案时返回 null。 */
+export function captureDeferredTurnError(
+ sessionId: string,
+ data:
+ | { message?: unknown; reason?: unknown; sdkError?: unknown; toolLoop?: unknown }
+ | null
+ | undefined,
+ agentMeta: AgentMeta | null = null,
+): DeferredTurnErrorRow | null {
+ const message = typeof data?.message === 'string' ? redactSensitiveText(data.message) : '';
+ if (!message) return null;
+ const occurredAt = Date.now();
+ return {
+ content: buildTurnErrorContent(sessionId, data, message),
+ agentMeta: agentMeta ?? lastAgentMetaBySession.get(sessionId) ?? null,
+ agentKind: getSessionDbAgentKind(sessionId) ?? undefined,
+ turnStartedAt:
+ _turnStartedAtBySession.get(sessionId) ??
+ _savedTurnStartedAtForDeferred.get(sessionId) ??
+ occurredAt,
+ occurredAt,
+ };
+}
+
+/**
+ * 补落 `captureDeferredTurnError` 取好的 error 行:只写这一行,不碰补落时正在进行的那一轮——不 flush 在飞正文
+ * (失败那一轮的正文在终态边界已经落库)、不占用去重键(当前一轮同样的错误照常落库)、不改相邻行记录。
+ * 行按出错的时刻排序:用户在这期间发的新消息仍排在它后面。返回行 id。
+ */
+export function persistDeferredTurnError(sessionId: string, row: DeferredTurnErrorRow): string {
+ const persistId = createId();
+ enqueueTurnErrorRow(sessionId, persistId, {
+ content: row.content,
+ agentMeta: row.agentMeta,
+ agentKind: row.agentKind,
+ orderedAt: Math.min(row.occurredAt, Date.now()),
+ turnStartedAt: row.turnStartedAt,
+ });
return persistId;
}
diff --git a/apps/desktop/src/main/provider-group/__tests__/heldTurnErrors.test.ts b/apps/desktop/src/main/provider-group/__tests__/heldTurnErrors.test.ts
new file mode 100644
index 0000000000..01b4ec4200
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/heldTurnErrors.test.ts
@@ -0,0 +1,135 @@
+/**
+ * 自动换电脑期间先不呈现的那次失败(provider-groups.md §6.1):换成了不留痕迹,没换成补落并呈现,
+ * 结算只认自己那次登记;补落的行在暂存那一刻就取好,换了账号不再写。
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import { createProviderGroupHeldTurnErrors } from '../heldTurnErrors';
+
+interface Row {
+ message: string;
+ agentMeta: unknown;
+ capturedAt: number;
+}
+
+function harness(live = true) {
+ let clock = 1_000;
+ let owner = 'owner-a';
+ const deps = {
+ // 暂存那一刻取好的行:记下当时的时刻与失败那一轮的身份。
+ capture: vi.fn((_sessionId: string, data: unknown, agentMeta: unknown): Row | null => {
+ const message = (data as { message?: unknown } | null)?.message;
+ return typeof message === 'string' && message ? { message, agentMeta, capturedAt: clock } : null;
+ }),
+ persist: vi.fn(),
+ surface: vi.fn(),
+ releaseHold: vi.fn(() => live),
+ ownerKey: () => owner,
+ log: vi.fn(),
+ };
+ return {
+ deps,
+ held: createProviderGroupHeldTurnErrors<Row>(deps),
+ advance: (ms: number) => { clock += ms; },
+ switchOwner: (next: string) => { owner = next; },
+ };
+}
+
+const DATA = { message: "You've hit your session limit", reason: 'usage_limit', sdkError: 'rate_limit', extra: 1 };
+const DETAIL = { message: "You've hit your session limit", reason: 'usage_limit', sdkError: 'rate_limit' };
+const META = { uuid: 'failed-turn' };
+const ROW: Row = { message: DATA.message, agentMeta: META, capturedAt: 1_000 };
+
+describe('provider group held turn errors', () => {
+ it('drops the error row when the task continued on another computer', () => {
+ const { deps, held } = harness();
+ expect(held.stash('s1', 1, DATA, META)).toBe(true);
+ held.discard('s1', 1);
+ expect(deps.releaseHold).toHaveBeenCalledWith('s1', 1);
+ expect(deps.persist).not.toHaveBeenCalled();
+ // 之后的结算(finally)什么都不做。
+ held.release('s1', 1);
+ expect(deps.persist).not.toHaveBeenCalled();
+ expect(deps.surface).not.toHaveBeenCalled();
+ });
+
+ it('writes the row captured when the error happened and surfaces it when the switch gives up', () => {
+ const { deps, held, advance } = harness(true);
+ held.stash('s1', 1, DATA, META);
+ // 换电脑花了一阵子:补落写的仍是出错那一刻取好的那一行(失败那一轮的身份与时刻)。
+ advance(90_000);
+ held.release('s1', 1);
+ expect(deps.capture).toHaveBeenCalledTimes(1);
+ expect(deps.persist).toHaveBeenCalledWith('s1', ROW);
+ expect(deps.surface).toHaveBeenCalledWith('s1', DETAIL);
+ // 重复结算无副作用。
+ held.release('s1', 1);
+ expect(deps.persist).toHaveBeenCalledTimes(1);
+ });
+
+ it('only writes the row when the error is no longer current (the user took over)', () => {
+ const { deps, held } = harness(false);
+ held.stash('s1', 1, DATA, META);
+ held.release('s1', 1);
+ expect(deps.persist).toHaveBeenCalledWith('s1', ROW);
+ expect(deps.surface).not.toHaveBeenCalled();
+ });
+
+ it('does not write into another account after the user switched accounts', () => {
+ const { deps, held, switchOwner } = harness(true);
+ held.stash('s1', 1, DATA);
+ switchOwner('owner-b');
+ held.release('s1', 1);
+ expect(deps.persist).not.toHaveBeenCalled();
+ expect(deps.surface).not.toHaveBeenCalled();
+ });
+
+ it('keeps one row for a repeated terminal error and lets a different error through with its alert', () => {
+ const { deps, held } = harness();
+ expect(held.stash('s1', 1, DATA, META)).toBe(true);
+ expect(held.stash('s1', 1, { ...DATA })).toBe(true);
+ expect(deps.capture).toHaveBeenCalledTimes(1);
+ // 同一次登记期间到达的另一条不同错误:不归这次暂存,调用方照常落库;换电脑期间被压下的 Agent Island 提醒
+ // 在这里补上。暂存的那条不被覆盖。
+ expect(held.stash('s1', 1, { message: 'Something else broke' })).toBe(false);
+ expect(deps.surface).toHaveBeenCalledWith('s1', { message: 'Something else broke' });
+ held.release('s1', 1);
+ expect(deps.persist).toHaveBeenCalledTimes(1);
+ expect(deps.persist).toHaveBeenCalledWith('s1', ROW);
+ });
+
+ it('writes nothing for an error without a message, but still holds and surfaces it', () => {
+ const { deps, held } = harness();
+ expect(held.stash('s1', 1, { reason: 'turn-failed' })).toBe(true);
+ held.release('s1', 1);
+ expect(deps.persist).not.toHaveBeenCalled();
+ expect(deps.surface).toHaveBeenCalledWith('s1', { reason: 'turn-failed' });
+ });
+
+ it('never lets a late settlement touch a newer failure', () => {
+ const { deps, held } = harness();
+ held.stash('s1', 1, DATA);
+ held.release('s1', 1);
+ held.stash('s1', 2, { message: 'second' });
+ held.discard('s1', 1);
+ held.release('s1', 1);
+ expect(deps.persist).toHaveBeenCalledTimes(1);
+ held.release('s1', 2);
+ expect(deps.persist).toHaveBeenLastCalledWith('s1', expect.objectContaining({ message: 'second' }));
+ });
+
+ it('leaves an earlier failure to its own settlement when a new one arrives first', () => {
+ // 换成了、续跑那一轮又很快失败:新的一次先暂存,上一次随后以「换成了」结算,不留错误卡。
+ const { deps, held } = harness();
+ held.stash('s1', 1, DATA);
+ held.stash('s1', 2, { message: 'second' });
+ expect(deps.persist).not.toHaveBeenCalled();
+ held.discard('s1', 1);
+ held.release('s1', 1);
+ expect(deps.persist).not.toHaveBeenCalled();
+ // 新的这次没换成:照常补落。
+ held.release('s1', 2);
+ expect(deps.persist).toHaveBeenCalledTimes(1);
+ expect(deps.persist).toHaveBeenCalledWith('s1', expect.objectContaining({ message: 'second' }));
+ });
+});
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 f0ae7da2a6..4c09988c47 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -649,3 +649,80 @@ describe('onTurnError for a shared user (the sharer’s group picks the computer
expect(h.deps.fallback).toHaveBeenCalledWith('s1', { sdkError: 'rate_limit' }, 4);
});
});
+
+describe('no error while switching (mayHandleTurnError + hooks)', () => {
+ const LIMIT = { sdkError: 'rate_limit' };
+
+ it('predicts a switch only for bound tasks in a group that can still move them', () => {
+ const h = harness();
+ // 没归组、也没有分享者的凭证:照常先报错。
+ expect(h.service.mayHandleTurnError('s1', LIMIT)).toBe(false);
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ expect(h.service.mayHandleTurnError('s1', LIMIT)).toBe(true);
+ // 换到哪台都一样的失败不换。
+ expect(h.service.mayHandleTurnError('s1', { message: 'prompt is too long', sdkError: 'invalid_request' })).toBe(false);
+
+ const off = harness({ autoSwitch: false });
+ off.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ expect(off.service.mayHandleTurnError('s1', LIMIT)).toBe(false);
+
+ // 组里只剩这一台电脑:换不了。
+ const alone = harness({ members: [LOCAL] });
+ alone.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ expect(alone.service.mayHandleTurnError('s1', LIMIT)).toBe(false);
+ });
+
+ it('predicts a switch for a shared task only with a fresh token from the group computer', () => {
+ let clock = 0;
+ const guestSwitch = createProviderGroupGuestSwitch(() => clock);
+ const h = harness({ row: { agentDeviceId: 'share:share-from-alice', providerId: 'alice-anthropic' } });
+ const service = createProviderGroupService({ ...h.deps, guestSwitch });
+ expect(service.mayHandleTurnError('s1', LIMIT)).toBe(false);
+ guestSwitch.offer('s1', 'token-aaaaaaaaaaaaaaaa');
+ expect(service.mayHandleTurnError('s1', LIMIT)).toBe(true);
+ // 只看不取:之后的换电脑仍拿得到凭证。
+ expect(guestSwitch.claim('s1')).toBe(true);
+ guestSwitch.offer('s1', 'token-bbbbbbbbbbbbbbbb');
+ clock += PROVIDER_GROUP_SWITCH_OFFER_TTL_MS + 1;
+ expect(service.mayHandleTurnError('s1', LIMIT)).toBe(false);
+ });
+
+ it('reports a successful switch and never hands back', async () => {
+ const h = harness();
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ const hooks = { beforeFallback: vi.fn(), resumed: vi.fn() };
+ await h.service.onTurnError('s1', LIMIT, 7, hooks);
+ expect(hooks.resumed).toHaveBeenCalledTimes(1);
+ expect(hooks.beforeFallback).not.toHaveBeenCalled();
+ expect(h.deps.fallback).not.toHaveBeenCalled();
+ });
+
+ it('lets the caller surface the error right before handing back to the existing handling', async () => {
+ const order: string[] = [];
+ const h = harness({ offline: [MINI.key, STUDIO.key] });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ h.deps.fallback.mockImplementation(() => { order.push('fallback'); });
+ const hooks = { beforeFallback: vi.fn(() => { order.push('surface'); }), resumed: vi.fn() };
+ // 组里没有别的电脑能接:全部试过才报错。
+ await h.service.onTurnError('s1', LIMIT, 7, hooks);
+ expect(order).toEqual(['surface', 'fallback']);
+ expect(hooks.resumed).not.toHaveBeenCalled();
+
+ // 不归组管的错误同样先放出来再交回。
+ const plain = harness({ row: { providerId: 'openai' } });
+ const plainHooks = { beforeFallback: vi.fn(), resumed: vi.fn() };
+ await plain.service.onTurnError('s1', LIMIT, 1, plainHooks);
+ expect(plainHooks.beforeFallback).toHaveBeenCalledTimes(1);
+ expect(plain.deps.fallback).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not report success when the continuation did not go through', async () => {
+ const h = harness();
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ h.deps.continueSession.mockResolvedValueOnce('no-progress' as never);
+ const hooks = { beforeFallback: vi.fn(), resumed: vi.fn() };
+ await h.service.onTurnError('s1', LIMIT, 7, hooks);
+ expect(hooks.resumed).not.toHaveBeenCalled();
+ expect(h.deps.cancelContinue).toHaveBeenCalledWith('s1', 99);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/guestSwitch.ts b/apps/desktop/src/main/provider-group/guestSwitch.ts
index 2da2b527b1..2a317641fc 100644
--- a/apps/desktop/src/main/provider-group/guestSwitch.ts
+++ b/apps/desktop/src/main/provider-group/guestSwitch.ts
@@ -21,6 +21,8 @@ const MAX_TRACKED_SESSIONS = 512;
export interface ProviderGroupGuestSwitch {
/** 组所在电脑发来凭证(任务的事件流里)。 */
offer(sessionId: string, token: string): void;
+ /** 只看不取:有没有还新鲜的凭证(终态错误那一刻判断要不要先不呈现这次错误)。 */
+ hasOffer(sessionId: string): boolean;
/** 这次错误要不要换一台:有新鲜的凭证则取走,登记给下一次打开,返回 true。 */
claim(sessionId: string): boolean;
/** 打开任务时带上的凭证(取走即用掉);没有返回 undefined。 */
@@ -63,6 +65,11 @@ export function createProviderGroupGuestSwitch(now: () => number = Date.now): Pr
}
},
+ hasOffer(sessionId) {
+ const entry = offered.get(sessionId);
+ return entry !== undefined && now() - entry.at <= PROVIDER_GROUP_SWITCH_OFFER_TTL_MS;
+ },
+
claim(sessionId) {
const entry = offered.get(sessionId);
offered.delete(sessionId);
diff --git a/apps/desktop/src/main/provider-group/heldTurnErrors.ts b/apps/desktop/src/main/provider-group/heldTurnErrors.ts
new file mode 100644
index 0000000000..4d887add71
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/heldTurnErrors.ts
@@ -0,0 +1,125 @@
+/**
+ * 自动换电脑期间先不呈现的那次失败(docs/product-rules/provider-groups.md §6.1「换电脑期间不报错」)。
+ *
+ * 输入协调器在终态错误那一刻判断供应商组会先试着换电脑时,投影里先不带这次错误(没有红横幅),只显示
+ * 「正在换一台电脑继续」;本该立刻落库的 error 行与 Agent Island 的错误提醒由 host 暂存在这里,按协调器那次
+ * 登记的 id 对号结算:
+ * - 换成了(续跑已发出):丢掉,历史里只留换电脑的活动行;
+ * - 没换成、交回原有处理(组里都不能用、自动换电脑关着、交接失败等):先放出来——横幅、error 行、Agent Island;
+ * - 这一趟以别的方式结束(用户中途接手、错误已被新的一轮换掉):补落 error 行,错误已不是当前状态时不再呈现。
+ *
+ * 补落的 error 行在暂存那一刻就取好写库要用的一切(`capture`):补落时任务可能已在跑新的一轮(用户中途接手),
+ * 旧会话也可能已在交接时关闭,补落只写这一行,不碰那时正在进行的那一轮。行按出错的时刻排序:用户在换电脑途中
+ * 发了新消息时,它仍排在那条消息之前。暂存时记下账号:结算时已换了账号就不再写(不往别的账号的数据里补行)。
+ *
+ * 暂存的必须有人结算,否则那次失败在历史里彻底消失;结算只认自己那次登记,迟到的旧结算碰不到下一次失败,
+ * 新的一次登记也不会替还没结算的上一次做决定(上一次可能正要以「换成了」结算)。
+ */
+
+/** 暂存的失败详情(与 error 行 content 同形),用于判断重复与 Agent Island 提醒。 */
+export interface HeldTurnErrorDetail {
+ message?: string;
+ reason?: string;
+ sdkError?: string;
+}
+
+export interface ProviderGroupHeldTurnErrorsDeps<Row> {
+ /**
+ * 暂存那一刻取好补落要用的 error 行(内容、agentMeta、错误来源等);没有可写的内容时返回 null。
+ * `agentMeta` 是失败那一轮的事件身份(没有时为 null)。
+ */
+ capture(sessionId: string, data: unknown, agentMeta: unknown): Row | null;
+ /** 补落 `capture` 取好的那一行:只写这一行,不碰补落时正在进行的那一轮。 */
+ persist(sessionId: string, row: Row): void;
+ /** 错误确定要呈现:同步到聊天之外的错误表面(Agent Island)。 */
+ surface(sessionId: string, detail: HeldTurnErrorDetail): void;
+ /** 撤掉协调器那次「先不呈现」的登记;错误仍是当前状态时投影随即带出横幅,返回 true。 */
+ releaseHold(sessionId: string, holdId: number): boolean;
+ /** 当前登录账号的作用域键。 */
+ ownerKey(): string;
+ log?(message: string, meta?: Record<string, unknown>): void;
+}
+
+export interface ProviderGroupHeldTurnErrors {
+ /**
+ * 终态错误被先不呈现时,暂存本该立刻落库的 error 行。返回 false = 这不是被暂存的那次失败(同一次登记期间
+ * 到达的另一条不同错误):调用方照常落库,这里替它补上换电脑期间被压下的 Agent Island 提醒。同一次失败的
+ * 重复终态 error 返回 true(只留一行)。
+ */
+ stash(sessionId: string, holdId: number, data: unknown, agentMeta?: unknown): boolean;
+ /** 换成了:这次失败不再落库、不再呈现。 */
+ discard(sessionId: string, holdId: number): void;
+ /** 不再换了:撤掉登记并补落;错误仍是当前状态时一并呈现。重复调用无副作用。 */
+ release(sessionId: string, holdId: number): void;
+}
+
+interface HeldEntry<Row> {
+ detail: HeldTurnErrorDetail;
+ row: Row | null;
+ owner: string;
+}
+
+function toDetail(data: unknown): HeldTurnErrorDetail {
+ const d = (data ?? {}) as { message?: unknown; reason?: unknown; sdkError?: unknown };
+ return {
+ ...(typeof d.message === 'string' ? { message: d.message } : {}),
+ ...(typeof d.reason === 'string' ? { reason: d.reason } : {}),
+ ...(typeof d.sdkError === 'string' ? { sdkError: d.sdkError } : {}),
+ };
+}
+
+export function createProviderGroupHeldTurnErrors<Row>(
+ deps: ProviderGroupHeldTurnErrorsDeps<Row>,
+): ProviderGroupHeldTurnErrors {
+ /** sessionId → 登记 id → 暂存的那次失败。同一任务可能同时有两次还没结算(上一次正在以续跑收尾)。 */
+ const held = new Map<string, Map<number, HeldEntry<Row>>>();
+
+ function take(sessionId: string, holdId: number): HeldEntry<Row> | null {
+ const entries = held.get(sessionId);
+ const entry = entries?.get(holdId);
+ if (!entries || !entry) return null;
+ entries.delete(holdId);
+ if (entries.size === 0) held.delete(sessionId);
+ return entry;
+ }
+
+ /** 补落;暂存后已换了账号时不写。返回是否写了。 */
+ function persist(sessionId: string, entry: HeldEntry<Row>): boolean {
+ if (entry.owner !== deps.ownerKey()) {
+ deps.log?.('provider group: dropped a held error row after the account changed', { sessionId });
+ return false;
+ }
+ if (entry.row !== null) deps.persist(sessionId, entry.row);
+ return true;
+ }
+
+ return {
+ stash(sessionId, holdId, data, agentMeta) {
+ const detail = toDetail(data);
+ const entries = held.get(sessionId) ?? new Map<number, HeldEntry<Row>>();
+ const previous = entries.get(holdId);
+ if (previous) {
+ // 同一次登记期间又来一条终态 error:同一次失败的重复就只留一行。不同的错误不归这次暂存:调用方照常落库,
+ // 换电脑期间被压下的 Agent Island 提醒在这里补上。
+ if (previous.detail.message === detail.message) return true;
+ deps.surface(sessionId, detail);
+ return false;
+ }
+ entries.set(holdId, { detail, row: deps.capture(sessionId, data, agentMeta ?? null), owner: deps.ownerKey() });
+ held.set(sessionId, entries);
+ return true;
+ },
+
+ discard(sessionId, holdId) {
+ take(sessionId, holdId);
+ deps.releaseHold(sessionId, holdId);
+ },
+
+ release(sessionId, holdId) {
+ const live = deps.releaseHold(sessionId, holdId);
+ const entry = take(sessionId, holdId);
+ if (!entry) return;
+ if (persist(sessionId, entry) && live) deps.surface(sessionId, entry.detail);
+ },
+ };
+}
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index a3c6ea6c57..652c7ded6d 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -163,7 +163,7 @@ export interface ProviderGroupServiceDeps {
/**
* 分享的人这边的「需要换一台」凭证(guestSwitch.ts);不提供 = 分享来的供应商出错时一律交回原有处理。
*/
- guestSwitch?: Pick<ProviderGroupGuestSwitch, 'claim' | 'release' | 'drop'>;
+ guestSwitch?: Pick<ProviderGroupGuestSwitch, 'hasOffer' | 'claim' | 'release' | 'drop'>;
/** 这个任务现在是否正在运行一轮。 */
isTurnRunning(sessionId: string): boolean;
continueSession(
@@ -187,8 +187,20 @@ export interface ProviderGroupService {
assignBeforeStart(input: { sessionId: string; agentKind: AgentKind; model: string }): Promise<ProviderGroupStartContext | null>;
/** 分配后 Agent 没能启动:换下一台,返回新的位置;不该换或没有下一台返回 null(调用方照常报错)。 */
nextAfterStartFailure(context: ProviderGroupStartContext, error: unknown): Promise<ProviderGroupStartContext | null>;
- /** 运行中的终态错误(输入协调器保留了重试入口)。 */
- onTurnError(sessionId: string, signals: InterruptedTurnErrorSignals, token: number): void;
+ /**
+ * 纯判定(同步、无副作用):这次终态错误会不会先由本机制试着换电脑。为 true 时输入协调器先不呈现这次错误
+ * (红横幅与错误卡):换成了就不出现,没换成再补出来(§6.1)。只看手上现成的:认得出的原因,加上已归组
+ * (本机的组要开着自动换电脑、组里还有别的电脑;另一台电脑上的组交给随后的异步判断),或组所在电脑已发来
+ * 「需要换一台」的凭证。出错时才纳入组的老任务这里认不出,照旧先报错再换。
+ */
+ mayHandleTurnError(sessionId: string, signals: InterruptedTurnErrorSignals): boolean;
+ /** 运行中的终态错误(输入协调器保留了重试入口)。整个处理(换电脑、续跑或交回原有处理)结束时兑现。 */
+ onTurnError(
+ sessionId: string,
+ signals: InterruptedTurnErrorSignals,
+ token: number,
+ hooks?: ProviderGroupTurnErrorHooks,
+ ): Promise<void>;
/**
* 发送前:已归组的任务所在那台现在不能用(离线、分享暂停、供应商关掉、冷却中)时,先交接到组里下一台,
* 这条消息直接发到新电脑。读不到状态或没有下一台时不动,照常发送。
@@ -198,6 +210,14 @@ export interface ProviderGroupService {
noteUserAction(sessionId: string): void;
}
+/** 一次终态错误的处理结局(调用方据此结算换电脑期间先不呈现的那次错误)。 */
+export interface ProviderGroupTurnErrorHooks {
+ /** 不换了,马上交回原有处理(报错与额度重置后自动继续):先把错误放出来。 */
+ beforeFallback?(): void;
+ /** 已换到另一台电脑并续上了这一轮。 */
+ resumed?(): void;
+}
+
/** 发送前检查组内电脑状态的上限:读不到就照常发送,不让一台卡住的电脑拖慢每次发送。 */
export const PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS = 3_000;
@@ -543,6 +563,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
signals: InterruptedTurnErrorSignals,
token: number,
lease: object,
+ hooks: ProviderGroupTurnErrorHooks | undefined,
body: (isCurrent: () => boolean, handBack: () => void) => Promise<void>,
): Promise<void> {
const run = { superseded: false };
@@ -552,6 +573,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
const isCurrent = () => !run.superseded && deps.isLeaseCurrent(sessionId, lease);
const handBack = () => {
if (!isCurrent()) return;
+ hooks?.beforeFallback?.();
const fallbackToken = deps.leaseRecovery(sessionId, token) ? token : deps.rearmContinue(sessionId, lease, null);
if (fallbackToken !== null) deps.fallback(sessionId, signals, fallbackToken);
};
@@ -567,11 +589,16 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
}
/** true = 已由本机制处理(含它自己交回原有处理);false = 不归它管,调用方照常交回。 */
- async function failover(sessionId: string, signals: InterruptedTurnErrorSignals, token: number): Promise<boolean> {
+ async function failover(
+ sessionId: string,
+ signals: InterruptedTurnErrorSignals,
+ token: number,
+ hooks: ProviderGroupTurnErrorHooks | undefined,
+ ): Promise<boolean> {
const cause = classifyProviderGroupSwitchCause(signals);
if (!cause) return false;
if (!deps.readBinding(sessionId) && !(await adoptOnFailure(sessionId))) {
- return guestFailover(sessionId, signals, token, cause);
+ return guestFailover(sessionId, signals, token, cause, hooks);
}
const bound = await loadBound(sessionId);
if (!bound) return false;
@@ -590,8 +617,8 @@ 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, (isCurrent, handBack) => switchUntilSettled({
- sessionId, signals, cause, binding, source, config, row: boundRow, current, lease, isCurrent, handBack,
+ await withSwitchRun(sessionId, signals, token, lease, hooks, (isCurrent, handBack) => switchUntilSettled({
+ sessionId, signals, cause, binding, source, config, row: boundRow, current, lease, isCurrent, handBack, hooks,
}));
return true;
}
@@ -607,6 +634,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
signals: InterruptedTurnErrorSignals,
token: number,
cause: ProviderGroupSwitchCause,
+ hooks: ProviderGroupTurnErrorHooks | undefined,
): Promise<boolean> {
const guestSwitch = deps.guestSwitch;
if (!guestSwitch) return false;
@@ -621,7 +649,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return true;
}
const model = row.model;
- await withSwitchRun(sessionId, signals, token, lease, async (isCurrent, handBack) => {
+ await withSwitchRun(sessionId, signals, token, lease, hooks, async (isCurrent, handBack) => {
try {
// 位置仍是同一个分享:强制重新交接、新建会话,打开时带上凭证,由组所在电脑换一台。
await deps.switchAgentLocation(sessionId, {
@@ -647,7 +675,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
sessionTotal: 0,
groupSwitch: { cause },
});
- if (outcome !== 'resumed') deps.cancelContinue(sessionId, continueToken);
+ if (outcome === 'resumed') hooks?.resumed?.();
+ else deps.cancelContinue(sessionId, continueToken);
});
return true;
}
@@ -664,8 +693,9 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
lease: object;
isCurrent: () => boolean;
handBack: () => void;
+ hooks: ProviderGroupTurnErrorHooks | undefined;
}): Promise<void> {
- const { sessionId, signals, cause, binding, source, config, row, current, lease, isCurrent, handBack } = input;
+ const { sessionId, signals, cause, binding, source, config, row, current, lease, isCurrent, handBack, hooks } = input;
source.cool(binding.providerId, current.key, cause, deps.readResetAt(signals));
source.invalidate(current);
const tried = router.markTried(sessionId, current.key);
@@ -734,7 +764,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
sessionTotal: 0,
agentSwitch: { from: fromLabel, to: pick.label, cause },
});
- if (outcome !== 'resumed') deps.cancelContinue(sessionId, continueToken);
+ if (outcome === 'resumed') hooks?.resumed?.();
+ else deps.cancelContinue(sessionId, continueToken);
return;
}
}
@@ -888,15 +919,29 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return { ...context, member: pick.member, route, overrideRoute: true };
},
- onTurnError(sessionId, signals, token) {
- void failover(sessionId, signals, token)
- .then((handled) => {
- if (!handled) deps.fallback(sessionId, signals, token);
- })
- .catch((error) => {
- deps.log.warn('provider group: automatic switch failed', { sessionId, error: errorText(error) });
- deps.fallback(sessionId, signals, token);
- });
+ mayHandleTurnError(sessionId, signals) {
+ if (!classifyProviderGroupSwitchCause(signals)) return false;
+ const binding = deps.readBinding(sessionId);
+ if (!binding) return deps.guestSwitch?.hasOffer(sessionId) === true;
+ if (binding.groupDeviceId) return deps.remote !== undefined;
+ const config = deps.readGroup(binding.providerId);
+ const current = config?.members.find((m) => m.key === binding.memberKey);
+ // 交接只在不同电脑之间进行(switchExclusion):组里没有别的电脑时换不了。
+ return Boolean(
+ config?.autoSwitch && current && config.members.some((m) => m.agentDeviceId !== current.agentDeviceId),
+ );
+ },
+
+ async onTurnError(sessionId, signals, token, hooks) {
+ let handled = false;
+ try {
+ handled = await failover(sessionId, signals, token, hooks);
+ } catch (error) {
+ deps.log.warn('provider group: automatic switch failed', { sessionId, error: errorText(error) });
+ }
+ if (handled) return;
+ hooks?.beforeFallback?.();
+ deps.fallback(sessionId, signals, token);
},
async beforeSend(sessionId) {
diff --git a/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts b/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts
index 852f566c95..911bbdff38 100644
--- a/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts
+++ b/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts
@@ -298,6 +298,22 @@ describe('applyInputProjection 自愈进行中提示', () => {
});
});
+ it('供应商组换电脑期间任务仍算运行中,没换成时以错误结束(侧栏红点与失败通知照常)', () => {
+ inputProjectionCb!(projection({
+ autoResumePending: {
+ error: "You've hit your session limit",
+ attempt: 0,
+ maxAttempts: 0,
+ sessionTotal: 0,
+ groupSwitchPending: { cause: 'usage-limit' },
+ },
+ }));
+ expect(makerChatStore.getSnapshot(SID).error).toBeNull();
+ expect(makerChatStore.getRunningSnapshot().get(SID)?.isRunning).toBe(true);
+ inputProjectionCb!(projection({ error: "You've hit your session limit" }));
+ expect(makerChatStore.getRunningSnapshot().get(SID)).toMatchObject({ isRunning: false, hasError: true });
+ });
+
it('does not classify a normal Continue as recovery when it finishes before projection cleanup', () => {
makerEventCb!({ sessionId: SID, event: { type: 'status', data: { isRunning: true } } });
inputProjectionCb!(projection({ continuationInFlightClientId: 'manual-continue' }));
@@ -1049,3 +1065,57 @@ describe('同一次中断事件的多次重连折叠成一行', () => {
expect(rows.find((m) => m.clientId === 'r1')?.systemCardType).toBeUndefined();
});
});
+
+describe('供应商组换电脑期间不报错(provider-groups.md §6.1)', () => {
+ const LIMIT_MESSAGE = "You've hit your session limit · resets 12:40am";
+ const switchingCard = (error = LIMIT_MESSAGE) => ({
+ ...serverMessage({ clientId: PENDING_CARD_ID, content: '' }),
+ systemCardType: 'auto-resume-pending' as const,
+ systemCardData: { error, attempt: 0, maxAttempts: 0, sessionTotal: 0, groupSwitchPending: { cause: 'usage-limit' } },
+ }) as ChatMessage;
+ const terminalError = (source: 'claude-code' | 'pi', message = LIMIT_MESSAGE) => ({
+ sessionId: SID,
+ type: 'error' as const,
+ source,
+ data: { message, isTerminal: true },
+ });
+
+ it.each(['claude-code', 'pi'] as const)('%s 的终态错误回声不点亮横幅,也不撤掉「正在换一台电脑继续」', (source) => {
+ const next = handleStreamEvent(
+ { ...EMPTY_SESSION_STATE, messages: [switchingCard()] },
+ terminalError(source),
+ );
+ expect(next.error).toBeNull();
+ expect(next.messages.some((m) => m.clientId === PENDING_CARD_ID)).toBe(true);
+ });
+
+ it('换电脑期间到达的另一次错误照常报错', () => {
+ const next = handleStreamEvent(
+ { ...EMPTY_SESSION_STATE, messages: [switchingCard()] },
+ terminalError('claude-code', 'Something else broke'),
+ );
+ expect(next.error).toBe('Something else broke');
+ });
+
+ it('不是换电脑的接管行不改变非 Codex 错误的呈现', () => {
+ const plainCard = {
+ ...serverMessage({ clientId: PENDING_CARD_ID, content: '' }),
+ systemCardType: 'auto-resume-pending' as const,
+ systemCardData: { ...PENDING_INFO, error: LIMIT_MESSAGE },
+ } as ChatMessage;
+ const next = handleStreamEvent({ ...EMPTY_SESSION_STATE, messages: [plainCard] }, terminalError('claude-code'));
+ expect(next.error).toBe(LIMIT_MESSAGE);
+ });
+
+ it('输入框状态写「正在换一台电脑继续」所需的标记随进行中行带出', () => {
+ const info = findActiveReconnect({
+ messages: [switchingCard()],
+ sessionRunning: false,
+ continuationTurnClientId: null,
+ projectionCapability: 'supported',
+ });
+ expect(info?.groupSwitchPending).toEqual({ cause: 'usage-limit' });
+ // 不是重连:没有次数。
+ expect(info?.attempt).toBeUndefined();
+ });
+});
diff --git a/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx b/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx
index 7b2913f19f..117661c1ac 100644
--- a/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx
@@ -115,6 +115,24 @@ describe('SystemCard auto-resume 行', () => {
).toBeNull();
});
+ it('供应商组换电脑进行中 → 「正在换一台电脑继续」,不带先不呈现的原始错误', () => {
+ render(
+ <SystemCard
+ cardType="auto-resume-pending"
+ data={{
+ error: "You've hit your session limit",
+ attempt: 0,
+ maxAttempts: 0,
+ sessionTotal: 0,
+ groupSwitchPending: { cause: 'usage-limit' },
+ }}
+ />,
+ );
+ expect(screen.getByText('chat.systemCard.autoResumePending.groupSwitch')).toBeTruthy();
+ expect(screen.queryByText(/session limit/)).toBeNull();
+ expect(screen.queryByText('chat.systemCard.autoResumePending.label')).toBeNull();
+ });
+
it('已回填时 inFlight 不参与:终态优先,仍定格 ✓ / ✗', () => {
render(
<SystemCard
diff --git a/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts b/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts
index 87c3808925..80fb3c0285 100644
--- a/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts
+++ b/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts
@@ -13,7 +13,7 @@ import {
} from '@/lib/silencedSessionDoneStore';
import { markSessionStarting, resetSessionStartingStoreForTests } from '@/lib/sessionStartingStore';
import { useSessionRunningStatus } from '@/hooks/useSessionRunningStatus';
-import { noteSessionTurnStartedForAlerts } from '@/hooks/usePendingAlertAttention';
+import { noteSessionTurnStartedForAlerts, refreshPendingAlerts } from '@/hooks/usePendingAlertAttention';
import {
addSessionAttention,
clearSessionAttention,
@@ -69,6 +69,7 @@ vi.mock('@/lib/sessionAttentionStore', () => ({
vi.mock('@/hooks/usePendingAlertAttention', () => ({
noteSessionTurnStartedForAlerts: vi.fn(),
+ refreshPendingAlerts: vi.fn(async () => {}),
}));
function status(isRunning: boolean, hasError = false, sideTask?: boolean): SessionStatusInfo {
@@ -825,3 +826,77 @@ describe('useSessionRunningStatus silenced completion handling', () => {
expect(onSessionDone).toHaveBeenCalledExactlyOnceWith('paused');
});
});
+
+describe('useSessionRunningStatus stale error dot', () => {
+ afterEach(() => {
+ storeMock.snapshot = new Map();
+ storeMock.listeners.clear();
+ storeMock.terminalErrorSessions.clear();
+ vi.clearAllMocks();
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ });
+
+ it('retires the error dot when the next turn finishes cleanly after the start missed it', async () => {
+ vi.useFakeTimers();
+ let kind: ReturnType<typeof getSessionAttentionKind>;
+ vi.mocked(addSessionAttention).mockImplementation((_sessionId, next) => {
+ kind = next;
+ });
+ vi.mocked(clearSessionAttention).mockImplementation(() => {
+ kind = undefined;
+ return true;
+ });
+ vi.mocked(getSessionAttentionKind).mockImplementation(() => kind);
+ renderHook(() => useSessionRunningStatus(undefined));
+ await emitSnapshot(new Map([['s', status(true)]]));
+ storeMock.terminalErrorSessions.add('s');
+ await emitSnapshot(new Map([['s', status(false, true)]]));
+ expect(kind).toBe('error');
+
+ // 自动续跑(换电脑后继续、额度恢复后继续)启动那一刻还读到旧错误:当时没收掉。
+ await emitSnapshot(new Map([['s', status(true)]]));
+ expect(kind).toBe('error');
+ storeMock.terminalErrorSessions.clear();
+ await emitSnapshot(new Map([['s', status(false)]]));
+ expect(clearSessionAttention).toHaveBeenCalledWith('s', { intent: 'explicit' });
+ // 派生账本重算:仍有未处置的错误尾行会重新点亮。
+ expect(refreshPendingAlerts).toHaveBeenCalled();
+ await act(async () => { await vi.advanceTimersByTimeAsync(1000); });
+ expect(kind).toBe('done');
+ });
+
+ it('stops owning its dot once the user handled it, so a later dot from elsewhere stays', async () => {
+ vi.useFakeTimers();
+ let kind: ReturnType<typeof getSessionAttentionKind>;
+ vi.mocked(addSessionAttention).mockImplementation((_sessionId, next) => {
+ kind = next;
+ });
+ vi.mocked(getSessionAttentionKind).mockImplementation(() => kind);
+ renderHook(() => useSessionRunningStatus(undefined));
+ await emitSnapshot(new Map([['s', status(true)]]));
+ storeMock.terminalErrorSessions.add('s');
+ await emitSnapshot(new Map([['s', status(false, true)]]));
+ // 用户关掉横幅:红点被处置。
+ kind = undefined;
+ storeMock.terminalErrorSessions.clear();
+ await emitSnapshot(new Map([['s', status(true)]]));
+ // 这一轮里别的来源(如 Make 卡片失败)点了红点,但这一轮本身正常结束。
+ kind = 'error';
+ vi.mocked(clearSessionAttention).mockClear();
+ await emitSnapshot(new Map([['s', status(false)]]));
+ expect(clearSessionAttention).not.toHaveBeenCalledWith('s', { intent: 'explicit' });
+ });
+
+ it('leaves an error dot it did not set to the pending-alert ledger', async () => {
+ vi.useFakeTimers();
+ vi.mocked(getSessionAttentionKind).mockReturnValue('error');
+ renderHook(() => useSessionRunningStatus(undefined));
+ storeMock.terminalErrorSessions.add('s');
+ await emitSnapshot(new Map([['s', status(true)]]));
+ storeMock.terminalErrorSessions.clear();
+ await emitSnapshot(new Map([['s', status(false)]]));
+ expect(clearSessionAttention).not.toHaveBeenCalledWith('s', { intent: 'explicit' });
+ expect(refreshPendingAlerts).toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/renderer/components/chat/SystemCard.tsx b/apps/desktop/src/renderer/components/chat/SystemCard.tsx
index 214617d287..6a9d4234eb 100644
--- a/apps/desktop/src/renderer/components/chat/SystemCard.tsx
+++ b/apps/desktop/src/renderer/components/chat/SystemCard.tsx
@@ -963,7 +963,9 @@ function AutoResumeActionRow({
// - 已回填 → ✓ / ✗ 定格,`inFlight` 不参与(终态优先)
const live = state === 'live' || (inFlight === true && info.outcome === undefined);
const outcome = live ? undefined : info.outcome;
- const label = info.agentSwitch
+ const label = info.groupSwitchPending
+ ? t('chat.systemCard.autoResumePending.groupSwitch')
+ : info.agentSwitch
? t(`chat.systemCard.autoResume.agentSwitch.${info.agentSwitch.cause}`, {
from: info.agentSwitch.from,
to: info.agentSwitch.to,
@@ -984,8 +986,10 @@ function AutoResumeActionRow({
: outcome === 'failed'
? t('chat.systemCard.autoResume.labelFailed')
: t('chat.systemCard.autoResume.labelNeutral');
- const summary = summarizeInterruption(info.error);
- const canExpand = Boolean(info.error) || hasProgress || showSessionTotal;
+ // 供应商组正在换电脑时错误先不呈现:行内不带原始错误(它只用来认出终态 event 的回声)。
+ const shownError = info.groupSwitchPending ? undefined : info.error;
+ const summary = summarizeInterruption(shownError);
+ const canExpand = Boolean(shownError) || hasProgress || showSessionTotal;
return (
<div className="flex flex-col">
<button
diff --git a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
index 51e443412d..168ac80fea 100644
--- a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx
@@ -2272,7 +2272,9 @@ export function CCAgentSessionView({
[messages, agentStatus.isRunning, isStreaming, continuationTurnClientId, continuationInFlightProjectionCapability],
);
const reconnectStatus = activeReconnect
- ? activeReconnect.attempt !== undefined && activeReconnect.maxAttempts !== undefined
+ ? activeReconnect.groupSwitchPending
+ ? t('chat.systemCard.autoResumePending.groupSwitch')
+ : activeReconnect.attempt !== undefined && activeReconnect.maxAttempts !== undefined
? t('chat.systemCard.autoResumePending.labelWithProgress', {
attempt: activeReconnect.attempt,
total: activeReconnect.maxAttempts,
diff --git a/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts b/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts
index 63f7ba71dd..db9eeaefb7 100644
--- a/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts
+++ b/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts
@@ -53,7 +53,10 @@ import {
isSessionTerminalNotificationOwnedByScheduler,
isSessionDoneSilenced,
} from '@/lib/silencedSessionDoneStore';
-import { noteSessionTurnStartedForAlerts } from '@/hooks/usePendingAlertAttention';
+import {
+ noteSessionTurnStartedForAlerts,
+ refreshPendingAlerts,
+} from '@/hooks/usePendingAlertAttention';
import {
ensureAgentIslandActivitySubscribed,
isSessionCompletionHeldByAgentIsland,
@@ -134,6 +137,9 @@ export function useSessionRunningStatus(
// when pending states disappear and auto-clear notifications.
const prevPendingRef = useRef(new Set<string>());
+ /** 本 hook 因 turn 以错误结束而点的红点(新一轮正常结束时据此收掉过期的那颗)。 */
+ const liveErrorMarkedRef = useRef(new Set<string>());
+
/**
* Pending done-notifications waiting for a debounce window to expire.
* 场景:用户排了队列,turn A done → main 会几十毫秒后自动 spawn turn B。
@@ -169,10 +175,11 @@ export function useSessionRunningStatus(
// hasSessionTerminalError 仍为 true 时不清(mivo 等 skipTurnReset 上升沿
// 不拆横幅);派生账本另走 noteSessionTurnStartedForAlerts,只在仍认领
// 错误尾行时重算,横幅已灭则差分熄灭红点。
- if (
- getSessionAttentionKind(sessionId) === 'error' &&
- !makerChatStore.hasSessionTerminalError(sessionId)
- ) {
+ if (getSessionAttentionKind(sessionId) !== 'error') {
+ // 本 hook 点的那颗已被处置(关横幅、重试等):不再认领,之后别的来源点的红点不归它收。
+ liveErrorMarkedRef.current.delete(sessionId);
+ } else if (!makerChatStore.hasSessionTerminalError(sessionId)) {
+ liveErrorMarkedRef.current.delete(sessionId);
clearSessionAttention(sessionId, { intent: 'explicit' });
}
noteSessionTurnStartedForAlerts(sessionId);
@@ -228,6 +235,7 @@ export function useSessionRunningStatus(
// 横幅就在眼前时列表同样亮点(2026-07 统一决策)。不能沿用「活跃会话不亮」
// 的 done 语义。清除只能来自用户处置横幅或 pending-alerts 派生收敛。
addSessionAttention(sessionId, 'error');
+ liveErrorMarkedRef.current.add(sessionId);
if (!notificationOwnedByScheduler) onSessionErrorRef.current?.(sessionId);
continue;
}
@@ -240,6 +248,19 @@ export function useSessionRunningStatus(
// retry. That idle gap is not completion, even if it lasts beyond debounce.
if (makerChatStore.hasSessionRecoveryPending(sessionId)) continue;
+ // 这一轮正常结束、错误已不在,上一次失败的红点却还亮着:新一轮启动那一刻可能还读到旧错误
+ // (撞上限后自动换电脑、额度恢复后自动继续时尤其如此),当时没收掉,之后就再没人收。本 hook
+ // 自己点的直接收;派生账本(错误尾行 / 中断)重算一次,仍有未处置的告警会重新点亮。
+ if (
+ getSessionAttentionKind(sessionId) === 'error' &&
+ !makerChatStore.hasSessionTerminalError(sessionId)
+ ) {
+ if (liveErrorMarkedRef.current.delete(sessionId)) {
+ clearSessionAttention(sessionId, { intent: 'explicit' });
+ }
+ void refreshPendingAlerts();
+ }
+
// 正常 done:走 debounce。QUEUE_DEBOUNCE_MS 内若同 session 又变 running
// (main 自动衔接下一条队列),上面的 "--- 1. Detect new turn starts ---"
// 分支会 clearTimeout 取消这次。窗口过完仍是 not-running,才认为队列真的
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index ed7df3a280..a6868fb96d 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -10589,7 +10589,8 @@
},
"autoResumePending": {
"label": "Reconnecting",
- "labelWithProgress": "Reconnecting {{attempt}}/{{total}}"
+ "labelWithProgress": "Reconnecting {{attempt}}/{{total}}",
+ "groupSwitch": "Switching to another computer"
},
"agentSwitch": {
"label": "Switched from {{from}} to {{to}}",
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index d13a6bbde1..974fbec36f 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -10565,7 +10565,8 @@
},
"autoResumePending": {
"label": "再接続中",
- "labelWithProgress": "再接続中 {{attempt}}/{{total}}"
+ "labelWithProgress": "再接続中 {{attempt}}/{{total}}",
+ "groupSwitch": "別のパソコンに切り替え中"
},
"agentSwitch": {
"label": "{{from}} から {{to}} に切り替えました",
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 254dcd93d6..e09be47837 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -10565,7 +10565,8 @@
},
"autoResumePending": {
"label": "다시 연결하는 중",
- "labelWithProgress": "다시 연결하는 중 {{attempt}}/{{total}}"
+ "labelWithProgress": "다시 연결하는 중 {{attempt}}/{{total}}",
+ "groupSwitch": "다른 컴퓨터로 전환하는 중"
},
"agentSwitch": {
"label": "{{from}}에서 {{to}}(으)로 전환됨",
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 a0fe6a0b58..f6a9a325a5 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -10565,7 +10565,8 @@
},
"autoResumePending": {
"label": "重新连接中",
- "labelWithProgress": "重新连接中 {{attempt}}/{{total}}"
+ "labelWithProgress": "重新连接中 {{attempt}}/{{total}}",
+ "groupSwitch": "正在换一台电脑继续"
},
"agentSwitch": {
"label": "已从 {{from}} 切换到 {{to}}",
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 b155c55fae..61a27bae67 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -10564,7 +10564,8 @@
},
"autoResumePending": {
"label": "重新連線中",
- "labelWithProgress": "重新連線中 {{attempt}}/{{total}}"
+ "labelWithProgress": "重新連線中 {{attempt}}/{{total}}",
+ "groupSwitch": "正在換一台電腦繼續"
},
"agentSwitch": {
"label": "已從 {{from}} 切換到 {{to}}",
diff --git a/apps/desktop/src/renderer/lib/autoResumePresentation.ts b/apps/desktop/src/renderer/lib/autoResumePresentation.ts
index 9daf259d43..cf69d147db 100644
--- a/apps/desktop/src/renderer/lib/autoResumePresentation.ts
+++ b/apps/desktop/src/renderer/lib/autoResumePresentation.ts
@@ -13,6 +13,8 @@ export interface AutoResumeCardInfo {
agentSwitch?: AutoResumeAgentSwitch;
/** 分享者的供应商组替分享的人换了一台电脑后继续(不知道是哪台,不显示电脑名称)。 */
groupSwitch?: AutoResumeGroupSwitch;
+ /** 进行中:供应商组正在为这次失败换电脑(错误先不呈现)。 */
+ groupSwitchPending?: AutoResumeGroupSwitch;
error?: string;
attempt?: number;
maxAttempts?: number;
@@ -39,6 +41,9 @@ export function readAutoResumeInfo(data?: Record<string, unknown>): AutoResumeCa
...(data?.reason === USAGE_LIMIT_RESET_AUTO_RESUME_REASON ? { usageLimitReset: true } : {}),
...(readAgentSwitch(data?.agentSwitch) ? { agentSwitch: readAgentSwitch(data?.agentSwitch)! } : {}),
...(readGroupSwitch(data?.groupSwitch) ? { groupSwitch: readGroupSwitch(data?.groupSwitch)! } : {}),
+ ...(readGroupSwitch(data?.groupSwitchPending)
+ ? { groupSwitchPending: readGroupSwitch(data?.groupSwitchPending)! }
+ : {}),
...(typeof data?.error === 'string' && data.error.length > 0 ? { error: data.error } : {}),
...(num(data?.attempt) !== undefined ? { attempt: num(data?.attempt) } : {}),
...(num(data?.maxAttempts) !== undefined ? { maxAttempts: num(data?.maxAttempts) } : {}),
diff --git a/apps/desktop/src/renderer/lib/makerChatStore.ts b/apps/desktop/src/renderer/lib/makerChatStore.ts
index 83e261a388..99a9f7ec4f 100644
--- a/apps/desktop/src/renderer/lib/makerChatStore.ts
+++ b/apps/desktop/src/renderer/lib/makerChatStore.ts
@@ -4593,6 +4593,15 @@ function hasMatchingAutoResumePendingError(messages: ChatMessage[], data: unknow
);
}
+/** 进行中行是「供应商组正在换电脑」:这次失败先不呈现,不论哪种 Agent(provider-groups.md §6.1)。 */
+function hasProviderGroupSwitchPendingCard(messages: ChatMessage[]): boolean {
+ return messages.some(
+ (item) =>
+ item.clientId === AUTO_RESUME_PENDING_CLIENT_ID &&
+ Boolean(item.systemCardData?.groupSwitchPending),
+ );
+}
+
function applyInputProjection(
projection: AgentInputProjection,
opts: { supersedeQueries?: boolean } = {},
@@ -6447,8 +6456,8 @@ export function handleStreamEvent(
const finalized = finalizeStreamingInState(state);
const derivedRetryText = deriveErrorRetryText(finalized);
const suppressAutoResumeBroadcastError =
- event.source === 'codex' &&
- !isCodexUserActionableRetryError(event.data) &&
+ ((event.source === 'codex' && !isCodexUserActionableRetryError(event.data)) ||
+ hasProviderGroupSwitchPendingCard(finalized.messages)) &&
hasMatchingAutoResumePendingError(finalized.messages, event.data);
// main coordinator 在终止型 error 时**先**同步 emit projection(errorRetryText
// = projectionRetryText 的权威 retry token,active-turn 恢复恒非空)再 broadcast
diff --git a/apps/desktop/src/shared/agentInputQueue.ts b/apps/desktop/src/shared/agentInputQueue.ts
index 5e2cdf7472..90a501f8a0 100644
--- a/apps/desktop/src/shared/agentInputQueue.ts
+++ b/apps/desktop/src/shared/agentInputQueue.ts
@@ -214,6 +214,12 @@ export interface AutoResumeInfo {
* 电脑继续」,不出现电脑名称(docs/product-rules/provider-groups.md §8)。旧端忽略该字段。
*/
groupSwitch?: AutoResumeGroupSwitch;
+ /**
+ * 只出现在投影的进行中行:供应商组正在为这次失败换电脑,错误先不呈现,行内显示「正在换一台电脑继续」
+ * (provider-groups.md §6.1)。此时 attempt / maxAttempts / sessionTotal 都是 0(不是重连,不显示次数);
+ * 旧端忽略该字段,显示成「重新连接中」。
+ */
+ groupSwitchPending?: AutoResumeGroupSwitch;
}
export interface AutoResumeGroupSwitch {
diff --git a/apps/mobile/src/__tests__/autoResumePresentation.test.ts b/apps/mobile/src/__tests__/autoResumePresentation.test.ts
index 3ef07fe6dd..c6835e73fb 100644
--- a/apps/mobile/src/__tests__/autoResumePresentation.test.ts
+++ b/apps/mobile/src/__tests__/autoResumePresentation.test.ts
@@ -34,6 +34,23 @@ describe('autoResumePresentation', () => {
expect(isMobileAutoResumeRowInFlight({ ...args, projectionCapability: 'unknown' })).toBe(false);
});
+ it('shows a provider group switch as live without the held error or attempt counts', () => {
+ const presentation = getMobileAutoResumePresentation({
+ error: "You've hit your session limit",
+ attempt: 0,
+ maxAttempts: 0,
+ sessionTotal: 0,
+ groupSwitchPending: { cause: 'usage-limit' },
+ live: true,
+ });
+ expect(presentation.state).toBe('live');
+ expect(presentation.info.groupSwitchPending).toEqual({ cause: 'usage-limit' });
+ expect(presentation.info.error).toBeUndefined();
+ expect(presentation.summary).toBeUndefined();
+ expect(presentation.hasProgress).toBe(false);
+ expect(presentation.canExpand).toBe(false);
+ });
+
it('lets terminal outcomes win over a stale in-flight signal', () => {
expect(getMobileAutoResumePresentation({ ...info, outcome: 'succeeded' }, true).state).toBe('succeeded');
expect(getMobileAutoResumePresentation({ ...info, outcome: 'failed' }, true).state).toBe('failed');
diff --git a/apps/mobile/src/i18n/locales/en/message.json b/apps/mobile/src/i18n/locales/en/message.json
index 30352ae10d..91623593c7 100644
--- a/apps/mobile/src/i18n/locales/en/message.json
+++ b/apps/mobile/src/i18n/locales/en/message.json
@@ -260,6 +260,7 @@
"usageReset": "Usage reset, continued automatically",
"pending": "Reconnecting…",
"pendingWithProgress": "Reconnecting {{attempt}}/{{total}}…",
+ "groupSwitchPending": "Switching to another computer…",
"details": "Attempt {{attempt}}/{{total}} · {{count}} reconnects in this session",
"detail": {
"reason": "Interruption reason",
diff --git a/apps/mobile/src/i18n/locales/ja/message.json b/apps/mobile/src/i18n/locales/ja/message.json
index fe2fc57354..fd473b8c29 100644
--- a/apps/mobile/src/i18n/locales/ja/message.json
+++ b/apps/mobile/src/i18n/locales/ja/message.json
@@ -260,6 +260,7 @@
"usageReset": "使用量が回復したため自動で続行しました",
"pending": "再接続中…",
"pendingWithProgress": "再接続中 {{attempt}}/{{total}}…",
+ "groupSwitchPending": "別のパソコンに切り替え中…",
"details": "今回の再試行 {{attempt}}/{{total}} · このセッションでの再接続 {{count}} 回",
"detail": {
"reason": "中断の理由",
diff --git a/apps/mobile/src/i18n/locales/ko/message.json b/apps/mobile/src/i18n/locales/ko/message.json
index 4f03797bf2..b70464ce92 100644
--- a/apps/mobile/src/i18n/locales/ko/message.json
+++ b/apps/mobile/src/i18n/locales/ko/message.json
@@ -260,6 +260,7 @@
"usageReset": "사용량이 복구되어 자동으로 계속했습니다",
"pending": "다시 연결하는 중…",
"pendingWithProgress": "다시 연결하는 중 {{attempt}}/{{total}}…",
+ "groupSwitchPending": "다른 컴퓨터로 전환하는 중…",
"details": "이번 재시도 {{attempt}}/{{total}} · 이 세션에서 재연결 {{count}}회",
"detail": {
"reason": "중단 원인",
diff --git a/apps/mobile/src/i18n/locales/zh-CN/message.json b/apps/mobile/src/i18n/locales/zh-CN/message.json
index bd6dd19bb8..37389b501e 100644
--- a/apps/mobile/src/i18n/locales/zh-CN/message.json
+++ b/apps/mobile/src/i18n/locales/zh-CN/message.json
@@ -260,6 +260,7 @@
"usageReset": "用量已恢复,已自动继续",
"pending": "重新连接中…",
"pendingWithProgress": "重新连接中 {{attempt}}/{{total}}…",
+ "groupSwitchPending": "正在换一台电脑继续…",
"details": "本次重试 {{attempt}}/{{total}} · 本任务累计重连 {{count}} 次",
"detail": {
"reason": "中断原因",
diff --git a/apps/mobile/src/i18n/locales/zh-TW/message.json b/apps/mobile/src/i18n/locales/zh-TW/message.json
index 6fbb9abd27..22b93ee13c 100644
--- a/apps/mobile/src/i18n/locales/zh-TW/message.json
+++ b/apps/mobile/src/i18n/locales/zh-TW/message.json
@@ -260,6 +260,7 @@
"usageReset": "用量已恢復,已自動繼續",
"pending": "重新連線中…",
"pendingWithProgress": "重新連線中 {{attempt}}/{{total}}…",
+ "groupSwitchPending": "正在換一台電腦繼續…",
"details": "本次重試 {{attempt}}/{{total}} · 本任務累計重連 {{count}} 次",
"detail": {
"reason": "中斷原因",
diff --git a/apps/mobile/src/session/MessageRenderer.tsx b/apps/mobile/src/session/MessageRenderer.tsx
index d06d54f97c..5de7204565 100644
--- a/apps/mobile/src/session/MessageRenderer.tsx
+++ b/apps/mobile/src/session/MessageRenderer.tsx
@@ -5323,7 +5323,9 @@ function MobileAutoResumeActionRow({
);
}
- const label = info.agentSwitch
+ const label = info.groupSwitchPending
+ ? t('message.systemCard.autoResume.groupSwitchPending')
+ : info.agentSwitch
? t(`message.systemCard.autoResume.agentSwitch.${info.agentSwitch.cause}`, {
from: info.agentSwitch.from,
to: info.agentSwitch.to,
diff --git a/apps/mobile/src/session/autoResumePresentation.ts b/apps/mobile/src/session/autoResumePresentation.ts
index 72c8852881..545ea4a485 100644
--- a/apps/mobile/src/session/autoResumePresentation.ts
+++ b/apps/mobile/src/session/autoResumePresentation.ts
@@ -41,6 +41,8 @@ export interface MobileAutoResumeInfo {
agentSwitch?: MobileAutoResumeAgentSwitch;
/** 分享的人这边的自动换电脑:活动行写「已自动换一台电脑继续」。 */
groupSwitch?: MobileAutoResumeGroupSwitch;
+ /** 进行中:供应商组正在为这次失败换电脑,错误先不呈现,写「正在换一台电脑继续」。 */
+ groupSwitchPending?: MobileAutoResumeGroupSwitch;
error?: string;
attempt?: number;
maxAttempts?: number;
@@ -67,11 +69,16 @@ export function readMobileAutoResumeInfo(data?: Record<string, unknown>): Mobile
const sessionTotal = usageLimitReset ? undefined : number(data?.sessionTotal);
const agentSwitch = readAgentSwitch(data?.agentSwitch);
const groupSwitch = readGroupSwitch(data?.groupSwitch);
+ const groupSwitchPending = readGroupSwitch(data?.groupSwitchPending);
return {
...(usageLimitReset ? { usageLimitReset: true } : {}),
...(agentSwitch ? { agentSwitch } : {}),
...(groupSwitch ? { groupSwitch } : {}),
- ...(typeof data?.error === 'string' && data.error.trim() ? { error: data.error } : {}),
+ ...(groupSwitchPending ? { groupSwitchPending } : {}),
+ // 正在换电脑时错误先不呈现:行内不带原始错误。
+ ...(!groupSwitchPending && typeof data?.error === 'string' && data.error.trim()
+ ? { error: data.error }
+ : {}),
...(attempt !== undefined ? { attempt } : {}),
...(maxAttempts !== undefined ? { maxAttempts } : {}),
...(sessionTotal !== undefined ? { sessionTotal } : {}),
diff --git a/apps/mobile/src/session/systemCard.ts b/apps/mobile/src/session/systemCard.ts
index 72b6ef29f6..c2708bb340 100644
--- a/apps/mobile/src/session/systemCard.ts
+++ b/apps/mobile/src/session/systemCard.ts
@@ -183,14 +183,18 @@ function formatAutoResumeCard(data: Record<string, unknown> | undefined): System
const outcome = data?.outcome === 'succeeded' || data?.outcome === 'failed' ? data.outcome : undefined;
const hasInterruptionContext = !!(data?.live === true || error || attempt || maxAttempts || sessionTotal || outcome);
if (!hasInterruptionContext) return { title: i18n.t('message.systemCard.autoResume.separator'), rows: [] };
+ // 供应商组正在换电脑:错误先不呈现,只写「正在换一台电脑继续」。
+ const groupSwitchPending = data?.live === true && !!data.groupSwitchPending && typeof data.groupSwitchPending === 'object';
const title = data?.live === true
- ? attempt && maxAttempts
+ ? groupSwitchPending
+ ? i18n.t('message.systemCard.autoResume.groupSwitchPending')
+ : attempt && maxAttempts
? i18n.t('message.systemCard.autoResume.pendingWithProgress', { attempt, total: maxAttempts })
: i18n.t('message.systemCard.autoResume.pending')
: i18n.t(`message.systemCard.autoResume.${outcome ?? 'neutral'}`);
const subtitle = attempt && maxAttempts && sessionTotal
? i18n.t('message.systemCard.autoResume.details', { attempt, total: maxAttempts, count: sessionTotal }) : undefined;
- return { title, ...(error ? { body: error } : {}), subtitle, rows: [] };
+ return { title, ...(error && !groupSwitchPending ? { body: error } : {}), subtitle, rows: [] };
}
type AgentSwitchTranslate = (key: string, options?: Record<string, unknown>) => string;
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index ccf07fe020..90eed9a64b 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -107,6 +107,12 @@ Claude Code 终态 error 事件可带 `usageResetAt`(unix ms)。服务端无
不合法时照常显示 `usage-limit-reset` 的文案,旧客户端忽略该字段。P1 不改远程 Agent 协议:被分配到别的电脑的
任务就是普通的远程 Agent 任务。分享的人这边的自动换电脑(P2c,2026-10-10)另加可选字段 `groupSwitch: { cause }`
(不带电脑名称),Desktop 与 Mobile 显示「已自动换一台电脑继续」;旧客户端忽略,显示「用量已恢复,已自动继续」。
+换电脑期间不报错(2026-10-10):被控端判断供应商组会先试着换电脑时,输入投影里先不带这次 `error`(也不带
+`usageLimitWait`),改带 `autoResumePending`,其中新增可选字段 `groupSwitchPending: { cause }`,次数字段为 0、
+`error` 只用于控制端认出随后的终态 event 是同一次失败的回声;新 Desktop 与 Mobile 据此显示「正在换一台电脑继续」,
+并且不论哪种 Agent 都不再用这次终态 event 点亮横幅。换成了投影直接进入续跑;没换成投影恢复带 `error`。旧客户端忽略该
+字段,按普通「重新连接中」显示(不带次数);旧 Desktop 控制端对 Claude Code / Pi 仍会被终态 event 短暂点亮横幅,
+下一份投影即收回。只改投影内容,不新增 invoke 或推送通道,服务端无需改动。
## Agent 跨设备历史发现与搜索
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index ed74b481f3..20624e7b9a 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -6,6 +6,8 @@
> 2026-10-10 用户确认:分享来的组内电脑按**本账号在那台实际跑着的任务数**统计(含不经组直接用的),见 §5。
> 2026-10-10 用户确认:建组的电脑要看到组里每台在跑几个任务;本机与同账号电脑按**那台这个供应商实际在跑的任务总数**
> 统计(含自己用的、不经组的与替分享的人跑的),见 §5。
+> 2026-10-10 用户确认:**换电脑期间不报错**——组里还能换时不出错误卡、红色横幅与红点,只显示「正在换一台电脑继续」;
+> 组里都不能用才报错,见 §6.1。
> 实现进度见 §12:P1 已实现;P2 全部已实现:同账号直连与模型列表只显示组(P2a)、分享的人经组中转与启动阶段换电脑(P2b)、
> 分享的人运行中换电脑与申请弹窗新说法(P2c);P3 未实现。
> 交互设计稿见 [`docs/design-previews/provider-groups/index.html`](../design-previews/provider-groups/index.html)。
@@ -176,6 +178,13 @@
下一台:新建会话并带上交接上下文,然后继续这一轮——这一轮还没有产出就重发原消息,已经有产出就发续跑指令,
与 [用量上限自动继续](usage-limit-auto-continue.md) 的续跑口径一致。消息流里显示一行活动记录
「{原电脑} {原因},已换到 {新电脑} 继续」(受邀者那边写「已自动换一台电脑继续」,§8),不计为用户发送。
+ - **换电脑期间不报错**(2026-10-10):这次失败会先试着换电脑时(已归组、自动换电脑开着、组里还有别的电脑;
+ 受邀者那边是收到了「需要换一台」凭证),失败那一刻就不呈现:没有红色横幅、不写错误卡、不亮红点、Agent Island 不提醒,
+ 消息流末尾只有一行「正在换一台电脑继续」,输入框上方的状态同样这样写。换成了,历史里只留上面那行换电脑的活动记录
+ (原因在展开详情里);没换成(组里都不能用、交接失败、自动换电脑关着等),这时才补上错误卡与横幅,交回原有的报错与
+ 额度重置后自动继续。换电脑途中用户亲自接手时,错误卡照常补进历史(按出错的时刻排在用户新消息之前),但不再弹横幅。
+ 换电脑久久没有结局(3 分钟)时先把错误放出来,之后换成了照常续跑。出错时才纳入组的老任务(§6)判断不到,仍会先报错再换。
+ 少见的时序例外:错误早于这一轮的用户消息落库完成到达时,错误卡与红点在判断之前已经出现,换电脑期间只是不再挂横幅。
- 换过去之后任务固定在新电脑上,原电脑恢复后也不换回去(每换一次都要重新交接)。
- **何时停止**:同一轮里每台组内电脑最多试一次;全部试过仍失败才报错,并提供换模型。
其中有电脑是撞到用量上限的,按 [用量上限自动继续](usage-limit-auto-continue.md) 等恢复后自动继续