plugin-agent-orchestrator 1.0.20 → 1.0.21

package/src/server/__tests__/context-aggregator.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ContextAggregator } from '../services/ContextAggregator';
+
+function createMockPlugin() {
+  const stepIdCounter = 1;
+  const stepsStore: any[] = [];
+  const runsStore: any[] = [];
+
+  const mockRepo = {
+    find: vi.fn(async ({ filter }: any) => {
+      if (filter?.runId) {
+        return stepsStore.filter((s) => s.runId === filter.runId);
+      }
+      return stepsStore;
+    }),
+    findOne: vi.fn(async ({ filter }: any) => {
+      if (filter?.id) {
+        return runsStore.find((r) => r.id === filter.id) || null;
+      }
+      return runsStore[0] || null;
+    }),
+  };
+
+  return {
+    db: {
+      getRepository: vi.fn((name: string) => {
+        if (name === 'agentLoopSteps') return mockRepo;
+        if (name === 'agentLoopRuns') return mockRepo;
+        return null;
+      }),
+    },
+    app: { log: { warn: vi.fn() } },
+    _stepsStore: stepsStore,
+    _runsStore: runsStore,
+    _repo: mockRepo,
+    _stepIdCounter: stepIdCounter,
+  };
+}
+
+function addStep(plugin: any, overrides: any = {}) {
+  const id = plugin._stepIdCounter++;
+  const step = {
+    id,
+    runId: overrides.runId || 1,
+    planKey: overrides.planKey || `step_${id}`,
+    index: overrides.index ?? id - 1,
+    title: overrides.title || `Step ${id}`,
+    description: overrides.description || '',
+    type: overrides.type || 'reasoning',
+    target: overrides.target || '',
+    status: overrides.status || 'succeeded',
+    output: overrides.output || {},
+    error: overrides.error || '',
+    metadata: overrides.metadata || {},
+    ...overrides,
+  };
+  plugin._stepsStore.push(step);
+  return step;
+}
+
+function addRun(plugin: any, overrides: any = {}) {
+  const run = {
+    id: overrides.id || 1,
+    policy: overrides.policy || {},
+    ...overrides,
+  };
+  plugin._runsStore.push(run);
+  return run;
+}
+
+describe('ContextAggregator', () => {
+  describe('buildStepContext', () => {
+    it('returns empty string when there are no steps', async () => {
+      const plugin = createMockPlugin();
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1);
+      expect(result).toBe('');
+    });
+
+    it('returns empty string when all steps are pending', async () => {
+      const plugin = createMockPlugin();
+      addStep(plugin, { status: 'pending' });
+      addStep(plugin, { status: 'running' });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1);
+      expect(result).toBe('');
+    });
+
+    it('builds XML for completed steps', async () => {
+      const plugin = createMockPlugin();
+      addStep(plugin, {
+        planKey: 'step_1',
+        title: 'Research topic',
+        type: 'sub_agent',
+        status: 'succeeded',
+        output: { summary: 'Found data' },
+      });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1);
+
+      expect(result).toContain('<previous_steps>');
+      expect(result).toContain('<step key="step_1"');
+      expect(result).toContain('<title>Research topic</title>');
+      expect(result).toContain('<output>');
+      expect(result).toContain('Found data');
+      expect(result).toContain('</previous_steps>');
+    });
+
+    it('includes error information for failed steps', async () => {
+      const plugin = createMockPlugin();
+      addStep(plugin, { planKey: 'step_1', status: 'failed', error: 'Something went wrong' });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1);
+
+      expect(result).toContain('<error>');
+      expect(result).toContain('Something went wrong');
+    });
+
+    it('respects last_n strategy', async () => {
+      const plugin = createMockPlugin();
+      for (let i = 1; i <= 15; i++) {
+        addStep(plugin, { planKey: `step_${i}`, title: `Step ${i}`, status: 'succeeded' });
+      }
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1, 4000, { strategy: 'last_n' });
+
+      // Should only include last 10
+      expect(result).toContain('step_6');
+      expect(result).not.toContain('planKey="step_1"');
+    });
+
+    it('omits output when includeStepOutputs is false', async () => {
+      const plugin = createMockPlugin();
+      addStep(plugin, { planKey: 'step_1', status: 'succeeded', output: { secret: 'data' } });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1, 4000, { includeStepOutputs: false });
+
+      expect(result).not.toContain('<output>');
+    });
+
+    it('includes tool_results when includeToolResults is true', async () => {
+      const plugin = createMockPlugin();
+      addStep(plugin, {
+        planKey: 'step_1',
+        status: 'succeeded',
+        metadata: { toolResults: [{ tool: 'search', result: 'found' }] },
+      });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1, 4000, { includeToolResults: true });
+
+      expect(result).toContain('<tool_results>');
+    });
+
+    it('escapes XML special characters', async () => {
+      const plugin = createMockPlugin();
+      addStep(plugin, { planKey: 'step_1', status: 'succeeded', title: 'Test & "Hello" <World>' });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1);
+
+      expect(result).toContain('&amp;');
+      expect(result).toContain('&lt;');
+      expect(result).toContain('&quot;');
+      expect(result).not.toContain('<World>');
+    });
+
+    it('truncates text exceeding maxTokens', async () => {
+      const plugin = createMockPlugin();
+      // Add many steps to force truncation
+      for (let i = 1; i <= 20; i++) {
+        addStep(plugin, { planKey: `step_${i}`, status: 'succeeded', description: 'A'.repeat(500) });
+      }
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1, 500); // very low token limit
+
+      expect(result).toContain('intermediate step(s) omitted');
+      expect(result.length).toBeLessThan(3000);
+    });
+
+    it('handles repository errors gracefully', async () => {
+      const plugin = createMockPlugin();
+      plugin.db.getRepository = vi.fn(() => null);
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.buildStepContext(1);
+      expect(result).toBe('');
+    });
+  });
+
+  describe('enrichSystemPrompt', () => {
+    it('returns base prompt when no run exists', async () => {
+      const plugin = createMockPlugin();
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.enrichSystemPrompt('You are a helpful assistant.', 999);
+      expect(result).toBe('You are a helpful assistant.');
+    });
+
+    it('enriches prompt with step context', async () => {
+      const plugin = createMockPlugin();
+      addRun(plugin, { id: 1, policy: { maxContextTokens: 4000 } });
+      addStep(plugin, { planKey: 'step_1', title: 'Research', status: 'succeeded', output: { data: 'results' } });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.enrichSystemPrompt('You are a helpful assistant.', 1);
+
+      expect(result).toContain('You are a helpful assistant.');
+      expect(result).toContain('<previous_steps_context>');
+      expect(result).toContain('Research');
+    });
+
+    it('reads policy settings from run', async () => {
+      const plugin = createMockPlugin();
+      addRun(plugin, {
+        id: 1,
+        policy: { maxContextTokens: 100, contextSummaryStrategy: 'last_n', includeStepOutputs: false },
+      });
+      addStep(plugin, { planKey: 'step_1', status: 'succeeded', output: { data: 'results' } });
+      addStep(plugin, { planKey: 'step_2', status: 'succeeded', output: { data: 'more' } });
+      const aggregator = new ContextAggregator(plugin);
+      const result = await aggregator.enrichSystemPrompt('Base prompt.', 1);
+
+      expect(result).not.toContain('<output>');
+    });
+  });
+});

package/src/server/__tests__/parallel-execution.test.ts

@@ -0,0 +1,318 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AgentLoopController } from '../services/AgentLoopController';
+
+// ── Mocks ──
+function createMockRepository() {
+  const runs = new Map<number, any>();
+  const steps = new Map<number, any>();
+  const events: any[] = [];
+  let runIdCounter = 1;
+  let stepIdCounter = 1;
+
+  return {
+    _runs: runs,
+    _steps: steps,
+    _events: events,
+
+    requireRun: vi.fn(async (id: number) => {
+      const run = runs.get(Number(id));
+      if (!run) throw new Error(`Run ${id} not found`);
+      return { ...run };
+    }),
+    getRun: vi.fn(async (id: number) => {
+      const run = runs.get(Number(id));
+      return run ? { ...run } : null;
+    }),
+    createRun: vi.fn(async (values: any) => {
+      const id = runIdCounter++;
+      const run = { id, ...values, createdAt: new Date(), updatedAt: new Date() };
+      runs.set(id, run);
+      return { ...run };
+    }),
+    updateRun: vi.fn(async (id: number, values: any) => {
+      const existing = runs.get(Number(id));
+      if (existing) {
+        runs.set(Number(id), { ...existing, ...values, updatedAt: new Date() });
+      }
+    }),
+    requireStep: vi.fn(async (id: number) => {
+      const step = steps.get(Number(id));
+      if (!step) throw new Error(`Step ${id} not found`);
+      return { ...step };
+    }),
+    getStep: vi.fn(async (id: number) => {
+      const step = steps.get(Number(id));
+      return step ? { ...step } : null;
+    }),
+    createStep: vi.fn(async (values: any) => {
+      const id = stepIdCounter++;
+      const step = { id, ...values, createdAt: new Date(), updatedAt: new Date() };
+      steps.set(id, step);
+      return { ...step };
+    }),
+    updateStep: vi.fn(async (id: number, values: any) => {
+      const existing = steps.get(Number(id));
+      if (existing) {
+        steps.set(Number(id), { ...existing, ...values, updatedAt: new Date() });
+      }
+    }),
+    getSteps: vi.fn(async (runId: number) => {
+      return Array.from(steps.values())
+        .filter((s) => s.runId === runId)
+        .map((s) => ({ ...s }))
+        .sort((a, b) => (a.index || 0) - (b.index || 0));
+    }),
+    createEvent: vi.fn(async (values: any) => {
+      const event = { id: events.length + 1, ...values, createdAt: new Date() };
+      events.push(event);
+      return event;
+    }),
+    getEvents: vi.fn(async () => []),
+    getLinkedSpans: vi.fn(async () => []),
+    getLinkedSkillExecutions: vi.fn(async () => []),
+    lockRun: vi.fn(async () => true),
+    unlockRun: vi.fn(async () => {}),
+  };
+}
+
+function createController(harnessExecute?: any) {
+  const repository = createMockRepository();
+  const harness = {
+    executeStep:
+      harnessExecute ||
+      vi.fn(async (_run: any, step: any) => ({
+        summary: `Executed: ${step.title}`,
+      })),
+  };
+
+  const controller = new AgentLoopController(
+    { getHarnessProfile: vi.fn(async () => ({ settings: {} })) } as any,
+    { buildPlan: vi.fn() } as any,
+    { validate: vi.fn() } as any,
+    repository as any,
+    harness as any,
+    { checkBudget: vi.fn(async () => ({ allowed: true })) } as any,
+  );
+
+  return { controller, repository, harness };
+}
+
+async function seedRunWithSteps(
+  repository: any,
+  stepDefs: { planKey: string; dependsOn?: string[]; title?: string; type?: string; target?: string }[],
+) {
+  const run = await repository.createRun({
+    goal: 'parallel test',
+    rootRunId: 'parallel-test-root',
+    status: 'approved',
+    policy: {
+      maxIterations: 20,
+      maxStepAttempts: 2,
+      allowReplan: false,
+      requireVerification: false,
+      stopOnApprovalRequired: false,
+      maxConcurrency: 5,
+    },
+    metadata: {
+      harnessSettings: {},
+      approvalMode: 'plan_first',
+    },
+  });
+
+  for (let i = 0; i < stepDefs.length; i++) {
+    const def = stepDefs[i];
+    await repository.createStep({
+      runId: run.id,
+      planKey: def.planKey,
+      index: i,
+      title: def.title || `Step ${i + 1}`,
+      type: def.type || 'reasoning',
+      target: def.target || '',
+      status: 'pending',
+      attempt: 0,
+      maxAttempts: 2,
+      dependsOn: def.dependsOn || [],
+    });
+  }
+
+  return run.id;
+}
+
+describe('Parallel execution', () => {
+  it('executes independent steps concurrently', async () => {
+    const executeOrder: number[] = [];
+    const { controller, repository } = createController(
+      vi.fn(async (_run: any, step: any) => {
+        executeOrder.push(step.id);
+        return { summary: `Done: ${step.title}` };
+      }),
+    );
+
+    // 3 independent steps + 1 dependent on the last
+    const runId = await seedRunWithSteps(repository, [
+      { planKey: 'step_a', title: 'Research A' },
+      { planKey: 'step_b', title: 'Research B' },
+      { planKey: 'step_c', title: 'Research C' },
+      { planKey: 'step_d', title: 'Combine', dependsOn: ['step_a', 'step_b', 'step_c'] },
+    ]);
+
+    const snapshot = await controller.executeApprovedPlan(runId);
+    expect(snapshot.run.status).toBe('succeeded');
+    expect(executeOrder.length).toBe(4);
+
+    // Steps A, B, C should have been executed before D
+    const aIdx = executeOrder.indexOf(1);
+    const bIdx = executeOrder.indexOf(2);
+    const cIdx = executeOrder.indexOf(3);
+    const dIdx = executeOrder.indexOf(4);
+    expect(dIdx).toBeGreaterThan(aIdx);
+    expect(dIdx).toBeGreaterThan(bIdx);
+    expect(dIdx).toBeGreaterThan(cIdx);
+  });
+
+  it('respects maxConcurrency limit', async () => {
+    let concurrentMax = 0;
+    let currentConcurrent = 0;
+
+    const { controller, repository } = createController(
+      vi.fn(async (_run: any, _step: any) => {
+        currentConcurrent++;
+        concurrentMax = Math.max(concurrentMax, currentConcurrent);
+        // Simulate async work
+        await new Promise<void>((resolve) => queueMicrotask(resolve));
+        currentConcurrent--;
+        return { summary: 'done' };
+      }),
+    );
+
+    const runId = await seedRunWithSteps(repository, [
+      { planKey: 'step_1', title: 'Task 1' },
+      { planKey: 'step_2', title: 'Task 2' },
+      { planKey: 'step_3', title: 'Task 3' },
+      { planKey: 'step_4', title: 'Task 4' },
+      { planKey: 'step_5', title: 'Task 5' },
+      { planKey: 'step_6', title: 'Task 6' },
+    ]);
+
+    // The repo policy has maxConcurrency=5
+    await controller.executeApprovedPlan(runId);
+    // With 6 independent steps and concurrency 5, at most 5 should run simultaneously
+    expect(concurrentMax).toBeLessThanOrEqual(5);
+  });
+
+  it('handles partial failure in a batch', async () => {
+    const { controller, repository } = createController(
+      vi.fn(async (_run: any, step: any) => {
+        if (step.planKey === 'step_b') {
+          throw new Error('Step B failed');
+        }
+        return { summary: `Done: ${step.title}` };
+      }),
+    );
+
+    const runId = await seedRunWithSteps(repository, [
+      { planKey: 'step_a', title: 'Works fine' },
+      { planKey: 'step_b', title: 'Fails', type: 'skill', target: 'bad_tool' },
+      { planKey: 'step_c', title: 'Also fine' },
+    ]);
+
+    const snapshot = await controller.executeApprovedPlan(runId);
+    // Step B should be marked failed
+    const failedStep = snapshot.steps.find((s: any) => s.planKey === 'step_b');
+    expect(failedStep.status).toBe('failed');
+  });
+
+  it('executes chain: step1 → step2 → step3 sequentially', async () => {
+    const executeOrder: number[] = [];
+    const { controller, repository } = createController(
+      vi.fn(async (_run: any, step: any) => {
+        executeOrder.push(step.id);
+        return { summary: `Done: ${step.title}` };
+      }),
+    );
+
+    const runId = await seedRunWithSteps(repository, [
+      { planKey: 'step_1', title: 'First' },
+      { planKey: 'step_2', title: 'Second', dependsOn: ['step_1'] },
+      { planKey: 'step_3', title: 'Third', dependsOn: ['step_2'] },
+    ]);
+
+    const snapshot = await controller.executeApprovedPlan(runId);
+    expect(snapshot.run.status).toBe('succeeded');
+    expect(executeOrder).toEqual([1, 2, 3]);
+  });
+
+  it('executes diamond dependencies: A → (B, C) → D', async () => {
+    const executeOrder: number[] = [];
+    const { controller, repository } = createController(
+      vi.fn(async (_run: any, step: any) => {
+        executeOrder.push(step.id);
+        return { summary: `Done: ${step.title}` };
+      }),
+    );
+
+    const runId = await seedRunWithSteps(repository, [
+      { planKey: 'step_a', title: 'Root' },
+      { planKey: 'step_b', title: 'Branch 1', dependsOn: ['step_a'] },
+      { planKey: 'step_c', title: 'Branch 2', dependsOn: ['step_a'] },
+      { planKey: 'step_d', title: 'Merge', dependsOn: ['step_b', 'step_c'] },
+    ]);
+
+    const snapshot = await controller.executeApprovedPlan(runId);
+    expect(snapshot.run.status).toBe('succeeded');
+
+    // A must be first, D must be last
+    const aIdx = executeOrder.indexOf(1);
+    const bIdx = executeOrder.indexOf(2);
+    const cIdx = executeOrder.indexOf(3);
+    const dIdx = executeOrder.indexOf(4);
+    expect(aIdx).toBe(0);
+    expect(dIdx).toBe(3);
+    // B and C can be in any order but both after A and before D
+    expect(bIdx).toBeGreaterThan(aIdx);
+    expect(cIdx).toBeGreaterThan(aIdx);
+    expect(bIdx).toBeLessThan(dIdx);
+    expect(cIdx).toBeLessThan(dIdx);
+  });
+
+  it('stops execution when budget is exceeded', async () => {
+    const { controller, repository } = createController();
+
+    // Override tokenTracker
+    const tokenTracker = {
+      checkBudget: vi.fn(async () => ({ allowed: false, reason: 'Budget exceeded' })),
+    };
+    const harness = {
+      executeStep: vi.fn(async () => ({ summary: 'done' })),
+    };
+    const repo2 = createMockRepository();
+    const controller2 = new AgentLoopController(
+      { getHarnessProfile: vi.fn(async () => ({ settings: {} })) } as any,
+      { buildPlan: vi.fn() } as any,
+      { validate: vi.fn() } as any,
+      repo2 as any,
+      harness as any,
+      tokenTracker as any,
+    );
+
+    const runId = await seedRunWithSteps(repo2, [{ planKey: 'step_1', title: 'Expensive step' }]);
+
+    const snapshot = await controller2.executeApprovedPlan(runId);
+    expect(snapshot.run.status).toBe('failed');
+  });
+
+  it('pauses for approval and does not continue', async () => {
+    const { controller, repository } = createController(
+      vi.fn(async (_run: any, _step: any) => {
+        throw new Error('requires_approval');
+      }),
+    );
+
+    const runId = await seedRunWithSteps(repository, [
+      { planKey: 'step_1', title: 'Needs approval', type: 'tool', target: 'restricted_tool' },
+    ]);
+
+    const snapshot = await controller.executeApprovedPlan(runId);
+    expect(snapshot.run.status).toBe('waiting_user');
+  });
+});

package/src/server/__tests__/smoke.test.ts

@@ -0,0 +1,120 @@
+import { createMockServer } from '@nocobase/test';
+
+describe('Agent Orchestrator plugin smoke', () => {
+  let app;
+
+  afterEach(async () => {
+    await app?.destroy();
+  });
+
+  it('loads without starting the full app', async () => {
+    app = await createMockServer({
+      plugins: ['nocobase', 'plugin-agent-orchestrator'],
+    });
+    expect(app).toBeTruthy();
+  });
+
+  it('registers collection definitions', async () => {
+    app = await createMockServer({
+      plugins: ['nocobase', 'plugin-agent-orchestrator'],
+    });
+    const collections = [
+      'agentLoopRuns',
+      'agentLoopSteps',
+      'agentLoopEvents',
+      'orchestratorConfig',
+      'orchestratorLogs',
+      'agentExecutionSpans',
+      'agentHarnessProfiles',
+      'skillDefinitions',
+      'skillExecutions',
+      'skillLoopConfigs',
+      'skillWorkerConfigs',
+    ];
+    for (const name of collections) {
+      const collection = app.db.getCollection(name);
+      expect(collection).toBeTruthy();
+    }
+  });
+
+  it('has agentLoopRuns schema with required fields', async () => {
+    app = await createMockServer({
+      plugins: ['nocobase', 'plugin-agent-orchestrator'],
+    });
+    const collection = app.db.getCollection('agentLoopRuns');
+    expect(collection).toBeTruthy();
+
+    const fields = {
+      goal: 'text',
+      status: 'string',
+      planVersion: 'integer',
+      iterationCount: 'integer',
+      totalTokens: 'integer',
+      totalCost: 'float',
+    };
+
+    for (const [name, type] of Object.entries(fields)) {
+      const field = collection.getField(name);
+      expect(field).toBeTruthy();
+      expect(field.type).toBe(type);
+    }
+  });
+
+  it('can create an agentLoopRun record', async () => {
+    app = await createMockServer({
+      plugins: ['nocobase', 'plugin-agent-orchestrator'],
+    });
+    const repo = app.db.getRepository('agentLoopRuns');
+    const run = await repo.create({
+      values: {
+        rootRunId: 'test-root',
+        goal: 'Test goal',
+        status: 'planning',
+      },
+    });
+    expect(run.id).toBeTruthy();
+    expect(run.goal).toBe('Test goal');
+    expect(run.status).toBe('planning');
+    expect(run.rootRunId).toBe('test-root');
+  });
+
+  it('can create agentLoopSteps with parent-child relationship', async () => {
+    app = await createMockServer({
+      plugins: ['nocobase', 'plugin-agent-orchestrator'],
+    });
+    const runRepo = app.db.getRepository('agentLoopRuns');
+    const stepRepo = app.db.getRepository('agentLoopSteps');
+
+    const run = await runRepo.create({
+      values: {
+        rootRunId: 'test-root-2',
+        goal: 'Multi-step test',
+      },
+    });
+
+    const parentStep = await stepRepo.create({
+      values: {
+        runId: run.id,
+        planKey: 'step_1',
+        title: 'Parent step',
+        type: 'reasoning',
+        status: 'succeeded',
+      },
+    });
+
+    const childStep = await stepRepo.create({
+      values: {
+        runId: run.id,
+        planKey: 'step_2',
+        title: 'Child step',
+        type: 'skill',
+        status: 'pending',
+        dependsOn: ['step_1'],
+      },
+    });
+
+    expect(parentStep.id).toBeTruthy();
+    expect(childStep.id).toBeTruthy();
+    expect(childStep.dependsOn).toEqual(['step_1']);
+  });
+});

package/src/server/collections/agent-execution-spans.ts

@@ -78,6 +78,30 @@ export default defineCollection({
       name: 'durationMs',
       type: 'integer',
     },
+    {
+      name: 'inputTokens',
+      type: 'integer',
+      defaultValue: 0,
+      comment: 'Number of input/prompt tokens consumed by this span',
+    },
+    {
+      name: 'outputTokens',
+      type: 'integer',
+      defaultValue: 0,
+      comment: 'Number of output/completion tokens generated by this span',
+    },
+    {
+      name: 'totalTokens',
+      type: 'integer',
+      defaultValue: 0,
+      comment: 'Total tokens consumed by this span (input + output)',
+    },
+    {
+      name: 'cost',
+      type: 'float',
+      defaultValue: 0,
+      comment: 'Estimated cost in USD for this span',
+    },
     {
       name: 'startedAt',
       type: 'date',