763 lines
43 KiB
JavaScript
763 lines
43 KiB
JavaScript
#!/usr/bin/env node
|
||
'use strict';
|
||
|
||
// 抽取服务端真实重试、开轮、完成与重连函数，只把模型边界和时钟替换为隔离夹具。
|
||
// 会话及完整运行态均使用真实存储实现，所有读写限制在临时目录。
|
||
const assert = require('node:assert/strict');
|
||
const crypto = require('node:crypto');
|
||
const fs = require('node:fs');
|
||
const os = require('node:os');
|
||
const path = require('node:path');
|
||
const { inspect } = require('node:util');
|
||
const vm = require('node:vm');
|
||
const { createServerHarness } = require('./session-history-store-unit');
|
||
const { createCodexAppServerClient } = require('../lib/codex-app-server-client');
|
||
const { LIFECYCLE_EVENT_TYPES: TASK_BOARD_LIFECYCLE_EVENTS } = require('../lib/task-board-lifecycle');
|
||
const { CLASSIFICATION_EVENT_TYPES: TASK_STATUS_CLASSIFICATION_EVENTS } = require('../lib/task-board-classifier');
|
||
|
||
const REPO_DIR = path.join(__dirname, '..');
|
||
const baselineIndex = process.argv.indexOf('--baseline');
|
||
const sourcePath = baselineIndex >= 0 ? process.argv[baselineIndex + 1] : path.join(REPO_DIR, 'server.js');
|
||
assert(sourcePath, '--baseline 需要提供修复前工作区 server.js 快照路径');
|
||
const serverSource = fs.readFileSync(sourcePath, 'utf8');
|
||
const runtimePath = baselineIndex >= 0 && fs.existsSync(path.join(path.dirname(sourcePath), 'ccweb-streaming-retry-baseline-runtime.js'))
|
||
? path.join(path.dirname(sourcePath), 'ccweb-streaming-retry-baseline-runtime.js')
|
||
: path.join(REPO_DIR, 'lib/codex-app-runtime.js');
|
||
const { createCodexAppRuntime } = require(runtimePath);
|
||
|
||
function extractFunction(name, optional = false) {
|
||
const match = new RegExp(`(?:^|\\n)(?:async )?function ${name}\\(`).exec(serverSource);
|
||
if (!match && optional) return '';
|
||
assert(match, `缺少生产函数 ${name}`);
|
||
const start = match.index + (serverSource[match.index] === '\n' ? 1 : 0);
|
||
const closingLine = /\n\}/g;
|
||
closingLine.lastIndex = start;
|
||
let end;
|
||
while ((end = closingLine.exec(serverSource))) {
|
||
const candidate = serverSource.slice(start, end.index + 2);
|
||
try {
|
||
new vm.Script(`(${candidate})`, { filename: sourcePath });
|
||
return candidate;
|
||
} catch (error) {
|
||
if (!(error instanceof SyntaxError)) throw error;
|
||
}
|
||
}
|
||
throw new Error(`${name} 函数体不完整`);
|
||
}
|
||
|
||
function extractConst(name) {
|
||
const match = serverSource.match(new RegExp(`^const ${name} = .*;$`, 'm'));
|
||
assert(match, `缺少生产常量 ${name}`);
|
||
return match[0];
|
||
}
|
||
|
||
function createApi(dir, options = {}) {
|
||
const storeApi = createServerHarness(dir);
|
||
const sent = [];
|
||
const logs = [];
|
||
const starts = [];
|
||
const runtimeRef = { current: null };
|
||
const timers = new Map();
|
||
const maps = Object.fromEntries([
|
||
'activeProcesses', 'activeCodexAppTurns', 'activeCodexAppGoalCommands', 'activeCodexAppCompactions',
|
||
'codexAppGoalStates', 'pendingCompactRetries', 'pendingCodexCapacityRetries', 'retainedCodexAppTurns',
|
||
'retiredCodexAppRuntimeTurns', 'wsSessionMap', 'ccwebMcpChildThreads',
|
||
].map(name => [name, new Map()]));
|
||
const realSaveTurn = storeApi.sessionHistoryStore.saveTurn.bind(storeApi.sessionHistoryStore);
|
||
storeApi.sessionHistoryStore.saveTurn = (...args) => {
|
||
if (options.failTurnSave) { const error = new Error('夹具：完整运行态保存失败'); error.code = 'ENOSPC'; throw error; }
|
||
return realSaveTurn(...args);
|
||
};
|
||
const requiredNames = [
|
||
'readPositiveIntEnv', 'sanitizeId', 'runDir', 'writeFileAtomicSync', 'cleanRunDir',
|
||
'textByteLength', 'truncateTextValue', 'sanitizePersistValue', 'sanitizeToolCallsForPersist',
|
||
'mapToPairs', 'codexAppStatePath', 'codexAppTurnKey', 'serializeCodexAppEntry',
|
||
'buildCodexAppStateJson', 'writeCodexAppTurnState', 'persistCodexAppTurnState',
|
||
'cleanupCodexAppTurnState', 'loadCodexAppTurnState', 'hasCodexAppTurnMessage',
|
||
'appendCodexAppRecoveryNotice', 'recoverCodexAppTurnState',
|
||
'hasRuntimeOutput', 'retryTailText', 'retryPreviewValue', 'buildCodexRetryToolSummary',
|
||
'shouldUseCodexAppContinuationRetry', 'buildCodexAppContinuationRetryText',
|
||
'isCodexTransientCapacityError', 'isCodexTransientConnectionError', 'isCodexTransientRetryableError',
|
||
'codexTransientRetryDelayMs', 'cancelCodexCapacityRetry', 'shouldRetryCodexTransientFailure',
|
||
'scheduleCodexCapacityRetry', 'stableMessageHash', 'messageReplyToRequestId', 'ensureStableMessageId',
|
||
'handleMessage', 'handleCodexAppMessage', 'handleCodexAppTurnComplete', 'handleCodexAppTurnFailure',
|
||
'attachActiveRuntimeToWs', 'handleResumeSession', 'isSessionRunning',
|
||
'bindAbortSessionToWs', 'handleCodexAppAbortSession', 'handleAbort',
|
||
'codexAppRuntimeThreadId', 'codexAppRuntimeTurnId', 'findCodexAppEntryByRuntime',
|
||
'isCodexAppAdoptableRuntimeMethod', 'adoptCodexAppUnroutedTurn', 'findCodexAppRouteByRuntime',
|
||
'handleCodexAppNotification', 'handleCodexAppServerExit',
|
||
];
|
||
const constNames = [
|
||
'CODEX_APP_STATE_FULL_TEXT_MAX_CHARS', 'CODEX_APP_STATE_MAP_VALUE_MAX_CHARS', 'CODEX_APP_STATE_MAX_MAP_ENTRIES',
|
||
'CODEX_APP_STATE_MAX_BYTES', 'CODEX_APP_STATE_LOAD_MAX_BYTES', 'CODEX_APP_STATE_FILE',
|
||
'CODEX_APP_STATE_FLUSH_DELAY_MS', 'SESSION_MESSAGE_CONTENT_MAX_CHARS',
|
||
'SESSION_TOOL_INPUT_MAX_CHARS', 'SESSION_TOOL_RESULT_MAX_CHARS', 'SESSION_MAX_TOOL_CALLS_PER_MESSAGE',
|
||
'PERSIST_TRUNCATED_TEXT',
|
||
];
|
||
const optionalNames = [
|
||
'ensureCodexAppAssistantMessageId', 'buildCodexAppResumePayload', 'retirePendingCodexCapacityRetry',
|
||
'retireCodexAppRuntimeTurn', 'codexAppAssistantMessageIdForEntry',
|
||
];
|
||
const api = new Function('deps', `
|
||
const { fs, path, crypto, dir, storeApi, sent, logs, starts, timers, maps, options, runtimeRef,
|
||
TASK_BOARD_LIFECYCLE_EVENTS, TASK_STATUS_CLASSIFICATION_EVENTS } = deps;
|
||
const SESSIONS_DIR = dir;
|
||
const INITIAL_HISTORY_COUNT = 12;
|
||
const DEFAULT_CODEX_CONFIG = { retry: { intervalSeconds: 1 } };
|
||
const { activeProcesses, activeCodexAppTurns, activeCodexAppGoalCommands, activeCodexAppCompactions,
|
||
codexAppGoalStates, pendingCompactRetries, pendingCodexCapacityRetries, retainedCodexAppTurns,
|
||
retiredCodexAppRuntimeTurns, wsSessionMap, ccwebMcpChildThreads } = maps;
|
||
const sessionHistoryStore = storeApi.sessionHistoryStore;
|
||
const loadSession = id => options.failSessionLoad ? null : storeApi.loadSession(id);
|
||
const saveSession = session => options.failSessionSave ? false : storeApi.saveSession(session);
|
||
const wsSend = (ws, payload) => sent.push({ ...payload, _ws: ws });
|
||
const plog = (level, event, data) => logs.push({ level, event, ...data });
|
||
const setTimeout = (callback, delay) => {
|
||
const timer = { callback, delay, unref() {} }; timers.set(timer, timer); return timer;
|
||
};
|
||
const clearTimeout = timer => timers.delete(timer);
|
||
const getCodexRetryConfig = () => ({ mode: 'limited', maxAttempts: 3, intervalSeconds: 1, ...options.retryConfig });
|
||
const crossConversationReplyRequestIds = () => [];
|
||
const resolveMessageAttachments = () => [];
|
||
const resolveComposerDecorators = text => ({ runtimeText: text, mentions: [] });
|
||
const attachClientRequestId = (payload, source) => ({ ...payload, requestId: source?.requestId });
|
||
const isCodexAppGoalActive = () => false;
|
||
const isCodexAppSession = session => session?.agent === 'codexapp';
|
||
const getSessionAgent = session => session?.agent || 'claude';
|
||
const getRuntimeSessionId = session => session?.codexAppThreadId || null;
|
||
const getDefaultSessionCwd = () => dir;
|
||
const normalizeAgent = agent => agent || 'codexapp';
|
||
const getDefaultCodexModel = () => 'fixture-model';
|
||
const normalizeSession = session => session;
|
||
const normalizeGiteaSource = value => value || null;
|
||
const reconcilePendingCrossConversationReplies = () => false;
|
||
const flushPendingCrossConversationReplies = () => false;
|
||
const detachWsFromActiveRuntimes = () => {};
|
||
const sendSessionList = () => {};
|
||
const broadcastSessionList = () => {};
|
||
const dispatchTaskBoardLifecycle = () => Promise.resolve(null);
|
||
const enqueueTaskStatusClassification = () => Promise.resolve(null);
|
||
const resolvePendingCodexAppUserInputsForSession = () => {};
|
||
const resolvePendingCodexAppApprovalsForSession = () => {};
|
||
const resolvePendingCodexAppElicitationsForSession = () => {};
|
||
const formatRuntimeError = (agent, raw) => String(raw || '');
|
||
const completeCrossConversationReply = () => false;
|
||
const recoverCcwebMcpChildThreadsFromPersistedToolCalls = () => {};
|
||
const setRuntimeSessionId = (session, threadId) => { session.codexAppThreadId = threadId; };
|
||
const resolveSessionHistory = storeApi.resolveSessionHistory;
|
||
const sanitizeMessageForTransport = value => value;
|
||
const sanitizeMessagesForTransport = value => value;
|
||
const wss = { clients: [] };
|
||
const buildNotifyContent = async () => ({ title: '', content: '' });
|
||
const sendNotification = () => {};
|
||
const giteaWorkflowWaiters = new Map();
|
||
const settleGiteaWorkflowTurn = () => Promise.resolve(null);
|
||
let codexAppClient = options.runtimeClient || null;
|
||
let codexAppClientSignature = 'fixture-signature';
|
||
const pauseCodexAppGoalForAbort = () => false;
|
||
const cancelCodexAppGoalCommand = () => false;
|
||
const cancelCodexAppCompaction = () => false;
|
||
const codexAppInputFromMessage = text => text ? [{ type: 'text', text }] : [];
|
||
const normalizeCodexAppThreadId = value => String(value || '').trim();
|
||
const getCodexAppClient = () => ({ client: options.runtimeClient });
|
||
const codexAppThreadParams = () => ({});
|
||
const ensureCodexAppMcpReadyForThread = async () => {};
|
||
const codexAppTurnParams = (session, input, threadId, clientUserMessageId) => ({ input, threadId, clientUserMessageId });
|
||
const codexAppRuntime = { processCodexAppNotification: (...args) => runtimeRef.current.processCodexAppNotification(...args) };
|
||
const handleCodexAppGoalNotification = () => false;
|
||
const handleCodexAppMcpStartupStatusNotification = () => false;
|
||
const shouldLogCodexAppUnroutedNotification = () => false;
|
||
const syncCcwebMcpChildAgentsFromCollabItem = () => {};
|
||
const processCcwebMcpChildNotification = () => ({ changed: false });
|
||
const sendCcwebMcpChildAgentUpdate = () => {};
|
||
const findViewingSessionWs = id => [...wsSessionMap].find(([, sessionId]) => sessionId === id)?.[0] || null;
|
||
const findCodexAppSessionByThreadId = threadId => {
|
||
for (const id of new Set(wsSessionMap.values())) {
|
||
const session = loadSession(id);
|
||
if (session?.codexAppThreadId === threadId) return { sessionId: id, session };
|
||
}
|
||
return null;
|
||
};
|
||
// 仅替换真正的模型边界；调度器、hideInHistory 与新 entry 的交接全部执行生产函数。
|
||
let startCodexAppTurn = async (sessionId, input) => {
|
||
const entry = activeCodexAppTurns.get(sessionId);
|
||
starts.push({ sessionId, input });
|
||
if (options.failStart) throw new Error('夹具：线程启动失败');
|
||
if (options.startTurn) { await options.startTurn(sessionId, input, entry); return; }
|
||
entry.turnId = 'fixture-turn-' + starts.length;
|
||
persistCodexAppTurnState(sessionId, entry, { immediate: true });
|
||
};
|
||
${requiredNames.map(name => extractFunction(name)).join('\n')}
|
||
${optionalNames.map(name => extractFunction(name, true)).join('\n')}
|
||
${constNames.map(name => extractConst(name)).join('\n')}
|
||
if (options.realStart) startCodexAppTurn = (${extractFunction('startCodexAppTurn')});
|
||
return {
|
||
handleMessage, handleCodexAppMessage, handleCodexAppTurnComplete, handleCodexAppTurnFailure,
|
||
scheduleCodexCapacityRetry, cancelCodexCapacityRetry, attachActiveRuntimeToWs, handleResumeSession,
|
||
handleAbort, writeCodexAppTurnState, loadCodexAppTurnState, persistCodexAppTurnState,
|
||
recoverCodexAppTurnState, codexAppTurnKey, isSessionRunning, findCodexAppEntryByRuntime,
|
||
handleCodexAppNotification, handleCodexAppServerExit,
|
||
};
|
||
`)({ fs, path, crypto, dir, storeApi, sent, logs, starts, timers, maps, options, runtimeRef,
|
||
TASK_BOARD_LIFECYCLE_EVENTS, TASK_STATUS_CLASSIFICATION_EVENTS });
|
||
const runtime = createCodexAppRuntime({ wsSend: (ws, payload) => sent.push({ ...payload, _ws: ws }),
|
||
loadSession: storeApi.loadSession, saveSession: storeApi.saveSession });
|
||
runtimeRef.current = runtime;
|
||
async function fireRetry(sessionId) {
|
||
const retry = maps.pendingCodexCapacityRetries.get(sessionId);
|
||
assert(retry?.timer, '应已安排自动重试计时器');
|
||
timers.delete(retry.timer);
|
||
retry.timer.callback();
|
||
await Promise.resolve();
|
||
await Promise.resolve();
|
||
}
|
||
return { ...api, ...maps, runtime, storeApi, sent, logs, starts, timers, fireRetry, options };
|
||
}
|
||
|
||
const ERROR = 'Our servers are currently overloaded. Please try again later.';
|
||
const A = 'A正文首段唯一\n' + '甲'.repeat(220000) + '\nA正文尾段唯一';
|
||
const B = 'B正文唯一\n' + '乙'.repeat(15000) + '\nB正文结束唯一';
|
||
const C = 'C正文唯一\n' + '丙'.repeat(15000) + '\nC正文结束唯一';
|
||
|
||
function seed(api, id = 'retry-history', text = '继续长任务') {
|
||
const session = { id, title: '重试历史夹具', agent: 'codexapp', codexAppThreadId: 'fixture-thread',
|
||
model: 'fixture-model', permissionMode: 'yolo', cwd: '/fixture', messages: [] };
|
||
assert.equal(api.storeApi.saveSession(session), true);
|
||
const ws = { readyState: 1, label: 'initial' };
|
||
assert.equal(api.handleMessage(ws, { type: 'message', sessionId: id, agent: 'codexapp',
|
||
clientMessageId: 'original-user', text, mode: 'yolo' }).ok, true);
|
||
return { id, ws };
|
||
}
|
||
|
||
function emit(api, id, text, label, reusedId = false) {
|
||
const entry = api.activeCodexAppTurns.get(id);
|
||
assert(entry, '应有活动 entry');
|
||
const base = { threadId: entry.threadId, turnId: entry.turnId };
|
||
const agentId = reusedId ? 'agent-fixed' : 'agent-' + label;
|
||
const toolId = reusedId ? 'tool-fixed' : 'tool-' + label;
|
||
for (let offset = 0; offset < text.length; offset += 8192) {
|
||
api.runtime.processCodexAppNotification(entry, { method: 'item/agentMessage/delta',
|
||
params: { ...base, itemId: agentId, delta: text.slice(offset, offset + 8192) } }, id);
|
||
}
|
||
api.runtime.processCodexAppNotification(entry, { method: 'item/completed',
|
||
params: { ...base, item: { id: agentId, type: 'agentMessage', text } } }, id);
|
||
api.runtime.processCodexAppNotification(entry, { method: 'item/started',
|
||
params: { ...base, item: { id: toolId, type: 'commandExecution',
|
||
command: 'fixture-' + label + '-' + '输入'.repeat(10000), status: 'inProgress' } } }, id);
|
||
api.runtime.processCodexAppNotification(entry, { method: 'item/commandExecution/outputDelta',
|
||
params: { ...base, itemId: toolId, delta: '工具' + label + '结果' + '输出'.repeat(20000) } }, id);
|
||
api.writeCodexAppTurnState(id, entry);
|
||
return entry;
|
||
}
|
||
|
||
function assertToolOrder(tools, labels) {
|
||
assert.equal(tools.length, labels.length, '工具调用数量不能缩水或重复');
|
||
labels.forEach((label, index) => assert(tools[index].result.includes('工具' + label + '结果'), '工具结果必须按开轮顺序保留'));
|
||
assert.equal(new Set(tools.map(tool => tool.id)).size, labels.length, '跨轮同原生 ID 必须独立保存');
|
||
}
|
||
|
||
function assertOnceInOrder(text, parts) {
|
||
let end = -1;
|
||
for (const part of parts) {
|
||
const at = text.indexOf(part);
|
||
assert(at > end, '正文应完整保留并按 A → B → C 排序');
|
||
assert.equal(text.indexOf(part, at + part.length), -1, '同一段正文不能重复');
|
||
end = at + part.length - 1;
|
||
}
|
||
}
|
||
|
||
let passed = 0;
|
||
const failures = [];
|
||
async function check(name, callback) {
|
||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ccweb-retry-history-'));
|
||
try {
|
||
await callback(dir);
|
||
passed += 1;
|
||
console.log(`通过：${name}`);
|
||
} catch (error) {
|
||
failures.push(name);
|
||
console.error(`失败：${name}：${inspect({ name: error.name, message: error.message.slice(0, 600),
|
||
stack: error.stack?.split('\n').filter(line => /^\s+at /.test(line)).slice(0, 3),
|
||
actual: error.actual, expected: error.expected,
|
||
}, { depth: 1, maxArrayLength: 3, maxStringLength: 160 })}`);
|
||
} finally {
|
||
fs.rmSync(dir, { recursive: true, force: true });
|
||
}
|
||
}
|
||
|
||
async function run() {
|
||
if (baselineIndex < 0 && !process.argv.includes('--only-handoff')) {
|
||
for (const startOutcome of ['response', 'timeout', 'exit']) {
|
||
const label = startOutcome === 'response'
|
||
? '取消启动时原生通知先于 RPC 返回，旧 A 不得进入或结束新 B'
|
||
: startOutcome === 'timeout'
|
||
? '取消启动 RPC 超时后保留门禁，晚到 ID 仅中断 A 且 B 正常完成'
|
||
: '取消启动未知 ID 时 app-server 明确退出，提交 A 前文并释放 B 门禁';
|
||
await check(label, async dir => {
|
||
const deferred = () => {
|
||
let resolve, reject;
|
||
const promise = new Promise((done, fail) => { resolve = done; reject = fail; });
|
||
return { promise, resolve, reject };
|
||
};
|
||
const aResponse = deferred();
|
||
const bResponse = deferred();
|
||
const nativeStarts = [];
|
||
const nativeInterrupts = [];
|
||
let clientRunning = true;
|
||
const runtimeClient = {
|
||
start: async () => { clientRunning = true; },
|
||
isRunning: () => clientRunning,
|
||
request: async (method, params) => {
|
||
if (method === 'thread/resume') return { thread: { id: params.threadId } };
|
||
if (method === 'turn/interrupt') { nativeInterrupts.push(params); return {}; }
|
||
assert.equal(method, 'turn/start', '夹具只替换线程 RPC 边界');
|
||
nativeStarts.push(params);
|
||
return nativeStarts.length === 1 ? aResponse.promise : bResponse.promise;
|
||
},
|
||
};
|
||
const api = createApi(dir, { realStart: true, runtimeClient });
|
||
const pump = async () => { for (let count = 0; count < 20; count += 1) await Promise.resolve(); };
|
||
// 路由、增量累积、完整运行态提交和完成函数均来自生产代码。
|
||
const receive = notification => {
|
||
const routed = api.findCodexAppEntryByRuntime(notification.params);
|
||
api.handleCodexAppNotification(notification);
|
||
return !!routed;
|
||
};
|
||
const { id, ws } = seed(api, 'cancel-start-race', '启动任务 A');
|
||
await pump();
|
||
assert.equal(nativeStarts.length, 1, 'A 的真实 turn/start RPC 应已发出但尚未返回');
|
||
assert.equal(api.activeCodexAppTurns.get(id).turnId, null);
|
||
if (startOutcome === 'exit') {
|
||
// 延续任务在新原生 ID 确认前已经拥有上轮正文，退出也不能丢弃它。
|
||
const carriedEntry = api.activeCodexAppTurns.get(id);
|
||
carriedEntry.fullText = '已经产生的 A 完整前文';
|
||
api.persistCodexAppTurnState(id, carriedEntry, { immediate: true });
|
||
}
|
||
api.handleAbort(ws, { sessionId: id });
|
||
const nextMessage = { sessionId: id, agent: 'codexapp', clientMessageId: 'race-b-user', text: '新任务 B' };
|
||
const beforeIdentity = api.handleMessage(ws, nextMessage);
|
||
await pump();
|
||
assert.equal(beforeIdentity.ok, false, '旧 A 身份未知时必须阻止同线程 B 开始');
|
||
assert.equal(nativeStarts.length, 1, '取消启动的 A 获取精确身份前不能发第二个 turn/start');
|
||
if (startOutcome !== 'response') {
|
||
aResponse.reject(new Error('夹具：turn/start RPC request timed out'));
|
||
await pump();
|
||
assert.equal(api.activeCodexAppTurns.get(id)?.turnId, null, 'RPC 超时不代表旧 A 没有启动，未知 ID 门禁应保留');
|
||
assert.equal(api.handleMessage(ws, nextMessage).ok, false, 'RPC 超时后 B 仍不能绕过未知身份门禁');
|
||
}
|
||
if (startOutcome === 'exit') {
|
||
clientRunning = false;
|
||
api.handleCodexAppServerExit('fixture-signature', { code: 1, stderr: '夹具：app-server 已明确退出' });
|
||
assert.equal(api.activeCodexAppTurns.has(id), false, 'app-server 明确退出后取消 A 不应永久占用门禁');
|
||
assert.equal(createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant')?.content,
|
||
'已经产生的 A 完整前文', '释放门禁前须提交 A 既有正文');
|
||
assert.equal(nativeInterrupts.length, 0, '已退出的进程无需请求未知 turn interrupt');
|
||
} else {
|
||
receive({ method: 'turn/started', params: { threadId: 'fixture-thread', turn: { id: 'native-A', status: 'inProgress' } } });
|
||
receive({ method: 'item/agentMessage/delta', params: { threadId: 'fixture-thread', turnId: 'native-A', itemId: 'agent-A', delta: '旧 A 的迟到正文' } });
|
||
if (startOutcome === 'response') aResponse.resolve({ turn: { id: 'native-A' } });
|
||
await pump();
|
||
assert(nativeInterrupts.some(params => params.turnId === 'native-A'), '旧 A 身份确认后必须按精确回合身份中断');
|
||
}
|
||
assert.equal(api.handleMessage(ws, nextMessage).ok, true, '旧 A 身份处理后 B 可以正常开始');
|
||
await pump();
|
||
assert.equal(nativeStarts.length, 2);
|
||
const bEntry = api.activeCodexAppTurns.get(id);
|
||
receive({ method: 'turn/started', params: { threadId: 'fixture-thread', turn: { id: 'native-B', status: 'inProgress' } } });
|
||
const bText = 'B 第一段完整正文\n' + '乙'.repeat(9000) + '\nB 最后一段完整正文';
|
||
receive({ method: 'item/agentMessage/delta', params: { threadId: 'fixture-thread', turnId: 'native-B', itemId: 'agent-B', delta: bText } });
|
||
if (startOutcome !== 'exit') {
|
||
assert.equal(receive({ method: 'turn/completed', params: { threadId: 'fixture-thread', turn: { id: 'native-A', status: 'interrupted' } } }), false);
|
||
}
|
||
assert.strictEqual(api.activeCodexAppTurns.get(id), bEntry, '旧 A 的迟到完成不能结束 B');
|
||
assert.equal(bEntry.fullText, bText, 'B 正文不能混入旧 A 通知');
|
||
bResponse.resolve({ turn: { id: 'native-B' } });
|
||
await pump();
|
||
receive({ method: 'item/completed', params: { threadId: 'fixture-thread', turnId: 'native-B', item: { id: 'agent-B', type: 'agentMessage', text: bText } } });
|
||
receive({ method: 'turn/completed', params: { threadId: 'fixture-thread', turn: { id: 'native-B', status: 'completed' } } });
|
||
const session = createServerHarness(dir).loadSession(id);
|
||
const replies = session.messages.filter(message => message.role === 'assistant' && message.content.includes('B 第一段完整正文'));
|
||
assert.equal(replies.length, 1, 'B 完成后只能归档一次');
|
||
assert.equal(replies[0].content, bText, 'B 完成与存储重开后前后文完整');
|
||
assert.equal(session.messages.filter(message => message.role === 'user' && message.id === 'race-b-user').length, 1);
|
||
assert.equal(api.activeCodexAppTurns.has(id), false);
|
||
if (startOutcome !== 'exit') {
|
||
assert.equal(receive({ method: 'turn/completed', params: { threadId: 'fixture-thread', turn: { id: 'native-A', status: 'interrupted' } } }), false);
|
||
}
|
||
});
|
||
}
|
||
if (process.argv.includes('--only-start-race')) return;
|
||
}
|
||
|
||
await check('真实自动重试开轮必须继承超过提示和快照上限的 A 正文及工具映射', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
const original = emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
const resumed = api.activeCodexAppTurns.get(id);
|
||
assert(resumed?.fullText.includes(A), '真实 schedule → handleMessage → handleCodexAppMessage 丢失了重试前 A 正文');
|
||
assert.deepEqual(resumed.toolCalls, original.toolCalls, '工具调用不得丢失或只剩预览');
|
||
assert.deepEqual(Array.from(resumed.toolOutputDeltas), Array.from(original.toolOutputDeltas));
|
||
assert.deepEqual(Array.from(resumed.agentMessageItems), Array.from(original.agentMessageItems));
|
||
assert.equal(resumed.codexRetry.attempt, 1);
|
||
assert.equal(api.storeApi.loadSession(id).messages.filter(message => message.role === 'user').length, 1);
|
||
});
|
||
if (process.argv.includes('--only-handoff')) return;
|
||
|
||
await check('A → B → C 两次重试后最终助手归档重开仍各保留一次且用户不重复', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
emit(api, id, B, 'B');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
const entry = emit(api, id, C, 'C');
|
||
assert.equal(entry.codexRetry.attempt, 2, '重试次数必须单调增长');
|
||
api.handleCodexAppTurnComplete(id);
|
||
const reloaded = createServerHarness(dir).loadSession(id);
|
||
const assistants = reloaded.messages.filter(message => message.role === 'assistant');
|
||
assert.equal(assistants.length, 1, '一个逻辑任务只保存一个累积助手气泡');
|
||
assertOnceInOrder(assistants[0].content, [A, B, C]);
|
||
assertToolOrder(assistants[0].toolCalls, ['A', 'B', 'C']);
|
||
for (const tool of assistants[0].toolCalls) assert(tool.result.length > 32768, '最终工具结果必须完整');
|
||
assert.equal(reloaded.messages.filter(message => message.role === 'user').length, 1);
|
||
assert.equal(api.storeApi.sessionHistoryStore.loadTurn(id), null, '完成提交后才清理完整运行态');
|
||
});
|
||
|
||
await check('等待重试期间及续跑启动后重连均提供全部已流出的正文与工具', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
const first = emit(api, id, A, 'A');
|
||
api.attachActiveRuntimeToWs({ readyState: 1, label: 'before-error' }, id);
|
||
const originalId = api.sent.findLast(message => message.type === 'resume_generating')?.assistantMessageId;
|
||
assert(originalId, '累积气泡必须有稳定身份');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
assert.equal(api.isSessionRunning(id), true, '等待重试仍属于运行中的逻辑任务');
|
||
api.handleResumeSession({ readyState: 1, label: 'wait-reconnect' }, { sessionId: id, requestId: 'waiting' });
|
||
let resume = api.sent.findLast(message => message.type === 'resume_generating');
|
||
assert.equal(resume?.text, first.fullText, '等待期刷新/重连不能清空或截断正文');
|
||
assert.deepEqual(resume.toolCalls, first.toolCalls);
|
||
assert.equal(resume.assistantMessageId, originalId, '等待期必须复用同一累积气泡身份');
|
||
await api.fireRetry(id);
|
||
emit(api, id, B, 'B');
|
||
assert.equal(api.attachActiveRuntimeToWs({ readyState: 1, label: 'running-reconnect' }, id), true);
|
||
resume = api.sent.findLast(message => message.type === 'resume_generating');
|
||
assertOnceInOrder(resume.text, [A, B]);
|
||
assertToolOrder(resume.toolCalls, ['A', 'B']);
|
||
assert.equal(resume.assistantMessageId, originalId, '新重试 turn 必须复用累积气泡身份');
|
||
api.handleCodexAppTurnComplete(id);
|
||
const assistant = createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant');
|
||
assert.equal(assistant.id, originalId, '归档及重连必须指向同一个助手气泡');
|
||
});
|
||
|
||
await check('等待期完整运行态存储重开保留 A 正文及两个映射', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
const entry = emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
const state = createServerHarness(dir).sessionHistoryStore.loadTurn(id);
|
||
assert.equal(state?.fullText, A, '安排重试前不能删除唯一完整运行态');
|
||
assert.deepEqual(state.toolCalls, entry.toolCalls);
|
||
assert.deepEqual(state.toolOutputDeltas, Array.from(entry.toolOutputDeltas));
|
||
assert.deepEqual(state.agentMessageItems, Array.from(entry.agentMessageItems));
|
||
});
|
||
|
||
await check('重试耗尽保存所有已产生正文，且不会再安排新轮', async dir => {
|
||
const api = createApi(dir, { retryConfig: { maxAttempts: 1 } });
|
||
const { id } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
emit(api, id, B, 'B');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
assert.equal(api.pendingCodexCapacityRetries.has(id), false);
|
||
assert.equal(api.activeCodexAppTurns.has(id), false);
|
||
const assistant = createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant');
|
||
assertOnceInOrder(assistant?.content || '', [A, B]);
|
||
});
|
||
|
||
await check('用户取消等待中的重试仍提交已产生正文', async dir => {
|
||
const api = createApi(dir);
|
||
const { id, ws } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
api.handleAbort(ws, { sessionId: id });
|
||
assert.equal(api.pendingCodexCapacityRetries.has(id), false);
|
||
const assistant = createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant');
|
||
assert.equal(assistant?.content, A, '取消等待不得删除尚未归档正文');
|
||
});
|
||
|
||
await check('重试前完整运行态保存失败时保留内存与上次落盘正文', async dir => {
|
||
const options = {};
|
||
const api = createApi(dir, options);
|
||
const { id } = seed(api);
|
||
const entry = emit(api, id, A, 'A');
|
||
entry.fullText += '\n最新未落盘正文';
|
||
options.failTurnSave = true;
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
const state = createServerHarness(dir).sessionHistoryStore.loadTurn(id);
|
||
assert.equal(state?.fullText, A, '保存失败不能清理此前完整运行态');
|
||
const retained = api.activeCodexAppTurns.get(id) || api.pendingCodexCapacityRetries.get(id)?.entry || api.retainedCodexAppTurns.get(id);
|
||
assert(retained?.fullText.includes('最新未落盘正文'), '保存失败不能丢弃唯一内存正文');
|
||
});
|
||
|
||
await check('续跑启动失败仍归档此前正文', async dir => {
|
||
const options = {};
|
||
const api = createApi(dir, options);
|
||
const { id } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
options.failStart = true;
|
||
await api.fireRetry(id);
|
||
const assistant = createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant');
|
||
assert.equal(assistant?.content, A);
|
||
});
|
||
|
||
await check('最终会话保存失败仍留下可重开的 A/B/C 完整运行态', async dir => {
|
||
const options = {};
|
||
const api = createApi(dir, options);
|
||
const { id } = seed(api);
|
||
for (const [text, label] of [[A, 'A'], [B, 'B']]) {
|
||
emit(api, id, text, label);
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
}
|
||
emit(api, id, C, 'C');
|
||
options.failSessionSave = true;
|
||
api.handleCodexAppTurnComplete(id);
|
||
const state = createServerHarness(dir).sessionHistoryStore.loadTurn(id);
|
||
assertOnceInOrder(state?.fullText || '', [A, B, C]);
|
||
assertToolOrder(state.toolCalls, ['A', 'B', 'C']);
|
||
assert.equal(api.sent.findLast(message => message.type === 'done')?.historySaved, false);
|
||
});
|
||
|
||
await check('普通新用户轮次从空正文开始而不继承上一气泡', async dir => {
|
||
const api = createApi(dir);
|
||
const { id, ws } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnComplete(id);
|
||
assert.equal(api.handleMessage(ws, { sessionId: id, clientMessageId: 'next-user', text: '新任务' }).ok, true);
|
||
const next = api.activeCodexAppTurns.get(id);
|
||
assert.equal(next.fullText, '');
|
||
assert.deepEqual(next.toolCalls, []);
|
||
assert.equal(next.toolOutputDeltas.size, 0);
|
||
assert.equal(next.agentMessageItems.size, 0);
|
||
});
|
||
|
||
await check('跨轮复用原生 item ID 不会覆盖工具或误拼已完成助手消息', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
for (const [text, label] of [[A, 'A'], [B, 'B']]) {
|
||
emit(api, id, text, label, true);
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
}
|
||
const entry = emit(api, id, C, 'C', true);
|
||
assertOnceInOrder(entry.fullText, [A, B, C]);
|
||
assertToolOrder(entry.toolCalls, ['A', 'B', 'C']);
|
||
assert.equal(entry.agentMessageItems.size, 3);
|
||
assert.equal(entry.toolOutputDeltas.size, 3);
|
||
api.handleCodexAppTurnComplete(id);
|
||
const assistant = createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant');
|
||
assertOnceInOrder(assistant.content, [A, B, C]);
|
||
assertToolOrder(assistant.toolCalls, ['A', 'B', 'C']);
|
||
});
|
||
|
||
await check('未完成消息的空白前缀及完整映射跨重试落盘且交接不丢', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
const oldEntry = emit(api, id, A, 'A');
|
||
api.runtime.processCodexAppNotification(oldEntry, { method: 'item/agentMessage/delta',
|
||
params: { threadId: oldEntry.threadId, turnId: oldEntry.turnId, itemId: 'pending-prefix', delta: '\n ' } }, id);
|
||
assert.equal(oldEntry.agentMessagePendingPrefixes.size, 1);
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
const state = createServerHarness(dir).sessionHistoryStore.loadTurn(id);
|
||
assert.deepEqual(state?.agentMessagePendingPrefixes, Array.from(oldEntry.agentMessagePendingPrefixes));
|
||
await api.fireRetry(id);
|
||
const resumed = api.activeCodexAppTurns.get(id);
|
||
assert.deepEqual(Array.from(resumed.agentMessagePendingPrefixes), Array.from(oldEntry.agentMessagePendingPrefixes));
|
||
assert.deepEqual(Array.from(resumed.agentMessageItems), Array.from(oldEntry.agentMessageItems));
|
||
});
|
||
|
||
await check('最终保存失败后重连能看完整正文，存储恢复前不得启动新用户轮', async dir => {
|
||
const options = {};
|
||
const api = createApi(dir, options);
|
||
const { id, ws } = seed(api);
|
||
const output = emit(api, id, A, 'A');
|
||
output.fullText += '\n最新完成段';
|
||
options.failSessionSave = true;
|
||
options.failTurnSave = true;
|
||
api.handleCodexAppTurnComplete(id);
|
||
assert(api.retainedCodexAppTurns.get(id)?.fullText.includes('最新完成段'), '双保存失败仍须保留最新内存正文');
|
||
api.attachActiveRuntimeToWs({ readyState: 1 }, id);
|
||
assert.equal(api.sent.findLast(message => message.type === 'resume_generating')?.text, output.fullText);
|
||
assert.equal(api.sent.findLast(message => message.type === 'done')?.historySaved, false);
|
||
assert.equal(api.handleMessage(ws, { sessionId: id, clientMessageId: 'next-user', text: '下一任务' }).ok, false);
|
||
assert.equal(api.starts.length, 1);
|
||
options.failSessionSave = false;
|
||
options.failTurnSave = false;
|
||
assert.equal(api.handleMessage(ws, { sessionId: id, clientMessageId: 'next-user', text: '下一任务' }).ok, true);
|
||
const reloaded = createServerHarness(dir).loadSession(id);
|
||
assert.equal(reloaded.messages.find(message => message.role === 'assistant')?.content, output.fullText);
|
||
assert.equal(reloaded.messages.filter(message => message.role === 'user').length, 2);
|
||
assert.equal(api.activeCodexAppTurns.get(id).fullText, '');
|
||
});
|
||
|
||
await check('等待期计时触发时会话暂不可读仍保留 A 的完整运行态及内存', async dir => {
|
||
const options = {};
|
||
const api = createApi(dir, options);
|
||
const { id } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
options.failSessionLoad = true;
|
||
await api.fireRetry(id);
|
||
assert.equal(createServerHarness(dir).sessionHistoryStore.loadTurn(id)?.fullText, A);
|
||
const held = api.retainedCodexAppTurns.get(id) || api.pendingCodexCapacityRetries.get(id)?.entry;
|
||
assert.equal(held?.fullText, A);
|
||
assert.equal(api.starts.length, 1, '会话暂时不可读时不能启动空白新线程');
|
||
});
|
||
|
||
await check('等待期收到新用户任务先提交 A，旧重试取消且新气泡从空开始', async dir => {
|
||
const api = createApi(dir);
|
||
const { id, ws } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
const oldTimer = api.pendingCodexCapacityRetries.get(id)?.timer;
|
||
assert(oldTimer);
|
||
assert.equal(api.handleMessage(ws, { sessionId: id, text: '新用户任务', clientMessageId: 'new-during-wait' }).ok, true);
|
||
assert.equal(api.pendingCodexCapacityRetries.has(id), false);
|
||
assert.equal(api.activeCodexAppTurns.get(id).fullText, '');
|
||
const reloaded = createServerHarness(dir).loadSession(id);
|
||
assert.deepEqual(reloaded.messages.map(message => message.role), ['user', 'assistant', 'user']);
|
||
assert.equal(reloaded.messages[1].content, A);
|
||
oldTimer.callback();
|
||
await Promise.resolve();
|
||
assert.equal(api.starts.length, 2, '已取消的计时器不能再启动旧任务');
|
||
});
|
||
|
||
await check('超过映射及工具预览数量的 105 项完整状态跨重试与归档保留', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
const first = api.activeCodexAppTurns.get(id);
|
||
const base = { threadId: first.threadId, turnId: first.turnId };
|
||
for (let index = 0; index < 105; index += 1) {
|
||
api.runtime.processCodexAppNotification(first, { method: 'item/agentMessage/delta',
|
||
params: { ...base, itemId: 'agent-many-' + index, delta: '正文段落-' + index } }, id);
|
||
api.runtime.processCodexAppNotification(first, { method: 'item/started',
|
||
params: { ...base, item: { id: 'tool-many-' + index, type: 'commandExecution', command: 'fixture-' + index } } }, id);
|
||
api.runtime.processCodexAppNotification(first, { method: 'item/commandExecution/outputDelta',
|
||
params: { ...base, itemId: 'tool-many-' + index, delta: '输出-' + index } }, id);
|
||
}
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
const state = createServerHarness(dir).sessionHistoryStore.loadTurn(id);
|
||
assert.equal(state?.toolCalls.length, 105);
|
||
assert.equal(state.toolOutputDeltas.length, 105);
|
||
assert.equal(state.agentMessageItems.length, 105);
|
||
await api.fireRetry(id);
|
||
const resumed = api.activeCodexAppTurns.get(id);
|
||
assert.equal(resumed.toolCalls.length, 105);
|
||
assert.equal(resumed.toolOutputDeltas.size, 105);
|
||
assert.equal(resumed.agentMessageItems.size, 105);
|
||
api.attachActiveRuntimeToWs({ readyState: 1 }, id);
|
||
assert.equal(api.sent.findLast(message => message.type === 'resume_generating').toolCalls.length, 105);
|
||
api.handleCodexAppTurnComplete(id);
|
||
const assistant = createServerHarness(dir).loadSession(id).messages.find(message => message.role === 'assistant');
|
||
assert.equal(assistant.toolCalls.length, 105);
|
||
assert.equal(assistant.content, first.fullText);
|
||
});
|
||
|
||
await check('等待期进程重开从完整运行态恢复 A/B，一次归档且重复恢复不再追加', async dir => {
|
||
const api = createApi(dir);
|
||
const { id } = seed(api);
|
||
emit(api, id, A, 'A');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
await api.fireRetry(id);
|
||
emit(api, id, B, 'B');
|
||
api.handleCodexAppTurnFailure(id, new Error(ERROR));
|
||
const savedState = createServerHarness(dir).sessionHistoryStore.loadTurn(id);
|
||
assertOnceInOrder(savedState?.fullText || '', [A, B]);
|
||
const reopened = createApi(dir);
|
||
assert.equal(reopened.recoverCodexAppTurnState(id), true);
|
||
let session = createServerHarness(dir).loadSession(id);
|
||
let assistants = session.messages.filter(message => message.role === 'assistant');
|
||
assert.equal(assistants.length, 1);
|
||
assertOnceInOrder(assistants[0].content, [A, B]);
|
||
assertToolOrder(assistants[0].toolCalls, ['A', 'B']);
|
||
assert.equal(assistants[0].id, savedState.assistantMessageId);
|
||
assert.equal(assistants[0].interrupted, true);
|
||
assert.equal(session.messages.filter(message => message.role === 'user').length, 1);
|
||
// 模拟运行态清理失败后下次重启再次读到同一状态，恢复入口必须幂等。
|
||
reopened.storeApi.sessionHistoryStore.saveTurn(id, savedState);
|
||
assert.equal(reopened.recoverCodexAppTurnState(id), true);
|
||
session = createServerHarness(dir).loadSession(id);
|
||
assistants = session.messages.filter(message => message.role === 'assistant');
|
||
assert.equal(assistants.length, 1);
|
||
assert.equal(reopened.storeApi.sessionHistoryStore.loadTurn(id), null);
|
||
});
|
||
|
||
if (baselineIndex >= 0 || process.argv.includes('--skip-mock')) return;
|
||
await check('真实 mock 协议三轮续接：A/B/C 正文、复用 ID 工具及用户归档完整', async dir => {
|
||
const options = {};
|
||
const api = createApi(dir, options);
|
||
const client = createCodexAppServerClient({ command: process.execPath,
|
||
args: [path.join(__dirname, 'mock-codex-app-server.js'), 'app-server'], cwd: dir,
|
||
env: { ...process.env, CODEX_HOME: path.join(dir, 'codex-home') },
|
||
onNotification: notification => {
|
||
const entry = api.activeCodexAppTurns.get('mock-history');
|
||
if (!entry) return;
|
||
const result = api.runtime.processCodexAppNotification(entry, notification, 'mock-history');
|
||
if (result.done) api.handleCodexAppTurnComplete('mock-history');
|
||
},
|
||
});
|
||
const waitFor = async predicate => {
|
||
const deadline = Date.now() + 5000;
|
||
while (!predicate()) {
|
||
assert(Date.now() < deadline, '隔离 mock 事件等待超过 5 秒');
|
||
await new Promise(resolve => setTimeout(resolve, 10));
|
||
}
|
||
};
|
||
try {
|
||
await client.start();
|
||
await client.request('thread/resume', { threadId: 'fixture-thread' });
|
||
options.startTurn = async (sessionId, input) => {
|
||
await client.request('turn/start', { threadId: 'fixture-thread', input });
|
||
};
|
||
const { id } = seed(api, 'mock-history', 'codexapp retry full history');
|
||
for (let attempt = 1; attempt <= 2; attempt += 1) {
|
||
await waitFor(() => api.pendingCodexCapacityRetries.has(id));
|
||
assert.equal(api.pendingCodexCapacityRetries.get(id).attempts, attempt);
|
||
api.handleResumeSession({ readyState: 1 }, { sessionId: id });
|
||
const resume = api.sent.findLast(message => message.type === 'resume_generating');
|
||
assert(resume.text.includes('retry-history-A-begin'));
|
||
await api.fireRetry(id);
|
||
}
|
||
await waitFor(() => !api.activeCodexAppTurns.has(id) && !api.pendingCodexCapacityRetries.has(id));
|
||
const reloaded = createServerHarness(dir).loadSession(id);
|
||
const assistant = reloaded.messages.find(message => message.role === 'assistant');
|
||
for (const label of ['A', 'B', 'C']) {
|
||
assert.equal(assistant.content.split(`retry-history-${label}-begin`).length, 2);
|
||
assert.equal(assistant.content.split(`retry-history-${label}-end`).length, 2);
|
||
}
|
||
assert.equal(assistant.toolCalls.length, 3);
|
||
assert.equal(new Set(assistant.toolCalls.map(tool => tool.id)).size, 3);
|
||
['A', 'B', 'C'].forEach((label, index) => {
|
||
assert(assistant.toolCalls[index].result.startsWith(`tool-${label}-full-result`));
|
||
assert(assistant.toolCalls[index].result.length > 32768);
|
||
});
|
||
assert.equal(reloaded.messages.filter(message => message.role === 'user').length, 1);
|
||
} finally {
|
||
await client.stop();
|
||
}
|
||
});
|
||
}
|
||
|
||
run().then(() => {
|
||
if (failures.length) {
|
||
console.error(`运行中气泡续接回归失败：${failures.length} 项；通过 ${passed} 项`);
|
||
process.exitCode = 1;
|
||
} else console.log(`运行中气泡续接回归通过：${passed} 项`);
|
||
}).catch(error => { console.error(error); process.exitCode = 1; });
|