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): replace usage only after receiving the complete report

Lizia4045d5dd9ac
diff --git a/apps/desktop/src/main/device-link/__tests__/remoteInvokeSendGuard.test.ts b/apps/desktop/src/main/device-link/__tests__/remoteInvokeSendGuard.test.ts
index dff5138859..9c821ed5e4 100644
--- a/apps/desktop/src/main/device-link/__tests__/remoteInvokeSendGuard.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/remoteInvokeSendGuard.test.ts
@@ -34,6 +34,61 @@ function loadRemoteInvoke(overrides: Record<string, unknown>) {
return new Function(...Object.keys(dependencies), compiled + '; return remoteInvoke;')(...Object.values(dependencies));
}
+function loadBackgroundInvoke(overrides: Record<string, unknown>) {
+ const declarations = source.statements.filter((node): node is ts.FunctionDeclaration =>
+ ts.isFunctionDeclaration(node) && ['remoteBackgroundInvoke', 'backgroundInvokeDevice'].includes(node.name?.text ?? ''));
+ const backgroundCode = ts.transpileModule(declarations.map((node) => node.getText(source).replace(/^export /, '')).join(' '), {
+ compilerOptions: { target: ts.ScriptTarget.ES2022 },
+ }).outputText;
+ const dependencies = {
+ resolveRemoteAgentTargetWhenReady: async (id: string) => id,
+ client: { isLinkReady: () => true },
+ remoteInvoke: loadRemoteInvoke({}),
+ openRemoteLink: vi.fn(),
+ assertBackgroundLinkAccepted: () => {},
+ snapshotSubscriptions: () => [],
+ closeRemoteLink: vi.fn(),
+ ...overrides,
+ };
+ return new Function(...Object.keys(dependencies), backgroundCode + '; return remoteBackgroundInvoke;')(...Object.values(dependencies));
+}
+
+it.each(['target resolution', 'link opening', 'online wait'])(
+ 'does not send an old account’s background request after account changes during %s', async (stage) => {
+ let current = true;
+ let release!: () => void;
+ const waiting = new Promise<void>((resolve) => { release = resolve; });
+ const reached = vi.fn();
+ const pause = async () => { reached(); await waiting; };
+ const invoke = vi.fn<DeviceLinkClient['invoke']>(async (_peer, _payload, _timeout, options) => {
+ options?.preSend?.();
+ return { ok: true, result: null };
+ });
+ const remoteInvoke = loadRemoteInvoke({
+ client: { invoke },
+ ensureOnlineForRequest: stage === 'online wait' ? pause : async () => {},
+ });
+ const remoteBackgroundInvoke = loadBackgroundInvoke({
+ remoteInvoke,
+ client: { isLinkReady: () => stage !== 'link opening' },
+ openRemoteLink: pause,
+ resolveRemoteAgentTargetWhenReady: async (id: string) => {
+ if (stage === 'target resolution') await pause();
+ return id;
+ },
+ });
+ const changed = new Error('account changed');
+ const pending = remoteBackgroundInvoke('host', 'provider-group:remote', [{ action: 'usage-part' }], {
+ preSend: () => { if (!current) throw changed; },
+ }).catch((error: unknown) => error);
+ await vi.waitFor(() => expect(reached).toHaveBeenCalledTimes(1));
+ current = false;
+ release();
+ expect(await pending).toBe(changed);
+ expect(invoke).not.toHaveBeenCalled();
+ },
+);
+
it.each(['caller cancelled', 'target disabled', 'link closed', 'still valid'])(
'revalidates %s after the client queue and never reopens an explicitly closed link', async (change) => {
let enabled = true;
diff --git a/apps/desktop/src/main/device-link/index.ts b/apps/desktop/src/main/device-link/index.ts
index 2fe1205eee..b0d4281d7c 100644
--- a/apps/desktop/src/main/device-link/index.ts
+++ b/apps/desktop/src/main/device-link/index.ts
@@ -1862,16 +1862,19 @@ export async function remoteBackgroundInvoke(
agentDeviceId: string,
channel: string,
args: unknown[],
+ options?: { preSend?: () => void },
): Promise<InvokeResultPayload> {
+ options?.preSend?.();
// 分享来的供应商:任务记录里是 `share:<id>`,换成分享者那台电脑的本地 peer key。
const deviceId = await resolveRemoteAgentTargetWhenReady(agentDeviceId);
+ options?.preSend?.();
const shared = deviceId !== agentDeviceId;
- if (!shared) return backgroundInvokeDevice(deviceId, channel, args);
+ if (!shared) return backgroundInvokeDevice(deviceId, channel, args, options);
try {
// 跨区域分享:分享者电脑在另一个区域的 relay 上,经那条连接发送。
const result = isCrossRegionProviderShareTarget(deviceId)
? await crossRegionInvoke(deviceId, channel, args, resolveRemoteInvokeTimeoutMs(channel, args, 'desktop'))
- : await backgroundInvokeDevice(deviceId, channel, args);
+ : await backgroundInvokeDevice(deviceId, channel, args, options);
if (result.ok) return result;
if (!isProviderShareRefusal(result.error.code, result.error.message)) return result;
noteProviderShareAccessFailure();
@@ -1894,14 +1897,16 @@ export function providerShareHostInvoke(target: string, channel: string, args: u
return backgroundInvokeDevice(target, channel, args);
}
-async function backgroundInvokeDevice(deviceId: string, channel: string, args: unknown[]): Promise<InvokeResultPayload> {
+async function backgroundInvokeDevice(deviceId: string, channel: string, args: unknown[], options?: { preSend?: () => void }): Promise<InvokeResultPayload> {
+ options?.preSend?.();
if (!client?.isLinkReady(deviceId)) {
assertBackgroundLinkAccepted(await openRemoteLink(deviceId), {
hasOutboundSubscriptions: () => snapshotSubscriptions(deviceId).length > 0,
closeLink: () => closeRemoteLink(deviceId),
});
}
- return remoteInvoke(deviceId, channel, args);
+ // 账号等调用方状态必须穿过建链、上线与排队等待,在实际发送边界复验。
+ return remoteInvoke(deviceId, channel, args, options);
}
/**
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 6460a596dc..dfaa1a2f6d 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -5,6 +5,14 @@
import { describe, expect, it, vi } from 'vitest';
import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
+import {
+ parseProviderGroupRemoteRequest,
+ providerGroupUsageRowsForWire,
+ PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS,
+ PROVIDER_GROUP_REMOTE_MAX_USAGE_REPORT_ROWS,
+ type ProviderGroupRemoteUsageRow,
+} from '../../../shared/providerGroup';
+import { createProviderGroupRemoteClient, ProviderGroupRemoteUnsupportedError, type ProviderGroupRemoteInvoke } from '../remoteClient';
import {
createProviderGroupExternalLoad,
PROVIDER_GROUP_LEASE_TTL_MS,
@@ -14,6 +22,7 @@ import {
decorateProviderListWithGroups,
handleProviderGroupRemote,
PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS,
+ PROVIDER_GROUP_USAGE_PART_TTL_MS,
sharedProviderGroupSize,
type ProviderGroupRemoteHandlerDeps,
} from '../remoteHandler';
@@ -258,6 +267,160 @@ describe('provider-group:remote', () => {
});
});
+describe('完整用量报告分批传输', () => {
+ const usageRow = (i: number): ProviderGroupRemoteUsageRow => ({
+ day: i === 0 ? '2026-10-10' : '2026-10-11', providerId: 'anthropic', memberKey: MINI.key,
+ kind: 'claude-code', model: `model-${i}`, turns: 1, inputTokens: i + 1, outputTokens: 1,
+ cacheReadTokens: 0, cacheCreateTokens: 0, sdkCostUsd: 0, lastAt: 1,
+ });
+ const rows = Array.from({ length: PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS + 2 }, (_, i) => usageRow(i));
+ const part = (seq: number, offset: number, sinceDay: string | null = null) => ({
+ action: 'usage-part', seq, sinceDay, offset, total: rows.length,
+ rows: providerGroupUsageRowsForWire(rows.slice(offset, offset + PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS)),
+ });
+
+ it('单日超过 3000 行时每帧仍受上限约束,收齐前保留旧记录,最后完整替换一次', async () => {
+ let received = [usageRow(9000)];
+ const replace = vi.fn<ProviderGroupRemoteHandlerDeps['replaceReportedUsage']>((_controller, _sinceDay, incoming) => { received = incoming; });
+ const d = deps({ replaceReportedUsage: replace });
+ const invoke = vi.fn<ProviderGroupRemoteInvoke>(async (_device, _channel, args) => {
+ const request = args[0] as { rows: unknown[]; offset: number };
+ expect(request.rows.length).toBeLessThanOrEqual(PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS);
+ if (request.offset > 0) {
+ expect(replace).not.toHaveBeenCalled();
+ expect(received).toEqual([usageRow(9000)]);
+ }
+ return { ok: true, result: await handleProviderGroupRemote(d, 'laptop', request) };
+ });
+ await createProviderGroupRemoteClient(invoke).usage('mini', { seq: 1, sinceDay: null, rows });
+ expect(invoke).toHaveBeenCalledTimes(2);
+ expect(replace).toHaveBeenCalledTimes(1);
+ expect(received).toEqual(rows);
+ // 完成后的旧份重送不再次记账。
+ expect(await handleProviderGroupRemote(d, 'laptop', part(1, 0))).toMatchObject({ committed: true });
+ expect(replace).toHaveBeenCalledTimes(1);
+ });
+
+ it('中途断开不改旧账本,新序号从头重报可完整恢复', async () => {
+ const d = deps();
+ let failLastPart = true;
+ const client = createProviderGroupRemoteClient(async (_device, _channel, args) => {
+ if (failLastPart && (args[0] as { offset: number }).offset > 0) throw new Error('offline');
+ return { ok: true, result: await handleProviderGroupRemote(d, 'laptop', args[0]) };
+ });
+ await expect(client.usage('mini', { seq: 1, sinceDay: null, rows })).rejects.toThrow('offline');
+ expect(d.replaceReportedUsage).not.toHaveBeenCalled();
+ failLastPart = false;
+ await client.usage('mini', { seq: 2, sinceDay: null, rows });
+ expect(d.replaceReportedUsage).toHaveBeenCalledWith('laptop', null, rows);
+ });
+
+ it('旧端拒绝新动作,发送方按不支持处理,不回退到部分替换', async () => {
+ const invoke = vi.fn<ProviderGroupRemoteInvoke>(async () => ({ ok: false, error: { message: '[INVALID_PARAMS] unknown provider group action' } }));
+ await expect(createProviderGroupRemoteClient(invoke).usage('mini', { seq: 1, sinceDay: null, rows }))
+ .rejects.toBeInstanceOf(ProviderGroupRemoteUnsupportedError);
+ expect(invoke).toHaveBeenCalledTimes(1);
+ expect(invoke.mock.calls[0]![2][0]).toMatchObject({ action: 'usage-part' });
+ });
+
+ it('小报告继续使用旧端可识别的 usage 动作', async () => {
+ const invoke = vi.fn<ProviderGroupRemoteInvoke>(async (_device, _channel, args) => {
+ expect(args[0]).toMatchObject({ action: 'usage', sinceDay: '2026-10-11' });
+ return { ok: true, result: {} };
+ });
+ await createProviderGroupRemoteClient(invoke).usage('mini', { seq: 1, sinceDay: '2026-10-11', rows: [usageRow(1)] });
+ expect(invoke).toHaveBeenCalledTimes(1);
+ });
+
+ it('缺批、乱序、改起始日及超限参数都不更新账本', async () => {
+ const d = deps();
+ await expect(handleProviderGroupRemote(d, 'laptop', part(1, 3000))).rejects.toThrow('PRECONDITION_FAILED');
+ await handleProviderGroupRemote(d, 'laptop', part(1, 0));
+ await expect(handleProviderGroupRemote(d, 'laptop', part(1, 3000, '2026-10-11'))).rejects.toThrow('PRECONDITION_FAILED');
+ for (const invalid of [
+ { ...part(1, 0), total: PROVIDER_GROUP_REMOTE_MAX_USAGE_REPORT_ROWS + 1 },
+ { ...part(1, 0), offset: -1 },
+ { ...part(1, 0), offset: 0.5 },
+ { ...part(1, 0), rows: [] },
+ { ...part(1, 0), rows: providerGroupUsageRowsForWire(rows) },
+ ]) expect(() => parseProviderGroupRemoteRequest(invalid)).toThrow('INVALID_PARAMS');
+ expect(d.replaceReportedUsage).not.toHaveBeenCalled();
+ });
+
+ it('暂存过期或接收端重启后不能用尾批覆盖整份,要求重新开始', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', part(1, 0));
+ d.advance(PROVIDER_GROUP_USAGE_PART_TTL_MS);
+ await expect(handleProviderGroupRemote(d, 'laptop', part(1, 3000))).rejects.toThrow('PRECONDITION_FAILED');
+ const restarted = deps();
+ await expect(handleProviderGroupRemote(restarted, 'laptop', part(1, 3000))).rejects.toThrow('PRECONDITION_FAILED');
+ expect(d.replaceReportedUsage).not.toHaveBeenCalled();
+ expect(restarted.replaceReportedUsage).not.toHaveBeenCalled();
+ });
+
+ it('两台报告电脑的暂存独立,新的整份报告使旧分批报告作废', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', part(1, 0));
+ await handleProviderGroupRemote(d, 'phone-controller', part(1, 0));
+ await handleProviderGroupRemote(d, 'phone-controller', part(1, 3000));
+ expect(d.replaceReportedUsage).toHaveBeenCalledWith('phone-controller', null, rows);
+ await handleProviderGroupRemote(d, 'laptop', { action: 'usage', seq: 2, sinceDay: null, rows: [] });
+ await handleProviderGroupRemote(d, 'laptop', part(1, 3000));
+ expect(d.replaceReportedUsage).toHaveBeenCalledTimes(2);
+ expect(d.replaceReportedUsage).toHaveBeenLastCalledWith('laptop', null, []);
+ });
+
+ it('换账号或账号已失效时不继续发送、不提交旧账号的暂存', async () => {
+ const d = deps();
+ let current = true;
+ const invoke = vi.fn<ProviderGroupRemoteInvoke>(async (_device, _channel, args) => {
+ const result = await handleProviderGroupRemote(d, 'laptop', args[0]);
+ current = false;
+ return { ok: true, result };
+ });
+ await expect(createProviderGroupRemoteClient(invoke).usage('mini', { seq: 1, sinceDay: null, rows }, () => {
+ if (!current) throw new Error('account changed');
+ })).rejects.toThrow('account changed');
+ expect(invoke).toHaveBeenCalledTimes(1);
+ d.switchAccount();
+ await handleProviderGroupRemote(d, 'laptop', part(1, 3000));
+ expect(d.replaceReportedUsage).not.toHaveBeenCalled();
+ // 新账号是另一份 scope,不会承接旧账号首批。
+ await expect(handleProviderGroupRemote(deps(), 'laptop', part(1, 3000))).rejects.toThrow('PRECONDITION_FAILED');
+ });
+
+ it('接收端没有确认收齐时,发送方不会假报成功', async () => {
+ const client = createProviderGroupRemoteClient(async () => ({ ok: true, result: {} }));
+ await expect(client.usage('mini', { seq: 1, sinceDay: null, rows })).rejects.toThrow('PRECONDITION_FAILED');
+ });
+
+ it('每批账号复验传到 invoke 的真实发送边界,等待建链期间换账号保留旧账本', async () => {
+ const d = deps();
+ let current = true;
+ const invoke = vi.fn<ProviderGroupRemoteInvoke>(async (_device, _channel, args, options) => {
+ // 模拟实际后台 invoke 在发送前的异步建链/排队;调用入口的检查此时已经通过。
+ await Promise.resolve();
+ current = false;
+ options?.preSend?.();
+ return { ok: true, result: await handleProviderGroupRemote(d, 'laptop', args[0]) };
+ });
+ await expect(createProviderGroupRemoteClient(invoke).usage('mini', { seq: 1, sinceDay: null, rows }, () => {
+ if (!current) throw new Error('account changed before dispatch');
+ })).rejects.toThrow('account changed before dispatch');
+ expect(d.replaceReportedUsage).not.toHaveBeenCalled();
+ expect(invoke).toHaveBeenCalledTimes(1);
+ });
+
+ it('账本替换抛错不记已提交序号,同一个尾批可以重试', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', part(1, 0));
+ vi.mocked(d.replaceReportedUsage).mockImplementationOnce(() => { throw new Error('store failure'); });
+ await expect(handleProviderGroupRemote(d, 'laptop', part(1, 3000))).rejects.toThrow('store failure');
+ await expect(handleProviderGroupRemote(d, 'laptop', part(1, 3000))).resolves.toMatchObject({ committed: true });
+ expect(d.replaceReportedUsage).toHaveBeenLastCalledWith('laptop', null, rows);
+ });
+});
+
describe('decorateProviderListWithGroups', () => {
it('adds the group summary only to providers that have a group and stay open for remote use', () => {
const result = decorateProviderListWithGroups({
diff --git a/apps/desktop/src/main/provider-group/__tests__/usageReporter.test.ts b/apps/desktop/src/main/provider-group/__tests__/usageReporter.test.ts
index 7512713001..1ebf0b74dc 100644
--- a/apps/desktop/src/main/provider-group/__tests__/usageReporter.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/usageReporter.test.ts
@@ -8,7 +8,6 @@ import type { ProviderGroupRemoteUsageRow } from '../../../shared/providerGroup'
import { ProviderGroupRemoteUnsupportedError } from '../remoteClient';
import {
createProviderGroupUsageReporter,
- fitUsageReport,
PROVIDER_GROUP_USAGE_DEBOUNCE_MS,
PROVIDER_GROUP_USAGE_RETRY_MIN_MS,
PROVIDER_GROUP_USAGE_STARTUP_DELAY_MS,
@@ -145,14 +144,16 @@ describe('provider group usage reporter', () => {
expect(send).toHaveBeenCalledTimes(2);
reporter.dispose();
});
-});
-describe('fitUsageReport', () => {
- it('keeps whole days from the newest when there are too many rows', () => {
- const rows = [row('2026-10-09'), row('2026-10-10'), row('2026-10-10', 2), row('2026-10-11')];
- expect(fitUsageReport(rows, null, 10)).toEqual({ sinceDay: null, rows });
- const fitted = fitUsageReport(rows, null, 3);
- expect(fitted.sinceDay).toBe('2026-10-10');
- expect(fitted.rows.map((item) => item.day).sort()).toEqual(['2026-10-10', '2026-10-10', '2026-10-11']);
+ it('单日超过 3000 行仍发送完整报告,失败后从原起始日重报', async () => {
+ const { reporter, send, ledger } = setup(['mini']);
+ ledger.mini = [row('2026-10-10'), ...Array.from({ length: 3001 }, (_, i) => ({ ...row('2026-10-11'), model: `model-${i}` }))];
+ send.mockRejectedValueOnce(new Error('part transfer interrupted'));
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_USAGE_STARTUP_DELAY_MS);
+ expect(send.mock.calls[0]![1]).toMatchObject({ sinceDay: null, rows: ledger.mini });
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_USAGE_RETRY_MIN_MS);
+ expect(send.mock.calls[1]![1]).toMatchObject({ sinceDay: null, rows: ledger.mini });
+ expect(send.mock.calls[1]![1].seq).toBeGreaterThan(send.mock.calls[0]![1].seq);
+ reporter.dispose();
});
});
diff --git a/apps/desktop/src/main/provider-group/remoteClient.ts b/apps/desktop/src/main/provider-group/remoteClient.ts
index 99b6a6e11e..5deffb97b2 100644
--- a/apps/desktop/src/main/provider-group/remoteClient.ts
+++ b/apps/desktop/src/main/provider-group/remoteClient.ts
@@ -10,17 +10,21 @@ import {
parseProviderGroupRemotePick,
parseProviderGroupRemoteView,
providerGroupUsageRowsForWire,
+ PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS,
+ PROVIDER_GROUP_REMOTE_MAX_USAGE_REPORT_ROWS,
type ProviderGroupRemoteCoolCause,
type ProviderGroupRemoteLease,
type ProviderGroupRemotePick,
type ProviderGroupRemoteUsageRow,
type ProviderGroupView,
} from '../../shared/providerGroup.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
export type ProviderGroupRemoteInvoke = (
deviceId: string,
channel: string,
args: unknown[],
+ options?: { preSend?: () => void },
) => Promise<{ ok: boolean; result?: unknown; error?: { code?: string; message?: string } }>;
export interface ProviderGroupRemoteClient {
@@ -40,7 +44,7 @@ export interface ProviderGroupRemoteClient {
leases(ownerDeviceId: string, seq: number, entries: readonly ProviderGroupRemoteLease[]): Promise<void>;
view(ownerDeviceId: string, providerId: string): Promise<ProviderGroupView>;
/** 报告经组、在组里别的电脑上运行的用量;组所在电脑是旧版本时抛 ProviderGroupRemoteUnsupportedError。 */
- usage(ownerDeviceId: string, report: { seq: number; sinceDay: string | null; rows: readonly ProviderGroupRemoteUsageRow[] }): Promise<void>;
+ usage(ownerDeviceId: string, report: { seq: number; sinceDay: string | null; rows: readonly ProviderGroupRemoteUsageRow[] }, beforeSend?: () => void): Promise<void>;
}
/** 组所在电脑没有这个通道(旧版本):当作没有组。 */
@@ -52,8 +56,10 @@ export class ProviderGroupRemoteUnsupportedError extends Error {
}
export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvoke): ProviderGroupRemoteClient {
- async function call(ownerDeviceId: string, request: Record<string, unknown>): Promise<unknown> {
- const result = await invoke(ownerDeviceId, PROVIDER_GROUP_REMOTE_CHANNEL, [request]);
+ async function call(ownerDeviceId: string, request: Record<string, unknown>, preSend?: () => void): Promise<unknown> {
+ const result = preSend
+ ? await invoke(ownerDeviceId, PROVIDER_GROUP_REMOTE_CHANNEL, [request], { preSend })
+ : await invoke(ownerDeviceId, PROVIDER_GROUP_REMOTE_CHANNEL, [request]);
if (result.ok) return result.result;
if (result.error?.code === 'CHANNEL_NOT_ALLOWED') throw new ProviderGroupRemoteUnsupportedError();
const message = result.error?.message ?? 'provider group request failed';
@@ -98,14 +104,30 @@ export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvok
return parseProviderGroupRemoteView(await call(ownerDeviceId, { action: 'view', providerId }), providerId);
},
- async usage(ownerDeviceId, report) {
+ async usage(ownerDeviceId, report, beforeSend) {
try {
- await call(ownerDeviceId, {
- action: 'usage',
- seq: report.seq,
- sinceDay: report.sinceDay,
- rows: providerGroupUsageRowsForWire(report.rows),
- });
+ const rows = providerGroupUsageRowsForWire(report.rows);
+ if (rows.length <= PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS) {
+ beforeSend?.();
+ await call(ownerDeviceId, { action: 'usage', seq: report.seq, sinceDay: report.sinceDay, rows }, beforeSend);
+ return;
+ }
+ if (rows.length > PROVIDER_GROUP_REMOTE_MAX_USAGE_REPORT_ROWS) {
+ throwIpcError('INVALID_PARAMS', 'provider group usage report exceeds ledger limit');
+ }
+ for (let offset = 0; offset < rows.length; offset += PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS) {
+ beforeSend?.();
+ const part = rows.slice(offset, offset + PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS);
+ const raw = await call(ownerDeviceId, {
+ action: 'usage-part', seq: report.seq, sinceDay: report.sinceDay, offset, total: rows.length, rows: part,
+ }, beforeSend);
+ const ack = raw as { seq?: unknown; received?: unknown; committed?: unknown } | null;
+ if (!ack || ack.seq !== report.seq || ack.received !== offset + part.length
+ || typeof ack.committed !== 'boolean' || (!ack.committed && offset + part.length === rows.length)) {
+ throwIpcError('PRECONDITION_FAILED', 'provider group usage report part was not acknowledged');
+ }
+ if (ack.committed) return;
+ }
} catch (error) {
// 有组、但还不认识用量报告的旧版本:按不支持处理(调用方之后再试)。
if (error instanceof Error && /unknown provider group action/.test(error.message)) {
diff --git a/apps/desktop/src/main/provider-group/remoteHandler.ts b/apps/desktop/src/main/provider-group/remoteHandler.ts
index 368cb542c2..d87276ace8 100644
--- a/apps/desktop/src/main/provider-group/remoteHandler.ts
+++ b/apps/desktop/src/main/provider-group/remoteHandler.ts
@@ -17,10 +17,12 @@ import {
type ProviderGroupConfig,
type ProviderGroupRemotePick,
type ProviderGroupRemoteUsageRow,
+ type ProviderGroupUsagePartAck,
type ProviderGroupView,
} from '../../shared/providerGroup.js';
import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, PROVIDER_GROUP_FAILURE_COOLDOWN_MS } from './router.js';
import type { ProviderGroupOwnerScope } from './runtime.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
/** 报告来的重置时刻最多信多远(账号用量上限最长按周重置),避免一台电脑被异常时刻长期冷却。 */
export const PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS = 8 * 24 * 60 * 60_000;
@@ -39,6 +41,17 @@ export interface ProviderGroupRemoteHandlerDeps {
/** 每个账号、每台报告来的电脑最近收下的用量报告序号(乱序到达的旧份丢弃)。按账号的负载对象区分账号。 */
const usageReportSeqs = new WeakMap<object, Map<string, number>>();
+/** 每个账号、每台报告电脑只暂存一份;断开后保留旧账本,后续完整报告会重发。 */
+interface PendingUsageReport {
+ seq: number;
+ sinceDay: string | null;
+ total: number;
+ rows: ProviderGroupRemoteUsageRow[];
+ lastAt: number;
+}
+const pendingUsageReports = new WeakMap<object, Map<string, PendingUsageReport>>();
+export const PROVIDER_GROUP_USAGE_PART_TTL_MS = 10 * 60_000;
+
/**
* 给同账号电脑的 `maker:provider:list` 补组摘要与运行数,都只加在仍允许被远程调用的供应商上:
* 建了组的带 `group`;`running`(这台电脑上每个供应商正在运行一轮的任务数,localLoad.ts)给出时每个都带
@@ -85,7 +98,7 @@ export async function handleProviderGroupRemote(
deps: ProviderGroupRemoteHandlerDeps,
controller: string,
raw: unknown,
-): Promise<ProviderGroupRemotePick | ProviderGroupView | Record<string, never>> {
+): Promise<ProviderGroupRemotePick | ProviderGroupView | ProviderGroupUsagePartAck | Record<string, never>> {
const request = parseProviderGroupRemoteRequest(raw);
const scope = deps.scope();
switch (request.action) {
@@ -128,20 +141,56 @@ export async function handleProviderGroupRemote(
if (!deps.isRemoteAllowed(request.providerId)) return { providerId: request.providerId, config: null, members: [] };
return scope.router.view(request.providerId);
}
- case 'usage': {
+ case 'usage':
+ case 'usage-part': {
if (!scope.isCurrent()) return {};
let seqs = usageReportSeqs.get(scope.externalLoad);
if (!seqs) {
seqs = new Map();
usageReportSeqs.set(scope.externalLoad, seqs);
}
- if ((seqs.get(controller) ?? -1) >= request.seq) return {};
- seqs.set(controller, request.seq);
+ const ack = (committed: boolean): ProviderGroupUsagePartAck | Record<string, never> =>
+ request.action === 'usage-part'
+ ? { seq: request.seq, received: request.offset + request.rows.length, committed }
+ : {};
+ if ((seqs.get(controller) ?? -1) >= request.seq) return ack(true);
+ let incoming = request.rows;
+ let pending = pendingUsageReports.get(scope.externalLoad);
+ if (request.action === 'usage-part') {
+ if (!pending) {
+ pending = new Map();
+ pendingUsageReports.set(scope.externalLoad, pending);
+ }
+ const now = deps.now();
+ for (const [device, report] of pending) {
+ if (now - report.lastAt >= PROVIDER_GROUP_USAGE_PART_TTL_MS) pending.delete(device);
+ }
+ let report = pending.get(controller);
+ if (!report || report.seq < request.seq) {
+ if (request.offset !== 0) throwIpcError('PRECONDITION_FAILED', 'usage report must restart from first part');
+ report = { seq: request.seq, sinceDay: request.sinceDay, total: request.total, rows: [], lastAt: now };
+ pending.set(controller, report);
+ }
+ if (report.seq !== request.seq || report.total !== request.total || report.sinceDay !== request.sinceDay
+ || request.offset !== report.rows.length) {
+ throwIpcError('PRECONDITION_FAILED', 'usage report part does not match pending report');
+ }
+ // 未收齐时不动账本,下一批失败、进程重启或换账号都不会用半份覆盖完整记录。
+ incoming = [...report.rows, ...request.rows];
+ if (incoming.length < report.total) {
+ report.rows = incoming;
+ report.lastAt = now;
+ return ack(false);
+ }
+ }
// 分到本机这台的那部分本机自己记过,报来的不再算一次。不按现在有没有组筛:组删了又建、这次整份报告时
// 那几个供应商的历史也要留着(报告整体替换那台从 sinceDay 起的全部行)。
- const rows = request.rows.filter((row) => row.memberKey !== PROVIDER_GROUP_LOCAL_MEMBER_KEY);
+ const rows = incoming.filter((row) => row.memberKey !== PROVIDER_GROUP_LOCAL_MEMBER_KEY);
deps.replaceReportedUsage(controller, request.sinceDay, rows);
- return {};
+ // 只有替换成功才记去重序号;落盘入口抛错时同一份仍能重试。
+ seqs.set(controller, request.seq);
+ if ((pending?.get(controller)?.seq ?? Infinity) <= request.seq) pending?.delete(controller);
+ return ack(true);
}
}
}
diff --git a/apps/desktop/src/main/provider-group/usageReportRuntime.ts b/apps/desktop/src/main/provider-group/usageReportRuntime.ts
index 448de075dc..227b3468ce 100644
--- a/apps/desktop/src/main/provider-group/usageReportRuntime.ts
+++ b/apps/desktop/src/main/provider-group/usageReportRuntime.ts
@@ -25,8 +25,10 @@ export function ensureProviderGroupUsageReporter(): ProviderGroupUsageReporter |
rows: (owner, sinceDay) => store.groupReport(owner, sinceDay),
send: async (owner, report) => {
// 只在这个账号还是当前账号时发:别的账号的连接上不发这份,之后照常重试。
- if (currentProviderPartyUsageStore() !== store) throw new Error('account is not active');
- await getProviderGroupRemoteClient().usage(owner, report);
+ await getProviderGroupRemoteClient().usage(owner, report, () => {
+ // 大报告的每一批都重查,上一批在途时换账号不能在新账号的连接上继续发送旧账本。
+ if (currentProviderPartyUsageStore() !== store) throw new Error('account is not active');
+ });
},
now: () => Date.now(),
log,
diff --git a/apps/desktop/src/main/provider-group/usageReporter.ts b/apps/desktop/src/main/provider-group/usageReporter.ts
index c2cdd81fbb..5c3b024483 100644
--- a/apps/desktop/src/main/provider-group/usageReporter.ts
+++ b/apps/desktop/src/main/provider-group/usageReporter.ts
@@ -8,10 +8,7 @@
* - 送不到(离线、断线)按退避稍后重报;对方是还不认识用量报告的旧版本时隔得更久再试;
* - 只影响用量显示,失败只记日志,不影响任务。
*/
-import {
- PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS,
- type ProviderGroupRemoteUsageRow,
-} from '../../shared/providerGroup.js';
+import type { ProviderGroupRemoteUsageRow } from '../../shared/providerGroup.js';
import { ProviderGroupRemoteUnsupportedError } from './remoteClient.js';
export const PROVIDER_GROUP_USAGE_DEBOUNCE_MS = 5_000;
@@ -58,36 +55,6 @@ function earlier(a: Pending | undefined, b: Pending): Pending {
return a < b ? a : b;
}
-/**
- * 行数超过一次报告的上限时,从最新的一天往前取整天,取到放不下为止;返回实际报告的起始日。
- * 更早的几天对方留着上次收到的那份。
- */
-export function fitUsageReport(
- rows: readonly ProviderGroupRemoteUsageRow[],
- sinceDay: string | null,
- max = PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS,
-): { sinceDay: string | null; rows: ProviderGroupRemoteUsageRow[] } {
- if (rows.length <= max) return { sinceDay, rows: [...rows] };
- const byDay = new Map<string, ProviderGroupRemoteUsageRow[]>();
- for (const row of rows) {
- const list = byDay.get(row.day);
- if (list) list.push(row);
- else byDay.set(row.day, [row]);
- }
- const days = [...byDay.keys()].sort().reverse();
- const out: ProviderGroupRemoteUsageRow[] = [];
- let first: string | null = null;
- for (const day of days) {
- const dayRows = byDay.get(day)!;
- if (out.length + dayRows.length > max) break;
- out.push(...dayRows);
- first = day;
- }
- // 单单一天就超了上限(不现实):只报这一天里最新的那些行。
- if (first === null && days[0]) return { sinceDay: days[0], rows: byDay.get(days[0])!.slice(0, max) };
- return { sinceDay: first, rows: out };
-}
-
export function createProviderGroupUsageReporter(deps: ProviderGroupUsageReporterDeps): ProviderGroupUsageReporter {
const schedule = deps.setTimeout ?? ((fn, ms) => {
const timer = setTimeout(fn, ms);
@@ -130,10 +97,11 @@ export function createProviderGroupUsageReporter(deps: ProviderGroupUsageReporte
const since = pending.get(owner);
if (since === undefined) return;
pending.delete(owner);
- const fitted = fitUsageReport(deps.rows(owner, since === 'all' ? null : since), since === 'all' ? null : since);
inFlight.add(owner);
try {
- await deps.send(owner, { seq: nextSeq(), ...fitted });
+ const sinceDay = since === 'all' ? null : since;
+ // 完整快照由 remoteClient 按帧上限分批发送;不能截断单日或丢掉尚未报告的旧日期。
+ await deps.send(owner, { seq: nextSeq(), sinceDay, rows: deps.rows(owner, sinceDay) });
failures.delete(owner);
} catch (error) {
// 没送到:把这次的起始日并回去,稍后整段重报。
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index 1e01f1d94e..b996e42245 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -306,8 +306,16 @@ export interface ProviderGroupRemoteUsageRow {
lastAt: number;
}
-/** 一次最多报告的用量行;多出来的按天从新到旧截断,旧的几天留在组所在电脑上次收到的那份。 */
+/** 单次请求的行数上限;完整报告超过此值时用 usage-part 分批收齐后再替换。 */
export const PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS = 3_000;
+/** 完整报告的上限,与按使用方账本的保留行数一致;不提高单帧上限。 */
+export const PROVIDER_GROUP_REMOTE_MAX_USAGE_REPORT_ROWS = 20_000;
+
+export interface ProviderGroupUsagePartAck {
+ seq: number;
+ received: number;
+ committed: boolean;
+}
export type ProviderGroupRemoteRequest =
/** 新任务该用组里哪台;选中即给那台记一个短暂的占用,同时开的几个任务不会全落到同一台。 */
@@ -322,7 +330,9 @@ export type ProviderGroupRemoteRequest =
* 这台电脑经组、在组里别的电脑上运行的用量(组所在电脑经手不到):整体替换这台从 sinceDay 起(含;null = 全部)
* 报过的行。seq 只增,乱序到达的旧份丢弃。
*/
- | { action: 'usage'; seq: number; sinceDay: string | null; rows: ProviderGroupRemoteUsageRow[] };
+ | { action: 'usage'; seq: number; sinceDay: string | null; rows: ProviderGroupRemoteUsageRow[] }
+ /** 新动作防止旧端忽略分批字段后把半份报告当整份替换。offset 从 0 开始,收齐 total 才提交。 */
+ | { action: 'usage-part'; seq: number; sinceDay: string | null; offset: number; total: number; rows: ProviderGroupRemoteUsageRow[] };
export type ProviderGroupRemotePick =
/** 那个供应商现在没有组(组被删了或旧版本):照常直接在组所在电脑上运行。 */
@@ -436,12 +446,19 @@ export function parseProviderGroupRemoteRequest(raw: unknown): ProviderGroupRemo
}
case 'view':
return { action: 'view', providerId: remoteProviderId(value.providerId) };
- case 'usage': {
+ case 'usage':
+ case 'usage-part': {
if (!Number.isSafeInteger(value.seq) || (value.seq as number) < 0) invalidRemote('invalid seq');
const sinceDay = value.sinceDay ?? null;
if (sinceDay !== null && (typeof sinceDay !== 'string' || !REMOTE_DAY.test(sinceDay))) invalidRemote('invalid since day');
if (!Array.isArray(value.rows) || value.rows.length > PROVIDER_GROUP_REMOTE_MAX_USAGE_ROWS) invalidRemote('invalid usage rows');
- return { action: 'usage', seq: value.seq as number, sinceDay: sinceDay as string | null, rows: value.rows.map(remoteUsageRow) };
+ const report = { seq: value.seq as number, sinceDay: sinceDay as string | null, rows: value.rows.map(remoteUsageRow) };
+ if (value.action === 'usage') return { action: 'usage', ...report };
+ if (!Number.isSafeInteger(value.total) || (value.total as number) < 1
+ || (value.total as number) > PROVIDER_GROUP_REMOTE_MAX_USAGE_REPORT_ROWS) invalidRemote('invalid usage total');
+ if (!Number.isSafeInteger(value.offset) || (value.offset as number) < 0
+ || report.rows.length === 0 || (value.offset as number) + report.rows.length > (value.total as number)) invalidRemote('invalid usage offset');
+ return { action: 'usage-part', ...report, offset: value.offset as number, total: value.total as number };
}
default:
invalidRemote('unknown provider group action');
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index c111d32231..421d8d317b 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -931,23 +931,33 @@ G 重新打开时换一台。G 与 O 之间新增四项可选内容,O 与 M
cacheCreateTokens, sdkCostUsd, lastAt]`,最多 3000 行;供应商与组内电脑都是 O 的坐标(`memberKey` 是 O 组里的稳定键)。
结构与校验在 `apps/desktop/src/shared/providerGroup.ts`(`parseProviderGroupRemoteRequest`、`providerGroupUsageRowsForWire`)。
- 语义是整体替换:O 删掉 C 报过的、`sinceDay`(含;null = 全部)起的行,再写入这一份;重复送同一份不多算。`seq` 只增
- (C 按时间生成),同一账号里乱序到达的旧份丢弃;换了账号之后到达的不收。
+ (C 以时间生成并以已持久化的上次序号为下限),同一账号里乱序到达的旧份丢弃;换了账号之后到达的不收。
- O 丢掉 `memberKey === 'local'` 的行(分到 O 本身的那部分 O 自己记过);不按此刻有没有组筛,组删了又建时整份报告
也不会抹掉那几个供应商的历史。
- C 侧:任务此刻所在电脑与供应商和绑定那台对得上才算经组(绑定没清掉的空档里不报);每轮记进按账号的账本(`group` 行,
只用来报告,不算进 C 自己的供应商),防抖 5s 报从那天起的一份;启动(账号确定)
- 后整份报一次补上次没送到的;送不到按 30s 起、最长 10 分钟退避重报;行数超上限时从最新一天往前取整天。
+ 后整份报一次补上次没送到的;送不到按 30s 起、最长 10 分钟退避重报,不截断单日或未报告的旧日期。
+- **超出单次 3000 行时用新动作 `usage-part` 分批传完整报告**:
+ - 请求 `{ action: 'usage-part', seq, sinceDay, offset, total, rows }`;每批仍最多 3000 行,整份最多 20000 行,
+ 与按使用方账本的保留上限一致。回包 `{ seq, received, committed }`,`received` 是本批结束的行偏移。
+ - O 按账号、报告电脑隔离暂存,每台只留一份;从 offset 0 开始顺序收取,同一份的 seq、sinceDay 和 total 必须一致。
+ 收齐后才整体替换并登记去重序号。缺批、乱序、暂存过期(10 分钟)或 O 重启都要求 C 从头重报,旧账本不变;
+ 更新的整份报告可替换未完成的暂存,已提交的旧序号不会重复记账。
+ - C 每批发出前重查账号仍有效,回执不足或任一批失败保留重报意图,用新序号从原起始日重新报告;
+ 故障只作用于这台组所在电脑的这份用量,不重建 link 或 relay,不影响任务及其它控制端。
- **兼容**:
- 旧 O(认识 `provider-group:remote`、不认识 `usage`)回 `[INVALID_PARAMS] unknown provider group action`,更早的回
`CHANNEL_NOT_ALLOWED`:C 都按不支持处理,30 分钟后再试,不影响任务;这部分用量在 O 上缺,直到 O 更新。
- 旧 C 不报:O 上缺这部分,其余照旧。
+ - 认识 `usage` 但不认识 `usage-part` 的 O 拒绝新动作;C 按不支持处理并保留完整重报意图,30 分钟后再试,
+ 不回退成部分 `usage` 报告。3000 行以内继续使用原动作。小报告无需双方同时更新,大报告在 O 更新后补报。
- `maker:provider:list`、relay、帧限制、服务器与数据库都不变。
- 降级:已发布的受邀者账本(`provider-share-usage.json`)行键与合计不变,各台组内电脑的分布放在行里的 `byMember`,旧版本
照常累计合计并原样写回,降级不丢用量(降级期间记的回来后算没区分电脑)。按使用方的账本(`provider-usage-by-party.json`)
还没进正式版:从带这次改动的构建降到它之前的构建时,同一天同模型分在几台电脑的行会合成一行(只剩其中一台的数),
`group` / `reported` 行也会被当成「我的其他电脑」,属于已知的降级损失。
- 实现:`apps/desktop/src/main/provider-group/usageReporter.ts`、`usageReportRuntime.ts`、`remoteHandler.ts`(`usage`)、
- `remoteClient.ts`(`usage`)、`remoteRegistration.ts`,`apps/desktop/src/main/usage/providerPartyUsageStore.ts`
+ `remoteClient.ts`(`usage` / `usage-part`)、`remoteRegistration.ts`,`apps/desktop/src/main/usage/providerPartyUsageStore.ts`
(`groupReport` / `replaceReported`),`maker-ipc/sessionProviderPartyUsage.ts`(`groupUsageReportOf`);回归见
`provider-group/__tests__/usageReporter.test.ts`、`remoteHandler.test.ts`、`usage/__tests__/providerPartyUsageStore.test.ts`、
`maker-ipc/__tests__/sessionProviderPartyUsage.test.ts`。