Files
Agent-Workbench/tests/role-routing.test.mjs

112 lines
9.3 KiB
JavaScript

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);
});