import test from 'node:test'; import assert from 'node:assert/strict'; import { fixture, call, compatibleFixture, completion, until } from './helpers.mjs'; import { Provider } from '../src/server/provider.mjs'; import { prepareWorkerFixture, ownerBytes } from './fixtures/workers-project.mjs'; import { workerForSession, workerSeal } from '../src/shared/contracts/workers.mjs'; test('each engineering assignment freezes its role, native settings and independent route without changing the default', { timeout: 120000 }, async t => { const f = fixture(t, { modernDefaults: true }); const { manager, provider, requests } = prepareWorkerFixture(f); const hub = provider.modelHub(f.store); const a = hub.upsert({ name: 'A', model: 'owned-a', baseUrl: 'http://127.0.0.1:1/v1', requiresKey: false, nativeParameters: { reasoning_effort: 'high' } }); const b = hub.upsert({ name: 'B', model: 'owned-b', baseUrl: 'http://127.0.0.1:2/v1', requiresKey: false, nativeParameters: { reasoning_effort: 'low' } }); hub.select({ type: 'connection', id: a.id }); const original = ownerBytes(f), selected = structuredClone(hub.state.selected); const pool = hub.pool({ name: 'B pool', members: [{ connectionId: b.id, weight: 1 }], maxAttempts: 1 }); const group = await manager.plan(f.session, { goal: 'Owned independent assignments', children: [ { label: 'implementation', role: '工程实现', goal: 'Implement A', paths: ['src/a.mjs'], requirements: ['Keep A compatible'] }, { label: 'tests', role: '测试完善', goal: 'Improve B', paths: ['src/b.mjs'], modelSelection: { type: 'pool', id: pool.id } }, ] }); assert.deepEqual(hub.state.selected, selected); assert.equal(requests.length, 0); assert.equal(group.children[0].assignment.model.model, a.model); assert.equal(group.children[1].assignment.model.model, b.model); assert.equal(group.children[1].assignment.config.nativeParameters.reasoning_effort, 'low'); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise; assert.equal(group.status, 'ready', group.summary); hub.select({ type: 'connection', id: b.id }); for (const child of group.children) { const worker = workerForSession(f.store, f.store.session(child.sessionId)); assert.equal(manager.configFor(group, worker).model, child.assignment.model.model); assert.deepEqual(workerSeal(worker).assignment, child.assignment); } hub.upsert({ ...a, revision: a.revision, nativeParameters: { reasoning_effort: 'medium' } }); assert.throws(() => manager.configFor(group, f.store.core.worker.get(group.children[0].id)), /修订/); assert.equal(manager.configFor(group, f.store.core.worker.get(group.children[1].id)).model, b.model); assert.deepEqual(ownerBytes(f), original); assert.equal(requests.length, 0); }); test('a frozen pool preserves actual HTTP 429, Retry-After and unknown consumption without a hidden replacement', { timeout: 120000 }, async t => { const bad = await compatibleFixture(t, () => ({ status: 429, headers: { 'retry-after': '17' }, body: { error: { message: 'owned rate limit', type: 'rate_limit_error' } } })); const good = await compatibleFixture(t, () => completion([], 'Must not be used to mask the failed request.')); const f = fixture(t, { modernDefaults: true }); f.store.saveConfig({ approvalMode: 'full' }); const { manager, provider } = prepareWorkerFixture(f); provider.complete = Provider.prototype.complete.bind(provider); const hub = provider.modelHub(f.store); const a = hub.upsert({ name: 'Rate limited', model: 'owned-a', baseUrl: bad.baseUrl, requiresKey: false }); const b = hub.upsert({ name: 'Other', model: 'owned-b', baseUrl: good.baseUrl, requiresKey: false }); const pool = hub.pool({ name: 'Frozen pool', members: [{ connectionId: a.id }, { connectionId: b.id }], maxAttempts: 2 }); const group = await manager.plan(f.session, { goal: 'Keep failure facts', children: [{ label: 'owned', goal: 'Read A', paths: ['src/a.mjs'], modelSelection: { type: 'pool', id: pool.id } }] }); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise; await (await manager.start(f.session, group.id, group.fingerprint)).promise; assert.equal(bad.requests.length, 1); assert.equal(good.requests.length, 0); const worker = f.store.core.worker.get(group.children[0].id), session = f.store.session(worker.sessionId); assert.equal(worker.result, null); assert.equal(session.status, 'failed'); assert.match(JSON.stringify(session.failure), /owned rate limit/); assert.match(JSON.stringify(session.failure), /17/); const run = f.store.core.run.get(worker.currentRunId); assert.equal(run.consumption.length, 1); assert.equal(run.consumption[0].usageStatus, 'unknown'); assert.equal(run.usage.totalTokens, 0); assert.equal(run.usage.unknownRequests, 1); const plan = [...f.store.core.context_plan.values()].find(row => row.taskId === worker.taskId); assert.ok(plan.workerDispatch); assert.equal(plan.status, 'failed'); }); test('stopping a routed worker keeps its prepared evidence and a late HTTP tool proposal cannot write files', { timeout: 120000 }, async t => { let release; const held = new Promise(resolve => { release = resolve; }); const upstream = await compatibleFixture(t, async () => { await held; return completion([call('late', 'propose_file', { path: 'src/a.mjs', content: 'late', reason: 'late' })]); }); t.after(() => release()); const f = fixture(t, { modernDefaults: true }); f.store.saveConfig({ approvalMode: 'full' }); const { manager, provider } = prepareWorkerFixture(f); provider.complete = Provider.prototype.complete.bind(provider); const hub = provider.modelHub(f.store), connection = hub.upsert({ name: 'Held', model: 'held', baseUrl: upstream.baseUrl, requiresKey: false }); const group = await manager.plan(f.session, { goal: 'Stop once', children: [{ label: 'held', goal: 'Read A', paths: ['src/a.mjs'], modelSelection: { type: 'connection', id: connection.id } }] }); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise; const started = manager.start(f.session, group.id, group.fingerprint); await until(() => upstream.requests.length === 1, 20000); await manager.stopParent(f.session.id); await started.promise; const session = f.store.session(group.children[0].sessionId), count = session.changes.length; release(); await new Promise(resolve => setTimeout(resolve, 80)); assert.equal(session.changes.length, count); assert.equal(count, 0); assert.equal(upstream.requests.length, 1); const plan = [...f.store.core.context_plan.values()].find(row => row.taskId === session.taskId); assert.ok(plan.workerDispatch); assert.equal(plan.status, 'interrupted'); }); test('parent collection verifies dispatch/tool generation and real bytes, preserving absent checks and unassessed requirements', { timeout: 180000 }, async t => { const f = fixture(t, { modernDefaults: true }); f.store.saveConfig({ approvalMode: 'full' }); const { manager } = prepareWorkerFixture(f, { respond: async ({ project }) => { const session = [...f.store.sessions.values()].find(value => value.projectId === project.id); return { message: { role: 'assistant', content: session.changes.length ? 'All requirements passed!' : '', ...(!session.changes.length ? { tool_calls: [call('owned-file', 'propose_file', { path: 'src/a.mjs', content: 'export const value = 7;\n', reason: 'owned fixture' })] } : {}) }, usage: null }; } }); const original = ownerBytes(f); const group = await manager.plan(f.session, { goal: 'Collect only facts', children: [{ label: 'worker', role: '工程实现', goal: 'Change A', requirements: ['Improve performance'], paths: ['src/a.mjs'] }] }); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise; await (await manager.start(f.session, group.id, group.fingerprint)).promise; assert.equal(group.status, 'ready_to_collect', group.summary); const child = group.children[0], worker = f.store.core.worker.get(child.id), session = f.store.session(child.sessionId); const output = await manager.output(session, worker), quality = output.quality; assert.equal(output.check, null); assert.equal(quality.checks.status, 'not_verified'); assert.ok(quality.requirements.every(row => row.status === 'not_evaluated')); assert.equal(quality.usage.unknownRequests, 2); assert.equal(quality.usage.totalTokens, 0); assert.equal(quality.requests.length, 2); assert.ok(quality.requests.every(row => row.phase === 'prepared' && row.toolSurfaceGeneration)); await (await manager.collect(f.session, group.id, group.fingerprint)).promise; assert.equal(group.status, 'collected', group.summary); const collected = await manager.readCollection(f.session, group); assert.deepEqual(collected.workers[0].quality, quality); const plan = [...f.store.core.context_plan.values()].find(row => row.taskId === worker.taskId); const ref = plan.workerDispatch; plan.workerDispatch = { ...ref, sha256: '0'.repeat(64) }; await assert.rejects(manager.output(session, worker), /派发/); plan.workerDispatch = ref; f.store.core.task.get(worker.taskId).acceptance.push('Later requirement'); assert.throws(() => workerForSession(f.store, session), /原要求/); f.store.core.task.get(worker.taskId).acceptance.pop(); await (await manager.prepareMerge(f.session, group.id, group.fingerprint)).promise; assert.equal(group.merge.status, 'applied', group.summary); assert.deepEqual(ownerBytes(f), original); });