Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* overload-error.test.ts
* ---------------------------------------------------------------------------
* 服务过载类错误识别与退避(maker-core 侧,决定 codex capacity 是否退避重投、
* goal-host 是否安排短窗口续跑)。pattern 与 renderer 的
* apps/desktop/src/renderer/utils/overloadError.ts 语义一致(两处同步,那边有
* 同款用例)。
*
* 锁三件事:
* 1. capacity / overloaded 两种形态分得开——它们由不同的一方负责重试;
* 2. 不误伤业务文案里的 "capacity" 与模型输出里的 "overloaded";
* 3. 退避序列的边界与 jitter 幅度,防止有人顺手把上限调大烧掉用户额度。
*/
import { describe, it, expect } from 'vitest';
import {
OVERLOAD_RETRY_MAX_ATTEMPTS,
formatOverloadRetryMessage,
isOverloadErrorMessage,
overloadRetryDelayMs,
parseOverloadError,
parseOverloadRetryProgress,
} from './overload-error.js';
describe('parseOverloadError', () => {
it('识别 Codex 的模型容量拒绝', () => {
expect(parseOverloadError('Selected model is at capacity. Please try a different model.')).toEqual({
kind: 'capacity',
});
});
it('识别包在 Guardian 审批失败里的容量拒绝', () => {
// 实录形态:容量抖动被 Codex 包装成"安全拒绝",理由里才是真因。
expect(
parseOverloadError(
'Automatic approval review failed: Selected model is at capacity. Please try a different model.',
),
).toEqual({ kind: 'capacity' });
});
it.each([529, undefined])('529 状态码优先判定为 overloaded(errorStatus=%s 时走文本)', (status) => {
const message = status === 529 ? 'upstream busy' : 'overloaded_error: Overloaded';
expect(parseOverloadError(message, status)).toEqual({ kind: 'overloaded' });
});
it('529 状态码的判定不依赖文本措辞', () => {
expect(parseOverloadError('', 529)).toEqual({ kind: 'overloaded' });
});
it.each([
// 业务/实现文案里的 capacity 不是平台容量问题
'buffer capacity dropping → replayLossy',
'dictionary capacity exceeded',
'increase the cache capacity to 256',
// 裸词 overloaded 常出现在模型输出与日志摘要里,不能当平台故障
'the operator is overloaded for this type',
// 邻近的其它错误类别不得被吞进来
'Invalid API key',
'context window exceeded',
'rate limit exceeded',
'Request timed out.',
// 长数字包含 529 片段不误伤(\b 词边界)
'order id 15294 rejected',
])('不误伤非过载消息: %s', (msg) => {
expect(parseOverloadError(msg)).toBeNull();
});
it('isOverloadErrorMessage 与 parseOverloadError 判定一致', () => {
expect(isOverloadErrorMessage('Selected model is at capacity.')).toBe(true);
expect(isOverloadErrorMessage('buffer capacity dropping')).toBe(false);
expect(isOverloadErrorMessage('upstream busy', 529)).toBe(true);
});
// ── 结构化 codexErrorInfo 优先 ───────────────────────────────────────────────
//
// 这一组锁的是「判定不再依赖 codex 的英文文案」。`Selected model is at capacity...`
// 是 codex 二进制里硬编码的用户可见提示语, 不是 API 契约; 它一改, 靠文案驱动的
// 退避重投就静默失效, 而用同一句文案写的测试仍然全绿 —— 所以必须有用例断言
// **文案缺席时也能判定**, 否则等于没有解开这个依赖。
it('结构化 tag 命中时不需要文案配合(真正解开对 codex 文案的依赖)', () => {
// 故意给一句完全不含 "at capacity" 的文案: 模拟 codex 改了措辞。
expect(parseOverloadError('upstream refused the request', undefined, 'serverOverloaded')).toEqual({
kind: 'capacity',
});
// 空文案同理 —— host 合成的错误可能压根没有 message。
expect(parseOverloadError('', undefined, 'serverOverloaded')).toEqual({ kind: 'capacity' });
});
it('结构化 tag 优先于文案与状态码', () => {
// 529 会被判成 overloaded(Anthropic 语义); 有 serverOverloaded tag 时按 Codex
// 的 capacity 处理 —— 决定「由谁重试」, 不能弄反。
expect(parseOverloadError('overloaded_error', 529, 'serverOverloaded')).toEqual({
kind: 'capacity',
});
});
it('非过载的结构化 tag 不触发过载判定', () => {
for (const tag of ['usageLimitExceeded', 'contextWindowExceeded', 'unauthorized', 'other']) {
expect(parseOverloadError('some failure', undefined, tag)).toBeNull();
}
});
it('tag 缺席或不认识时退回文案兜底(老 daemon 不发该字段)', () => {
expect(parseOverloadError('Selected model is at capacity.', undefined, undefined)).toEqual({
kind: 'capacity',
});
// 上游将来新增的变体名: 不认识就当没有, 由文案接手, 不能因此丢掉判定。
expect(parseOverloadError('Selected model is at capacity.', undefined, 'someFutureVariant')).toEqual(
{ kind: 'capacity' },
);
});
it('isOverloadErrorMessage 同样吃结构化 tag', () => {
expect(isOverloadErrorMessage('nothing quotable', undefined, 'serverOverloaded')).toBe(true);
expect(isOverloadErrorMessage('nothing quotable', undefined, 'other')).toBe(false);
});
});
describe('overloadRetryDelayMs', () => {
it('无 jitter 时按 2s 起指数退避', () => {
const mid = () => 0.5; // factor = 1
expect(overloadRetryDelayMs(1, mid)).toBe(2_000);
expect(overloadRetryDelayMs(2, mid)).toBe(4_000);
expect(overloadRetryDelayMs(3, mid)).toBe(8_000);
expect(overloadRetryDelayMs(4, mid)).toBe(16_000);
});
it('单次退避封顶 30s,不随 attempt 无限增长', () => {
const mid = () => 0.5;
expect(overloadRetryDelayMs(5, mid)).toBe(30_000);
expect(overloadRetryDelayMs(50, mid)).toBe(30_000);
});
it('jitter 之后也不越过 30s 上限', () => {
// 只封 base 的话触顶那几档乘上 1.25 会回到约 37.5s, 与常量声明的"单次上限"矛盾。
expect(overloadRetryDelayMs(5, () => 0.999999)).toBe(30_000);
expect(overloadRetryDelayMs(50, () => 0.999999)).toBe(30_000);
// 下边界照常受 jitter 影响(触顶后只能往下拉, 打散作用仍在)。
expect(overloadRetryDelayMs(5, () => 0)).toBe(22_500);
});
it('jitter 幅度为 ±25%', () => {
expect(overloadRetryDelayMs(1, () => 0)).toBe(1_500);
expect(overloadRetryDelayMs(1, () => 0.999999)).toBe(2_500);
});
it('attempt 小于 1 时退化为基数,不产生负指数', () => {
const mid = () => 0.5;
expect(overloadRetryDelayMs(0, mid)).toBe(2_000);
});
it('重试上限保持在小数值,避免容量故障期烧额度', () => {
// 容量被拒时额度照扣,上限调大是有代价的改动,必须显式改测试。
expect(OVERLOAD_RETRY_MAX_ATTEMPTS).toBe(4);
});
});
describe('重投进度编码', () => {
it('保留原始错误原文并追加进度后缀', () => {
const raw = 'Selected model is at capacity. Please try a different model.';
const formatted = formatOverloadRetryMessage(raw, 2, 4);
expect(formatted).toBe(`${raw} (auto-retry 2/4)`);
// 追加后仍必须能被识别为过载错误,否则 renderer 会退回裸英文分支。
expect(isOverloadErrorMessage(formatted)).toBe(true);
});
it('format 与 parse 互为逆运算', () => {
const formatted = formatOverloadRetryMessage('upstream at capacity', 3, 4);
expect(parseOverloadRetryProgress(formatted)).toEqual({ attempt: 3, maxAttempts: 4 });
});
it.each([
// 退避耗尽后的终止错误没有后缀 → 必须区分于"正在重试"
'Selected model is at capacity. Please try a different model.',
// 后缀必须在结尾,防止误配正文里提到的数字
'auto-retry 2/4 was attempted earlier',
// 越界/畸形不接受
'foo (auto-retry 0/4)',
'foo (auto-retry 5/4)',
'foo (auto-retry 2)',
])('无有效进度后缀时返回 null: %s', (msg) => {
expect(parseOverloadRetryProgress(msg)).toBeNull();
});
});