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): 组内状态以组所在电脑为准,使用方自己那边的问题不记进组里

Lizib7fe5d531b60
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 914280311b..e699551054 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -7881,8 +7881,6 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
assertAccess?.();
}
}
- // 供应商组分到的那台起来了:组里之前对它的「连不上 / 起不来」记录作废,之后照常分给它。
- if (providerGroupStart) providerGroupService?.noteStarted(providerGroupStart);
await markProjectContextIfNeeded(session.id, didInjectProjectContext);
wireSessionToIpc(session);
markOrcaMcpHydratedIfNeeded(session.id, o);
diff --git a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
index b9f0110e37..431d0d3b24 100644
--- a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
@@ -329,6 +329,17 @@ describe('resolving members quickly when choosing a computer (2026-10-11)', () =
}
});
+ it('reads the latest state instead of the short-lived cache when asked', async () => {
+ const readDeviceProviders = vi.fn(async () => [view('anthropic-1a2b3c4d', 'Claude')]);
+ const directory = createProviderGroupDirectory(deps({ listDevices: async () => [device('mini')], readDeviceProviders }));
+ const cfg: ProviderGroupConfig = { strategy: 'order', autoSwitch: true, members: [MINI] };
+ await directory.resolveMembers('anthropic', cfg);
+ await directory.resolveMembers('anthropic', cfg);
+ expect(readDeviceProviders).toHaveBeenCalledTimes(1);
+ await directory.resolveMembers('anthropic', cfg, { fresh: true });
+ expect(readDeviceProviders).toHaveBeenCalledTimes(2);
+ });
+
it('tells how long a same-account computer has been offline', async () => {
const directory = createProviderGroupDirectory(deps({
listDevices: async () => [
diff --git a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
index 2f70c57427..db6ccd7f02 100644
--- a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
@@ -31,18 +31,11 @@ function setup(picks: ProviderGroupMember[], config: ProviderGroupConfig = CONFI
view: vi.fn(),
running: vi.fn(() => 0),
markCooling: vi.fn(),
- noteFailure: vi.fn(() => 0),
coolingUntil: vi.fn(() => null),
- isAvoided: vi.fn(() => false),
- noteWorking: vi.fn(),
markTried: vi.fn(() => new Set<string>()),
triedThisTurn: vi.fn(() => new Set<string>()),
resetTurn: vi.fn(),
- } as unknown as ProviderGroupRouter & {
- pick: ReturnType<typeof vi.fn>;
- markCooling: ReturnType<typeof vi.fn>;
- noteFailure: ReturnType<typeof vi.fn>;
- };
+ } as unknown as ProviderGroupRouter & { pick: ReturnType<typeof vi.fn>; markCooling: ReturnType<typeof vi.fn> };
const externalLoad = createProviderGroupExternalLoad({ now: () => now });
const invoke = vi.fn(async () => ({}));
const relay = createProviderGroupGuestRelay({
@@ -81,23 +74,30 @@ describe('provider group guest relay planner', () => {
const env = setup([MINI, FRIEND]);
env.relay.noteStartFailure('anthropic', { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true },
new Error('[REMOTE_AGENT_PEER_TOO_OLD] old'));
- expect(env.router.noteFailure).not.toHaveBeenCalled();
+ expect(env.router.markCooling).not.toHaveBeenCalled();
expect((await env.relay.plan(PLAN))).toMatchObject({ memberKey: FRIEND.key });
env.advance(PROVIDER_GROUP_GUEST_INCAPABLE_MS + 1);
expect((await env.relay.plan(PLAN))).toMatchObject({ memberKey: MINI.key });
});
- it('records a computer that failed to start for a reason of its own', async () => {
+ it('cools a computer only for problems with its account, not when it cannot be reached', async () => {
const env = setup([MINI]);
const mini = { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true };
env.relay.noteStartFailure('anthropic', mini, new Error('prompt is too long'));
- expect(env.router.noteFailure).not.toHaveBeenCalled();
- // 只是本机连不过去:只对本机(含中转)避开。
+ // 连不上不记进组的状态(状态以组所在电脑读到的为准):下次选电脑时现读那台。
env.relay.noteStartFailure('anthropic', mini, new Error('[REMOTE_AGENT_DEVICE_UNREACHABLE] gone'));
- expect(env.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, { cause: 'unavailable', connectionLost: true });
- // 那台起不来:记给全组。
- env.relay.noteStartFailure('anthropic', mini, new Error('[REMOTE_AGENT_UNAVAILABLE] agent did not start'));
- expect(env.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, { cause: 'unavailable', connectionLost: false });
+ expect(env.router.markCooling).not.toHaveBeenCalled();
+ env.relay.noteStartFailure('anthropic', mini, new Error('401 unauthorized'));
+ expect(env.router.markCooling).toHaveBeenCalledWith('anthropic', MINI.key, expect.any(Number));
+ expect(env.router.markCooling.mock.calls[0][2]).toBeLessThan(1_000 + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS);
+ });
+
+ it('reads the latest state when choosing again after a computer did not work', async () => {
+ const env = setup([MINI, FRIEND]);
+ await env.relay.plan(PLAN);
+ expect(env.router.pick.mock.calls[0][0].fresh).toBeUndefined();
+ await env.relay.plan({ ...PLAN, exclude: new Set([MINI.key]) });
+ expect(env.router.pick.mock.calls[1][0]).toMatchObject({ fresh: true });
});
it('cools a computer whose relayed task failed mid-run for a reason of its own', () => {
@@ -105,22 +105,22 @@ describe('provider group guest relay planner', () => {
const mini = { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true };
// 换到哪台都一样的失败:不冷却,也不换。
expect(env.relay.noteRunFailure('anthropic', mini, { message: 'prompt is too long', sdkError: 'invalid_request' })).toBe(false);
- expect(env.router.noteFailure).not.toHaveBeenCalled();
+ expect(env.router.markCooling).not.toHaveBeenCalled();
expect(env.relay.noteRunFailure('anthropic', mini, { usageLimit: true, message: 'usage limit' })).toBe(true);
- expect(env.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, {
- cause: 'usage-limit', until: 1_000 + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, connectionLost: false,
- });
+ expect(env.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 1_000 + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS);
+ // 连不上:照常换一台,但不记进组的状态。
+ const cooled = env.router.markCooling.mock.calls.length;
expect(env.relay.noteRunFailure('anthropic', mini, { reason: 'remote_agent_closed' })).toBe(true);
- expect(env.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, { cause: 'unavailable', connectionLost: true });
+ expect(env.router.markCooling.mock.calls.length).toBe(cooled);
// 没有组的供应商,或那台已被移出组:不冷却、不换(成为普通的远程 Agent 任务)。
- const calls = env.router.noteFailure.mock.calls.length;
+ const calls = env.router.markCooling.mock.calls.length;
expect(env.relay.noteRunFailure('openai', mini, { usageLimit: true })).toBe(false);
expect(env.relay.noteRunFailure('anthropic', { ...mini, memberKey: 'device:gone:anthropic' }, { usageLimit: true })).toBe(false);
- expect(env.router.noteFailure.mock.calls.length).toBe(calls);
+ expect(env.router.markCooling.mock.calls.length).toBe(calls);
});
it('cools until the reported reset time, trusting it at most 8 days', () => {
- const router = { noteFailure: vi.fn() } as unknown as ProviderGroupRouter & { noteFailure: ReturnType<typeof vi.fn> };
+ const router = { markCooling: vi.fn() } as unknown as ProviderGroupRouter & { markCooling: ReturnType<typeof vi.fn> };
let resetAt = 1_000 + 3 * 60 * 60_000;
const externalLoad = createProviderGroupExternalLoad({ now: () => 1_000 });
const relay = createProviderGroupGuestRelay({
@@ -133,19 +133,17 @@ describe('provider group guest relay planner', () => {
});
const mini = { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true };
relay.noteRunFailure('anthropic', mini, { usageLimit: true });
- expect(router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, expect.objectContaining({ until: resetAt }));
+ expect(router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, resetAt);
resetAt = 1_000 + 30 * 24 * 60 * 60_000;
relay.noteRunFailure('anthropic', mini, { usageLimit: true });
- expect(router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, expect.objectContaining({
- until: 1_000 + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
- }));
+ expect(router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 1_000 + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS);
});
it('still cools the computer but offers no switch when the group has automatic switching turned off', () => {
const env = setup([MINI], { ...CONFIG, autoSwitch: false });
const mini = { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true };
expect(env.relay.noteRunFailure('anthropic', mini, { usageLimit: true, message: 'usage limit' })).toBe(false);
- expect(env.router.noteFailure).toHaveBeenCalledWith('anthropic', MINI.key, expect.objectContaining({ cause: 'usage-limit' }));
+ expect(env.router.markCooling).toHaveBeenCalledWith('anthropic', MINI.key, expect.any(Number));
});
it('counts the picked computer in the same step it is picked, when asked to', async () => {
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
index a3215a91c7..75c7122d25 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteGroup.test.ts
@@ -268,10 +268,8 @@ describe('assigning through a group on another computer', () => {
const context = await h.service.assignBeforeStart(START);
const next = await h.service.nextAfterStartFailure(context!, new Error('[REMOTE_AGENT_DEVICE_UNREACHABLE] gone'));
expect(h.remote.pick).toHaveBeenLastCalledWith(OWNER, expect.objectContaining({ exclude: [STUDIO.key] }));
- // 报给组所在电脑:只是这台连不过去,组所在电脑只让这台之后避开它,不替全组冷却那台。
- expect(h.remote.cool).toHaveBeenCalledWith(OWNER, {
- providerId: 'anthropic', memberKey: STUDIO.key, cause: 'unavailable', resetAt: null, connectionLost: true,
- });
+ // 连不上只由本机自己避开,不替全组冷却那台。
+ expect(h.remote.cool).not.toHaveBeenCalled();
expect(next?.route).toEqual({ agentDeviceId: 'share:s1', providerId: 'anthropic' });
expect(h.bindings.get('s1')).toMatchObject({ memberKey: SHARED.key, groupDeviceId: OWNER });
});
@@ -334,15 +332,13 @@ describe('switching computers within a group on another computer', () => {
expect(h.deps.fallback).not.toHaveBeenCalled();
});
- it('reports an unreachable computer so only this computer avoids it, instead of cooling it for the whole group', async () => {
+ it('only avoids an unreachable computer itself instead of cooling it for the whole group', async () => {
const h = bound({ picks: [SELF] });
await h.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
// 先等它恢复:本机现读那台(组内电脑坐标照本机的写法),重试用完才换。
expect(h.probe).toHaveBeenCalledWith('studio', STUDIO.providerId);
expect(h.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
- expect(h.remote.cool).toHaveBeenCalledWith(OWNER, expect.objectContaining({
- memberKey: STUDIO.key, cause: 'unavailable', connectionLost: true,
- }));
+ expect(h.remote.cool).not.toHaveBeenCalled();
expect(h.deps.switchAgentLocation).toHaveBeenCalledWith('s1', expect.objectContaining({ agentDeviceId: null, providerId: 'anthropic' }), expect.anything());
});
@@ -583,18 +579,14 @@ describe('old tasks already running on the group computer', () => {
});
});
-describe('a group on another computer that already knows a computer cannot be used (2026-10-11)', () => {
- function bound(options: Parameters<typeof harness>[0] = {}) {
- const h = harness({ row: { agentDeviceId: 'studio', providerId: STUDIO.providerId, sdkSessionId: 'native-1' }, ...options });
+describe('a group on another computer whose state shows a computer cannot be used (2026-10-11)', () => {
+ it('switches at once when the group computer shows the computer cooling down', async () => {
+ const h = harness({ row: { agentDeviceId: 'studio', providerId: STUDIO.providerId, sdkSessionId: 'native-1' }, view: { [STUDIO.key]: 'cooling' }, picks: [SELF] });
h.bindings.set('s1', { providerId: 'anthropic', memberKey: STUDIO.key, groupDeviceId: OWNER, at: 1 });
- return h;
- }
-
- it('switches at once when the group computer already avoids it for this computer', async () => {
- const h = bound({ view: { [STUDIO.key]: 'cooling' }, picks: [SELF] });
h.probe.mockResolvedValue('offline');
await h.service.onTurnError('s1', { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] gone' }, 3);
expect(h.deps.sleep).not.toHaveBeenCalled();
+ expect(h.remote.cool).not.toHaveBeenCalled();
expect(h.deps.switchAgentLocation).toHaveBeenCalledWith(
's1', expect.objectContaining({ agentDeviceId: null, providerId: 'anthropic' }), expect.anything(),
);
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
index 053876265e..6460a596dc 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -21,6 +21,7 @@ import type { ProviderGroupDirectory } from '../directory';
import {
createProviderGroupRouter,
PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
+ PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
type ProviderGroupPickInput,
type ProviderGroupRouter,
} from '../router';
@@ -53,10 +54,7 @@ function deps(overrides: Partial<ProviderGroupRemoteHandlerDeps> = {}) {
view: vi.fn(async () => ({ providerId: 'anthropic', config: CONFIG, members: [] })),
running: vi.fn(() => 0),
markCooling: vi.fn(),
- noteFailure: vi.fn(() => 0),
coolingUntil: vi.fn(() => null),
- isAvoided: vi.fn(() => false),
- noteWorking: vi.fn(),
markTried: vi.fn(() => new Set<string>()),
triedThisTurn: vi.fn(() => new Set<string>()),
resetTurn: vi.fn(),
@@ -84,9 +82,8 @@ describe('provider-group:remote', () => {
it('picks a computer, honouring what the caller already tried, and holds it briefly', async () => {
const d = deps();
const result = await handleProviderGroupRemote(d, 'laptop', PICK);
- // 按发问的那台电脑选:只它连不过去的组内电脑对它避开。
expect(d.router.pick).toHaveBeenCalledWith(expect.objectContaining({
- providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: new Set(['local']), reporter: 'laptop',
+ providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: new Set(['local']),
}));
expect(result).toEqual({
kind: 'member',
@@ -98,6 +95,14 @@ describe('provider-group:remote', () => {
expect(d.externalLoad.running('anthropic', MINI.key)).toBe(0);
});
+ it('reads the latest state when a computer asks again after trying some', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', { ...PICK, exclude: [] });
+ expect(d.router.pick.mock.calls[0][0].fresh).toBeUndefined();
+ await handleProviderGroupRemote(d, 'laptop', PICK);
+ expect(d.router.pick.mock.calls[1][0]).toMatchObject({ fresh: true });
+ });
+
it('answers that there is no group for providers without one or no longer open to other computers', async () => {
expect(await handleProviderGroupRemote(deps(), 'laptop', { ...PICK, providerId: 'openai' })).toEqual({ kind: 'none' });
expect(await handleProviderGroupRemote(deps({ isRemoteAllowed: () => false }), 'laptop', PICK)).toEqual({ kind: 'none' });
@@ -109,52 +114,26 @@ describe('provider-group:remote', () => {
expect(await handleProviderGroupRemote(d, 'laptop', PICK)).toEqual({ kind: 'unavailable' });
});
- it('cools computers for usage limits up to a bounded reset time, and records other failures for the whole group', async () => {
+ it('cools computers for usage limits up to a bounded reset time, and briefly for other causes', async () => {
const d = deps();
- const cool = (body: Record<string, unknown>) =>
- handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, ...body });
- await cool({ cause: 'usage-limit', resetAt: 50_000 });
- expect(d.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, {
- cause: 'usage-limit', until: 50_000, reporter: 'laptop', connectionLost: false,
- });
- await cool({ cause: 'usage-limit', resetAt: 10_000 + 365 * 86_400_000 });
- expect(d.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, expect.objectContaining({
- until: 10_000 + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
- }));
- await cool({ cause: 'usage-limit' });
- expect(d.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, expect.objectContaining({
- until: 10_000 + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
- }));
- await cool({ cause: 'auth' });
- expect(d.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, {
- cause: 'auth', reporter: 'laptop', connectionLost: false,
- });
- // 那台起不来(不是连接断了):记给全组。
- await cool({ cause: 'unavailable' });
- expect(d.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, {
- cause: 'unavailable', reporter: 'laptop', connectionLost: false,
- });
- // 只是那台电脑连不过去:只对它避开。
- await cool({ cause: 'unavailable', connectionLost: true });
- expect(d.router.noteFailure).toHaveBeenLastCalledWith('anthropic', MINI.key, {
- cause: 'unavailable', reporter: 'laptop', connectionLost: true,
- });
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'usage-limit', resetAt: 50_000 });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 50_000);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'usage-limit', resetAt: 10_000 + 365 * 86_400_000 });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 10_000 + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'usage-limit' });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 10_000 + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'auth' });
+ expect(d.router.markCooling).toHaveBeenLastCalledWith('anthropic', MINI.key, 10_000 + PROVIDER_GROUP_FAILURE_COOLDOWN_MS);
});
- it('refuses to cool computers outside the group and rejects causes it does not know', async () => {
+ it('refuses to cool computers outside the group and rejects causes it does not cool for', async () => {
const d = deps();
await handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: 'device:x:y', cause: 'auth' });
- expect(d.router.noteFailure).not.toHaveBeenCalled();
- await expect(handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'tool-error' }))
+ expect(d.router.markCooling).not.toHaveBeenCalled();
+ await expect(handleProviderGroupRemote(d, 'laptop', { action: 'cool', providerId: 'anthropic', memberKey: MINI.key, cause: 'unavailable' }))
.rejects.toThrow('[INVALID_PARAMS]');
});
- it('shows the group as the asking computer sees it', async () => {
- const d = deps();
- await handleProviderGroupRemote(d, 'laptop', { action: 'view', providerId: 'anthropic' });
- expect(d.router.view).toHaveBeenCalledWith('anthropic', { reporter: 'laptop' });
- });
-
it('counts the running tasks each computer reports and drops stale or out-of-order reports', async () => {
const d = deps();
const lease = { sessionId: 's1', providerId: 'anthropic', memberKey: MINI.key };
diff --git a/apps/desktop/src/main/provider-group/__tests__/router.failures.test.ts b/apps/desktop/src/main/provider-group/__tests__/router.failures.test.ts
deleted file mode 100644
index c2c3596ec1..0000000000
--- a/apps/desktop/src/main/provider-group/__tests__/router.failures.test.ts
+++ /dev/null
@@ -1,220 +0,0 @@
-/**
- * 组内电脑的失败所有使用方共用一份(provider-groups.md §5,2026-10-11 用户要求:选电脑第一时间选到能用的,
- * 不再每次从不能用的那台开始试;组里都确认不能用就直接说都不能用)。
- */
-import type { ProviderView } from '@cindy/model-providers';
-import { describe, expect, it, vi } from 'vitest';
-
-import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
-import type { ProviderGroupDirectory, ResolvedMemberState, ResolvedProviderGroupMember } from '../directory';
-import {
- createProviderGroupRouter,
- PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
- PROVIDER_GROUP_FAILURE_BACKOFF_MS,
- PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
- PROVIDER_GROUP_PICK_QUICK_MS,
- PROVIDER_GROUP_SUSPECT_MS,
- type ProviderGroupPersistedCooling,
-} from '../router';
-
-const MODEL = 'claude-opus-5-5';
-
-function view(id: string): ProviderView {
- return {
- id,
- name: id,
- agents: ['claude-code'],
- connected: true,
- models: { 'claude-code': [{ id: MODEL, name: MODEL, efforts: [], defaultEffort: null }] },
- routing: { 'claude-code': {} },
- } as unknown as ProviderView;
-}
-
-function member(key: string, agentDeviceId: string): ProviderGroupMember {
- return { key, kind: 'device', agentDeviceId, providerId: 'anthropic', limit: 4, weight: 1, paused: false };
-}
-
-const A = member('device:a:anthropic', 'a');
-const B = member('device:b:anthropic', 'b');
-const START = 1_000_000;
-
-function harness(options: { members?: ProviderGroupMember[]; strategy?: ProviderGroupConfig['strategy'] } = {}) {
- let now = START;
- const states = new Map<string, ResolvedMemberState>();
- const config: ProviderGroupConfig = { strategy: options.strategy ?? 'least', autoSwitch: true, members: options.members ?? [A, B] };
- let persisted: ProviderGroupPersistedCooling = {};
- const invalidate = vi.fn();
- const directory: ProviderGroupDirectory = {
- async resolveMembers(_providerId, current) {
- return current.members.map((m): ResolvedProviderGroupMember => {
- const state = states.get(m.key) ?? 'ok';
- return state === 'ok' ? { member: m, label: m.key, state, view: view(m.providerId) } : { member: m, label: m.key, state };
- });
- },
- async listCandidates() {
- return [];
- },
- async readDeviceCatalog() {
- return [];
- },
- async probe() {
- return 'ok' as const;
- },
- memberLabel: (m) => m.key,
- invalidate,
- };
- const create = () => createProviderGroupRouter({
- directory,
- readGroup: (id) => (id === 'anthropic' ? config : null),
- listBindings: () => ({}),
- isTurnRunning: () => false,
- coolingStore: {
- read: () => persisted,
- write: (value) => {
- persisted = value;
- },
- },
- now: () => now,
- random: () => 0,
- });
- const router = create();
- const pickFor = async (reporter?: string) => {
- const pick = await router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, ...(reporter ? { reporter } : {}) });
- return pick.kind === 'member' ? pick.member.key : pick.kind;
- };
- return {
- router,
- create,
- states,
- invalidate,
- pickFor,
- persisted: () => persisted,
- advance: (ms: number) => {
- now += ms;
- },
- };
-}
-
-describe('provider group failures shared by every user of the group', () => {
- it('makes everyone skip a computer once any user finds it cannot run tasks, and says so at once when none can', async () => {
- const h = harness();
- // 最少占用:两台都空,本该选 A。
- expect(await h.pickFor()).toBe(A.key);
- h.router.noteFailure('anthropic', A.key, { cause: 'unavailable', reporter: 'laptop' });
- // 本机、报告它的那台、其他同账号电脑都直接选到 B。
- expect(await h.pickFor()).toBe(B.key);
- expect(await h.pickFor('laptop')).toBe(B.key);
- expect(await h.pickFor('desktop')).toBe(B.key);
- h.router.noteFailure('anthropic', B.key, { cause: 'auth' });
- // 组里都确认不能用:直接说都不能用,不再挨个去试。
- expect(await h.pickFor()).toBe('unavailable');
- const shown = await h.router.view('anthropic');
- expect(shown.members.map((m) => [m.key, m.state, m.reason])).toEqual([
- [A.key, 'cooling', 'failed'],
- [B.key, 'cooling', 'failed'],
- ]);
- });
-
- it('only makes the reporting user skip a computer that just could not be reached from there', async () => {
- const h = harness();
- h.router.noteFailure('anthropic', A.key, { cause: 'unavailable', reporter: 'laptop', connectionLost: true });
- expect(await h.pickFor('laptop')).toBe(B.key);
- expect(await h.pickFor('desktop')).toBe(A.key);
- expect(await h.pickFor()).toBe(A.key);
- // 下次选电脑时组所在电脑现读那台:真连不上就是离线,所有使用方都会避开。
- expect(h.invalidate).toHaveBeenCalledWith('a');
- expect((await h.router.view('anthropic', { reporter: 'laptop' })).members[0]).toMatchObject({ state: 'cooling', reason: 'failed' });
- expect((await h.router.view('anthropic')).members[0]).toMatchObject({ state: 'available' });
- });
-
- it('waits longer each time the same computer fails again, and tries it only after the others while it is suspect', async () => {
- const h = harness();
- const until = h.router.noteFailure('anthropic', A.key, { cause: 'unavailable' });
- expect(until).toBe(START + PROVIDER_GROUP_FAILURE_COOLDOWN_MS);
- // 同一阵子里几个任务一起撞上:不重复加码。
- expect(h.router.noteFailure('anthropic', A.key, { cause: 'unavailable' })).toBe(until);
- h.advance(PROVIDER_GROUP_FAILURE_COOLDOWN_MS + 1);
- // 避开期过了:B 有空位时仍先选 B(最少占用下 A 的运行数一直是 0,不会总被最先选中)。
- expect(h.router.isAvoided('anthropic', A.key)).toBe(false);
- expect(await h.pickFor()).toBe(B.key);
- // 又失败一次:避开得更久。
- const again = h.router.noteFailure('anthropic', A.key, { cause: 'unavailable' });
- expect(again - (START + PROVIDER_GROUP_FAILURE_COOLDOWN_MS + 1)).toBe(PROVIDER_GROUP_FAILURE_BACKOFF_MS[1]);
- // 一阵子没再失败:照常参与分配。
- h.advance(PROVIDER_GROUP_FAILURE_BACKOFF_MS[1] + PROVIDER_GROUP_SUSPECT_MS + 1);
- expect(await h.pickFor()).toBe(A.key);
- });
-
- it('forgets a failure once the computer comes back online, or once a session opens there', async () => {
- const h = harness();
- h.router.noteFailure('anthropic', A.key, { cause: 'unavailable' });
- h.states.set(A.key, 'offline');
- expect(await h.pickFor()).toBe(B.key);
- // 重新上线:清掉,马上又能分给它。
- h.states.delete(A.key);
- expect(await h.pickFor()).toBe(A.key);
-
- h.router.noteFailure('anthropic', A.key, { cause: 'unavailable' });
- h.router.noteWorking('anthropic', A.key);
- expect(await h.pickFor()).toBe(A.key);
- // 登录失效不因打开了会话就算好了。
- h.router.noteFailure('anthropic', A.key, { cause: 'auth' });
- h.router.noteWorking('anthropic', A.key);
- expect(await h.pickFor()).toBe(B.key);
- });
-
- it('remembers usage-limit cooldowns across restarts, and nothing else', async () => {
- const h = harness();
- const resetAt = START + 3 * 60 * 60_000;
- h.router.noteFailure('anthropic', A.key, { cause: 'usage-limit', until: resetAt });
- h.router.noteFailure('anthropic', B.key, { cause: 'unavailable' });
- expect(h.persisted()).toEqual({ anthropic: { [A.key]: resetAt } });
- const restarted = h.create();
- expect(restarted.isAvoided('anthropic', A.key)).toBe(true);
- expect(restarted.isAvoided('anthropic', B.key)).toBe(false);
- const [shownA] = (await restarted.view('anthropic')).members;
- expect(shownA).toMatchObject({ state: 'cooling', coolingUntil: resetAt });
- expect(shownA.reason).toBeUndefined();
- // 拿不到重置时刻时按默认时长。
- expect(h.router.noteFailure('anthropic', B.key, { cause: 'usage-limit' })).toBe(START + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS);
- });
-
- it('asks the directory not to wait for slow computers once one that can take the task is known', async () => {
- const config: ProviderGroupConfig = { strategy: 'order', autoSwitch: true, members: [A, B] };
- const resolveMembers = vi.fn<ProviderGroupDirectory['resolveMembers']>(async () => [
- // A 到点还没读完:这次按不能用算。
- { member: A, label: 'a', state: 'offline', pending: true },
- { member: B, label: 'b', state: 'ok', view: view('anthropic') },
- ]);
- const router = createProviderGroupRouter({
- directory: {
- resolveMembers,
- listCandidates: async () => [],
- readDeviceCatalog: async () => [],
- probe: async () => 'ok' as const,
- memberLabel: (m) => m.key,
- invalidate: () => undefined,
- },
- readGroup: () => config,
- listBindings: () => ({}),
- isTurnRunning: () => false,
- now: () => START,
- random: () => 0,
- });
- const pick = await router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL });
- expect(pick).toMatchObject({ kind: 'member', member: { key: B.key } });
- const options = resolveMembers.mock.calls[0][2];
- expect(options?.quickMs).toBe(PROVIDER_GROUP_PICK_QUICK_MS);
- // 够用 = 能用、没失败过、没满。
- expect(options?.enough?.({ member: B, label: 'b', state: 'ok', view: view('anthropic') })).toBe(true);
- expect(options?.enough?.({ member: A, label: 'a', state: 'offline' })).toBe(false);
- // 没读完的那台不算「从不能用变回能用」,不会因此清掉它的失败记录。
- router.noteFailure('anthropic', A.key, { cause: 'unavailable' });
- resolveMembers.mockResolvedValueOnce([
- { member: A, label: 'a', state: 'ok', view: view('anthropic') },
- { member: B, label: 'b', state: 'ok', view: view('anthropic') },
- ]);
- await router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL });
- expect(router.isAvoided('anthropic', A.key)).toBe(true);
- });
-});
diff --git a/apps/desktop/src/main/provider-group/__tests__/router.state.test.ts b/apps/desktop/src/main/provider-group/__tests__/router.state.test.ts
new file mode 100644
index 0000000000..876d83cea7
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/router.state.test.ts
@@ -0,0 +1,101 @@
+/**
+ * 组内电脑的状态以组所在电脑为准(provider-groups.md §5,2026-10-11 用户确认):冷却落盘、重启后照样避开;
+ * 选电脑不等慢的那台;带着这一轮试过的来选时现读最新状态。
+ */
+import type { ProviderView } from '@cindy/model-providers';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
+import type { ProviderGroupDirectory, ResolvedProviderGroupMember } from '../directory';
+import {
+ createProviderGroupRouter,
+ PROVIDER_GROUP_PICK_QUICK_MS,
+ type ProviderGroupPersistedCooling,
+} from '../router';
+
+const MODEL = 'claude-opus-5-5';
+const START = 1_000_000;
+
+function view(id: string): ProviderView {
+ return {
+ id,
+ name: id,
+ agents: ['claude-code'],
+ connected: true,
+ models: { 'claude-code': [{ id: MODEL, name: MODEL, efforts: [], defaultEffort: null }] },
+ routing: { 'claude-code': {} },
+ } as unknown as ProviderView;
+}
+
+function member(key: string, agentDeviceId: string): ProviderGroupMember {
+ return { key, kind: 'device', agentDeviceId, providerId: 'anthropic', limit: 4, weight: 1, paused: false };
+}
+
+const A = member('device:a:anthropic', 'a');
+const B = member('device:b:anthropic', 'b');
+const CONFIG: ProviderGroupConfig = { strategy: 'order', autoSwitch: true, members: [A, B] };
+
+function harness(resolveMembers: ProviderGroupDirectory['resolveMembers'], persisted: { value: ProviderGroupPersistedCooling }) {
+ return createProviderGroupRouter({
+ directory: {
+ resolveMembers,
+ listCandidates: async () => [],
+ readDeviceCatalog: async () => [],
+ probe: async () => 'ok' as const,
+ memberLabel: (m) => m.key,
+ invalidate: () => undefined,
+ },
+ readGroup: (id) => (id === 'anthropic' ? CONFIG : null),
+ listBindings: () => ({}),
+ isTurnRunning: () => false,
+ coolingStore: {
+ read: () => persisted.value,
+ write: (value) => {
+ persisted.value = value;
+ },
+ },
+ now: () => START,
+ random: () => 0,
+ });
+}
+
+const bothOk = async (): Promise<ResolvedProviderGroupMember[]> => [
+ { member: A, label: 'a', state: 'ok', view: view('anthropic') },
+ { member: B, label: 'b', state: 'ok', view: view('anthropic') },
+];
+
+describe('provider group state kept by the group computer', () => {
+ it('remembers cooldowns across restarts and drops the ones that have ended', async () => {
+ const persisted = { value: {} as ProviderGroupPersistedCooling };
+ const router = harness(bothOk, persisted);
+ router.markCooling('anthropic', A.key, START + 3 * 60 * 60_000);
+ expect(persisted.value).toEqual({ anthropic: { [A.key]: START + 3 * 60 * 60_000 } });
+ const restarted = harness(bothOk, { value: { anthropic: { [A.key]: START + 60_000, [B.key]: START - 1 } } });
+ expect(restarted.coolingUntil('anthropic', A.key)).toBe(START + 60_000);
+ expect(restarted.coolingUntil('anthropic', B.key)).toBeNull();
+ expect(await restarted.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL }))
+ .toMatchObject({ kind: 'member', member: { key: B.key } });
+ });
+
+ it('does not wait for slow computers once one that can take the task is known, and reads fresh when asked', async () => {
+ const resolveMembers = vi.fn<ProviderGroupDirectory['resolveMembers']>(async () => [
+ // A 到点还没读完:这次按不能用算。
+ { member: A, label: 'a', state: 'offline', pending: true },
+ { member: B, label: 'b', state: 'ok', view: view('anthropic') },
+ ]);
+ const router = harness(resolveMembers, { value: {} });
+ expect(await router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL }))
+ .toMatchObject({ kind: 'member', member: { key: B.key } });
+ const options = resolveMembers.mock.calls[0][2];
+ expect(options?.quickMs).toBe(PROVIDER_GROUP_PICK_QUICK_MS);
+ expect(options?.fresh).toBeUndefined();
+ // 够用 = 能用、没在冷却、没满、这一轮没试过。
+ expect(options?.enough?.({ member: B, label: 'b', state: 'ok', view: view('anthropic') })).toBe(true);
+ expect(options?.enough?.({ member: A, label: 'a', state: 'offline' })).toBe(false);
+ router.markCooling('anthropic', B.key, START + 60_000);
+ expect(options?.enough?.({ member: B, label: 'b', state: 'ok', view: view('anthropic') })).toBe(false);
+
+ await router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, exclude: new Set([A.key]), fresh: true });
+ expect(resolveMembers.mock.calls[1][2]?.fresh).toBe(true);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts b/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts
index 6d78bb4d51..19ce0f52f9 100644
--- a/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts
@@ -23,18 +23,6 @@ describe('pickProviderGroupMember', () => {
expect(pickProviderGroupMember(members, 'order', { exclude: new Set(['c', 'd']) })).toBeNull();
});
- it('puts computers that failed recently behind the rest, so a computer that never takes a task is not always picked first', () => {
- // 一直接不下任务的那台运行数最少:最少占用 / 按顺序都不再先选它。
- const members = [m('broken', { suspect: true }), m('a', { running: 2 }), m('b', { running: 1 })];
- expect(pickProviderGroupMember(members, 'least')).toBe('b');
- expect(pickProviderGroupMember(members, 'order')).toBe('a');
- // 没失败过的都满了:先试有空位的那台,再不行才分给最空的。
- expect(pickProviderGroupMember([m('broken', { suspect: true }), m('a', { running: 4 })], 'least')).toBe('broken');
- expect(pickProviderGroupMember([m('broken', { suspect: true, running: 5 }), m('a', { running: 4 })], 'least')).toBe('a');
- // 只剩它时照样分给它。
- expect(pickProviderGroupMember([m('broken', { suspect: true })], 'least')).toBe('broken');
- });
-
it('least busy picks the computer running the fewest tasks, ties by list order', () => {
expect(pickProviderGroupMember([m('a', { running: 2 }), m('b', { running: 1 }), m('c', { running: 1 })], 'least')).toBe('b');
});
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 b43ca87d2d..436f2962e2 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -11,11 +11,7 @@ import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/p
import type { ProviderGroupBinding, ProviderGroupRef } from '../bindings';
import type { ProviderGroupDirectory, ResolvedMemberState, ResolvedProviderGroupMember } from '../directory';
import { createProviderGroupGuestSwitch, PROVIDER_GROUP_SWITCH_OFFER_TTL_MS } from '../guestSwitch';
-import {
- createProviderGroupRouter,
- PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
- PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
-} from '../router';
+import { createProviderGroupRouter, PROVIDER_GROUP_DEFAULT_COOLDOWN_MS } from '../router';
import {
createProviderGroupService,
PROVIDER_GROUP_PRE_SEND_FAILED_TTL_MS,
@@ -729,8 +725,7 @@ describe('waiting for a computer that cannot be reached before switching (§6.1)
await local.service.onTurnError('s1', { message: '[REMOTE_AGENT_UNAVAILABLE] gone' }, 1);
expect(local.probe).not.toHaveBeenCalled();
expect(local.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
- // 那台起不来:记给全组,之后谁选电脑都先避开它(2026-10-11)。
- expect(local.router.coolingUntil('anthropic', 'local')).not.toBeNull();
+ expect(local.router.coolingUntil('anthropic', 'local')).toBeNull();
const limited = onMini();
await limited.service.onTurnError('s1', { sdkError: 'rate_limit' }, 1, limited.hooks);
@@ -942,20 +937,14 @@ describe('beforeSend when the next computer cannot be reached from here', () =>
expect(late.deps.switchAgentLocation).toHaveBeenCalledTimes(2);
expect(late.bindings.get('s1')?.memberKey).toBe(MINI.key);
- // 下一条消息:刚等过没等回来的那台在避开期里(组里已确认用不了),不再去试、去等;避开期过了照常再试。
+ // 下一条消息发送前重新记:上一条换不过去的不带过来。
const next = coolingLocal();
next.deps.switchAgentLocation.mockRejectedValueOnce(new Error(UNREACHABLE_TARGET));
next.probe.mockResolvedValue('offline');
await next.service.beforeSend('s1');
- expect(next.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
next.service.noteUserAction('s1');
next.probe.mockResolvedValue('ok');
await next.service.beforeSend('s1');
- expect(next.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
- expect(next.deps.sleep).toHaveBeenCalledTimes(PROVIDER_GROUP_RECONNECT_MAX_ATTEMPTS);
- next.advance(PROVIDER_GROUP_FAILURE_COOLDOWN_MS + 1);
- next.service.noteUserAction('s1');
- await next.service.beforeSend('s1');
expect(next.deps.switchAgentLocation).toHaveBeenCalledTimes(2);
expect(next.bindings.get('s1')?.memberKey).toBe(MINI.key);
});
@@ -1260,7 +1249,7 @@ describe('no error while switching (mayHandleTurnError + hooks)', () => {
});
});
-describe('not waiting for a computer the group already knows cannot be used (2026-10-11)', () => {
+describe('using the state the group keeps (2026-10-11)', () => {
const UNREACHABLE = { message: '[REMOTE_AGENT_DEVICE_UNREACHABLE] unreachable' };
function onMini() {
@@ -1270,10 +1259,10 @@ describe('not waiting for a computer the group already knows cannot be used (202
return { ...h, hooks };
}
- it('switches at once when another task already found that computer unusable', async () => {
+ it('switches at once when the group state already shows that computer cooling down', async () => {
const h = onMini();
h.probe.mockResolvedValue('offline');
- h.router.noteFailure('anthropic', MINI.key, { cause: 'unavailable', connectionLost: true });
+ h.router.markCooling('anthropic', MINI.key, 2_000_000);
await h.service.onTurnError('s1', UNREACHABLE, 7, h.hooks);
expect(h.deps.sleep).not.toHaveBeenCalled();
expect(h.hooks.reconnecting).not.toHaveBeenCalled();
@@ -1308,20 +1297,16 @@ describe('not waiting for a computer the group already knows cannot be used (202
expect(h.bindings.get('s1')?.memberKey).not.toBe(MINI.key);
});
- it('sends the next new task straight to a computer that works after one failed to start', async () => {
+ it('reads the latest group state before trying the next computer, and does not record this computer\'s own problems', async () => {
const h = harness({ members: [MINI, LOCAL] });
+ const resolve = vi.spyOn(h.deps.directory, 'resolveMembers');
const first = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
expect(first?.member.key).toBe(MINI.key);
- const next = await h.service.nextAfterStartFailure(first!, new Error('[REMOTE_AGENT_UNAVAILABLE] the agent did not start'));
+ expect(resolve.mock.calls.at(-1)?.[2]?.fresh).toBeUndefined();
+ const next = await h.service.nextAfterStartFailure(first!, new Error('[REMOTE_AGENT_DEVICE_UNREACHABLE] gone'));
expect(next?.member.key).toBe('local');
- h.service.noteStarted(next!);
- // 另一个新任务:不再先去试起不来的那台。
- h.row.agentDeviceId = null;
- h.row.providerId = 'anthropic';
- const other = await h.service.assignBeforeStart({ sessionId: 's2', agentKind: 'claude-code', model: MODEL });
- expect(other?.member.key).toBe('local');
- // 那台后来起来了:它的记录作废,照常参与分配。
- h.service.noteStarted({ ...first!, sessionId: 's3' });
- expect(h.router.isAvoided('anthropic', MINI.key)).toBe(false);
+ expect(resolve.mock.calls.at(-1)?.[2]).toMatchObject({ fresh: true });
+ // 连不上是这台电脑这边的情况:不记进组的状态,别人照常能被分到那台。
+ expect(h.router.coolingUntil('anthropic', MINI.key)).toBeNull();
});
});
diff --git a/apps/desktop/src/main/provider-group/directory.ts b/apps/desktop/src/main/provider-group/directory.ts
index cfdf8a2934..1c34fe84d3 100644
--- a/apps/desktop/src/main/provider-group/directory.ts
+++ b/apps/desktop/src/main/provider-group/directory.ts
@@ -66,6 +66,8 @@ export interface ResolveMembersOptions {
*/
quickMs?: number;
enough?(resolved: ResolvedProviderGroupMember): boolean;
+ /** 不用短时缓存,现读设备列表与每台的目录(试过不行之后拉最新状态)。 */
+ fresh?: boolean;
}
const CATALOG_TTL_MS = 15_000;
@@ -247,6 +249,10 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
return {
async resolveMembers(_providerId, config, options) {
+ if (options?.fresh) {
+ devices = null;
+ for (const member of config.members) if (member.agentDeviceId) catalogs.delete(member.agentDeviceId);
+ }
const needsDevices = config.members.some((m) => m.kind === 'device');
const deviceList = needsDevices ? await readDevices().catch(() => null) : null;
const reads = config.members.map((member) => {
diff --git a/apps/desktop/src/main/provider-group/guestRelay.ts b/apps/desktop/src/main/provider-group/guestRelay.ts
index fb2e81024f..24adc940e4 100644
--- a/apps/desktop/src/main/provider-group/guestRelay.ts
+++ b/apps/desktop/src/main/provider-group/guestRelay.ts
@@ -14,9 +14,9 @@ import type { RelayRunFailure } from '../remote-agent/host/groupRelay.js';
import type { GroupRelayLoad, GroupRelayMember, RemoteAgentGroupRelayDeps } from '../remote-agent/host/runHost.js';
import type { RemoteAgentInvoke, RemoteAgentPoller } from '../remote-agent/controller/runClient.js';
import { PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS } from './remoteHandler.js';
-import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS } from './router.js';
+import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, PROVIDER_GROUP_FAILURE_COOLDOWN_MS } from './router.js';
import type { ProviderGroupOwnerScope } from './runtime.js';
-import { classifyProviderGroupSwitchCause, isProviderGroupConnectionLoss } from './switchCause.js';
+import { classifyProviderGroupSwitchCause } from './switchCause.js';
/** 同账号电脑不支持接受受邀者任务时,多久内不再试它。 */
export const PROVIDER_GROUP_GUEST_INCAPABLE_MS = 10 * 60_000;
@@ -65,6 +65,8 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
agentKind: kind as AgentKind,
model,
exclude: skip,
+ // 这一轮试过不行的再来选:现读最新状态(状态以本机为准,2026-10-11)。
+ ...(exclude.size > 0 ? { fresh: true } : {}),
// 选中的同一步就计入那台的负载:同时来的几个受邀者任务不会读到同一份负载、全落到同一台。
...(reserve ? { onPicked: (memberKey: string) => { load = scope.externalLoad.trackRelay(providerId, memberKey); } } : {}),
});
@@ -97,13 +99,14 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
return;
}
const cause = classifyProviderGroupSwitchCause({ message });
- if (!cause) return;
- // 记给全组:本机、同账号其他电脑与别的受邀者之后都先避开它;只是本机连不过去的只对本机(含中转)生效。
- deps.scope().router.noteFailure(providerId, member.memberKey, {
- cause,
- ...(cause === 'usage-limit' ? { until: deps.now() + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS } : {}),
- connectionLost: isProviderGroupConnectionLoss({ message }),
- });
+ // 连不上、起不来不记进组的状态:下次选电脑时现读那台(状态以本机读到的为准,2026-10-11)。
+ if (!cause || cause === 'unavailable') return;
+ const now = deps.now();
+ deps.scope().router.markCooling(
+ providerId,
+ member.memberKey,
+ now + (cause === 'usage-limit' ? PROVIDER_GROUP_DEFAULT_COOLDOWN_MS : PROVIDER_GROUP_FAILURE_COOLDOWN_MS),
+ );
},
noteRunFailure(providerId, member: GroupRelayMember, failure) {
@@ -119,12 +122,9 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
? (resetAt !== null && resetAt > now
? Math.min(resetAt, now + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS)
: now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS)
- : undefined;
- deps.scope().router.noteFailure(providerId, member.memberKey, {
- cause,
- ...(until !== undefined ? { until } : {}),
- connectionLost: isProviderGroupConnectionLoss(failure),
- });
+ : now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
+ // 只记那台账号的问题(用量上限、登录失效、服务繁忙);连不上不记,照常换一台。
+ if (cause !== 'unavailable') deps.scope().router.markCooling(providerId, member.memberKey, until);
// 冷却照常(之后的新任务避开它);组设置里关掉了自动换电脑时不发凭证,受邀者照现有方式看到错误(§6.1)。
return config.autoSwitch;
},
diff --git a/apps/desktop/src/main/provider-group/remoteClient.ts b/apps/desktop/src/main/provider-group/remoteClient.ts
index 8f43526808..99b6a6e11e 100644
--- a/apps/desktop/src/main/provider-group/remoteClient.ts
+++ b/apps/desktop/src/main/provider-group/remoteClient.ts
@@ -36,8 +36,6 @@ export interface ProviderGroupRemoteClient {
memberKey: string;
cause: ProviderGroupRemoteCoolCause;
resetAt?: number | null;
- /** 只是这台和那台的连接断了:组所在电脑只让这台避开它。 */
- connectionLost?: boolean;
}): Promise<void>;
leases(ownerDeviceId: string, seq: number, entries: readonly ProviderGroupRemoteLease[]): Promise<void>;
view(ownerDeviceId: string, providerId: string): Promise<ProviderGroupView>;
@@ -89,7 +87,6 @@ export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvok
memberKey: input.memberKey,
cause: input.cause,
...(typeof input.resetAt === 'number' ? { resetAt: input.resetAt } : {}),
- ...(input.connectionLost ? { connectionLost: true } : {}),
});
},
diff --git a/apps/desktop/src/main/provider-group/remoteHandler.ts b/apps/desktop/src/main/provider-group/remoteHandler.ts
index e0735abc05..368cb542c2 100644
--- a/apps/desktop/src/main/provider-group/remoteHandler.ts
+++ b/apps/desktop/src/main/provider-group/remoteHandler.ts
@@ -2,8 +2,8 @@
* 组所在电脑处理同账号其他电脑的 `provider-group:remote` 请求(docs/product-rules/provider-groups.md §4–§6)。
*
* 那台电脑上的任务选了本机的这个供应商:先来问该用组里哪台,再自己直接连过去运行;出问题时报告
- * 那台电脑(本机记给全组,之后谁选电脑都先避开它;只是它连不过去的只对它避开),运行期间报告正在跑的任务,让本机的
- * 分配看到全组真实的负载;每轮结束后报告在组里别的电脑上用掉的用量,「远程与分享」页的用量才算得全(§7)。
+ * 需要冷却的电脑,运行期间报告正在跑的任务,让本机的分配看到全组真实的负载;每轮结束后报告在组里别的电脑上
+ * 用掉的用量,「远程与分享」页的用量才算得全(§7)。
*
* 只服务同账号电脑(dispatch 已拒绝受邀者与共享任务访客),且只对仍「允许被远程调用」的供应商提供组:
* 没开放的供应商对其他电脑本来就不可见。
@@ -19,7 +19,7 @@ import {
type ProviderGroupRemoteUsageRow,
type ProviderGroupView,
} from '../../shared/providerGroup.js';
-import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS } from './router.js';
+import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, PROVIDER_GROUP_FAILURE_COOLDOWN_MS } from './router.js';
import type { ProviderGroupOwnerScope } from './runtime.js';
/** 报告来的重置时刻最多信多远(账号用量上限最长按周重置),避免一台电脑被异常时刻长期冷却。 */
@@ -97,8 +97,8 @@ export async function handleProviderGroupRemote(
agentKind: request.agentKind,
model: request.model,
exclude: new Set(request.exclude),
- // 只有那台电脑连不过去的组内电脑对它避开。
- reporter: controller,
+ // 带着这一轮试过的来问:那台电脑试过不行,本机现读最新状态再选(状态以本机为准,2026-10-11)。
+ ...(request.exclude.length > 0 ? { fresh: true } : {}),
// 选中的同一步记上临时占用:同时来的几个请求不会读到同一份负载、全落到同一台。
onPicked: (memberKey) => scope.externalLoad.recordPick(controller, request.sessionId, providerId, memberKey),
});
@@ -117,14 +117,8 @@ export async function handleProviderGroupRemote(
request.resetAt !== undefined && request.resetAt > now ? request.resetAt : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
now + PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
)
- : undefined;
- // 记给全组;只是那台电脑和它的连接断了的只对那台电脑避开(本机下次现读它,真连不上时就是离线,大家都会避开)。
- scope.router.noteFailure(request.providerId, request.memberKey, {
- cause: request.cause,
- ...(until !== undefined ? { until } : {}),
- reporter: controller,
- connectionLost: request.connectionLost === true,
- });
+ : now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
+ scope.router.markCooling(request.providerId, request.memberKey, until);
return {};
}
case 'leases':
@@ -132,8 +126,7 @@ export async function handleProviderGroupRemote(
return {};
case 'view': {
if (!deps.isRemoteAllowed(request.providerId)) return { providerId: request.providerId, config: null, members: [] };
- // 按那台电脑看:只它连不过去的组内电脑对它显示为刚才没能使用。
- return scope.router.view(request.providerId, { reporter: controller });
+ return scope.router.view(request.providerId);
}
case 'usage': {
if (!scope.isCurrent()) return {};
diff --git a/apps/desktop/src/main/provider-group/router.ts b/apps/desktop/src/main/provider-group/router.ts
index 8d9e11b61d..f53c8ad16a 100644
--- a/apps/desktop/src/main/provider-group/router.ts
+++ b/apps/desktop/src/main/provider-group/router.ts
@@ -5,61 +5,36 @@
* 分配结果写回任务记录(`sessions.agent_device_id` / `provider_id`):选中别的电脑后,这个任务就是
* 普通的远程 Agent 任务,复用现有的整条链路,不改协议。
*
- * 组内电脑的失败记在这里,所有使用方(本机任务、同账号其他电脑、分享的人)共用一份:哪个使用方试出那台不能用,
- * 之后谁选电脑都先避开它,不再每次从不能用的那台开始试(2026-10-11 用户要求)。用量上限的冷却落盘(重启后照样避开);
- * 其余失败、轮询游标与「这一轮已试过」只在本次运行内有效,重启后按组内电脑的实时状态重新判断。
+ * 组内电脑的状态以本机(组所在电脑)为准(2026-10-11 用户确认):本机读到的在线、供应商、模型、负载,加上那台账号的问题
+ * (用量上限、登录失效、服务繁忙)记下的冷却,同步给所有使用方,使用方按它筛选;使用方自己那边的问题(连不上、版本不配等)
+ * 不记进组里。状态有延迟时使用方试过不行就换下一台,带着这一轮试过的来选时本机现读最新状态。
+ *
+ * 冷却按账号落盘(coolingStore.ts),重启后照样避开;轮询游标与「这一轮已试过」只在本次运行内有效。
*/
import { findCatalogModel, isModelSelectableForNewRoute } from '@cindy/model-providers';
import type { AgentKind } from '@cindy/maker-core';
-import type { AutoResumeAgentSwitchCause } from '../../shared/agentInputQueue.js';
import type { ProviderGroupConfig, ProviderGroupMember, ProviderGroupView } from '../../shared/providerGroup.js';
import type { ProviderGroupBinding } from './bindings.js';
-import type { ProviderGroupDirectory, ResolvedMemberState, ResolvedProviderGroupMember } from './directory.js';
+import type { ProviderGroupDirectory, ResolvedProviderGroupMember } from './directory.js';
import { pickProviderGroupMember, type SchedulableMember } from './scheduler.js';
/** 撞到用量上限但拿不到重置时刻时,默认冷却多久。 */
export const PROVIDER_GROUP_DEFAULT_COOLDOWN_MS = 30 * 60_000;
-/** 连不上 / 登录失效等失败后第一次避开多久(同一台再失败时按 PROVIDER_GROUP_FAILURE_BACKOFF_MS 递增)。 */
+/** 连不上 / 登录失效等失败后,短时间内不再给它分新任务。 */
export const PROVIDER_GROUP_FAILURE_COOLDOWN_MS = 2 * 60_000;
-/** 同一台避开期过后再试又失败时,每次避开多久:2、5、15、30、60 分钟,之后都按 60 分钟。 */
-export const PROVIDER_GROUP_FAILURE_BACKOFF_MS: readonly number[] = [
- PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
- ...[5, 15, 30, 60].map((m) => m * 60_000),
-];
-/** 避开期过后多久内,仍把它排在没失败过的电脑后面:组里有别的能用就先不去试它。 */
-export const PROVIDER_GROUP_SUSPECT_MS = 30 * 60_000;
-/** 多久没再失败,连续失败的次数清零。 */
-export const PROVIDER_GROUP_FAILURE_STREAK_RESET_MS = 6 * 60 * 60_000;
-/**
- * 选电脑时等组内电脑状态的时间:到点已经有能用的电脑就不再等更慢的那几台(那几台这次按不能用算,读取照常在后台
- * 完成、留在缓存里);一台能用的都还没有时照旧等全部读完,不会因为慢就误报「都不能用」。
- */
-export const PROVIDER_GROUP_PICK_QUICK_MS = 3_000;
-/** 组所在电脑自己作为使用方(本机任务、替分享的人中转)的键;同账号其他电脑用它的设备 id。 */
-export const PROVIDER_GROUP_LOCAL_REPORTER = '\u0000self';
/**
* 「这一轮已试过」多久后作废:一轮里每台最多试一次;换过去之后正常跑了一阵再出错,算新的一轮。
*/
export const PROVIDER_GROUP_TURN_WINDOW_MS = 30 * 60_000;
-/** 防止异常对端无限占内存的边界,远高于实际同账号电脑数。 */
-const MAX_REPORTERS = 256;
-
-export interface ProviderGroupFailureNote {
- cause: AutoResumeAgentSwitchCause;
- /** 用量上限冷却到何时(调用方按重置时刻算好);不给按默认时长。其余原因忽略。 */
- until?: number | null;
- /** 哪个使用方遇到的;不给 = 组所在电脑自己。 */
- reporter?: string;
- /**
- * 只是这个使用方和那台的连接断了(断线、不响应):只对它生效——可能只是它连不过去。那台真连不上时,组所在电脑
- * 读它的状态本来就是离线,所有使用方都会避开。
- */
- connectionLost?: boolean;
-}
+/**
+ * 选电脑时等组内电脑状态的时间:到点已经有一台能接的就不再等更慢的那几台(那几台这次按不能用算,读取照常在后台
+ * 完成、留在缓存里);一台能接的都还没有时照旧等全部读完,不会因为慢就误报都不能用。
+ */
+export const PROVIDER_GROUP_PICK_QUICK_MS = 3_000;
-/** 落盘的用量上限冷却:供应商 → 组内电脑 → 冷却到何时(unix ms)。 */
+/** 落盘的冷却:供应商 → 组内电脑 → 冷却到何时(unix ms)。 */
export type ProviderGroupPersistedCooling = Record<string, Record<string, number>>;
export interface ProviderGroupRouterDeps {
@@ -73,7 +48,7 @@ export interface ProviderGroupRouterDeps {
* 不提供 = 只算本机任务。
*/
externalRunning?(providerId: string, memberKey: string): number;
- /** 用量上限冷却的落盘位置;不提供 = 只在本次运行内有效。 */
+ /** 冷却的落盘位置;不提供 = 只在本次运行内有效。 */
coolingStore?: {
read(): ProviderGroupPersistedCooling;
write(value: ProviderGroupPersistedCooling): void;
@@ -87,8 +62,8 @@ export interface ProviderGroupPickInput {
agentKind: AgentKind;
model: string;
exclude?: ReadonlySet<string>;
- /** 替哪个使用方选(只它连不过去的电脑对它避开);不给 = 组所在电脑自己。 */
- reporter?: string;
+ /** 现读组内电脑的最新状态,不用短时缓存(试过不行、带着这一轮试过的来选时)。 */
+ fresh?: boolean;
/**
* 选中后在同一步(读负载与选电脑之间没有等待)调用,用来立即记上占用:同时来的几个请求各自读到前一个的
* 占用,不会全落到同一台。
@@ -103,25 +78,11 @@ export type ProviderGroupPickResult =
export interface ProviderGroupRouter {
pick(input: ProviderGroupPickInput): Promise<ProviderGroupPickResult>;
- /** `reporter`:按哪个使用方看(只它连不过去的电脑对它显示为刚才没能使用);不给 = 组所在电脑自己。 */
- view(providerId: string, options?: { reporter?: string }): Promise<ProviderGroupView>;
+ view(providerId: string): Promise<ProviderGroupView>;
/** 经本组分到这台、正在运行的任务数。 */
running(providerId: string, memberKey: string): number;
markCooling(providerId: string, memberKey: string, until: number): void;
- /**
- * 记一次这台的失败(§5):之后所有使用方选电脑都先避开它。用量上限冷却到重置时刻;其余原因(连不上、登录失效、
- * 服务繁忙、Agent 起不来)按同一台连续失败的次数递增避开,那台重新上线或恢复可用时清掉。返回避开到何时。
- */
- noteFailure(providerId: string, memberKey: string, failure: ProviderGroupFailureNote): number;
- /** 这台对这个使用方避开到何时(冷却或刚失败过);没在避开返回 null。 */
- coolingUntil(providerId: string, memberKey: string, reporter?: string): number | null;
- /** 组里已经知道这台现在用不了(冷却中、刚失败过还在避开期):确认用不了的不再等它恢复(§6.1)。 */
- isAvoided(providerId: string, memberKey: string, reporter?: string): boolean;
- /**
- * 刚在这台上打开了会话(换过去、启动成功):它连得上、起得来,清掉这个使用方连不过去的记录与全组的「连不上 / 起不来」
- * 记录。登录失效、服务繁忙不清(打开会话不说明它们好了),用量上限的冷却也不动。
- */
- noteWorking(providerId: string, memberKey: string, reporter?: string): void;
+ coolingUntil(providerId: string, memberKey: string): number | null;
/** 记一次「这一轮试过这台」,返回这一轮已试过的全部。 */
markTried(sessionId: string, memberKey: string): ReadonlySet<string>;
triedThisTurn(sessionId: string): ReadonlySet<string>;
@@ -129,47 +90,20 @@ export interface ProviderGroupRouter {
resetTurn(sessionId: string): void;
}
-/** 一台电脑的失败记录:连续失败几次、避开到何时、最近一次失败的时间与原因。 */
-interface FailureRecord {
- streak: number;
- until: number;
- at: number;
- cause: AutoResumeAgentSwitchCause;
-}
-
function coolKey(providerId: string, memberKey: string): string {
return `${providerId}\u0000${memberKey}`;
}
-function backoffMs(streak: number): number {
- const steps = PROVIDER_GROUP_FAILURE_BACKOFF_MS;
- return steps[Math.min(streak, steps.length) - 1];
-}
-
export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): ProviderGroupRouter {
- /** 用量上限:冷却到重置时刻。 */
const cooling = new Map<string, number>();
- /** 其余失败,对所有使用方生效。 */
- const failures = new Map<string, FailureRecord>();
- /** 只是某个使用方连不过去:只对它生效。 */
- const reporterFailures = new Map<string, Map<string, FailureRecord>>();
- /** 上一次读到的组内电脑状态:从不能用变回能用时清掉失败记录。 */
- const lastStates = new Map<string, ResolvedMemberState>();
- const lastPicked = new Map<string, string>();
- const tried = new Map<string, { at: number; keys: Set<string> }>();
-
- for (const [providerId, members] of Object.entries(readPersistedCooling())) {
- for (const [memberKey, until] of Object.entries(members)) {
- if (until > deps.now()) cooling.set(coolKey(providerId, memberKey), until);
- }
- }
-
- function readPersistedCooling(): ProviderGroupPersistedCooling {
- try {
- return deps.coolingStore?.read() ?? {};
- } catch {
- return {};
+ try {
+ for (const [providerId, members] of Object.entries(deps.coolingStore?.read() ?? {})) {
+ for (const [memberKey, until] of Object.entries(members)) {
+ if (until > deps.now()) cooling.set(coolKey(providerId, memberKey), until);
+ }
}
+ } catch {
+ // 读不到落盘的冷却:按没有冷却开始,之后撞上的照常记。
}
function persistCooling(): void {
@@ -179,8 +113,7 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
for (const [key, until] of cooling) {
if (until <= now) continue;
const split = key.indexOf('\u0000');
- const providerId = key.slice(0, split);
- (value[providerId] ??= {})[key.slice(split + 1)] = until;
+ (value[key.slice(0, split)] ??= {})[key.slice(split + 1)] = until;
}
try {
deps.coolingStore.write(value);
@@ -189,6 +122,9 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
}
}
+ const lastPicked = new Map<string, string>();
+ const tried = new Map<string, { at: number; keys: Set<string> }>();
+
function currentTried(sessionId: string): Set<string> | null {
const entry = tried.get(sessionId);
if (!entry) return null;
@@ -199,7 +135,8 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
return entry.keys;
}
- function usageCoolingUntil(key: string): number | null {
+ function coolingUntil(providerId: string, memberKey: string): number | null {
+ const key = coolKey(providerId, memberKey);
const until = cooling.get(key);
if (until === undefined) return null;
if (until <= deps.now()) {
@@ -209,90 +146,6 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
return until;
}
- /** 这台对这个使用方的失败记录(全组的与只对它的);过了清零期的丢掉。 */
- function failureRecords(key: string, reporter: string): FailureRecord[] {
- const now = deps.now();
- const records: FailureRecord[] = [];
- const global = failures.get(key);
- if (global) {
- if (now - global.at > PROVIDER_GROUP_FAILURE_STREAK_RESET_MS) failures.delete(key);
- else records.push(global);
- }
- const own = reporterFailures.get(reporter)?.get(key);
- if (own) {
- if (now - own.at > PROVIDER_GROUP_FAILURE_STREAK_RESET_MS) reporterFailures.get(reporter)!.delete(key);
- else records.push(own);
- }
- return records;
- }
-
- /** 失败后的避开期还没过:到何时。 */
- function failureUntil(key: string, reporter: string): number | null {
- const now = deps.now();
- let until: number | null = null;
- for (const record of failureRecords(key, reporter)) {
- if (record.until > now && (until === null || record.until > until)) until = record.until;
- }
- return until;
- }
-
- /** 避开期过了不久(PROVIDER_GROUP_SUSPECT_MS 内):有没失败过的电脑能用时先不去试它。 */
- function isSuspect(key: string, reporter: string): boolean {
- const now = deps.now();
- return failureRecords(key, reporter).some((record) => record.until <= now && now - record.until < PROVIDER_GROUP_SUSPECT_MS);
- }
-
- function coolingUntil(providerId: string, memberKey: string, reporter = PROVIDER_GROUP_LOCAL_REPORTER): number | null {
- const key = coolKey(providerId, memberKey);
- const usage = usageCoolingUntil(key);
- const failed = failureUntil(key, reporter);
- if (usage === null) return failed;
- return failed === null ? usage : Math.max(usage, failed);
- }
-
- /** 同一阵子里的失败(几个任务一起撞上)不重复加码;避开期过后再试又失败才算连续失败多一次。 */
- function nextFailure(previous: FailureRecord | undefined, cause: AutoResumeAgentSwitchCause): FailureRecord {
- const now = deps.now();
- if (previous && previous.until > now) return { ...previous, at: now, cause };
- const streak = previous && now - previous.at <= PROVIDER_GROUP_FAILURE_STREAK_RESET_MS ? previous.streak + 1 : 1;
- return { streak, until: now + backoffMs(streak), at: now, cause };
- }
-
- function reporterMap(reporter: string): Map<string, FailureRecord> {
- let map = reporterFailures.get(reporter);
- if (map) return map;
- if (reporterFailures.size >= MAX_REPORTERS) {
- // 淘汰最久没有新失败的一个使用方。
- let oldest: string | null = null;
- let oldestAt = Infinity;
- for (const [candidate, records] of reporterFailures) {
- const latest = Math.max(0, ...[...records.values()].map((r) => r.at));
- if (latest < oldestAt) {
- oldestAt = latest;
- oldest = candidate;
- }
- }
- if (oldest !== null) reporterFailures.delete(oldest);
- }
- map = new Map();
- reporterFailures.set(reporter, map);
- return map;
- }
-
- /** 读到组内电脑的状态:从不能用(离线、供应商关掉等)变回能用说明它恢复了,失败记录清掉。用量上限冷却不受影响。 */
- function observe(providerId: string, resolved: readonly ResolvedProviderGroupMember[]): void {
- for (const r of resolved) {
- if (r.pending) continue;
- const key = coolKey(providerId, r.member.key);
- const previous = lastStates.get(key);
- if (previous !== undefined && previous !== 'ok' && r.state === 'ok') {
- failures.delete(key);
- for (const records of reporterFailures.values()) records.delete(key);
- }
- lastStates.set(key, r.state);
- }
- }
-
function running(providerId: string, memberKey: string): number {
let count = 0;
for (const [sessionId, binding] of Object.entries(deps.listBindings())) {
@@ -324,24 +177,21 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
async pick(input) {
const config = deps.readGroup(input.providerId);
if (!config) return { kind: 'none' };
- const reporter = input.reporter ?? PROVIDER_GROUP_LOCAL_REPORTER;
const usable = (r: ResolvedProviderGroupMember) =>
- offersModel(r, input.agentKind, input.model) && coolingUntil(input.providerId, r.member.key, reporter) === null;
+ offersModel(r, input.agentKind, input.model) && coolingUntil(input.providerId, r.member.key) === null;
const resolved = await deps.directory.resolveMembers(input.providerId, config, {
quickMs: PROVIDER_GROUP_PICK_QUICK_MS,
- // 已经有一台没失败过、没满、可以分的电脑:不再等慢的那几台。
+ // 已经有一台能用、没满、可以分的电脑:不再等慢的那几台。
enough: (r) => usable(r)
&& !r.member.paused
&& !input.exclude?.has(r.member.key)
- && !isSuspect(coolKey(input.providerId, r.member.key), reporter)
&& memberRunning(input.providerId, r) < r.member.limit,
+ ...(input.fresh ? { fresh: true } : {}),
});
- observe(input.providerId, resolved);
const schedulable: SchedulableMember[] = resolved.map((r) => ({
key: r.member.key,
usable: usable(r),
paused: r.member.paused,
- suspect: isSuspect(coolKey(input.providerId, r.member.key), reporter),
running: memberRunning(input.providerId, r),
limit: r.member.limit,
weight: r.member.weight,
@@ -358,20 +208,15 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
return { kind: 'member', member: chosen.member, label: chosen.label, resolved };
},
- async view(providerId, options) {
+ async view(providerId) {
const config = deps.readGroup(providerId);
if (!config) return { providerId, config: null, members: [] };
- const reporter = options?.reporter ?? PROVIDER_GROUP_LOCAL_REPORTER;
const resolved = await deps.directory.resolveMembers(providerId, config);
- observe(providerId, resolved);
return {
providerId,
config,
members: resolved.map((r) => {
- const key = coolKey(providerId, r.member.key);
- const until = coolingUntil(providerId, r.member.key, reporter);
- // 避开期比用量上限的冷却还长(或只有失败记录):写「刚才没能使用」,不写用量冷却。
- const failed = until !== null && failureUntil(key, reporter) === until;
+ const until = coolingUntil(providerId, r.member.key);
const count = memberRunning(providerId, r);
const state = r.member.paused
? 'paused' as const
@@ -382,14 +227,13 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
: count >= r.member.limit
? 'full' as const
: 'available' as const;
- const reason = r.reason ?? (state === 'cooling' && failed ? 'failed' as const : undefined);
return {
key: r.member.key,
kind: r.member.kind,
label: r.label,
...(r.ownerName ? { ownerName: r.ownerName } : {}),
state,
- ...(reason ? { reason } : {}),
+ ...(r.reason ? { reason: r.reason } : {}),
running: count,
limit: r.member.limit,
weight: r.member.weight,
@@ -408,43 +252,8 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
persistCooling();
},
- noteFailure(providerId, memberKey, failure) {
- const now = deps.now();
- const key = coolKey(providerId, memberKey);
- if (failure.cause === 'usage-limit') {
- const until = typeof failure.until === 'number' && failure.until > now
- ? failure.until
- : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS;
- cooling.set(key, Math.max(cooling.get(key) ?? 0, until));
- persistCooling();
- return cooling.get(key)!;
- }
- if (failure.connectionLost) {
- const records = reporterMap(failure.reporter ?? PROVIDER_GROUP_LOCAL_REPORTER);
- const record = nextFailure(records.get(key), failure.cause);
- records.set(key, record);
- // 下次选电脑时组所在电脑现读那台:真连不上就是离线,所有使用方都会避开。
- const agentDeviceId = deps.readGroup(providerId)?.members.find((m) => m.key === memberKey)?.agentDeviceId;
- if (agentDeviceId) deps.directory.invalidate(agentDeviceId);
- return record.until;
- }
- const record = nextFailure(failures.get(key), failure.cause);
- failures.set(key, record);
- return record.until;
- },
-
coolingUntil,
- isAvoided(providerId, memberKey, reporter) {
- return coolingUntil(providerId, memberKey, reporter) !== null;
- },
-
- noteWorking(providerId, memberKey, reporter = PROVIDER_GROUP_LOCAL_REPORTER) {
- const key = coolKey(providerId, memberKey);
- reporterFailures.get(reporter)?.delete(key);
- if (failures.get(key)?.cause === 'unavailable') failures.delete(key);
- },
-
markTried(sessionId, memberKey) {
const keys = currentTried(sessionId) ?? new Set<string>();
keys.add(memberKey);
diff --git a/apps/desktop/src/main/provider-group/runtime.ts b/apps/desktop/src/main/provider-group/runtime.ts
index e18c37efe0..694d820758 100644
--- a/apps/desktop/src/main/provider-group/runtime.ts
+++ b/apps/desktop/src/main/provider-group/runtime.ts
@@ -3,7 +3,7 @@
* 这样设置页看到的「正在运行 / 冷却中」与实际分配一致。
*
* 目录缓存、冷却、轮询位置都属于当前账号:换账号后另起一份,旧账号还在路上的远端读取只落进旧的那份,
- * 新账号看不到旧账号的电脑与冷却。用量上限的冷却按账号落盘(coolingStore.ts),新起的那份先读回来。
+ * 新账号看不到旧账号的电脑与冷却。冷却按账号落盘(coolingStore.ts),新起的那份先读回来。
* 调用方拿到的是固定的门面,每次调用按当前账号转发。
*/
import type { ProviderView } from '@cindy/model-providers';
@@ -85,14 +85,10 @@ const directoryFacade: ProviderGroupDirectory = {
const routerFacade: ProviderGroupRouter = {
pick: (input) => runtimeForActiveOwner().router.pick(input),
- view: (providerId, options) => runtimeForActiveOwner().router.view(providerId, options),
+ view: (providerId) => runtimeForActiveOwner().router.view(providerId),
running: (providerId, memberKey) => runtimeForActiveOwner().router.running(providerId, memberKey),
markCooling: (providerId, memberKey, until) => runtimeForActiveOwner().router.markCooling(providerId, memberKey, until),
- noteFailure: (providerId, memberKey, failure) => runtimeForActiveOwner().router.noteFailure(providerId, memberKey, failure),
- coolingUntil: (providerId, memberKey, reporter) =>
- runtimeForActiveOwner().router.coolingUntil(providerId, memberKey, reporter),
- isAvoided: (providerId, memberKey, reporter) => runtimeForActiveOwner().router.isAvoided(providerId, memberKey, reporter),
- noteWorking: (providerId, memberKey, reporter) => runtimeForActiveOwner().router.noteWorking(providerId, memberKey, reporter),
+ coolingUntil: (providerId, memberKey) => runtimeForActiveOwner().router.coolingUntil(providerId, memberKey),
markTried: (sessionId, memberKey) => runtimeForActiveOwner().router.markTried(sessionId, memberKey),
triedThisTurn: (sessionId) => runtimeForActiveOwner().router.triedThisTurn(sessionId),
resetTurn: (sessionId) => runtimeForActiveOwner().router.resetTurn(sessionId),
diff --git a/apps/desktop/src/main/provider-group/scheduler.ts b/apps/desktop/src/main/provider-group/scheduler.ts
index 352e6325aa..96becdd3ab 100644
--- a/apps/desktop/src/main/provider-group/scheduler.ts
+++ b/apps/desktop/src/main/provider-group/scheduler.ts
@@ -8,8 +8,6 @@ export interface SchedulableMember {
/** 在线、供应商可用、提供所选模型、不在冷却中。 */
usable: boolean;
paused: boolean;
- /** 最近失败过、避开期刚过:没失败过的电脑能接时先不分给它。 */
- suspect?: boolean;
running: number;
limit: number;
weight: number;
@@ -26,8 +24,7 @@ export interface PickOptions {
/**
* 只分给可用、未暂停、没试过的电脑;优先未满载的,都满了时分给相对最空的一台(并发上限只用来
- * 分摊,不因满载拒绝用户的消息)。最近失败过的排在没失败过的后面:没失败过的有空位时不先去试它们,
- * 不会因为它们一直接不下任务、运行数最少就总被最先选中。没有可分的电脑返回 null。
+ * 分摊,不因满载拒绝用户的消息)。没有可分的电脑返回 null。
*/
export function pickProviderGroupMember(
members: readonly SchedulableMember[],
@@ -36,10 +33,8 @@ export function pickProviderGroupMember(
): string | null {
const eligible = members.filter((m) => m.usable && !m.paused && !options.exclude?.has(m.key));
if (eligible.length === 0) return null;
- const clean = eligible.filter((m) => !m.suspect);
- const cleanOpen = clean.filter((m) => m.running < m.limit);
- const open = cleanOpen.length > 0 ? cleanOpen : eligible.filter((m) => m.running < m.limit);
- if (open.length === 0) return leastBusy(clean.length > 0 ? clean : eligible).key;
+ const open = eligible.filter((m) => m.running < m.limit);
+ if (open.length === 0) return leastBusy(eligible).key;
switch (strategy) {
case 'order':
return open[0].key;
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index 639ad35413..a379afe8a1 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -44,7 +44,7 @@ import type { ProviderGroupDirectory } from './directory.js';
import type { ProviderGroupGuestSwitch } from './guestSwitch.js';
import {
PROVIDER_GROUP_DEFAULT_COOLDOWN_MS,
- PROVIDER_GROUP_LOCAL_REPORTER,
+ PROVIDER_GROUP_FAILURE_COOLDOWN_MS,
PROVIDER_GROUP_TURN_WINDOW_MS,
type ProviderGroupRouter,
} from './router.js';
@@ -120,8 +120,6 @@ export interface ProviderGroupRemoteGroups {
memberKey: string;
cause: ProviderGroupRemoteCoolCause;
resetAt: number | null;
- /** 只是这台电脑和那台的连接断了:组所在电脑只让这台避开它。 */
- connectionLost?: boolean;
}): Promise<void>;
view(ownerDeviceId: string, providerId: string): Promise<ProviderGroupView>;
/** 忘掉组所在电脑目录的缓存(组员失败后下次现读)。 */
@@ -219,8 +217,6 @@ export interface ProviderGroupService {
}): Promise<ProviderGroupStartContext | null>;
/** 分配后 Agent 没能启动:换下一台,返回新的位置;不该换或没有下一台返回 null(调用方照常报错)。 */
nextAfterStartFailure(context: ProviderGroupStartContext, error: unknown): Promise<ProviderGroupStartContext | null>;
- /** 分配后 Agent 在那台起来了:它连得上、起得来,清掉组里对它的这类失败记录(§5)。 */
- noteStarted(context: ProviderGroupStartContext): void;
/**
* 纯判定(同步、无副作用):这次终态错误会不会先由本机制试着换电脑。为 true 时输入协调器先不呈现这次错误
* (红横幅与错误卡):换成了就不出现,没换成再补出来(§6.1)。只看手上现成的:认得出的原因,加上已归组
@@ -330,15 +326,9 @@ interface GroupSource {
model: string;
exclude: ReadonlySet<string>;
}): Promise<SourcePick>;
- /**
- * 记一次这台的失败,之后所有使用方选电脑都先避开它(§5);`connectionLost` = 只是这台电脑和它的连接断了,
- * 只对这台电脑生效(那台真连不上时组所在电脑读它就是离线,所有使用方都会避开)。
- */
- cool(providerId: string, memberKey: string, cause: ProviderGroupSwitchCause, resetAt: number | null, connectionLost?: boolean): void;
- /** 组里已经知道这台现在用不了(冷却中、刚失败过还在避开期)。 */
+ cool(providerId: string, memberKey: string, cause: ProviderGroupSwitchCause, resetAt: number | null): void;
+ /** 组的状态里这台现在冷却中(组所在电脑记着它账号的问题)。 */
isKnownDown(providerId: string, memberKey: string): Promise<boolean>;
- /** 刚在这台上打开了会话(换过去、启动成功):它连得上、起得来,清掉这类失败记录。 */
- noteWorking(providerId: string, memberKey: string): void;
/** 发送前:这台现在该不该换掉;null = 读不到,照常发送。 */
shouldMoveAway(providerId: string, config: ProviderGroupConfig, memberKey: string): Promise<{ reason: string } | false | null>;
invalidate(member: ProviderGroupMember): void;
@@ -349,38 +339,31 @@ interface GroupSource {
}
/**
- * 一趟换电脑里因这台电脑连不上而跳过的组内电脑(§6.1):组里只剩它们时挨个等它恢复再试。等回来的那台直接再试一次
- * ——组里对它的避开是这一趟刚记下的,按组的选法不会再选到它;再换不过去就重新记下(等的次数按电脑计,不会无休止地
- * 来回试)。`fallbackLabel`:等回来的那台没在这一趟的选择结果里出现过时的称呼。
+ * 一趟换电脑里因这台电脑连不上而跳过的组内电脑(§6.1):组里只剩它们时挨个等它恢复再试。等回来的那台从这一轮
+ * 试过的名单里放出来、可以再被选中;再换不过去就重新记下(等的次数按电脑计,不会无休止地来回试)。
*/
-function createSkippedTargets(fallbackLabel: (member: ProviderGroupMember) => string) {
+function createSkippedTargets() {
const waiting: ProviderGroupMember[] = [];
- const labels = new Map<string, string>();
- let comeBack: ProviderGroupMember | null = null;
+ const retrying = new Set<string>();
return {
- /** 这一次换到哪台:等回来的那台直接再试,否则按组的选法选。 */
- async pick(choose: () => Promise<SourcePick>): Promise<SourcePick> {
- const member = comeBack;
- comeBack = null;
- if (member) {
- return { kind: 'member', member, label: labels.get(member.key) ?? fallbackLabel(member), labelOf: () => undefined };
- }
- const pick = await choose();
- if (pick.kind === 'member') labels.set(pick.member.key, pick.label);
- return pick;
+ /** 选电脑时排除的:这一轮试过的,去掉等回来、可以再试的。 */
+ exclusion(base: Set<string>): Set<string> {
+ for (const key of retrying) base.delete(key);
+ return base;
},
/** 换过去失败:连不上的记下,组里只剩它们时再等。 */
failed(member: ProviderGroupMember, unreachable: boolean): void {
+ retrying.delete(member.key);
if (unreachable && !waiting.some((m) => m.key === member.key)) waiting.push(member);
},
- /** 挨个等记下的电脑恢复(后跳过的先等),等回来一台就返回 true,下一次直接再试它。 */
+ /** 挨个等记下的电脑恢复(后跳过的先等),等回来一台就返回 true。 */
async awaitAny(
awaitOne: (member: ProviderGroupMember) => Promise<boolean>,
isCurrent: () => boolean,
): Promise<boolean> {
for (let member = waiting.pop(); member && isCurrent(); member = waiting.pop()) {
if (await awaitOne(member)) {
- comeBack = member;
+ retrying.add(member.key);
return true;
}
}
@@ -463,9 +446,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
connectionLost?: boolean;
/** 发送被停止:退避与现读都立刻停下。 */
signal?: AbortSignal;
- /**
- * 组里已经确认这台用不了(别的使用方刚试过、冷却中、离线已久):不等,直接 `gone`。只在确实连不上、要开始等时问。
- */
+ /** 已经确认这台用不了(组的状态里冷却中、离线已久):不等,直接 `gone`。只在确实连不上、要开始等时问。 */
knownDown?: () => Promise<boolean>;
},
): Promise<ReturnOutcome> {
@@ -547,9 +528,9 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
}
/**
- * 组里已经确认这台用不了,不用等它恢复(2026-10-11 用户确认):组里记着它冷却中或刚失败过还在避开期(别的任务、
- * 同账号其他电脑或分享的人刚试过),或同账号那台离线已经超过 PROVIDER_GROUP_RECENT_DROP_MS。读不到的都按不知道,
- * 照旧先等——刚断开的可能马上恢复。组读不到时 `source` 为 null,只看离线多久。
+ * 已经确认这台用不了,不用等它恢复(2026-10-11 用户确认:确认用不了的直接换,只有刚断开的才先等):组的状态里它
+ * 冷却中(组所在电脑记着它账号的问题),或同账号那台离线已经超过 PROVIDER_GROUP_RECENT_DROP_MS。读不到的按不知道,
+ * 照旧先等。组读不到时 `source` 为 null,只看离线多久。
*/
async function knownDown(
source: GroupSource | null,
@@ -586,10 +567,11 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
};
}
- /** 用量上限冷却到何时:报错里的重置时刻,取不到按默认时长。 */
- function usageCoolUntil(resetAt: number | null): number {
+ function coolUntil(cause: ProviderGroupSwitchCause, resetAt: number | null): number {
const now = deps.now();
- return resetAt !== null && resetAt > now ? resetAt : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS;
+ return cause === 'usage-limit'
+ ? (resetAt !== null && resetAt > now ? resetAt : now + PROVIDER_GROUP_DEFAULT_COOLDOWN_MS)
+ : now + PROVIDER_GROUP_FAILURE_COOLDOWN_MS;
}
const localSource: GroupSource = {
@@ -598,7 +580,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return deps.readGroup(providerId);
},
async pick({ providerId, agentKind, model, exclude }) {
- const pick = await router.pick({ providerId, agentKind, model, exclude });
+ // 带着这一轮试过的来选:试过不行说明状态可能旧了,现读最新状态再选。
+ const pick = await router.pick({ providerId, agentKind, model, exclude, ...(exclude.size > 0 ? { fresh: true } : {}) });
if (pick.kind !== 'member') return { kind: pick.kind };
return {
kind: 'member',
@@ -610,21 +593,14 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
},
};
},
- cool(providerId, memberKey, cause, resetAt, connectionLost) {
- // 记给全组:之后本机、同账号其他电脑与分享的人选电脑都先避开它。只是本机和它的连接断了的只对本机(含替分享的人
- // 中转)生效;它真连不上时,下次读它的状态就是离线,所有使用方都会避开。
- router.noteFailure(providerId, memberKey, {
- cause,
- ...(cause === 'usage-limit' ? { until: usageCoolUntil(resetAt) } : {}),
- reporter: PROVIDER_GROUP_LOCAL_REPORTER,
- connectionLost: connectionLost === true,
- });
+ cool(providerId, memberKey, cause, resetAt) {
+ // 连不上只在这一轮避开,不把本机的连接故障扩散成后续全局冷却;
+ // 其它原因(额度、登录、过载)仍按组的冷却策略处理。
+ if (cause === 'unavailable') return;
+ router.markCooling(providerId, memberKey, coolUntil(cause, resetAt));
},
async isKnownDown(providerId, memberKey) {
- return router.isAvoided(providerId, memberKey, PROVIDER_GROUP_LOCAL_REPORTER);
- },
- noteWorking(providerId, memberKey) {
- router.noteWorking(providerId, memberKey, PROVIDER_GROUP_LOCAL_REPORTER);
+ return router.coolingUntil(providerId, memberKey) !== null;
},
async shouldMoveAway(providerId, config, memberKey) {
const resolved = await withTimeout(deps.directory.resolveMembers(providerId, config), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
@@ -680,16 +656,10 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
?? { ...pick.member, limit: 1, weight: 1, paused: false };
return { kind: 'member', member, label: pick.label, labelOf };
},
- cool(providerId, memberKey, cause, resetAt, connectionLost) {
- // 报给组所在电脑记给全组;只是这台连不过去的(connectionLost),组所在电脑只让这台避开它。旧版本组所在电脑不收
- // 「连不上」,只在这一轮避开。
- void remote.cool(ownerDeviceId, {
- providerId,
- memberKey,
- cause,
- resetAt,
- ...(connectionLost ? { connectionLost: true } : {}),
- }).catch((error) => {
+ cool(providerId, memberKey, cause, resetAt) {
+ // 连不上只由发现它的这台电脑自己避开(这一轮已试过),不替全组判断:可能只是这台连不过去。
+ if (cause === 'unavailable') return;
+ void remote.cool(ownerDeviceId, { providerId, memberKey, cause, resetAt }).catch((error) => {
deps.log.warn('provider group: reporting a computer to cool down failed', { error: errorText(error) });
});
},
@@ -697,8 +667,6 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
const view = await remote.view(ownerDeviceId, providerId);
return view.members.find((m) => m.key === memberKey)?.state === 'cooling';
},
- // 组所在电脑那边的记录到期或那台重新上线时清掉;这台对它的避开最多几分钟,不另报。
- noteWorking() {},
async shouldMoveAway(providerId, _config, memberKey) {
const view = await withTimeout(remote.view(ownerDeviceId, providerId), PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS);
const state = view?.members.find((m) => m.key === memberKey)?.state;
@@ -1062,8 +1030,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
}
/**
- * 发送前等那台恢复(这条还没派出去):进度交给调用方显示;发送被停止或用户接手时停下。组里已经确认那台用不了时
- * 不等(`knownDown`)。
+ * 发送前等那台恢复(这条还没派出去):进度交给调用方显示;发送被停止或用户接手时停下。已经确认那台用不了时
+ * 不等(`isKnownDown`)。
*/
async function waitBeforeSend(
sessionId: string,
@@ -1180,7 +1148,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
hooks: ProviderGroupTurnErrorHooks | undefined;
}): Promise<void> {
const { sessionId, signals, cause, binding, source, config, row, current, lease, isCurrent, handBack, hooks } = input;
- source.cool(binding.providerId, current.key, cause, deps.readResetAt(signals), isProviderGroupConnectionLoss(signals));
+ source.cool(binding.providerId, current.key, cause, deps.readResetAt(signals));
source.invalidate(current);
const tried = router.markTried(sessionId, current.key);
// 这条消息发出前刚换不过去的电脑不再重复去试、重复去等。
@@ -1193,18 +1161,18 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
const localProviderId = current.kind === 'local' ? row.providerId : binding.providerId;
// 分享来的电脑用分享者的昵称(不用电脑名);读不到时为空,活动记录退回不写电脑的说法。
let fromLabel = deps.directory.memberLabel(current);
- const skipped = createSkippedTargets((member) => deps.directory.memberLabel(member));
+ const skipped = createSkippedTargets();
for (;;) {
if (!isCurrent()) return;
- const pick = await skipped.pick(() => source.pick({
+ const pick = await source.pick({
sessionId,
providerId: binding.providerId,
config,
agentKind: row.agentKind,
model: row.model,
- exclude: switchExclusion(config, current, tried),
- }));
+ exclude: skipped.exclusion(switchExclusion(config, current, tried)),
+ });
// 选电脑期间用户已接手:绑定与任务记录都还没动,直接停下。
if (!isCurrent()) return;
if (pick.kind !== 'member') {
@@ -1247,12 +1215,11 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
error: errorText(error),
});
router.markTried(sessionId, pick.member.key);
- source.cool(binding.providerId, pick.member.key, targetCause, null, isUnreachableTarget(error));
+ source.cool(binding.providerId, pick.member.key, targetCause, null);
skipped.failed(pick.member, isUnreachableTarget(error));
continue;
}
deps.log.info('provider group: switched computer', { sessionId, cause, to: pick.member.key });
- source.noteWorking(binding.providerId, pick.member.key);
// 交接期间用户已接手(发消息、重试、换模型、收下错误):不替用户续跑。
if (!isCurrent()) return;
const continueToken = deps.rearmContinue(sessionId, lease, deps.now());
@@ -1475,7 +1442,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return null;
}
if (!config?.autoSwitch) return null;
- source.cool(context.groupProviderId, context.member.key, cause, null, isProviderGroupConnectionLoss({ message: errorText(error) }));
+ source.cool(context.groupProviderId, context.member.key, cause, null);
source.invalidate(context.member);
const tried = router.markTried(context.sessionId, context.member.key);
const pick = await source.pick({
@@ -1501,12 +1468,6 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
return { ...context, member: pick.member, route, overrideRoute: true };
},
- noteStarted(context) {
- // 启动时组还没读到(纳入待定):不知道它在组里的哪一项,不动记录。
- if (context.pendingGroupAdoption) return;
- sourceFor(context.groupDeviceId)?.noteWorking(context.groupProviderId, context.member.key);
- },
-
mayHandleTurnError(sessionId, signals) {
if (!classifyProviderGroupSwitchCause(signals)) return false;
const binding = deps.readBinding(sessionId);
@@ -1583,21 +1544,21 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
}
const tried = router.markTried(sessionId, current.key);
const localProviderId = current.kind === 'local' && !source.ownerDeviceId ? row.providerId : binding.providerId;
- const skipped = createSkippedTargets((member) => deps.directory.memberLabel(member));
+ const skipped = createSkippedTargets();
const failedTargets: string[] = [];
const { run, done } = trackRun(sessionId);
const isCurrent = () => !run.superseded && options?.signal?.aborted !== true;
try {
for (;;) {
if (!isCurrent()) return;
- const pick = await skipped.pick(() => source.pick({
+ const pick = await source.pick({
sessionId,
providerId: binding.providerId,
config,
agentKind: row.agentKind,
model: row.model,
- exclude: switchExclusion(config, current, tried),
- }));
+ exclude: skipped.exclusion(switchExclusion(config, current, tried)),
+ });
if (!isCurrent()) return;
if (pick.kind !== 'member') {
// 组里只剩这次因连不上而跳过的电脑:先等它们恢复再换,消息还没发出,进行中行显示「正在换一台电脑继续」。
@@ -1628,7 +1589,6 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
to: pick.member.key,
reason,
});
- source.noteWorking(binding.providerId, pick.member.key);
return;
} catch (error) {
await restoreBindingAfterFailedSwitch(sessionId, source, binding.providerId, config);
@@ -1646,7 +1606,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
});
if (!failedTargets.includes(pick.member.key)) failedTargets.push(pick.member.key);
router.markTried(sessionId, pick.member.key);
- source.cool(binding.providerId, pick.member.key, targetCause, null, isUnreachableTarget(error));
+ source.cool(binding.providerId, pick.member.key, targetCause, null);
skipped.failed(pick.member, isUnreachableTarget(error));
}
}
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index 1f01ede850..2ad4435aae 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -395,12 +395,6 @@ export function memberStatusText(
case 'cooling': {
// 不在今天恢复的(周上限等)带上日期,不让「约 16:00 恢复」看起来像今天就能用。
const time = status.coolingUntil ? formatQuotaResetAt(status.coolingUntil / 1000, nowMs, locale) : null;
- // 不是用量上限,是刚才没能使用(连不上、起不来等):组里暂时避开它,到点再试。
- if (status.reason === 'failed') {
- return time
- ? t('providerGroup.member.status.failedUntil', { time })
- : t('providerGroup.member.status.failed');
- }
return time
? t('providerGroup.member.status.coolingUntil', { time })
: t('providerGroup.member.status.cooling');
diff --git a/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx b/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
index 5e3aef2ff9..bf6314ba55 100644
--- a/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
@@ -274,12 +274,4 @@ describe('memberStatusText', () => {
expect(memberStatusText(t, cooling(new Date(2026, 9, 15, 16, 0).getTime()), 'en-US', now))
.toBe('providerGroup.member.status.coolingUntil:{"time":"Oct 15 16:00"}');
});
-
- it('says a computer could not be used just now instead of calling it a usage cooldown', () => {
- const now = new Date(2026, 9, 11, 9, 30).getTime();
- expect(memberStatusText(t, { ...cooling(new Date(2026, 9, 11, 9, 35).getTime()), reason: 'failed' }, 'en-US', now))
- .toBe('providerGroup.member.status.failedUntil:{"time":"09:35"}');
- expect(memberStatusText(t, { ...cooling(0), coolingUntil: undefined, reason: 'failed' }, 'en-US', now))
- .toBe('providerGroup.member.status.failed');
- });
});
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index f16746fef7..b215618caa 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -478,8 +478,6 @@
"paused": "Assignments paused",
"cooling": "Cooling down",
"coolingUntil": "Cooling down · back around {{time}}",
- "failed": "Couldn’t be used just now",
- "failedUntil": "Couldn’t be used just now · retry around {{time}}",
"offline": "Offline",
"unreachableHere": "Can’t reach it from this computer",
"unavailable": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 06f5c0f746..01137efa3a 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -473,8 +473,6 @@
"paused": "割り当て停止中",
"cooling": "クールダウン中",
"coolingUntil": "クールダウン中 · {{time}} ごろ回復",
- "failed": "先ほど使えませんでした",
- "failedUntil": "先ほど使えませんでした · {{time}} ごろ再試行",
"offline": "オフライン",
"unreachableHere": "このパソコンから接続できません",
"unavailable": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 47037c30b1..e7e6befc06 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -473,8 +473,6 @@
"paused": "배정 일시 중지됨",
"cooling": "대기 중",
"coolingUntil": "대기 중 · {{time}}쯤 복구",
- "failed": "방금 사용할 수 없었음",
- "failedUntil": "방금 사용할 수 없었음 · {{time}}쯤 다시 시도",
"offline": "오프라인",
"unreachableHere": "이 컴퓨터에서 연결할 수 없음",
"unavailable": {
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 76fa8c0bb8..37b8f3ca36 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -473,8 +473,6 @@
"paused": "已暂停分配",
"cooling": "冷却中",
"coolingUntil": "冷却中 · 约 {{time}} 恢复",
- "failed": "刚才没能使用",
- "failedUntil": "刚才没能使用 · 约 {{time}} 再试",
"offline": "不在线",
"unreachableHere": "从这台电脑连不上",
"unavailable": {
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 b6fb8a0795..5052f2768a 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -473,8 +473,6 @@
"paused": "已暫停分配",
"cooling": "冷卻中",
"coolingUntil": "冷卻中 · 約 {{time}} 恢復",
- "failed": "剛才無法使用",
- "failedUntil": "剛才無法使用 · 約 {{time}} 再試",
"offline": "離線",
"unreachableHere": "從這台電腦連不上",
"unavailable": {
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index e0c6d88176..1e01f1d94e 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -63,7 +63,7 @@ export type ProviderGroupMemberState =
| 'full'
/** 暂停分配。 */
| 'paused'
- /** 撞到用量上限后冷却中,或刚才没能使用、暂时避开(`reason: 'failed'`)。 */
+ /** 撞到用量上限后冷却中。 */
| 'cooling'
/** 连不上(离线、未开远程控制、分享者电脑不在线)。 */
| 'offline'
@@ -76,9 +76,7 @@ export type ProviderGroupUnavailableReason =
/** 供应商未连接或已停用。 */
| 'disconnected'
| 'share-paused'
- | 'share-removed'
- /** `cooling` 专用:不是用量上限,是刚才没能使用(连不上、起不来、登录失效等),暂时避开、到点再试。 */
- | 'failed';
+ | 'share-removed';
export interface ProviderGroupMemberStatus {
key: string;
@@ -278,12 +276,9 @@ export function readProviderGroupSummary(raw: unknown, groupProviderId: string):
return normalizeProviderGroupConfig(raw, groupProviderId);
}
-/**
- * 同账号电脑报给组所在电脑的失败原因(2026-10-11 起含连不上:`connectionLost` 时组所在电脑只让报告的那台避开它,
- * 不替全组判断;旧版本组所在电脑不认识 `unavailable`,回 `[INVALID_PARAMS]`)。
- */
-export type ProviderGroupRemoteCoolCause = 'usage-limit' | 'auth' | 'overload' | 'unavailable';
-const REMOTE_COOL_CAUSES: readonly ProviderGroupRemoteCoolCause[] = ['usage-limit', 'auth', 'overload', 'unavailable'];
+/** 换电脑的原因里,会让组所在电脑冷却那台的几种(连不上只由发现它的电脑自己避开,不替全组判断)。 */
+export type ProviderGroupRemoteCoolCause = 'usage-limit' | 'auth' | 'overload';
+const REMOTE_COOL_CAUSES: readonly ProviderGroupRemoteCoolCause[] = ['usage-limit', 'auth', 'overload'];
export interface ProviderGroupRemoteLease {
sessionId: string;
@@ -317,18 +312,8 @@ export const PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS = 3_000;
export type ProviderGroupRemoteRequest =
/** 新任务该用组里哪台;选中即给那台记一个短暂的占用,同时开的几个任务不会全落到同一台。 */
| { action: 'pick'; sessionId: string; providerId: string; agentKind: 'claude-code' | 'codex' | 'pi'; model: string; exclude: string[] }
- /**
- * 那台电脑出了问题(用量上限、登录失效、服务繁忙、连不上、起不来):组所在电脑记给全组,之后谁选电脑都先避开它;
- * `connectionLost` = 只是报告的这台和它的连接断了,只对这台避开。
- */
- | {
- action: 'cool';
- providerId: string;
- memberKey: string;
- cause: ProviderGroupRemoteCoolCause;
- resetAt?: number;
- connectionLost?: true;
- }
+ /** 那台电脑出了问题(用量上限、登录失效、服务繁忙):组所在电脑冷却它,不再分新任务。 */
+ | { action: 'cool'; providerId: string; memberKey: string; cause: ProviderGroupRemoteCoolCause; resetAt?: number }
/** 这台电脑经组运行、正在跑的任务(整体替换上一份;seq 只增,乱序到达的旧份丢弃)。 */
| { action: 'leases'; seq: number; entries: ProviderGroupRemoteLease[] }
/** 组内电脑的状态(发送前检查、设置页展示)。 */
@@ -431,7 +416,6 @@ export function parseProviderGroupRemoteRequest(raw: unknown): ProviderGroupRemo
memberKey: remoteMemberKey(value.memberKey),
cause: cause as ProviderGroupRemoteCoolCause,
...(resetAt !== undefined ? { resetAt } : {}),
- ...(value.connectionLost === true ? { connectionLost: true as const } : {}),
};
}
case 'leases': {
@@ -481,9 +465,7 @@ export function parseProviderGroupRemotePick(raw: unknown, groupProviderId: stri
}
const MEMBER_STATES: readonly ProviderGroupMemberState[] = ['available', 'full', 'paused', 'cooling', 'offline', 'unavailable'];
-const UNAVAILABLE_REASONS: readonly ProviderGroupUnavailableReason[] = [
- 'provider-off', 'disconnected', 'share-paused', 'share-removed', 'failed',
-];
+const UNAVAILABLE_REASONS: readonly ProviderGroupUnavailableReason[] = ['provider-off', 'disconnected', 'share-paused', 'share-removed'];
/** 同账号电脑读组所在电脑 `view` 的回包(设置页只读展示、发送前检查);坏条目丢弃。 */
export function parseProviderGroupRemoteView(raw: unknown, groupProviderId: string): ProviderGroupView {
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 4a6d41b6dd..c111d32231 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -778,12 +778,12 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
- `pick { sessionId, providerId, agentKind, model, exclude[] }` → `{ kind: 'member', member: { key, kind, agentDeviceId, providerId }, label }`
/ `{ kind: 'unavailable' }` / `{ kind: 'none' }`(没有组或供应商没开放远程调用)。组员坐标是 O 视角(`local` = O 自己),C 换算成
本机位置;选中即给那台记 30s 临时占用;
- - `cool { providerId, memberKey, cause: 'usage-limit' | 'auth' | 'overload' | 'unavailable', resetAt?, connectionLost? }` →
- O 把那台记给全组(`resetAt` 最多信 8 天);`connectionLost: true` = 只是 C 和那台的连接断了,O 只让 C 避开它
- (2026-10-11 起,见下文「供应商组:失败共用」);
+ - `cool { providerId, memberKey, cause: 'usage-limit' | 'auth' | 'overload', resetAt? }` → O 冷却那台(`resetAt` 最多信 8 天);
+ 连不上不报,只由 C 自己避开(组内状态以 O 为准,C 那边的问题不记进组里,2026-10-11)。`exclude` 非空(C 这一轮试过
+ 不行再来问)时 O 不用短时缓存、现读组内电脑的最新状态再选,请求格式不变;
- `leases { seq, entries: [{ sessionId, providerId, memberKey }] }` → 整体替换 C 正在运行的经组任务,`seq` 只增(C 按时间生成,
重启后仍增大),乱序旧包丢弃,150s 不刷新作废;只用于分摊负载;
- - `view { providerId }` → 组设置与组员状态(`ProviderGroupView`),按 C 看(只 C 连不过去的组员对 C 写 `cooling`)。
+ - `view { providerId }` → 组设置与组员状态(`ProviderGroupView`)。
旧 O 回 `CHANNEL_NOT_ALLOWED`:`pick` 按 `none` 处理,任务照旧直接在 O 上运行。
- **`maker:provider:list` 新增可选字段 `group`**:只对同账号调用方、只加在建了组且「允许被远程调用」的供应商上:
`{ strategy, autoSwitch, members: [{ key, kind, agentDeviceId, providerId, label?, paused }] }`(并发上限与权重不外发)。
@@ -795,7 +795,9 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
- **本地数据**:C 上经另一台电脑的组分配的任务绑定存 `provider-group-remote-bindings.json`(按账号,与本机组的
`provider-group-bindings.json` 分开,降级后旧版本读不到它,不会误认成本机的同名组)。因组内电脑被移出或组被删除而
解除过绑定的任务按组记在 `provider-group-released.json`(按账号,2026-10-10),老任务纳入组时据此跳过(provider-groups.md
- §6、§9.4);旧版本不读也不改写它,降级再升级后记录仍在。不改数据库与服务端。
+ §6、§9.4);旧版本不读也不改写它,降级再升级后记录仍在。组所在电脑的冷却按账号存 `provider-group-cooling.json`
+ (`{ cooling: { [providerId]: { [memberKey]: until } } }`,只存未到期的,2026-10-11),重启后照样避开;旧版本不读它。
+ 不改数据库与服务端。
- 实现:`apps/desktop/src/main/provider-group/`(`remoteHandler.ts`、`remoteClient.ts`、`externalLoad.ts`、`leaseReporter.ts`、
`service.ts` 的组来源);回归见同目录 `__tests__/remoteGroup.test.ts`、`remoteHandler.test.ts`、`leaseReporter.test.ts`,
`device-link/__tests__/providerShareDispatch.test.ts`(受邀者拒绝与不泄露组摘要)。
@@ -950,26 +952,6 @@ G 重新打开时换一台。G 与 O 之间新增四项可选内容,O 与 M
`provider-group/__tests__/usageReporter.test.ts`、`remoteHandler.test.ts`、`usage/__tests__/providerPartyUsageStore.test.ts`、
`maker-ipc/__tests__/sessionProviderPartyUsage.test.ts`。
-## 供应商组:失败共用(2026-10-11)
-
-产品规则见 [`provider-groups.md`](../product-rules/provider-groups.md) §5「失败共用」、§6.1「确认用不了的不等」。组内电脑的失败由
-组所在电脑 O 记给全组,所有使用方选电脑时都先避开它。
-
-- **`provider-group:remote` 的 `cool` 新增 `cause: 'unavailable'` 与可选 `connectionLost: true`**:C 发现组员连不上、起不来时也报;
- `connectionLost` 时 O 只让 C 避开它(按 C 的设备 id 记),并在下次选电脑时现读那台。`pick` 与 `view` 按发来的 C 区分(不新增字段)。
-- **`ProviderGroupMemberStatus.reason` 新增 `'failed'`**(只配 `state: 'cooling'`):刚才没能使用、暂时避开,与用量上限冷却区分。
-- **兼容**:
- - 旧 O 不认识 `unavailable`,回 `[INVALID_PARAMS] invalid cause`:新 C 记日志、照旧只在这一轮避开;其余 `cool` 不变。
- - 旧 C 不报 `unavailable`:O 上缺这部分记录,旧 C 照旧只在这一轮避开;O 自己的任务与替分享的人中转仍会记。
- - 旧版本读 `view` 时丢弃不认识的 `reason`,`cooling` 照旧显示「冷却中」。
- - `maker:provider:list`、远程 Agent open 载荷、relay、服务器与数据库都不变。
-- **本地数据**:用量上限的冷却按账号存 `provider-group-cooling.json`(`{ cooling: { [providerId]: { [memberKey]: until } } }`,只存
- 未到期的),重启后照样避开;旧版本不读也不写它。其余失败只在内存里。
-- 实现:`apps/desktop/src/main/provider-group/router.ts`(`noteFailure` / `noteWorking` / `isAvoided`、选电脑不等慢的那台)、
- `coolingStore.ts`、`directory.ts`(`resolveMembers` 的 `quickMs`、`offlineForMs`)、`service.ts`(`knownDown`、组来源的 `cool` /
- `isKnownDown` / `noteWorking`)、`remoteHandler.ts`、`guestRelay.ts`;回归见同目录 `__tests__/router.failures.test.ts`、
- `service.test.ts`、`remoteGroup.test.ts`、`remoteHandler.test.ts`、`directory.test.ts`、`scheduler.test.ts`。
-
## 事实来源
| 内容 | 权威来源 |
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index 54b93a27f5..5938810447 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -12,9 +12,9 @@
> 2026-10-11 用户要求:**要换过去的那台从这台电脑连不上时也先等**——组里还有别的就先换别的,只剩它时按同样的退避等它恢复再换,
> 不急着报错;发送前换不过去时换下一台,不把消息发给冷却中的那台;另一台电脑上的组里,这台连不上的电脑标出「从这台电脑连不上」,
> 见 §5、§6.1、§10。
-> 2026-10-11 用户要求:**选电脑第一时间选到能用的**——自己和分享的人都一样,不再每次从不能用的那台开始试;组里都确认不能用就
-> 直接提示都不能用。组内电脑的失败由组所在电脑记给全组、所有使用方共用(只是某个使用方连不过去的只对它),选电脑不等慢的那台;
-> 用户确认:**确认用不了的直接换、直接提示,只有刚断开的才先等一会儿**,见 §5「失败共用」、§6.1。
+> 2026-10-11 用户确认:**组内电脑的状态以组所在电脑为准**——组所在电脑有组内供应商的状态并同步给使用方,使用方按它筛选;
+> 使用方自己那边的问题不记进组里;状态有延迟时试过不行就换下一台,并现读最新的组内状态。确认用不了的直接换、直接提示,
+> 只有刚断开的才先等一会儿,见 §5「组内状态以组所在电脑为准」、§6.1。
> 2026-10-11 用户要求:模型列表里**组里的都聚合成一项**——任务正跑在组员上也不单独列出,显示在组那一项下,在组那一项里
> 选模型留在此刻运行的那台;挪到组里另一台后的第一次失败也照常换电脑,见 §6、§10。
> 2026-10-11 用户确认:模型列表里组那一项的订阅用量**跟着任务实际运行的那台**,还没分到电脑时不显示某一台的配额,见 §10「模型列表」;
@@ -151,26 +151,19 @@
- **冷却**:组内电脑上的任务报用量上限时,这台电脑进入冷却,不再接新任务。重置时刻按
[用量上限自动继续](usage-limit-auto-continue.md) 的口径取(不采用不带时区的钟点);取不到时默认冷却 30 分钟。
冷却不主动迁移这台电脑上正在运行的其他任务;它们自己撞到上限时再按 §6.1 换电脑。
- 用量上限的冷却按账号存在组所在电脑本机(`provider-group-cooling.json`),重启后照样避开。
-- **失败共用**(2026-10-11 用户要求:选电脑第一时间选到能用的,不再每次从不能用的那台开始试):组内电脑的失败由组所在电脑
- 记给全组,本机的任务、同账号其他电脑与分享的人选电脑时都先避开它,不用每个使用方各自撞一次。
- - 记哪些:§6.1 列出的会换电脑的失败都记——用量上限(按上面的冷却)、登录失效、服务繁忙、Agent 起不来、连不上;不论是在
- 打开任务、运行中,还是换电脑、发送前换电脑时发现的。同账号其他电脑直连时发现的报告给组所在电脑(报来的重置时刻最多信
- 8 天),分享的人那边由中转的组所在电脑自己记。
- - **只是某个使用方连不过去**(断线、不响应)只对它生效,不替全组判断——可能只是它连不过去;组所在电脑下次读那台的状态
- 时现读,那台真连不上就是离线,所有使用方都会避开。
- - 避开多久:用量上限到重置时刻;其余原因第一次 2 分钟,避开期过后再试又失败依次 5、15、30、60 分钟(同一阵子几个任务
- 一起撞上只算一次);6 小时没再失败就从头算。避开期过后 30 分钟内它排在没失败过的电脑后面:组里有别的能接,就先不去试它
- (最少占用下,一直接不下任务的那台运行数最少,以前会总被最先选中)。
- - 什么时候清掉:那台从离线、不可用变回能用(重新上线);在那台上成功打开了会话(换过去、启动成功)时清掉「连不上 / 起不来」
- 这两种,登录失效与服务繁忙不因打开会话就算好了,等避开期过去。
- - 选电脑不等慢的那台:读组内电脑状态最多等 3 秒,到点已经有一台能接的就不再等其余的(那几台这次按不能用算,读取照常在后台
- 完成);一台能接的都还没有时照旧等全部读完,不会因为慢就误报都不能用。
- - 组里都确认不能用时直接提示「供应商组里的电脑现在都不能运行这个任务」(新任务),或交回原有的报错与额度重置后自动继续
- (运行中),不再挨个去试。
- - 组内电脑一行的状态写「刚才没能使用 · 约 {时间} 再试」,与用量上限的「冷却中 · 约 {时间} 恢复」区分;另一台电脑上的组
- 按这台电脑看(只它连不过去的电脑对它这样写)。
+ 同账号其他电脑直连时撞到用量上限、登录失效或服务繁忙,也报告给组所在电脑冷却那台(报来的重置时刻最多信 8 天);
+ 连不上只由发现它的那台电脑自己在这一轮避开,不替全组判断——可能只是那台电脑自己连不过去;这一轮组里只剩这样的电脑时,
+ 先等它恢复再换(§6.1)。
- 组内电脑的在线状态、分享状态与模型目录定时核对;不可用的电脑在组里标出原因。
+- **组内状态以组所在电脑为准**(2026-10-11 用户确认):组所在电脑有组内每台电脑的状态——在不在线、供应商开没开、提供哪些
+ 模型、在跑几个、是否暂停分配,以及那台账号的问题(用量上限、登录失效、服务繁忙)记下的冷却——同步给所有使用方,使用方
+ (组所在电脑自己的任务、同账号其他电脑、分享的人)都按这份状态筛选、选电脑。
+ - 使用方自己那边的问题(这台连不上它、版本不配等)不记进组的状态,不影响别人;这一轮里试过的照旧不再试。
+ - 状态有延迟是可以接受的:试过不行就换下一台;带着这一轮试过的电脑再来选时,组所在电脑不用短时缓存,现读最新状态再选。
+ - 选电脑时读状态最多等 3 秒:到点已经有一台能接的就不再等更慢的那几台(这次按不能用算,读取照常在后台完成);一台能接的
+ 都还没有时照旧等全部读完,不会因为慢就误报都不能用。组里都不能用时直接提示「供应商组里的电脑现在都不能运行这个任务」。
+ - 冷却按账号存在组所在电脑本机(`provider-group-cooling.json`),重启后照样避开撞了上限的那台。
+ - 已知局限:组所在电脑读不出来的问题(例如那台目录读得到、Agent 却起不来)不在状态里,每个任务仍会先试到它再换下一台。
- 组里所有电脑都失败才报错,见 §6 自动换电脑。
## 6. 任务与组内电脑的绑定
@@ -219,10 +212,9 @@
继续;同一轮次数照算,那台反复断也只这 5 次,用完就换。
- 不等、直接换的情况:现读连得上但问题不在连接(如那台 Agent 起不来);那台本身不能用(供应商关掉、关闭了远程控制或
远程调用、分享暂停或删除等);本机这台;用量上限、登录失效、过载等不是连不上的原因。
- - **确认用不了的不等**(2026-10-11 用户确认:确认用不了的直接换、组里都不能用就直接提示,只有刚断开的才先等一会儿):
- 组里已经记着它用不了(冷却中、别的任务或使用方刚试过它还在避开期,§5「失败共用」),或同账号那台已经离线超过 2 分钟,
- 就不等,直接换;只有刚才还在正常用、突然断开的那台才按上面先等。运行中失败、发送前、别的电脑上的组读不到时都这样;
- 组所在电脑或设备列表读不到时按不知道,照旧先等。
+ - **确认用不了的不等**(2026-10-11 用户确认):组的状态里它在冷却中,或同账号那台已经离线超过 2 分钟,就不等,直接换;
+ 只有刚才还在正常用、突然断开的那台才按上面先等。运行中失败、发送前、别的电脑上的组读不到时都这样;组所在电脑或设备
+ 列表读不到时按不知道,照旧先等。
- 次数按一轮、按电脑计,自动续跑与运行中失败共用;用户亲自发消息、重试、换模型即开始新的一轮,重新计。
- 发送前:已归组的任务所在那台显示离线、或这次发送要重新打开那台上的会话(会话没开着或不在运行态)时,现读一次那台的
状态;离线就同样先等(消息还没发出,进行中行显示「重新连接中 n/5」),恢复了照常发到原电脑,等不到再换到下一台
@@ -233,10 +225,9 @@
恢复了在原电脑继续(活动记录写「原来的电脑」),等不到照原有方式报错;发送前同理。
- **要换过去的那台连不上也先等**(2026-10-11):换电脑时选中的那台从这台电脑连不上(断线、不响应;组所在电脑那边看它
可能是正常的),组里还有别的电脑就先换别的;只剩这一轮因连不上而跳过的电脑时不急着报错,按同样的退避等它恢复(刚换过去
- 失败,先等一会儿再现读),恢复了直接再换过去(这一趟刚记下的避开不挡它),等不到才交回原有的报错。次数按电脑计、与等原电脑
- 共用一份,那台「看着连得上却换不过去」时也最多试这几次;等的期间消息流与输入框状态仍写「正在换一台电脑继续」。运行中换电脑
- 与发送前换电脑都这样;换过去失败的原因不是连不上(那台不提供这个模型、分享暂停等)时不等,照旧换下一台或报错。
- 等过却没等回来的那台照 §5「失败共用」记下:之后的消息与新任务在避开期内不再去试、去等。
+ 失败,先等一会儿再现读),恢复了再换过去,等不到才交回原有的报错。次数按电脑计、与等原电脑共用一份,那台「看着连得上
+ 却换不过去」时也最多试这几次;等的期间消息流与输入框状态仍写「正在换一台电脑继续」。运行中换电脑与发送前换电脑都这样;
+ 换过去失败的原因不是连不上(那台不提供这个模型、分享暂停等)时不等,照旧换下一台或报错。
- 已经发出却在那台上没确认收到的消息(如请求超时)不自动重发:可能已经在跑,重发会让同一条消息执行两次,照原有方式报错。
- 下面「换电脑久久没有结局(3 分钟)先把错误放出来」的计时不吃掉等它恢复的时间:每次重试、开始换电脑时重新计时。
- **换电脑期间不报错**(2026-10-10):这次失败会先试着换电脑时(已归组、自动换电脑开着、组里还有别的电脑;