plugin-agent-orchestrator 1.1.3 → 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/253.59577b40d9875be0.js +10 -0
- package/dist/client-v2/264.7ed8bee71fa5935c.js +10 -0
- package/dist/client-v2/{41.ba6e080cc0488143.js → 41.3deb9e57a0f64fc4.js} +1 -1
- package/dist/client-v2/418.41ed200e7d6da332.js +10 -0
- package/dist/client-v2/53.349fff8db80b19d4.js +10 -0
- package/dist/client-v2/619.0a2144aaffefe018.js +10 -0
- package/dist/client-v2/{70.bda9518881c05360.js → 70.ffff2997c10fd4b0.js} +1 -1
- package/dist/client-v2/{794.9bbb8d3a61b2bdf2.js → 794.a67a2614405ba627.js} +1 -1
- package/dist/client-v2/981.e4a1f41cfc94a856.js +10 -0
- package/dist/client-v2/{993.82778b6fd6db3cb1.js → 993.b0688fdc5ccb000a.js} +1 -1
- package/dist/client-v2/index.js +1 -1
- package/dist/externalVersion.js +8 -7
- package/dist/locale/en-US.json +199 -123
- package/dist/locale/vi-VN.json +199 -123
- package/dist/locale/zh-CN.json +199 -123
- package/dist/server/collections/agent-execution-spans.js +55 -0
- package/dist/server/collections/agent-harness-profile-versions.js +56 -0
- package/dist/server/collections/agent-harness-profiles.js +12 -0
- package/dist/server/collections/agent-loop-action-approvals.js +69 -0
- package/dist/server/collections/agent-loop-artifacts.js +55 -0
- package/dist/server/collections/agent-loop-circuit-states.js +53 -0
- package/dist/server/collections/agent-loop-control-settings.js +51 -0
- package/dist/server/collections/agent-loop-events.js +27 -0
- package/dist/server/collections/agent-loop-path-locks.js +57 -0
- package/dist/server/collections/agent-loop-patterns.js +72 -0
- package/dist/server/collections/agent-loop-runs.js +170 -3
- package/dist/server/collections/agent-loop-steps.js +76 -0
- package/dist/server/collections/agent-loop-usage-buckets.js +52 -0
- package/dist/server/collections/agent-loop-worktrees.js +55 -0
- package/dist/server/collections/skill-executions.js +8 -0
- package/dist/server/migrations/{20260427000000-change-packages-to-text.js → 20260427000002-change-packages-to-text.js} +2 -0
- package/dist/server/migrations/20260429000000-add-llm-fields.js +3 -2
- package/dist/server/migrations/{20260429000000-fix-inputargs-json-to-text.js → 20260429000001-fix-inputargs-json-to-text.js} +14 -6
- package/dist/server/migrations/20260503000000-add-orchestrator-trace-fields.js +2 -1
- package/dist/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.js +2 -1
- package/dist/server/migrations/20260803010000-backfill-loop-control-plane-data.js +262 -0
- package/dist/server/plugin.js +54 -150
- 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 +108 -0
- package/dist/server/resources/agent-loop-artifact.js +86 -0
- package/dist/server/resources/agent-loop-events-stream.js +130 -0
- package/dist/server/resources/agent-loop.js +183 -139
- package/dist/server/resources/resource-helpers.js +63 -0
- package/dist/server/resources/tracing.js +121 -107
- package/dist/server/services/AgentMemoryContextService.js +34 -0
- package/dist/server/services/DurableCircuitBreakerService.js +229 -0
- package/dist/server/services/HarnessCompiler.js +175 -0
- package/dist/server/services/HarnessProfileService.js +233 -0
- package/dist/server/services/HarnessSchema.js +194 -0
- package/dist/server/services/LoopBudgetService.js +269 -0
- package/dist/server/services/LoopControlService.js +139 -0
- package/dist/server/services/LoopPatternSchema.js +195 -0
- package/dist/server/services/LoopPatternService.js +132 -0
- package/dist/server/services/LoopRunRepository.js +285 -0
- package/dist/server/services/LoopRunStateMachine.js +478 -0
- package/dist/server/services/LoopSchedulerService.js +193 -0
- package/dist/server/services/LoopTriggerService.js +165 -0
- package/dist/server/services/LoopWorkerService.js +699 -0
- package/dist/server/services/NativeSubAgentObserver.js +165 -23
- package/dist/server/services/PathLockService.js +288 -0
- package/dist/server/services/PluginAiRuntimeAdapter.js +226 -0
- package/dist/server/services/ToolLoopDetectionService.js +210 -0
- package/dist/server/services/VerificationSchema.js +59 -0
- package/dist/server/services/VerificationService.js +235 -0
- package/dist/server/services/harness-runtime-policy.js +139 -0
- package/dist/server/skill-hub/actions/git-import.js +13 -7
- package/dist/server/skill-hub/plugin.js +36 -3
- package/dist/server/skill-hub/services/RegistrySkillSnapshotService.js +1 -5
- package/dist/server/skill-hub/tasks/SkillExecutionTask.js +29 -0
- package/dist/server/utils/ensure-indexes.js +111 -0
- package/dist/server/utils/loop-pattern-context.js +56 -0
- package/package.json +53 -53
- package/src/client/ApprovalsTab.tsx +2 -0
- package/src/client/OrchestratorSettings.tsx +55 -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 +100 -18
- package/src/client-v2/components/ApprovalsTab.tsx +337 -0
- package/src/client-v2/components/HarnessProfilesTab.tsx +385 -100
- package/src/client-v2/components/MemoryInspectorTab.tsx +141 -125
- package/src/client-v2/components/TracingTab.tsx +160 -77
- package/src/client-v2/hooks/useApiRequest.ts +28 -8
- 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 +11 -6
- package/src/locale/en-US.json +199 -123
- package/src/locale/vi-VN.json +199 -123
- package/src/locale/zh-CN.json +199 -123
- package/src/server/__tests__/circuit-breaker.test.ts +248 -169
- package/src/server/__tests__/harness-compiler.test.ts +214 -0
- package/src/server/__tests__/harness-profile-service.test.ts +167 -0
- package/src/server/__tests__/harness-runtime-policy.test.ts +293 -0
- package/src/server/__tests__/harness-tool-plan.test.ts +172 -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 -0
- package/src/server/__tests__/loop-control-plane-backfill.test.ts +266 -0
- package/src/server/__tests__/loop-pattern-schema.test.ts +73 -0
- package/src/server/__tests__/loop-pattern-service.test.ts +148 -0
- package/src/server/__tests__/loop-run-state-machine.test.ts +101 -0
- package/src/server/__tests__/loop-trigger-service.test.ts +148 -0
- package/src/server/__tests__/loop-worker-claim.test.ts +341 -0
- package/src/server/__tests__/loop-worker-execution.test.ts +317 -0
- package/src/server/__tests__/native-sub-agent-observer.test.ts +288 -4
- package/src/server/__tests__/path-lock-service.test.ts +254 -0
- package/src/server/__tests__/skill-execution-task-policy.test.ts +140 -0
- package/src/server/__tests__/smoke.test.ts +162 -121
- package/src/server/__tests__/tool-loop-detection.test.ts +275 -0
- package/src/server/collections/agent-execution-spans.ts +55 -0
- package/src/server/collections/agent-harness-profile-versions.ts +26 -0
- package/src/server/collections/agent-harness-profiles.ts +71 -59
- package/src/server/collections/agent-loop-action-approvals.ts +39 -0
- package/src/server/collections/agent-loop-artifacts.ts +25 -0
- package/src/server/collections/agent-loop-circuit-states.ts +23 -0
- package/src/server/collections/agent-loop-control-settings.ts +21 -0
- package/src/server/collections/agent-loop-events.ts +98 -71
- package/src/server/collections/agent-loop-path-locks.ts +27 -0
- package/src/server/collections/agent-loop-patterns.ts +42 -0
- package/src/server/collections/agent-loop-runs.ts +170 -3
- package/src/server/collections/agent-loop-steps.ts +76 -0
- package/src/server/collections/agent-loop-usage-buckets.ts +22 -0
- package/src/server/collections/agent-loop-worktrees.ts +25 -0
- package/src/server/collections/skill-executions.ts +8 -0
- package/src/server/migrations/{20260427000000-change-packages-to-text.ts → 20260427000002-change-packages-to-text.ts} +52 -49
- package/src/server/migrations/20260429000000-add-llm-fields.ts +47 -46
- package/src/server/migrations/{20260429000000-fix-inputargs-json-to-text.ts → 20260429000001-fix-inputargs-json-to-text.ts} +45 -38
- package/src/server/migrations/20260503000000-add-orchestrator-trace-fields.ts +33 -32
- package/src/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.ts +31 -30
- package/src/server/migrations/20260803010000-backfill-loop-control-plane-data.ts +293 -0
- package/src/server/plugin.ts +55 -167
- 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 +84 -0
- package/src/server/resources/agent-loop-artifact.ts +56 -0
- package/src/server/resources/agent-loop-events-stream.ts +105 -0
- package/src/server/resources/agent-loop.ts +204 -143
- package/src/server/resources/agent-monitor.ts +482 -482
- package/src/server/resources/resource-helpers.ts +33 -0
- package/src/server/resources/tracing.ts +266 -258
- package/src/server/services/AgentMemoryContextService.ts +44 -0
- package/src/server/services/DurableCircuitBreakerService.ts +239 -0
- package/src/server/services/ExecutionSpanService.ts +2 -0
- package/src/server/services/HarnessCompiler.ts +170 -0
- package/src/server/services/HarnessProfileService.ts +239 -0
- package/src/server/services/HarnessSchema.ts +194 -0
- package/src/server/services/LoopBudgetService.ts +275 -0
- package/src/server/services/LoopControlService.ts +124 -0
- package/src/server/services/LoopPatternSchema.ts +185 -0
- package/src/server/services/LoopPatternService.ts +143 -0
- package/src/server/services/LoopRunRepository.ts +336 -0
- package/src/server/services/LoopRunStateMachine.ts +529 -0
- package/src/server/services/LoopSchedulerService.ts +199 -0
- package/src/server/services/LoopTriggerService.ts +157 -0
- package/src/server/services/LoopWorkerService.ts +822 -0
- package/src/server/services/NativeSubAgentObserver.ts +186 -21
- package/src/server/services/PathLockService.ts +321 -0
- package/src/server/services/PluginAiRuntimeAdapter.ts +332 -0
- package/src/server/services/ToolLoopDetectionService.ts +213 -0
- package/src/server/services/VerificationSchema.ts +31 -0
- package/src/server/services/VerificationService.ts +264 -0
- package/src/server/services/harness-runtime-policy.ts +141 -0
- package/src/server/skill-hub/actions/__tests__/git-import.test.ts +15 -1
- package/src/server/skill-hub/actions/git-import.ts +9 -3
- package/src/server/skill-hub/plugin.ts +41 -3
- package/src/server/skill-hub/services/RegistrySkillSnapshotService.ts +235 -239
- package/src/server/skill-hub/services/__tests__/RegistrySkillSnapshotService.test.ts +61 -63
- package/src/server/skill-hub/tasks/SkillExecutionTask.ts +43 -2
- package/src/server/utils/ensure-indexes.ts +96 -0
- package/src/server/utils/logging.ts +62 -63
- package/src/server/utils/loop-pattern-context.ts +20 -0
- package/dist/client-v2/214.79650a549273f163.js +0 -10
- package/dist/client-v2/253.9f0537713cee9e6c.js +0 -10
- package/dist/client-v2/264.718a107e43fc163c.js +0 -10
- package/dist/client-v2/373.f5d5292e53c4e832.js +0 -10
- package/dist/client-v2/418.ce8f5b2b8a229d1d.js +0 -10
- package/dist/client-v2/53.7c29c28043e9112d.js +0 -10
- package/dist/client-v2/619.bd3c5698b40705c3.js +0 -10
- package/dist/client-v2/677.a991ce0250ff5c77.js +0 -10
- package/dist/client-v2/925.f5370de8f6632d65.js +0 -10
- package/dist/server/services/AgentHarness.js +0 -81
- package/dist/server/services/AgentLoopController.js +0 -1023
- package/dist/server/services/AgentLoopRepository.js +0 -192
- package/dist/server/services/AgentLoopService.js +0 -142
- package/dist/server/services/AgentPlanValidator.js +0 -99
- package/dist/server/services/AgentPlannerService.js +0 -99
- package/dist/server/services/CircuitBreaker.js +0 -125
- package/dist/server/services/ContextAggregator.js +0 -201
- package/dist/server/services/PlanningPromptService.js +0 -95
- package/dist/server/tools/agent-loop.js +0 -373
- package/dist/server/tools/orchestrator-plan.js +0 -254
- 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
- package/src/server/__tests__/agent-loop-controller.test.ts +0 -375
- package/src/server/__tests__/context-aggregator.test.ts +0 -222
- package/src/server/__tests__/parallel-execution.test.ts +0 -318
- package/src/server/__tests__/planning-prompt-service.test.ts +0 -23
- package/src/server/services/AgentHarness.ts +0 -67
- package/src/server/services/AgentLoopController.ts +0 -1263
- package/src/server/services/AgentLoopRepository.ts +0 -178
- package/src/server/services/AgentLoopService.ts +0 -177
- package/src/server/services/AgentPlanValidator.ts +0 -73
- package/src/server/services/AgentPlannerService.ts +0 -80
- package/src/server/services/CircuitBreaker.ts +0 -126
- package/src/server/services/ContextAggregator.ts +0 -239
- package/src/server/services/PlanningPromptService.ts +0 -72
- package/src/server/tools/agent-loop.ts +0 -360
- package/src/server/tools/orchestrator-plan.ts +0 -255
|
@@ -0,0 +1,167 @@
|
|
|
1
|
+
import type { Database } from '@nocobase/database';
|
|
2
|
+
import { describe, expect, it } from 'vitest';
|
|
3
|
+
import { HarnessProfileService } from '../services/HarnessProfileService';
|
|
4
|
+
|
|
5
|
+
type Row = Record<string, unknown>;
|
|
6
|
+
|
|
7
|
+
function readField(record: unknown, key: string) {
|
|
8
|
+
const model = record as { get?: (name: string) => unknown; [key: string]: unknown };
|
|
9
|
+
return typeof model?.get === 'function' ? model.get(key) : model?.[key];
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
function matches(row: Row, filter: Row) {
|
|
13
|
+
return Object.entries(filter).every(([key, value]) => row[key] === value);
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
class MemoryRepository {
|
|
17
|
+
private nextId: number;
|
|
18
|
+
|
|
19
|
+
constructor(readonly rows: Row[] = []) {
|
|
20
|
+
this.nextId = rows.reduce((maximum, row) => Math.max(maximum, Number(row.id) || 0), 0) + 1;
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
async findOne(options: Row) {
|
|
24
|
+
if (options.filterByTk !== undefined) {
|
|
25
|
+
return this.rows.find((row) => row.id === options.filterByTk) || null;
|
|
26
|
+
}
|
|
27
|
+
const filter = (options.filter as Row | undefined) || {};
|
|
28
|
+
const matchesFilter = this.rows.filter((row) => matches(row, filter));
|
|
29
|
+
if (options.sort && (options.sort as string[]).includes('-version')) {
|
|
30
|
+
matchesFilter.sort((left, right) => Number(right.version) - Number(left.version));
|
|
31
|
+
}
|
|
32
|
+
return matchesFilter[0] || null;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
async create(options: Row) {
|
|
36
|
+
const row = { id: this.nextId++, ...((options.values as Row | undefined) || {}) };
|
|
37
|
+
this.rows.push(row);
|
|
38
|
+
return row;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
async update(options: Row) {
|
|
42
|
+
const values = (options.values as Row | undefined) || {};
|
|
43
|
+
for (const row of this.rows) {
|
|
44
|
+
if (options.filterByTk !== undefined && row.id === options.filterByTk) {
|
|
45
|
+
Object.assign(row, values);
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
function createService() {
|
|
52
|
+
const profiles = new MemoryRepository([{ id: 1, tag: 'safe', enabled: true, schemaVersion: 1 }]);
|
|
53
|
+
const versions = new MemoryRepository();
|
|
54
|
+
const repositories = new Map([
|
|
55
|
+
['agentHarnessProfiles', profiles],
|
|
56
|
+
['agentHarnessProfileVersions', versions],
|
|
57
|
+
]);
|
|
58
|
+
const transaction = { LOCK: { UPDATE: 'UPDATE' } };
|
|
59
|
+
const database = {
|
|
60
|
+
getRepository(name: string) {
|
|
61
|
+
const repository = repositories.get(name);
|
|
62
|
+
if (!repository) throw new Error(`Unexpected repository ${name}`);
|
|
63
|
+
return repository;
|
|
64
|
+
},
|
|
65
|
+
sequelize: {
|
|
66
|
+
async transaction<T>(callback: (value: typeof transaction) => Promise<T>) {
|
|
67
|
+
return callback(transaction);
|
|
68
|
+
},
|
|
69
|
+
},
|
|
70
|
+
};
|
|
71
|
+
return {
|
|
72
|
+
profiles,
|
|
73
|
+
versions,
|
|
74
|
+
service: new HarnessProfileService(database as unknown as Database),
|
|
75
|
+
};
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
describe('HarnessProfileService', () => {
|
|
79
|
+
it('creates sequential drafts, publishes atomically, and keeps snapshots immutable', async () => {
|
|
80
|
+
const { profiles, versions, service } = createService();
|
|
81
|
+
const firstDraft = await service.createDraft({
|
|
82
|
+
profileId: 1,
|
|
83
|
+
settings: { tools: { allow: ['read_file'], effects: { read_file: 'read' } } },
|
|
84
|
+
});
|
|
85
|
+
expect(firstDraft).toMatchObject({ profileId: 1, version: 1, status: 'draft' });
|
|
86
|
+
|
|
87
|
+
const updatedDraft = await service.updateDraft(firstDraft.id, {
|
|
88
|
+
tools: { allow: ['read_file', 'read_test'], effects: { read_file: 'read', read_test: 'read' } },
|
|
89
|
+
});
|
|
90
|
+
expect(updatedDraft.settings.tools.allow).toEqual(['read_file', 'read_test']);
|
|
91
|
+
|
|
92
|
+
const published = await service.publish(firstDraft.id, 9);
|
|
93
|
+
expect(published).toMatchObject({ version: 1, status: 'published', publishedById: 9 });
|
|
94
|
+
expect(profiles.rows[0].currentVersionId).toBe(firstDraft.id);
|
|
95
|
+
await expect(service.updateDraft(firstDraft.id, {})).rejects.toThrow('immutable');
|
|
96
|
+
|
|
97
|
+
const runSnapshot = structuredClone(published.settings);
|
|
98
|
+
const secondDraft = await service.createDraft({
|
|
99
|
+
profileId: 1,
|
|
100
|
+
settings: { tools: { deny: ['read_file'] } },
|
|
101
|
+
});
|
|
102
|
+
expect(secondDraft.version).toBe(2);
|
|
103
|
+
expect(versions.rows).toHaveLength(2);
|
|
104
|
+
|
|
105
|
+
const currentBeforePublish = await service.getPublishedByTag('safe');
|
|
106
|
+
expect(currentBeforePublish?.version).toBe(1);
|
|
107
|
+
expect(runSnapshot.tools.allow).toEqual(['read_file', 'read_test']);
|
|
108
|
+
|
|
109
|
+
await service.publish(secondDraft.id, 10);
|
|
110
|
+
const currentAfterPublish = await service.getPublishedByTag('safe');
|
|
111
|
+
expect(currentAfterPublish?.version).toBe(2);
|
|
112
|
+
expect(runSnapshot.tools.allow).toEqual(['read_file', 'read_test']);
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
it('returns validation errors without writing a draft', async () => {
|
|
116
|
+
const { versions, service } = createService();
|
|
117
|
+
expect(service.validate({ limits: { timeoutMs: -1 } }).success).toBe(false);
|
|
118
|
+
await expect(service.createDraft({ profileId: 1, settings: { limits: { timeoutMs: -1 } } })).rejects.toThrow();
|
|
119
|
+
expect(versions.rows).toHaveLength(0);
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
it('saveDraft keeps a single open draft and starts a new version after publish', async () => {
|
|
123
|
+
const { versions, service } = createService();
|
|
124
|
+
|
|
125
|
+
const first = await service.saveDraft({ profileId: 1, settings: { memory: { maxChars: 1000 } } });
|
|
126
|
+
expect(first).toMatchObject({ version: 1, status: 'draft' });
|
|
127
|
+
|
|
128
|
+
// The open draft is updated in place instead of accumulating another draft row.
|
|
129
|
+
const updated = await service.saveDraft({ profileId: 1, settings: { memory: { maxChars: 2000 } } });
|
|
130
|
+
expect(updated.id).toBe(first.id);
|
|
131
|
+
expect(updated.settings.memory.maxChars).toBe(2000);
|
|
132
|
+
expect(versions.rows).toHaveLength(1);
|
|
133
|
+
|
|
134
|
+
await service.publish(first.id, 9);
|
|
135
|
+
const next = await service.saveDraft({ profileId: 1, settings: { memory: { maxChars: 3000 } } });
|
|
136
|
+
expect(next).toMatchObject({ version: 2, status: 'draft' });
|
|
137
|
+
expect(versions.rows).toHaveLength(2);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
it('createProfile publishes the first version atomically with the profile row', async () => {
|
|
141
|
+
const { profiles, service } = createService();
|
|
142
|
+
|
|
143
|
+
const { profile, version } = await service.createProfile({
|
|
144
|
+
tag: 'strict',
|
|
145
|
+
title: 'Strict policy',
|
|
146
|
+
settings: { memory: { scopes: ['public'] } },
|
|
147
|
+
publishedById: 9,
|
|
148
|
+
});
|
|
149
|
+
|
|
150
|
+
expect(readField(profile, 'tag')).toBe('strict');
|
|
151
|
+
expect(version).toMatchObject({ version: 1, status: 'published', publishedById: 9 });
|
|
152
|
+
const row = profiles.rows.find((item) => item.tag === 'strict');
|
|
153
|
+
expect(row?.currentVersionId).toBe(version.id);
|
|
154
|
+
|
|
155
|
+
// The published version is resolvable by tag immediately after create.
|
|
156
|
+
const published = await service.getPublishedByTag('strict');
|
|
157
|
+
expect(published?.version).toBe(1);
|
|
158
|
+
expect(published?.settings.memory.scopes).toEqual(['public']);
|
|
159
|
+
});
|
|
160
|
+
|
|
161
|
+
it('rejects createProfile when settings fail validation', async () => {
|
|
162
|
+
const { profiles, service } = createService();
|
|
163
|
+
|
|
164
|
+
await expect(service.createProfile({ tag: 'broken', settings: { limits: { timeoutMs: -1 } } })).rejects.toThrow();
|
|
165
|
+
expect(profiles.rows.find((item) => item.tag === 'broken')).toBeUndefined();
|
|
166
|
+
});
|
|
167
|
+
});
|
|
@@ -0,0 +1,293 @@
|
|
|
1
|
+
import { describe, expect, it } from 'vitest';
|
|
2
|
+
import type { Database } from '@nocobase/database';
|
|
3
|
+
import { compileHarness } from '../services/HarnessCompiler';
|
|
4
|
+
import type { CompiledHarness } from '../services/HarnessCompiler';
|
|
5
|
+
import {
|
|
6
|
+
REDACTED_PLACEHOLDER,
|
|
7
|
+
harnessTimeoutMs,
|
|
8
|
+
redactSecretsIn,
|
|
9
|
+
resolveRunRoleHarness,
|
|
10
|
+
resolveTraceHarness,
|
|
11
|
+
spilledText,
|
|
12
|
+
} from '../services/harness-runtime-policy';
|
|
13
|
+
|
|
14
|
+
function resolved(harness: CompiledHarness | null): CompiledHarness {
|
|
15
|
+
if (!harness) throw new Error('expected resolveTraceHarness to return a harness');
|
|
16
|
+
return harness;
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
describe('redactSecretsIn', () => {
|
|
20
|
+
it('replaces values whose keys look secret-bearing, recursively', () => {
|
|
21
|
+
const input = {
|
|
22
|
+
apiKey: 'abc123',
|
|
23
|
+
db_password: 'hunter2',
|
|
24
|
+
accessToken: 'tok-1',
|
|
25
|
+
session_passwd: 'pw',
|
|
26
|
+
clientCredential: 'cred',
|
|
27
|
+
nested: { clientSecret: 'shh', keep: 'visible' },
|
|
28
|
+
list: [{ sessionToken: 'xyz', ok: 1 }],
|
|
29
|
+
plain: 'free text mentioning TOKEN stays untouched',
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
const out = redactSecretsIn(input);
|
|
33
|
+
|
|
34
|
+
expect(out.apiKey).toBe(REDACTED_PLACEHOLDER);
|
|
35
|
+
expect(out.db_password).toBe(REDACTED_PLACEHOLDER);
|
|
36
|
+
expect(out.accessToken).toBe(REDACTED_PLACEHOLDER);
|
|
37
|
+
expect(out.session_passwd).toBe(REDACTED_PLACEHOLDER);
|
|
38
|
+
expect(out.clientCredential).toBe(REDACTED_PLACEHOLDER);
|
|
39
|
+
expect(out.nested.clientSecret).toBe(REDACTED_PLACEHOLDER);
|
|
40
|
+
expect(out.nested.keep).toBe('visible');
|
|
41
|
+
expect(out.list[0].sessionToken).toBe(REDACTED_PLACEHOLDER);
|
|
42
|
+
expect(out.list[0].ok).toBe(1);
|
|
43
|
+
expect(out.plain).toBe(input.plain);
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
it('leaves non-object values untouched', () => {
|
|
47
|
+
expect(redactSecretsIn('text')).toBe('text');
|
|
48
|
+
expect(redactSecretsIn(42)).toBe(42);
|
|
49
|
+
expect(redactSecretsIn(null)).toBeNull();
|
|
50
|
+
});
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
describe('spilledText', () => {
|
|
54
|
+
it('returns null when the text fits the inline budget', () => {
|
|
55
|
+
expect(spilledText('small output', 1000, 'loc')).toBeNull();
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
it('replaces oversized output with a bounded head/tail preview plus locator', () => {
|
|
59
|
+
const head = 'HEAD-MARKER ';
|
|
60
|
+
const tail = ' TAIL-MARKER';
|
|
61
|
+
const text = head + 'x'.repeat(20_000) + tail;
|
|
62
|
+
const budget = 1200;
|
|
63
|
+
|
|
64
|
+
const replaced = spilledText(text, budget, '/api/skillHub:download?execId=1&f=abc');
|
|
65
|
+
if (replaced === null) throw new Error('expected spilledText to replace oversized output');
|
|
66
|
+
|
|
67
|
+
expect(Buffer.byteLength(replaced, 'utf8')).toBeLessThanOrEqual(budget);
|
|
68
|
+
expect(replaced).toContain('HEAD-MARKER');
|
|
69
|
+
expect(replaced).toContain('TAIL-MARKER');
|
|
70
|
+
expect(replaced).toContain('/api/skillHub:download?execId=1&f=abc');
|
|
71
|
+
expect(replaced).toContain('bytes omitted');
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
it('never splits a multi-byte character at the cut point', () => {
|
|
75
|
+
const text = '😀'.repeat(2000); // 4 bytes each
|
|
76
|
+
const budget = 600;
|
|
77
|
+
|
|
78
|
+
const replaced = spilledText(text, budget, 'loc');
|
|
79
|
+
if (replaced === null) throw new Error('expected spilledText to replace oversized output');
|
|
80
|
+
|
|
81
|
+
expect(Buffer.byteLength(replaced, 'utf8')).toBeLessThanOrEqual(budget);
|
|
82
|
+
expect(replaced).not.toContain('�');
|
|
83
|
+
});
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
describe('harnessTimeoutMs', () => {
|
|
87
|
+
it('prefers the per-tool timeout and falls back to the generic skill timeout', () => {
|
|
88
|
+
const harness = compileHarness([
|
|
89
|
+
{
|
|
90
|
+
source: 'test',
|
|
91
|
+
settings: { tools: { timeouts: { skill_hub_report: 5000, skill_hub_execute: 90_000 } } },
|
|
92
|
+
},
|
|
93
|
+
]);
|
|
94
|
+
|
|
95
|
+
expect(harnessTimeoutMs(harness, 'skill_hub_report')).toBe(5000);
|
|
96
|
+
expect(harnessTimeoutMs(harness, 'skill_hub_anything_else')).toBe(90_000);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
it('returns null when no timeout applies', () => {
|
|
100
|
+
const harness = compileHarness([{ source: 'test', settings: {} }]);
|
|
101
|
+
expect(harnessTimeoutMs(harness, 'skill_hub_report')).toBeNull();
|
|
102
|
+
});
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
type MockDbOptions = {
|
|
106
|
+
runs?: Record<number, Record<string, unknown>>;
|
|
107
|
+
employees?: Record<string, Record<string, unknown>>;
|
|
108
|
+
profilesByTag?: Record<string, { currentVersionId: number }>;
|
|
109
|
+
versionsById?: Record<number, Record<string, unknown>>;
|
|
110
|
+
};
|
|
111
|
+
|
|
112
|
+
function mockDatabase(options: MockDbOptions): Database {
|
|
113
|
+
return {
|
|
114
|
+
getRepository(name: string) {
|
|
115
|
+
if (name === 'agentLoopRuns') {
|
|
116
|
+
return {
|
|
117
|
+
findOne: async (opts: { filterByTk?: number }) => options.runs?.[Number(opts.filterByTk)] ?? null,
|
|
118
|
+
};
|
|
119
|
+
}
|
|
120
|
+
if (name === 'aiEmployees') {
|
|
121
|
+
return {
|
|
122
|
+
findOne: async (opts: { filter?: { username?: string } }) =>
|
|
123
|
+
options.employees?.[String(opts.filter?.username)] ?? null,
|
|
124
|
+
};
|
|
125
|
+
}
|
|
126
|
+
if (name === 'agentHarnessProfiles') {
|
|
127
|
+
return {
|
|
128
|
+
findOne: async (opts: { filter?: { tag?: string; enabled?: boolean } }) => {
|
|
129
|
+
const profile = options.profilesByTag?.[String(opts.filter?.tag)];
|
|
130
|
+
return profile ?? null;
|
|
131
|
+
},
|
|
132
|
+
};
|
|
133
|
+
}
|
|
134
|
+
if (name === 'agentHarnessProfileVersions') {
|
|
135
|
+
return {
|
|
136
|
+
findOne: async (opts: { filter?: { id?: number; status?: string } }) => {
|
|
137
|
+
const version = options.versionsById?.[Number(opts.filter?.id)];
|
|
138
|
+
if (!version || opts.filter?.status !== version.status) return null;
|
|
139
|
+
return version;
|
|
140
|
+
},
|
|
141
|
+
};
|
|
142
|
+
}
|
|
143
|
+
return { findOne: async () => null };
|
|
144
|
+
},
|
|
145
|
+
} as unknown as Database;
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
const compiledEffective = (settings: Record<string, unknown>) => compileHarness([{ source: 'test', settings }]);
|
|
149
|
+
|
|
150
|
+
describe('resolveTraceHarness', () => {
|
|
151
|
+
it('resolves the run snapshot for the leader role', async () => {
|
|
152
|
+
const database = mockDatabase({
|
|
153
|
+
runs: {
|
|
154
|
+
7: {
|
|
155
|
+
roleBindingsSnapshot: { leader: 'leader-ai', verifier: 'verifier-ai' },
|
|
156
|
+
leaderHarnessSnapshot: {
|
|
157
|
+
effective: compiledEffective({ tools: { timeouts: { skill_hub_execute: 45_000 } } }),
|
|
158
|
+
},
|
|
159
|
+
},
|
|
160
|
+
},
|
|
161
|
+
});
|
|
162
|
+
|
|
163
|
+
const harness = resolved(await resolveTraceHarness(database, { agentLoopRunId: 7, employeeUsername: 'leader-ai' }));
|
|
164
|
+
|
|
165
|
+
expect(harness.tools.timeouts).toEqual({ skill_hub_execute: 45_000 });
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
it('resolves the per-maker snapshot from the makers map', async () => {
|
|
169
|
+
const database = mockDatabase({
|
|
170
|
+
runs: {
|
|
171
|
+
8: {
|
|
172
|
+
roleBindingsSnapshot: { leader: 'leader-ai' },
|
|
173
|
+
makerHarnessSnapshot: {
|
|
174
|
+
'maker-ai': {
|
|
175
|
+
effective: compiledEffective({ context: { spill: { maxInlineBytes: 12_000 } } }),
|
|
176
|
+
},
|
|
177
|
+
},
|
|
178
|
+
},
|
|
179
|
+
},
|
|
180
|
+
});
|
|
181
|
+
|
|
182
|
+
const harness = resolved(await resolveTraceHarness(database, { agentLoopRunId: 8, employeeUsername: 'maker-ai' }));
|
|
183
|
+
|
|
184
|
+
expect(harness.context.spill.maxInlineBytes).toBe(12_000);
|
|
185
|
+
});
|
|
186
|
+
|
|
187
|
+
it('backfills new policy fields with defaults for snapshots compiled by older revisions', async () => {
|
|
188
|
+
// What the previous compiler revision persisted: no context section, no timeouts,
|
|
189
|
+
// no redactSecrets/sharing keys.
|
|
190
|
+
const legacyEffective = {
|
|
191
|
+
sources: ['legacy'],
|
|
192
|
+
tools: { allow: [], ask: [], deny: [], effects: {}, trustedPreHandlerTools: [] },
|
|
193
|
+
memory: { enabled: true, scopes: ['public'], maxChars: 6000 },
|
|
194
|
+
delegation: { allowedEmployees: [], maxDepth: null, maxCount: null },
|
|
195
|
+
limits: {
|
|
196
|
+
timeoutMs: null,
|
|
197
|
+
recursionLimit: null,
|
|
198
|
+
maxInvocations: null,
|
|
199
|
+
maxToolCalls: null,
|
|
200
|
+
maxInputTokens: null,
|
|
201
|
+
maxOutputTokens: null,
|
|
202
|
+
maxTotalTokens: null,
|
|
203
|
+
maxCost: null,
|
|
204
|
+
},
|
|
205
|
+
isolation: { mode: 'none', requireWorktree: false, allowedConnectors: [], networkAccess: 'restricted' },
|
|
206
|
+
observability: { enabled: true, tracingRetentionDays: 30, captureInputs: true, captureOutputs: true },
|
|
207
|
+
};
|
|
208
|
+
|
|
209
|
+
const database = mockDatabase({
|
|
210
|
+
runs: {
|
|
211
|
+
9: {
|
|
212
|
+
roleBindingsSnapshot: { leader: 'leader-ai' },
|
|
213
|
+
leaderHarnessSnapshot: { effective: legacyEffective },
|
|
214
|
+
},
|
|
215
|
+
},
|
|
216
|
+
});
|
|
217
|
+
|
|
218
|
+
const harness = resolved(await resolveTraceHarness(database, { agentLoopRunId: 9, employeeUsername: 'leader-ai' }));
|
|
219
|
+
|
|
220
|
+
expect(harness.tools.timeouts).toEqual({});
|
|
221
|
+
expect(harness.context.spill.maxInlineBytes).toBeNull();
|
|
222
|
+
expect(harness.observability.redactSecrets).toBe(true);
|
|
223
|
+
expect(harness.observability.sharing).toBe('full');
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
it('falls back to the employee harness-tag profile outside a loop run', async () => {
|
|
227
|
+
const database = mockDatabase({
|
|
228
|
+
employees: { 'solo-ai': { username: 'solo-ai', skillSettings: { harnessTag: 'strict' } } },
|
|
229
|
+
profilesByTag: { strict: { currentVersionId: 11 } },
|
|
230
|
+
versionsById: {
|
|
231
|
+
11: {
|
|
232
|
+
id: 11,
|
|
233
|
+
profileId: 1,
|
|
234
|
+
version: 2,
|
|
235
|
+
schemaVersion: 1,
|
|
236
|
+
status: 'published',
|
|
237
|
+
settings: { tools: { timeouts: { skill_hub_execute: 20_000 } } },
|
|
238
|
+
},
|
|
239
|
+
},
|
|
240
|
+
});
|
|
241
|
+
|
|
242
|
+
const harness = resolved(await resolveTraceHarness(database, { employeeUsername: 'solo-ai' }));
|
|
243
|
+
|
|
244
|
+
expect(harness.tools.timeouts).toEqual({ skill_hub_execute: 20_000 });
|
|
245
|
+
});
|
|
246
|
+
|
|
247
|
+
it('returns null when no run snapshot matches and no employee profile applies', async () => {
|
|
248
|
+
const database = mockDatabase({});
|
|
249
|
+
|
|
250
|
+
expect(await resolveTraceHarness(database, { employeeUsername: 'ghost' })).toBeNull();
|
|
251
|
+
expect(await resolveTraceHarness(database, {})).toBeNull();
|
|
252
|
+
});
|
|
253
|
+
});
|
|
254
|
+
|
|
255
|
+
describe('resolveRunRoleHarness', () => {
|
|
256
|
+
it('returns the compiled role snapshot for a known run and role', async () => {
|
|
257
|
+
const database = mockDatabase({
|
|
258
|
+
runs: {
|
|
259
|
+
7: {
|
|
260
|
+
roleBindingsSnapshot: { leader: 'leader-ai', makers: ['maker-ai'], verifier: 'verifier-ai' },
|
|
261
|
+
leaderHarnessSnapshot: {
|
|
262
|
+
effective: compiledEffective({ delegation: { maxDepth: 3 } }),
|
|
263
|
+
},
|
|
264
|
+
makerHarnessSnapshot: {
|
|
265
|
+
'maker-ai': { effective: compiledEffective({ delegation: { maxDepth: 2 } }) },
|
|
266
|
+
},
|
|
267
|
+
},
|
|
268
|
+
},
|
|
269
|
+
});
|
|
270
|
+
|
|
271
|
+
const leader = resolved(await resolveRunRoleHarness(database, 7, 'leader-ai'));
|
|
272
|
+
expect(leader.delegation.maxDepth).toBe(3);
|
|
273
|
+
|
|
274
|
+
const maker = resolved(await resolveRunRoleHarness(database, 7, 'maker-ai'));
|
|
275
|
+
expect(maker.delegation.maxDepth).toBe(2);
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
it('returns null for unknown runs, unbound roles, or missing usernames', async () => {
|
|
279
|
+
const database = mockDatabase({
|
|
280
|
+
runs: {
|
|
281
|
+
7: {
|
|
282
|
+
roleBindingsSnapshot: { leader: 'leader-ai' },
|
|
283
|
+
leaderHarnessSnapshot: { effective: compiledEffective({}) },
|
|
284
|
+
},
|
|
285
|
+
},
|
|
286
|
+
});
|
|
287
|
+
|
|
288
|
+
expect(await resolveRunRoleHarness(database, 999, 'leader-ai')).toBeNull();
|
|
289
|
+
expect(await resolveRunRoleHarness(database, 7, 'unbound-ai')).toBeNull();
|
|
290
|
+
expect(await resolveRunRoleHarness(database, 7, undefined)).toBeNull();
|
|
291
|
+
expect(await resolveRunRoleHarness(database, 0, 'leader-ai')).toBeNull();
|
|
292
|
+
});
|
|
293
|
+
});
|
|
@@ -0,0 +1,172 @@
|
|
|
1
|
+
import type { Application } from '@nocobase/server';
|
|
2
|
+
import { describe, expect, it } from 'vitest';
|
|
3
|
+
import { compileHarness } from '../services/HarnessCompiler';
|
|
4
|
+
import { planHarnessTools } from '../services/PluginAiRuntimeAdapter';
|
|
5
|
+
|
|
6
|
+
type ToolEntry = { scope?: string; defaultPermission?: string };
|
|
7
|
+
|
|
8
|
+
// Mirrors `DefaultToolsManager.getTools(name, filter)`: a statically registered tool resolves
|
|
9
|
+
// immediately, but a dynamic provider (the MCP one, for instance) only registers its tools when a
|
|
10
|
+
// filter carrying `ctx` is supplied. A mock that ignores the second argument cannot tell the two
|
|
11
|
+
// apart, which is how the context-scoped discovery gap went unnoticed.
|
|
12
|
+
function createApp(tools: Record<string, ToolEntry>, contextTools: Record<string, ToolEntry> = {}) {
|
|
13
|
+
return {
|
|
14
|
+
aiManager: {
|
|
15
|
+
toolsManager: {
|
|
16
|
+
async getTools(name: string, filter?: { ctx?: unknown }) {
|
|
17
|
+
if (tools[name]) return tools[name];
|
|
18
|
+
if (!filter?.ctx) return undefined;
|
|
19
|
+
return contextTools[name];
|
|
20
|
+
},
|
|
21
|
+
},
|
|
22
|
+
},
|
|
23
|
+
} as unknown as Application;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
function harness(tools: {
|
|
27
|
+
allow?: string[];
|
|
28
|
+
ask?: string[];
|
|
29
|
+
deny?: string[];
|
|
30
|
+
escalate?: string[];
|
|
31
|
+
effects?: Record<string, 'read' | 'write' | 'external'>;
|
|
32
|
+
trustedPreHandlerTools?: string[];
|
|
33
|
+
}) {
|
|
34
|
+
return compileHarness([{ source: 'test', settings: { tools } }]);
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
describe('planHarnessTools', () => {
|
|
38
|
+
it('sends a string filter to the constructor and objects to the employee override', async () => {
|
|
39
|
+
const app = createApp({
|
|
40
|
+
readFile: { scope: 'CUSTOM' },
|
|
41
|
+
applyPatch: { scope: 'CUSTOM' },
|
|
42
|
+
});
|
|
43
|
+
const plan = await planHarnessTools(
|
|
44
|
+
app,
|
|
45
|
+
harness({
|
|
46
|
+
allow: ['readFile', 'applyPatch'],
|
|
47
|
+
effects: { readFile: 'read', applyPatch: 'write' },
|
|
48
|
+
trustedPreHandlerTools: ['applyPatch'],
|
|
49
|
+
}),
|
|
50
|
+
);
|
|
51
|
+
|
|
52
|
+
// plugin-ai filters candidate tools with `toolFilter.includes(t.definition.name)`. Passing
|
|
53
|
+
// objects here matched nothing and silently dropped every tool the harness granted.
|
|
54
|
+
expect(plan.filter).toEqual(['applyPatch', 'readFile']);
|
|
55
|
+
expect(plan.filter.every((name) => typeof name === 'string')).toBe(true);
|
|
56
|
+
expect(plan.employeeTools).toEqual([
|
|
57
|
+
{ name: 'applyPatch', autoCall: true },
|
|
58
|
+
{ name: 'readFile', autoCall: true },
|
|
59
|
+
]);
|
|
60
|
+
expect(plan.withheld).toEqual([]);
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
it('marks an ask decision as a non-auto-call instead of exposing it un-gated', async () => {
|
|
64
|
+
const app = createApp({ deployService: { scope: 'CUSTOM' } });
|
|
65
|
+
// Allowed but not trusted for a write effect, so `decideTool` downgrades it to `ask`.
|
|
66
|
+
const plan = await planHarnessTools(
|
|
67
|
+
app,
|
|
68
|
+
harness({ allow: ['deployService'], effects: { deployService: 'write' } }),
|
|
69
|
+
);
|
|
70
|
+
|
|
71
|
+
expect(plan.filter).toEqual(['deployService']);
|
|
72
|
+
expect(plan.employeeTools).toEqual([{ name: 'deployService', autoCall: false }]);
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
it('withholds a tool whose approval gate plugin-ai would ignore', async () => {
|
|
76
|
+
// `isAutoCall` short-circuits for non-CUSTOM scope and returns `defaultPermission === 'ALLOW'`,
|
|
77
|
+
// so an `ask` decision on this tool would auto-call anyway. Withholding is the safe outcome.
|
|
78
|
+
const app = createApp({ searchWeb: { scope: 'GENERAL', defaultPermission: 'ALLOW' } });
|
|
79
|
+
const plan = await planHarnessTools(app, harness({ ask: ['searchWeb'] }));
|
|
80
|
+
|
|
81
|
+
expect(plan.filter).toEqual([]);
|
|
82
|
+
expect(plan.employeeTools).toEqual([]);
|
|
83
|
+
expect(plan.withheld).toEqual([{ name: 'searchWeb', reason: 'approval cannot be enforced for this tool' }]);
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
it('keeps an enforceable ask on a general tool that does not default to allow', async () => {
|
|
87
|
+
const app = createApp({ searchWeb: { scope: 'GENERAL', defaultPermission: 'ASK' } });
|
|
88
|
+
const plan = await planHarnessTools(app, harness({ ask: ['searchWeb'] }));
|
|
89
|
+
|
|
90
|
+
expect(plan.filter).toEqual(['searchWeb']);
|
|
91
|
+
expect(plan.employeeTools).toEqual([{ name: 'searchWeb', autoCall: false }]);
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
it('offers escalatable tools as ask-gated candidates without granting them', async () => {
|
|
95
|
+
const app = createApp({ deployService: { scope: 'CUSTOM' }, readFile: { scope: 'CUSTOM' } });
|
|
96
|
+
const plan = await planHarnessTools(
|
|
97
|
+
app,
|
|
98
|
+
harness({ allow: ['readFile'], escalate: ['deployService'], effects: { readFile: 'read' } }),
|
|
99
|
+
);
|
|
100
|
+
|
|
101
|
+
expect(plan.filter).toEqual(['deployService', 'readFile']);
|
|
102
|
+
expect(plan.employeeTools).toEqual([
|
|
103
|
+
{ name: 'deployService', autoCall: false },
|
|
104
|
+
{ name: 'readFile', autoCall: true },
|
|
105
|
+
]);
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
it('withholds an escalatable tool whose approval gate plugin-ai would ignore', async () => {
|
|
109
|
+
const app = createApp({ searchWeb: { scope: 'GENERAL', defaultPermission: 'ALLOW' } });
|
|
110
|
+
const plan = await planHarnessTools(app, harness({ escalate: ['searchWeb'] }));
|
|
111
|
+
|
|
112
|
+
expect(plan.filter).toEqual([]);
|
|
113
|
+
expect(plan.employeeTools).toEqual([]);
|
|
114
|
+
expect(plan.withheld).toEqual([{ name: 'searchWeb', reason: 'approval cannot be enforced for this tool' }]);
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
it('withholds denied and unregistered tools', async () => {
|
|
118
|
+
const app = createApp({ readFile: { scope: 'CUSTOM' } });
|
|
119
|
+
const plan = await planHarnessTools(
|
|
120
|
+
app,
|
|
121
|
+
harness({ allow: ['readFile', 'ghostTool'], ask: ['dropDatabase'], deny: ['dropDatabase'] }),
|
|
122
|
+
);
|
|
123
|
+
|
|
124
|
+
expect(plan.filter).toEqual(['readFile']);
|
|
125
|
+
expect(plan.withheld).toEqual([
|
|
126
|
+
{ name: 'dropDatabase', reason: 'denied by harness' },
|
|
127
|
+
{ name: 'ghostTool', reason: 'not registered with plugin-ai' },
|
|
128
|
+
]);
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
it('reports every ungranted system tool so the caller can switch off its injector', async () => {
|
|
132
|
+
const app = createApp({ readFile: { scope: 'CUSTOM' } });
|
|
133
|
+
const plan = await planHarnessTools(app, harness({ allow: ['readFile'], deny: ['knowledge-base-retrieve'] }));
|
|
134
|
+
|
|
135
|
+
// plugin-ai keeps system tools through the constructor filter unconditionally
|
|
136
|
+
// (`systemTools.includes(name) || toolFilter.includes(name)`), so dropping a denied system tool
|
|
137
|
+
// from `filter` does nothing. It has to be reported separately and disabled at its source.
|
|
138
|
+
expect(plan.filter).toEqual(['readFile']);
|
|
139
|
+
expect(plan.blockedSystemTools).toEqual([
|
|
140
|
+
'aiEmployeeWorkflowTaskOutput',
|
|
141
|
+
'knowledge-base-retrieve',
|
|
142
|
+
'subAgentWebSearch',
|
|
143
|
+
]);
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
it('leaves a granted system tool out of the blocked list', async () => {
|
|
147
|
+
const app = createApp({ subAgentWebSearch: { scope: 'SPECIFIED', defaultPermission: 'ALLOW' } });
|
|
148
|
+
const plan = await planHarnessTools(
|
|
149
|
+
app,
|
|
150
|
+
harness({ allow: ['subAgentWebSearch'], effects: { subAgentWebSearch: 'read' } }),
|
|
151
|
+
);
|
|
152
|
+
|
|
153
|
+
expect(plan.filter).toEqual(['subAgentWebSearch']);
|
|
154
|
+
expect(plan.blockedSystemTools).not.toContain('subAgentWebSearch');
|
|
155
|
+
});
|
|
156
|
+
|
|
157
|
+
it('finds a context-scoped tool only when discovery passes the invocation ctx', async () => {
|
|
158
|
+
const app = createApp({}, { 'mcp-personal-search': { scope: 'CUSTOM' } });
|
|
159
|
+
const granted = harness({ allow: ['mcp-personal-search'] });
|
|
160
|
+
|
|
161
|
+
// Without ctx the MCP provider never registers the user's tools, so the lookup misses and the
|
|
162
|
+
// harness grant is silently withheld even though `AIEmployee.getToolsMap()` would resolve it.
|
|
163
|
+
await expect(planHarnessTools(app, granted)).resolves.toMatchObject({
|
|
164
|
+
filter: [],
|
|
165
|
+
withheld: [{ name: 'mcp-personal-search', reason: 'not registered with plugin-ai' }],
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
const plan = await planHarnessTools(app, granted, { ctx: { auth: {} }, sessionId: 'session-1' });
|
|
169
|
+
expect(plan.filter).toEqual(['mcp-personal-search']);
|
|
170
|
+
expect(plan.withheld).toEqual([]);
|
|
171
|
+
});
|
|
172
|
+
});
|