plugin-agent-orchestrator 1.1.4 → 1.1.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +204 -114
- package/dist/client/index.js +1 -1
- package/dist/client-v2/117.7565cff57c39318a.js +10 -0
- package/dist/client-v2/214.106635011859dede.js +10 -0
- package/dist/client-v2/418.41ed200e7d6da332.js +10 -0
- package/dist/client-v2/53.349fff8db80b19d4.js +10 -0
- package/dist/client-v2/981.e4a1f41cfc94a856.js +10 -0
- package/dist/client-v2/index.js +1 -1
- package/dist/externalVersion.js +7 -8
- package/dist/locale/en-US.json +226 -170
- package/dist/locale/vi-VN.json +226 -170
- package/dist/locale/zh-CN.json +226 -170
- package/dist/server/collections/agent-execution-spans.js +8 -0
- package/dist/server/collections/agent-loop-action-approvals.js +1 -0
- package/dist/server/collections/agent-loop-runs.js +7 -1
- package/dist/server/collections/agent-loop-steps.js +7 -0
- package/dist/server/collections/skill-executions.js +8 -0
- package/dist/server/plugin.js +3 -1
- package/dist/server/resources/agent-harness-profile.js +117 -0
- package/dist/server/resources/agent-knowledge-insights.js +1 -3
- package/dist/server/resources/agent-loop-approval.js +25 -0
- package/dist/server/resources/agent-loop.js +3 -1
- package/dist/server/services/AgentMemoryContextService.js +34 -0
- package/dist/server/services/HarnessCompiler.js +35 -2
- package/dist/server/services/HarnessProfileService.js +74 -9
- package/dist/server/services/HarnessSchema.js +30 -3
- package/dist/server/services/LoopPatternSchema.js +16 -1
- package/dist/server/services/LoopRunRepository.js +80 -0
- package/dist/server/services/LoopRunStateMachine.js +92 -3
- package/dist/server/services/LoopTriggerService.js +37 -0
- package/dist/server/services/LoopWorkerService.js +261 -23
- package/dist/server/services/NativeSubAgentObserver.js +165 -23
- package/dist/server/services/PluginAiRuntimeAdapter.js +16 -5
- package/dist/server/services/ToolLoopDetectionService.js +210 -0
- package/dist/server/services/VerificationService.js +66 -0
- package/dist/server/services/harness-runtime-policy.js +139 -0
- package/dist/server/skill-hub/plugin.js +36 -3
- package/dist/server/skill-hub/tasks/SkillExecutionTask.js +29 -0
- package/package.json +53 -53
- package/src/client/ApprovalsTab.tsx +2 -0
- package/src/client/OrchestratorSettings.tsx +11 -0
- package/src/client/skill-hub/components/GitSkillImport.tsx +3 -3
- package/src/client/skill-hub/components/SkillMetrics.tsx +15 -10
- package/src/client/skill-hub/index.tsx +0 -52
- package/src/client-v2/components/AgentRunsTab.tsx +576 -576
- package/src/client-v2/components/ApprovalsTab.tsx +337 -0
- package/src/client-v2/components/HarnessProfilesTab.tsx +385 -105
- package/src/client-v2/components/MemoryInspectorTab.tsx +141 -141
- package/src/client-v2/components/TracingTab.tsx +515 -515
- package/src/client-v2/hooks/useApiRequest.ts +141 -141
- package/src/client-v2/pages/ApprovalsPage.tsx +10 -0
- package/src/client-v2/plugin.tsx +6 -6
- package/src/client-v2/skill-hub/components/SkillMetrics.tsx +5 -2
- package/src/locale/en-US.json +226 -174
- package/src/locale/vi-VN.json +226 -174
- package/src/locale/zh-CN.json +226 -174
- package/src/server/__tests__/circuit-breaker.test.ts +248 -248
- package/src/server/__tests__/harness-compiler.test.ts +83 -0
- package/src/server/__tests__/harness-profile-service.test.ts +51 -0
- package/src/server/__tests__/harness-runtime-policy.test.ts +293 -0
- package/src/server/__tests__/harness-tool-plan.test.ts +24 -0
- package/src/server/__tests__/loop-approval-decision.test.ts +512 -0
- package/src/server/__tests__/loop-approval-expiry.test.ts +258 -0
- package/src/server/__tests__/loop-budget-service.test.ts +255 -255
- package/src/server/__tests__/loop-control-plane-backfill.test.ts +266 -266
- package/src/server/__tests__/loop-pattern-schema.test.ts +18 -1
- package/src/server/__tests__/loop-pattern-service.test.ts +148 -148
- package/src/server/__tests__/loop-run-state-machine.test.ts +11 -0
- package/src/server/__tests__/loop-trigger-service.test.ts +148 -0
- package/src/server/__tests__/loop-worker-claim.test.ts +341 -341
- package/src/server/__tests__/loop-worker-execution.test.ts +82 -1
- package/src/server/__tests__/native-sub-agent-observer.test.ts +288 -4
- package/src/server/__tests__/path-lock-service.test.ts +254 -254
- package/src/server/__tests__/skill-execution-task-policy.test.ts +140 -0
- package/src/server/__tests__/smoke.test.ts +162 -162
- package/src/server/__tests__/tool-loop-detection.test.ts +275 -0
- package/src/server/collections/agent-execution-spans.ts +8 -0
- package/src/server/collections/agent-harness-profile-versions.ts +26 -26
- package/src/server/collections/agent-harness-profiles.ts +71 -71
- package/src/server/collections/agent-loop-action-approvals.ts +1 -0
- package/src/server/collections/agent-loop-artifacts.ts +25 -25
- package/src/server/collections/agent-loop-circuit-states.ts +23 -23
- package/src/server/collections/agent-loop-control-settings.ts +21 -21
- package/src/server/collections/agent-loop-events.ts +98 -98
- package/src/server/collections/agent-loop-path-locks.ts +27 -27
- package/src/server/collections/agent-loop-patterns.ts +42 -42
- package/src/server/collections/agent-loop-runs.ts +7 -1
- package/src/server/collections/agent-loop-steps.ts +7 -0
- package/src/server/collections/agent-loop-usage-buckets.ts +22 -22
- package/src/server/collections/agent-loop-worktrees.ts +25 -25
- package/src/server/collections/skill-executions.ts +8 -0
- package/src/server/migrations/20260427000002-change-packages-to-text.ts +52 -52
- package/src/server/migrations/20260429000000-add-llm-fields.ts +47 -47
- package/src/server/migrations/20260429000001-fix-inputargs-json-to-text.ts +45 -45
- package/src/server/migrations/20260503000000-add-orchestrator-trace-fields.ts +33 -33
- package/src/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.ts +31 -31
- package/src/server/migrations/20260803010000-backfill-loop-control-plane-data.ts +293 -293
- package/src/server/plugin.ts +3 -1
- package/src/server/resources/agent-harness-profile.ts +94 -0
- package/src/server/resources/agent-knowledge-insights.ts +5 -3
- package/src/server/resources/agent-loop-approval.ts +32 -0
- package/src/server/resources/agent-loop-artifact.ts +56 -56
- package/src/server/resources/agent-loop-events-stream.ts +105 -105
- package/src/server/resources/agent-loop.ts +3 -1
- package/src/server/resources/resource-helpers.ts +33 -33
- package/src/server/resources/tracing.ts +266 -266
- package/src/server/services/AgentMemoryContextService.ts +44 -0
- package/src/server/services/DurableCircuitBreakerService.ts +239 -239
- package/src/server/services/ExecutionSpanService.ts +2 -0
- package/src/server/services/HarnessCompiler.ts +37 -0
- package/src/server/services/HarnessProfileService.ts +92 -10
- package/src/server/services/HarnessSchema.ts +31 -0
- package/src/server/services/LoopBudgetService.ts +275 -275
- package/src/server/services/LoopControlService.ts +124 -124
- package/src/server/services/LoopPatternSchema.ts +19 -1
- package/src/server/services/LoopPatternService.ts +143 -143
- package/src/server/services/LoopRunRepository.ts +99 -0
- package/src/server/services/LoopRunStateMachine.ts +100 -3
- package/src/server/services/LoopSchedulerService.ts +199 -199
- package/src/server/services/LoopTriggerService.ts +42 -0
- package/src/server/services/LoopWorkerService.ts +327 -27
- package/src/server/services/NativeSubAgentObserver.ts +186 -21
- package/src/server/services/PathLockService.ts +321 -321
- package/src/server/services/PluginAiRuntimeAdapter.ts +24 -7
- package/src/server/services/ToolLoopDetectionService.ts +213 -0
- package/src/server/services/VerificationSchema.ts +31 -31
- package/src/server/services/VerificationService.ts +81 -2
- package/src/server/services/harness-runtime-policy.ts +141 -0
- package/src/server/skill-hub/plugin.ts +41 -3
- package/src/server/skill-hub/services/RegistrySkillSnapshotService.ts +235 -235
- package/src/server/skill-hub/services/__tests__/RegistrySkillSnapshotService.test.ts +61 -61
- package/src/server/skill-hub/tasks/SkillExecutionTask.ts +43 -2
- package/src/server/utils/ensure-indexes.ts +96 -96
- package/src/server/utils/logging.ts +62 -62
- package/src/server/utils/loop-pattern-context.ts +20 -20
- package/dist/client-v2/214.b063f33ba044a808.js +0 -10
- package/dist/client-v2/373.f5d5292e53c4e832.js +0 -10
- package/dist/client-v2/418.58fa350f5496efd3.js +0 -10
- package/dist/client-v2/53.9a10455323390f14.js +0 -10
- package/dist/client-v2/677.a991ce0250ff5c77.js +0 -10
- package/dist/client-v2/925.e5925bf21ed68e7a.js +0 -10
- package/src/client/AIEmployeeSelect.tsx +0 -47
- package/src/client/AIEmployeesContext.tsx +0 -102
- package/src/client/RulesTab.tsx +0 -2
- package/src/client/TracingTab.tsx +0 -436
- package/src/client/skill-hub/components/ExecutionProgress.tsx +0 -51
- package/src/client-v2/components/RulesTab.tsx +0 -2
- package/src/client-v2/pages/AgentRunsPage.tsx +0 -13
|
@@ -0,0 +1,512 @@
|
|
|
1
|
+
import type { Database } from '@nocobase/database';
|
|
2
|
+
import type { Application } from '@nocobase/server';
|
|
3
|
+
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
4
|
+
import { compileHarness } from '../services/HarnessCompiler';
|
|
5
|
+
import type { CompiledHarness } from '../services/HarnessCompiler';
|
|
6
|
+
import { loopPatternPolicySchema } from '../services/LoopPatternSchema';
|
|
7
|
+
|
|
8
|
+
type Row = Record<string, unknown>;
|
|
9
|
+
|
|
10
|
+
type InvokeCall = { username: string; prompt: string; harness: CompiledHarness };
|
|
11
|
+
type ResumeCall = {
|
|
12
|
+
username: string;
|
|
13
|
+
sessionId: string;
|
|
14
|
+
messageId: string;
|
|
15
|
+
decisions: Array<{ toolCallId: string; decision: { type: string; message?: string; editedAction?: unknown } }>;
|
|
16
|
+
};
|
|
17
|
+
type ResumeOutcome = {
|
|
18
|
+
sessionId: string;
|
|
19
|
+
messageId: string;
|
|
20
|
+
interrupted: Array<{ toolCallId: string; toolName: string; args: unknown; interruptId: string }>;
|
|
21
|
+
content: string;
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
const invokeCalls: InvokeCall[] = [];
|
|
25
|
+
const resumeCalls: ResumeCall[] = [];
|
|
26
|
+
let resumeOutcome: ResumeOutcome = { sessionId: 'session-1', messageId: 'message-2', interrupted: [], content: '' };
|
|
27
|
+
|
|
28
|
+
vi.mock('../services/PluginAiRuntimeAdapter', () => ({
|
|
29
|
+
PluginAiRuntimeAdapter: class {
|
|
30
|
+
async createConversation() {
|
|
31
|
+
return 'session-1';
|
|
32
|
+
}
|
|
33
|
+
async invoke(input: InvokeCall) {
|
|
34
|
+
invokeCalls.push(input);
|
|
35
|
+
return { sessionId: 'session-1', messageId: 'message-1', interrupted: [], content: `${input.username} done` };
|
|
36
|
+
}
|
|
37
|
+
async resume(input: ResumeCall) {
|
|
38
|
+
resumeCalls.push(input);
|
|
39
|
+
return resumeOutcome;
|
|
40
|
+
}
|
|
41
|
+
},
|
|
42
|
+
}));
|
|
43
|
+
|
|
44
|
+
vi.mock('../services/VerificationService', () => ({
|
|
45
|
+
VerificationService: class {
|
|
46
|
+
async verifyAndFinalize() {
|
|
47
|
+
return { verdict: { verdict: 'pass' }, finalStatus: 'succeeded' as const };
|
|
48
|
+
}
|
|
49
|
+
},
|
|
50
|
+
}));
|
|
51
|
+
|
|
52
|
+
const { LoopRunRepository } = await import('../services/LoopRunRepository');
|
|
53
|
+
const { LoopWorkerService } = await import('../services/LoopWorkerService');
|
|
54
|
+
|
|
55
|
+
class MemoryRepository {
|
|
56
|
+
private nextId = 1;
|
|
57
|
+
|
|
58
|
+
constructor(readonly rows: Row[] = []) {
|
|
59
|
+
this.nextId = rows.reduce((maximum, row) => Math.max(maximum, Number(row.id) || 0), 0) + 1;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
async find(options: Row = {}) {
|
|
63
|
+
const filter = (options.filter as Row | undefined) || {};
|
|
64
|
+
return this.rows.filter((row) => Object.entries(filter).every(([key, value]) => row[key] === value));
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
async findOne(options: Row) {
|
|
68
|
+
if (options.filterByTk !== undefined) return this.rows.find((row) => row.id === options.filterByTk) || null;
|
|
69
|
+
return (await this.find(options))[0] || null;
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
async create(options: Row) {
|
|
73
|
+
const row = { id: this.nextId++, ...((options.values as Row | undefined) || {}) };
|
|
74
|
+
this.rows.push(row);
|
|
75
|
+
return row;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
async update(options: Row) {
|
|
79
|
+
const values = (options.values as Row | undefined) || {};
|
|
80
|
+
for (const row of this.rows) {
|
|
81
|
+
if (row.id === options.filterByTk) Object.assign(row, values);
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
function createDatabase(repositories: Map<string, MemoryRepository>) {
|
|
87
|
+
return {
|
|
88
|
+
getRepository(name: string) {
|
|
89
|
+
const repository = repositories.get(name);
|
|
90
|
+
if (!repository) throw new Error(`Unexpected repository ${name}`);
|
|
91
|
+
return repository;
|
|
92
|
+
},
|
|
93
|
+
sequelize: {
|
|
94
|
+
transaction<T>(callback: (value: { LOCK: { UPDATE: string } }) => Promise<T>) {
|
|
95
|
+
return callback({ LOCK: { UPDATE: 'UPDATE' } });
|
|
96
|
+
},
|
|
97
|
+
},
|
|
98
|
+
} as unknown as Database;
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
beforeEach(() => {
|
|
102
|
+
invokeCalls.length = 0;
|
|
103
|
+
resumeCalls.length = 0;
|
|
104
|
+
resumeOutcome = { sessionId: 'session-1', messageId: 'message-2', interrupted: [], content: 'resumed done' };
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
function waitingRun(overrides: Row = {}) {
|
|
108
|
+
return {
|
|
109
|
+
id: 1,
|
|
110
|
+
runtimeVersion: 'control-plane-v2',
|
|
111
|
+
patternId: 1,
|
|
112
|
+
userId: 7,
|
|
113
|
+
status: 'waiting_approval',
|
|
114
|
+
approvalStatus: 'pending',
|
|
115
|
+
resumeContext: null,
|
|
116
|
+
lockedBy: null,
|
|
117
|
+
lockedUntil: null,
|
|
118
|
+
...overrides,
|
|
119
|
+
};
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
function pendingApproval(overrides: Row = {}) {
|
|
123
|
+
return {
|
|
124
|
+
id: 10,
|
|
125
|
+
runId: 1,
|
|
126
|
+
toolCallId: 'call-1',
|
|
127
|
+
toolName: 'editFile',
|
|
128
|
+
inputHash: 'hash-1',
|
|
129
|
+
status: 'pending',
|
|
130
|
+
assignedToId: null,
|
|
131
|
+
expiresAt: new Date(Date.now() + 3_600_000),
|
|
132
|
+
consumedAt: null,
|
|
133
|
+
decisionNote: null,
|
|
134
|
+
editedInput: undefined,
|
|
135
|
+
...overrides,
|
|
136
|
+
};
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
describe('LoopRunRepository.decideApproval', () => {
|
|
140
|
+
function setup(runs: Row[], approvals: Row[]) {
|
|
141
|
+
const repositories = new Map<string, MemoryRepository>([
|
|
142
|
+
['agentLoopRuns', new MemoryRepository(runs)],
|
|
143
|
+
['agentLoopActionApprovals', new MemoryRepository(approvals)],
|
|
144
|
+
['agentLoopEvents', new MemoryRepository()],
|
|
145
|
+
]);
|
|
146
|
+
return { repositories, repository: new LoopRunRepository(createDatabase(repositories)) };
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
it('records the decision and requeues the run once every approval is decided', async () => {
|
|
150
|
+
const { repositories, repository } = setup(
|
|
151
|
+
[waitingRun()],
|
|
152
|
+
[pendingApproval({ id: 10, status: 'approved', consumedAt: null }), pendingApproval({ id: 11 })],
|
|
153
|
+
);
|
|
154
|
+
|
|
155
|
+
const result = await repository.decideApproval({
|
|
156
|
+
approvalId: 11,
|
|
157
|
+
userId: 7,
|
|
158
|
+
isAdmin: false,
|
|
159
|
+
decision: 'approved',
|
|
160
|
+
note: 'looks safe',
|
|
161
|
+
});
|
|
162
|
+
|
|
163
|
+
expect(result).toMatchObject({ status: 'approved', decidedById: 7, requeued: true });
|
|
164
|
+
expect(repositories.get('agentLoopRuns')?.rows[0]).toMatchObject({ status: 'queued', approvalStatus: 'decided' });
|
|
165
|
+
const decided = repositories.get('agentLoopActionApprovals')?.rows.find((row) => row.id === 11);
|
|
166
|
+
expect(decided).toMatchObject({ status: 'approved', decidedById: 7, decisionNote: 'looks safe' });
|
|
167
|
+
expect(decided?.decidedAt).toBeInstanceOf(Date);
|
|
168
|
+
|
|
169
|
+
const events = repositories.get('agentLoopEvents')?.rows || [];
|
|
170
|
+
expect(events).toHaveLength(1);
|
|
171
|
+
expect(events[0]).toMatchObject({ runId: 1, type: 'run_approval_decided', actorType: 'human' });
|
|
172
|
+
});
|
|
173
|
+
|
|
174
|
+
it('records the decision but keeps the run parked while approvals remain pending', async () => {
|
|
175
|
+
const { repositories, repository } = setup(
|
|
176
|
+
[waitingRun()],
|
|
177
|
+
[pendingApproval({ id: 10 }), pendingApproval({ id: 11 })],
|
|
178
|
+
);
|
|
179
|
+
|
|
180
|
+
const result = await repository.decideApproval({ approvalId: 10, userId: 7, isAdmin: false, decision: 'rejected' });
|
|
181
|
+
|
|
182
|
+
expect(result).toMatchObject({ status: 'rejected', requeued: false });
|
|
183
|
+
expect(repositories.get('agentLoopRuns')?.rows[0].status).toBe('waiting_approval');
|
|
184
|
+
expect(repositories.get('agentLoopEvents')?.rows).toHaveLength(0);
|
|
185
|
+
});
|
|
186
|
+
|
|
187
|
+
it('stores editedInput only for approvals', async () => {
|
|
188
|
+
const { repositories, repository } = setup([waitingRun()], [pendingApproval()]);
|
|
189
|
+
|
|
190
|
+
await repository.decideApproval({
|
|
191
|
+
approvalId: 10,
|
|
192
|
+
userId: 7,
|
|
193
|
+
isAdmin: false,
|
|
194
|
+
decision: 'approved',
|
|
195
|
+
editedInput: { path: '/tmp/safe.txt' },
|
|
196
|
+
});
|
|
197
|
+
|
|
198
|
+
expect(repositories.get('agentLoopActionApprovals')?.rows[0].editedInput).toEqual({ path: '/tmp/safe.txt' });
|
|
199
|
+
});
|
|
200
|
+
|
|
201
|
+
it('rejects a decision on an approval that is already decided', async () => {
|
|
202
|
+
const { repository } = setup([waitingRun()], [pendingApproval({ status: 'approved' })]);
|
|
203
|
+
|
|
204
|
+
await expect(
|
|
205
|
+
repository.decideApproval({ approvalId: 10, userId: 7, isAdmin: false, decision: 'rejected' }),
|
|
206
|
+
).rejects.toMatchObject({ status: 409 });
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
it('rejects a decision once the approval window has expired', async () => {
|
|
210
|
+
const { repositories, repository } = setup(
|
|
211
|
+
[waitingRun()],
|
|
212
|
+
[pendingApproval({ expiresAt: new Date(Date.now() - 1_000) })],
|
|
213
|
+
);
|
|
214
|
+
|
|
215
|
+
await expect(
|
|
216
|
+
repository.decideApproval({ approvalId: 10, userId: 7, isAdmin: false, decision: 'approved' }),
|
|
217
|
+
).rejects.toMatchObject({ status: 409 });
|
|
218
|
+
// Fail closed: the row stays pending for the reaper to expire, a late click cannot revive it.
|
|
219
|
+
expect(repositories.get('agentLoopActionApprovals')?.rows[0].status).toBe('pending');
|
|
220
|
+
});
|
|
221
|
+
|
|
222
|
+
it('rejects a decision once the run has moved on', async () => {
|
|
223
|
+
const { repository } = setup([waitingRun({ status: 'running' })], [pendingApproval()]);
|
|
224
|
+
|
|
225
|
+
await expect(
|
|
226
|
+
repository.decideApproval({ approvalId: 10, userId: 7, isAdmin: false, decision: 'approved' }),
|
|
227
|
+
).rejects.toMatchObject({ status: 409 });
|
|
228
|
+
});
|
|
229
|
+
|
|
230
|
+
it('records decisions for a paused run without requeueing it', async () => {
|
|
231
|
+
const { repositories, repository } = setup([waitingRun({ status: 'paused' })], [pendingApproval()]);
|
|
232
|
+
|
|
233
|
+
const result = await repository.decideApproval({
|
|
234
|
+
approvalId: 10,
|
|
235
|
+
userId: 7,
|
|
236
|
+
isAdmin: false,
|
|
237
|
+
decision: 'approved',
|
|
238
|
+
});
|
|
239
|
+
|
|
240
|
+
expect(result).toMatchObject({ status: 'approved', requeued: false });
|
|
241
|
+
expect(repositories.get('agentLoopRuns')?.rows[0].status).toBe('paused');
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
it('refuses decisions from users who own neither the run nor the approval', async () => {
|
|
245
|
+
const { repository } = setup([waitingRun()], [pendingApproval({ assignedToId: 8 })]);
|
|
246
|
+
|
|
247
|
+
await expect(
|
|
248
|
+
repository.decideApproval({ approvalId: 10, userId: 9, isAdmin: false, decision: 'approved' }),
|
|
249
|
+
).rejects.toMatchObject({ status: 403 });
|
|
250
|
+
});
|
|
251
|
+
|
|
252
|
+
it('lets the assigned approver decide even without owning the run', async () => {
|
|
253
|
+
const { repository } = setup([waitingRun()], [pendingApproval({ assignedToId: 8 })]);
|
|
254
|
+
|
|
255
|
+
const result = await repository.decideApproval({
|
|
256
|
+
approvalId: 10,
|
|
257
|
+
userId: 8,
|
|
258
|
+
isAdmin: false,
|
|
259
|
+
decision: 'approved',
|
|
260
|
+
});
|
|
261
|
+
|
|
262
|
+
expect(result).toMatchObject({ status: 'approved', decidedById: 8 });
|
|
263
|
+
});
|
|
264
|
+
});
|
|
265
|
+
|
|
266
|
+
describe('LoopWorkerService approval resume-mode', () => {
|
|
267
|
+
type WorkerInternals = { execute(claimed: { run: Row; leaseToken: string; leaseUntil: Date }): Promise<void> };
|
|
268
|
+
|
|
269
|
+
function harnessSnapshot(allow: string[]) {
|
|
270
|
+
return { effective: compileHarness([{ source: 'test', settings: { tools: { allow } } }]) };
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
const policy = loopPatternPolicySchema.parse({ maxConcurrency: 1 });
|
|
274
|
+
|
|
275
|
+
function createWorker(run: Row, approvals: Row[] = []) {
|
|
276
|
+
const repositories = new Map<string, MemoryRepository>([
|
|
277
|
+
[
|
|
278
|
+
'agentLoopControlSettings',
|
|
279
|
+
new MemoryRepository([
|
|
280
|
+
{ id: 1, key: 'global', state: 'running', acceptNewRuns: true, globalMaxConcurrency: 5 },
|
|
281
|
+
]),
|
|
282
|
+
],
|
|
283
|
+
['agentLoopRuns', new MemoryRepository([{ ...run }])],
|
|
284
|
+
['agentLoopActionApprovals', new MemoryRepository(approvals)],
|
|
285
|
+
['agentLoopEvents', new MemoryRepository()],
|
|
286
|
+
['agentLoopSteps', new MemoryRepository()],
|
|
287
|
+
['aiMessages', new MemoryRepository()],
|
|
288
|
+
['agentLoopUsageBuckets', new MemoryRepository()],
|
|
289
|
+
['agentLoopCircuitStates', new MemoryRepository()],
|
|
290
|
+
['agentLoopPathLocks', new MemoryRepository()],
|
|
291
|
+
['agentLoopArtifacts', new MemoryRepository()],
|
|
292
|
+
]);
|
|
293
|
+
const app = {
|
|
294
|
+
name: 'test',
|
|
295
|
+
logger: { warn: vi.fn(), error: vi.fn(), info: vi.fn() },
|
|
296
|
+
log: { warn: vi.fn(), error: vi.fn(), info: vi.fn() },
|
|
297
|
+
lockManager: { runExclusive: <T>(_key: string, operation: () => Promise<T>) => operation() },
|
|
298
|
+
};
|
|
299
|
+
const worker = new LoopWorkerService(app as unknown as Application, createDatabase(repositories));
|
|
300
|
+
return { repositories, worker: worker as unknown as WorkerInternals };
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
function resumedRun(overrides: Row = {}) {
|
|
304
|
+
return {
|
|
305
|
+
id: 1,
|
|
306
|
+
runtimeVersion: 'control-plane-v2',
|
|
307
|
+
patternId: 1,
|
|
308
|
+
userId: 7,
|
|
309
|
+
status: 'preparing',
|
|
310
|
+
lockedBy: 'worker-a:lease',
|
|
311
|
+
lockedUntil: new Date(Date.now() + 60_000),
|
|
312
|
+
goal: 'Ship the feature',
|
|
313
|
+
autonomyLevel: 'L1',
|
|
314
|
+
policySnapshot: policy,
|
|
315
|
+
roleBindingsSnapshot: { leader: 'lead', makers: ['maker-one', 'maker-two'], verifier: 'checker' },
|
|
316
|
+
leaderHarnessSnapshot: harnessSnapshot(['readFile']),
|
|
317
|
+
makerHarnessSnapshot: {
|
|
318
|
+
'maker-one': harnessSnapshot(['editFile']),
|
|
319
|
+
'maker-two': harnessSnapshot(['runTests']),
|
|
320
|
+
},
|
|
321
|
+
verifierHarnessSnapshot: harnessSnapshot(['readFile']),
|
|
322
|
+
repositoryKey: '',
|
|
323
|
+
actingOn: [],
|
|
324
|
+
approvalStatus: 'decided',
|
|
325
|
+
resumeContext: {
|
|
326
|
+
role: 'maker',
|
|
327
|
+
username: 'maker-one',
|
|
328
|
+
sessionId: 'session-1',
|
|
329
|
+
messageId: 'message-1',
|
|
330
|
+
makerReports: ['the leader plan'],
|
|
331
|
+
makerQueue: ['maker-two'],
|
|
332
|
+
},
|
|
333
|
+
...overrides,
|
|
334
|
+
};
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
function claimed(run: Row) {
|
|
338
|
+
return { run, leaseToken: 'worker-a:lease', leaseUntil: new Date(Date.now() + 60_000) };
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
it('resumes the interrupted role instead of restarting from the leader', async () => {
|
|
342
|
+
const run = resumedRun();
|
|
343
|
+
const { repositories, worker } = createWorker(run, [
|
|
344
|
+
pendingApproval({ status: 'approved', decidedById: 7, consumedAt: null }),
|
|
345
|
+
]);
|
|
346
|
+
|
|
347
|
+
await worker.execute(claimed(run));
|
|
348
|
+
|
|
349
|
+
expect(resumeCalls).toHaveLength(1);
|
|
350
|
+
expect(resumeCalls[0]).toMatchObject({
|
|
351
|
+
username: 'maker-one',
|
|
352
|
+
sessionId: 'session-1',
|
|
353
|
+
messageId: 'message-1',
|
|
354
|
+
decisions: [{ toolCallId: 'call-1', decision: { type: 'approve' } }],
|
|
355
|
+
});
|
|
356
|
+
// Only the makers still queued run; the leader and completed makers are not re-invoked.
|
|
357
|
+
expect(invokeCalls.map((call) => call.username)).toEqual(['maker-two']);
|
|
358
|
+
expect(repositories.get('agentLoopRuns')?.rows[0].status).toBe('verifying');
|
|
359
|
+
});
|
|
360
|
+
|
|
361
|
+
it('maps edited and rejected approvals onto plugin-ai decisions', async () => {
|
|
362
|
+
const run = resumedRun();
|
|
363
|
+
const { worker } = createWorker(run, [
|
|
364
|
+
pendingApproval({
|
|
365
|
+
id: 10,
|
|
366
|
+
toolCallId: 'call-1',
|
|
367
|
+
status: 'approved',
|
|
368
|
+
editedInput: { path: '/tmp/safe.txt' },
|
|
369
|
+
consumedAt: null,
|
|
370
|
+
}),
|
|
371
|
+
pendingApproval({
|
|
372
|
+
id: 11,
|
|
373
|
+
toolCallId: 'call-2',
|
|
374
|
+
status: 'rejected',
|
|
375
|
+
decisionNote: 'too risky',
|
|
376
|
+
consumedAt: null,
|
|
377
|
+
}),
|
|
378
|
+
]);
|
|
379
|
+
|
|
380
|
+
await worker.execute(claimed(run));
|
|
381
|
+
|
|
382
|
+
expect(resumeCalls[0].decisions).toEqual([
|
|
383
|
+
{
|
|
384
|
+
toolCallId: 'call-1',
|
|
385
|
+
decision: { type: 'edit', editedAction: { name: 'editFile', args: { path: '/tmp/safe.txt' } } },
|
|
386
|
+
},
|
|
387
|
+
{ toolCallId: 'call-2', decision: { type: 'reject', message: 'too risky' } },
|
|
388
|
+
]);
|
|
389
|
+
});
|
|
390
|
+
|
|
391
|
+
it('consumes each decision exactly once', async () => {
|
|
392
|
+
const run = resumedRun();
|
|
393
|
+
const { repositories, worker } = createWorker(run, [pendingApproval({ status: 'approved', consumedAt: null })]);
|
|
394
|
+
|
|
395
|
+
await worker.execute(claimed(run));
|
|
396
|
+
|
|
397
|
+
const approval = repositories.get('agentLoopActionApprovals')?.rows[0];
|
|
398
|
+
expect(approval?.consumedAt).toBeInstanceOf(Date);
|
|
399
|
+
});
|
|
400
|
+
|
|
401
|
+
it('parks again with the same resume point when the resumed call hits another gate', async () => {
|
|
402
|
+
resumeOutcome = {
|
|
403
|
+
sessionId: 'session-1',
|
|
404
|
+
messageId: 'message-3',
|
|
405
|
+
interrupted: [{ toolCallId: 'call-9', toolName: 'runShell', args: { cmd: 'rm' }, interruptId: 'int-9' }],
|
|
406
|
+
content: '',
|
|
407
|
+
};
|
|
408
|
+
const run = resumedRun();
|
|
409
|
+
const { repositories, worker } = createWorker(run, [pendingApproval({ status: 'approved', consumedAt: null })]);
|
|
410
|
+
|
|
411
|
+
await worker.execute(claimed(run));
|
|
412
|
+
|
|
413
|
+
const row = repositories.get('agentLoopRuns')?.rows[0];
|
|
414
|
+
expect(row?.status).toBe('waiting_approval');
|
|
415
|
+
expect(row?.approvalStatus).toBe('pending');
|
|
416
|
+
// The queue and reports survive the second gate, so the next resume continues in place.
|
|
417
|
+
expect(row?.resumeContext).toMatchObject({
|
|
418
|
+
role: 'maker',
|
|
419
|
+
username: 'maker-one',
|
|
420
|
+
messageId: 'message-3',
|
|
421
|
+
makerQueue: ['maker-two'],
|
|
422
|
+
makerReports: ['the leader plan'],
|
|
423
|
+
});
|
|
424
|
+
const approvals = repositories.get('agentLoopActionApprovals')?.rows || [];
|
|
425
|
+
expect(approvals.filter((approval) => approval.status === 'pending')).toHaveLength(1);
|
|
426
|
+
expect(approvals[approvals.length - 1]).toMatchObject({ toolCallId: 'call-9' });
|
|
427
|
+
});
|
|
428
|
+
|
|
429
|
+
it('tags approvals for escalatable tools as escalations', async () => {
|
|
430
|
+
resumeOutcome = {
|
|
431
|
+
sessionId: 'session-1',
|
|
432
|
+
messageId: 'message-3',
|
|
433
|
+
interrupted: [
|
|
434
|
+
{ toolCallId: 'call-9', toolName: 'runShell', args: { cmd: 'ls' }, interruptId: 'int-9' },
|
|
435
|
+
{ toolCallId: 'call-10', toolName: 'editFile', args: { path: '/tmp/x' }, interruptId: 'int-10' },
|
|
436
|
+
],
|
|
437
|
+
content: '',
|
|
438
|
+
};
|
|
439
|
+
const run = resumedRun({
|
|
440
|
+
makerHarnessSnapshot: {
|
|
441
|
+
'maker-one': {
|
|
442
|
+
// runShell is not granted but escalatable; editFile is granted yet still ask-gated here
|
|
443
|
+
// because the interrupted call reached the approval gate through the plan.
|
|
444
|
+
effective: compileHarness([
|
|
445
|
+
{ source: 'test', settings: { tools: { allow: ['editFile'], escalate: ['runShell'] } } },
|
|
446
|
+
]),
|
|
447
|
+
},
|
|
448
|
+
'maker-two': harnessSnapshot(['runTests']),
|
|
449
|
+
},
|
|
450
|
+
});
|
|
451
|
+
const { repositories, worker } = createWorker(run, [pendingApproval({ status: 'approved', consumedAt: null })]);
|
|
452
|
+
|
|
453
|
+
await worker.execute(claimed(run));
|
|
454
|
+
|
|
455
|
+
const approvals = repositories.get('agentLoopActionApprovals')?.rows || [];
|
|
456
|
+
const escalation = approvals.find((approval) => approval.toolCallId === 'call-9');
|
|
457
|
+
const plain = approvals.find((approval) => approval.toolCallId === 'call-10');
|
|
458
|
+
expect(escalation).toMatchObject({
|
|
459
|
+
actionType: 'escalation',
|
|
460
|
+
toolName: 'runShell',
|
|
461
|
+
status: 'pending',
|
|
462
|
+
});
|
|
463
|
+
expect(String(escalation?.reason)).toContain('widens authority for this single call only');
|
|
464
|
+
expect(plain).toMatchObject({ actionType: 'tool_call', toolName: 'editFile' });
|
|
465
|
+
expect(String(plain?.reason)).toContain('requires human approval');
|
|
466
|
+
});
|
|
467
|
+
|
|
468
|
+
it('re-parks a requeued run whose decisions never arrived', async () => {
|
|
469
|
+
const run = resumedRun({ approvalStatus: 'pending' });
|
|
470
|
+
const { repositories, worker } = createWorker(run, [pendingApproval()]);
|
|
471
|
+
|
|
472
|
+
await worker.execute(claimed(run));
|
|
473
|
+
|
|
474
|
+
expect(resumeCalls).toHaveLength(0);
|
|
475
|
+
expect(invokeCalls).toHaveLength(0);
|
|
476
|
+
expect(repositories.get('agentLoopRuns')?.rows[0].status).toBe('waiting_approval');
|
|
477
|
+
});
|
|
478
|
+
|
|
479
|
+
it('ignores a stale resume context left behind by an expired window', async () => {
|
|
480
|
+
// The reaper blocks expired runs; a later retry clears approvalStatus to null. Either way the
|
|
481
|
+
// saved context must not replay an old conversation, so the run starts fresh from the leader.
|
|
482
|
+
const run = resumedRun({ approvalStatus: 'expired' });
|
|
483
|
+
const { worker } = createWorker(run, []);
|
|
484
|
+
|
|
485
|
+
await worker.execute(claimed(run));
|
|
486
|
+
|
|
487
|
+
expect(resumeCalls).toHaveLength(0);
|
|
488
|
+
expect(invokeCalls.map((call) => call.username)).toEqual(['lead', 'maker-one', 'maker-two']);
|
|
489
|
+
});
|
|
490
|
+
|
|
491
|
+
it('resumes the leader into a full maker pass', async () => {
|
|
492
|
+
const run = resumedRun({
|
|
493
|
+
resumeContext: {
|
|
494
|
+
role: 'leader',
|
|
495
|
+
username: 'lead',
|
|
496
|
+
sessionId: 'session-1',
|
|
497
|
+
messageId: 'message-1',
|
|
498
|
+
makerReports: [],
|
|
499
|
+
makerQueue: ['maker-one', 'maker-two'],
|
|
500
|
+
},
|
|
501
|
+
});
|
|
502
|
+
resumeOutcome = { sessionId: 'session-1', messageId: 'message-2', interrupted: [], content: 'the resumed plan' };
|
|
503
|
+
const { worker } = createWorker(run, [pendingApproval({ status: 'approved', consumedAt: null })]);
|
|
504
|
+
|
|
505
|
+
await worker.execute(claimed(run));
|
|
506
|
+
|
|
507
|
+
expect(resumeCalls).toHaveLength(1);
|
|
508
|
+
expect(invokeCalls.map((call) => call.username)).toEqual(['maker-one', 'maker-two']);
|
|
509
|
+
// The resumed leader content replaces the plan handed to the makers.
|
|
510
|
+
expect(invokeCalls[0].prompt).toContain('the resumed plan');
|
|
511
|
+
});
|
|
512
|
+
});
|