plugin-agent-orchestrator 1.0.28 → 1.0.32

package/src/server/__tests__/native-sub-agent-observer.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AgentMemoryContextService } from '../services/AgentMemoryContextService';
+import { NativeSubAgentObserver } from '../services/NativeSubAgentObserver';
+
+function createObserverHarness(profileSettings: Record<string, unknown> | null = {}) {
+  let nextSpanId = 1;
+  const spanRepo = {
+    create: vi.fn(async ({ values }) => ({ id: nextSpanId++, ...values })),
+    update: vi.fn(async () => ({})),
+  };
+  const originalRun = vi.fn(async (task) => {
+    task.writer?.({
+      action: 'beforeToolCall',
+      body: {
+        toolCall: {
+          id: 'tool-1',
+          name: 'skill_hub_execute',
+          args: { input: 'x' },
+          messageId: 'msg-1',
+        },
+      },
+      currentConversation: {
+        sessionId: 'sub-session',
+        username: 'sub-agent',
+        from: 'sub-agent',
+      },
+    });
+    task.writer?.({
+      action: 'afterToolCall',
+      body: {
+        toolCall: {
+          id: 'tool-1',
+          name: 'skill_hub_execute',
+          messageId: 'msg-1',
+        },
+        toolCallResult: {
+          status: 'success',
+          content: { ok: true },
+        },
+      },
+      currentConversation: {
+        sessionId: 'sub-session',
+        username: 'sub-agent',
+        from: 'sub-agent',
+      },
+    });
+    return `answer:${task.question}`;
+  });
+  const dispatcher = { run: originalRun };
+  const repos: Record<string, unknown> = {
+    agentExecutionSpans: spanRepo,
+    agentHarnessProfiles: {
+      findOne: vi.fn(async () => (profileSettings ? { settings: profileSettings } : null)),
+    },
+    agentMemoryContexts: {
+      find: vi.fn(async () => []),
+    },
+    aiToolMessages: {
+      findOne: vi.fn(async () => ({
+        id: 10,
+        messageId: 20,
+        toolCallId: 'dispatch-call',
+        sessionId: 'parent-session',
+      })),
+    },
+    aiConversations: {
+      findOne: vi.fn(async ({ filter }) =>
+        filter?.sessionId === 'parent-session'
+          ? { sessionId: 'parent-session', aiEmployeeUsername: 'leader', userId: 7 }
+          : null,
+      ),
+    },
+  };
+  const plugin = {
+    app: {
+      logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+      },
+      pm: {
+        get: vi.fn((name) => (name === 'ai' ? { subAgentsDispatcher: dispatcher } : null)),
+        getPlugins: vi.fn(() => new Map()),
+      },
+    },
+    db: {
+      getRepository: vi.fn((name) => repos[name]),
+    },
+  };
+
+  return { plugin, dispatcher, originalRun, spanRepo, repos };
+}
+
+function createTask(getRepository?: (name: string) => unknown) {
+  return {
+    ctx: {
+      action: {
+        params: {
+          values: {
+            sessionId: 'parent-session',
+          },
+        },
+      },
+      auth: {
+        user: { id: 7 },
+      },
+      db: {
+        getRepository: getRepository || vi.fn(),
+      },
+    },
+    sessionId: 'sub-session',
+    employee: { username: 'sub-agent' },
+    question: 'do the work',
+  };
+}
+
+describe('NativeSubAgentObserver', () => {
+  it('wraps dispatcher once and calls the original native run', async () => {
+    const { plugin, dispatcher, originalRun, spanRepo } = createObserverHarness();
+    const observer = new NativeSubAgentObserver(plugin);
+
+    expect(observer.install()).toBe(true);
+    expect(observer.install()).toBe(false);
+
+    const result = await dispatcher.run(createTask());
+
+    expect(result).toBe('answer:do the work');
+    expect(originalRun).toHaveBeenCalledTimes(1);
+    expect(spanRepo.create).toHaveBeenCalled();
+    expect(spanRepo.update).toHaveBeenCalled();
+  });
+
+  it('restores the native dispatcher when uninstalled', async () => {
+    const { plugin, dispatcher, originalRun } = createObserverHarness();
+    const observer = new NativeSubAgentObserver(plugin);
+
+    observer.install();
+    expect(dispatcher.run).not.toBe(originalRun);
+
+    expect(observer.uninstall()).toBe(true);
+    await dispatcher.run(createTask());
+    expect(originalRun).toHaveBeenCalledTimes(1);
+    expect(observer.uninstall()).toBe(false);
+  });
+
+  it('maps dispatch toolCallId from native sub-agent metadata by sub-session', async () => {
+    const { plugin, dispatcher, spanRepo, repos } = createObserverHarness();
+    repos.aiMessages = {
+      find: vi.fn(async () => [
+        {
+          messageId: 30,
+          metadata: {
+            subAgentConversations: [
+              { sessionId: 'other-sub-session', toolCallId: 'other-dispatch-call', status: 'pending' },
+              { sessionId: 'sub-session', toolCallId: 'metadata-dispatch-call', status: 'pending' },
+            ],
+          },
+        },
+      ]),
+    };
+    repos.aiToolMessages = {
+      findOne: vi.fn(async ({ filter }) => ({
+        id: 11,
+        messageId: 30,
+        toolCallId: filter.toolCallId,
+        sessionId: filter.sessionId,
+      })),
+    };
+    const observer = new NativeSubAgentObserver(plugin);
+    observer.install();
+
+    await dispatcher.run(createTask(plugin.db.getRepository));
+
+    const rootSpanValues = spanRepo.create.mock.calls[0][0].values;
+    expect(rootSpanValues.toolCallId).toBe('metadata-dispatch-call');
+    expect(rootSpanValues.metadata.dispatchToolMessageId).toBe(11);
+  });
+
+  it('bypasses tracing and injection when policy disables the native observer', async () => {
+    const { plugin, dispatcher, originalRun, spanRepo } = createObserverHarness({ nativeObserverEnabled: false });
+    const observer = new NativeSubAgentObserver(plugin);
+    observer.install();
+
+    await dispatcher.run(createTask());
+
+    expect(originalRun).toHaveBeenCalledTimes(1);
+    expect(originalRun.mock.calls[0][0].question).toBe('do the work');
+    expect(spanRepo.create).not.toHaveBeenCalled();
+  });
+});
+
+describe('AgentMemoryContextService', () => {
+  it('builds context in public, user-memory, user, agent_user precedence', async () => {
+    const rows = [
+      { scope: 'public', enabled: true, userId: null, aiEmployeeUsername: '', contentMd: 'Public fact' },
+      { scope: 'user', enabled: true, userId: 7, aiEmployeeUsername: '', contentMd: 'User context' },
+      { scope: 'agent_user', enabled: true, userId: 7, aiEmployeeUsername: 'sub-agent', contentMd: 'Private graph' },
+      { scope: 'agent_user', enabled: true, userId: 8, aiEmployeeUsername: 'sub-agent', contentMd: 'Other private' },
+    ];
+    const plugin = {
+      app: {
+        logger: { warn: vi.fn() },
+        pm: {
+          get: vi.fn((name) =>
+            name === 'plugin-user-memory'
+              ? {
+                  memoryInjector: {
+                    getMemoryPromptSection: vi.fn(async () => '<user_memory>User profile</user_memory>'),
+                  },
+                }
+              : null,
+          ),
+        },
+      },
+      db: {
+        getRepository: vi.fn((name) => {
+          if (name === 'agentMemoryContexts') {
+            return {
+              find: vi.fn(async ({ filter }) =>
+                rows.filter(
+                  (row) =>
+                    row.scope === filter.scope &&
+                    row.enabled === filter.enabled &&
+                    (filter.userId === undefined || row.userId === filter.userId),
+                ),
+              ),
+            };
+          }
+          return null;
+        }),
+      },
+    };
+    const service = new AgentMemoryContextService(plugin);
+
+    const result = await service.buildContext({
+      userId: 7,
+      aiEmployeeUsername: 'sub-agent',
+      settings: { memoryScopes: ['public', 'user', 'agent_user'], maxMemoryContextChars: 10000 },
+    });
+
+    expect(result.appliedScopes).toEqual(['public', 'user-memory', 'user', 'agent_user']);
+    expect(result.context.indexOf('Public fact')).toBeLessThan(result.context.indexOf('<user_memory>'));
+    expect(result.context.indexOf('<user_memory>')).toBeLessThan(result.context.indexOf('User context'));
+    expect(result.context.indexOf('User context')).toBeLessThan(result.context.indexOf('Private graph'));
+    expect(result.context).not.toContain('Other private');
+  });
+});

package/src/server/__tests__/skill-settings.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { normalizeAIEmployeeSkillSettings } from '../utils/skill-settings';
 
 describe('normalizeAIEmployeeSkillSettings', () => {
-  it('moves legacy object tool bindings from skills to tools', () => {
+  it('removes retired orchestrator plan tool bindings from skills', () => {
     const result = normalizeAIEmployeeSkillSettings({
       skills: [{ name: 'orchestrator_plan_goal', autoCall: false }, 'crm-research'],
       tools: [],
@@ -10,20 +10,20 @@ describe('normalizeAIEmployeeSkillSettings', () => {
 
     expect(result.changed).toBe(true);
     expect(result.skillSettings.skills).toEqual(['crm-research']);
-    expect(result.skillSettings.tools).toEqual([{ name: 'orchestrator_plan_goal', autoCall: false }]);
+    expect(result.skillSettings.tools).toEqual([]);
   });
 
-  it('moves orchestrator tool names stored as skill strings to tools', () => {
+  it('removes retired delegate tool names stored as skill strings', () => {
     const result = normalizeAIEmployeeSkillSettings({
       skills: ['delegate_lead_to_researcher', 'crm-research'],
     });
 
     expect(result.changed).toBe(true);
     expect(result.skillSettings.skills).toEqual(['crm-research']);
-    expect(result.skillSettings.tools).toEqual([{ name: 'delegate_lead_to_researcher', autoCall: false }]);
+    expect(result.skillSettings.tools).toEqual([]);
   });
 
-  it('keeps current tool bindings and avoids duplicate migrated tools', () => {
+  it('removes retired dispatch tool bindings from current tools', () => {
     const result = normalizeAIEmployeeSkillSettings({
       skills: [{ name: 'dispatch_subagents_lead', autoCall: true }],
       tools: [{ name: 'dispatch_subagents_lead', autoCall: false }],
@@ -31,7 +31,7 @@ describe('normalizeAIEmployeeSkillSettings', () => {
 
     expect(result.changed).toBe(true);
     expect(result.skillSettings.skills).toEqual([]);
-    expect(result.skillSettings.tools).toEqual([{ name: 'dispatch_subagents_lead', autoCall: false }]);
+    expect(result.skillSettings.tools).toEqual([]);
   });
 
   it('moves browser and drawio tools stored as skill strings to tools', () => {

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

@@ -25,6 +25,7 @@ describe('Agent Orchestrator plugin smoke', () => {
       'orchestratorConfig',
       'orchestratorLogs',
       'agentExecutionSpans',
+      'agentMemoryContexts',
       'agentHarnessProfiles',
       'skillDefinitions',
       'skillExecutions',

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

@@ -28,6 +28,28 @@ export default defineCollection({
       type: 'string',
       length: 100,
     },
+    {
+      name: 'source',
+      type: 'string',
+      length: 100,
+      comment: 'native-plugin-ai or legacy orchestrator source.',
+    },
+    {
+      name: 'parentSessionId',
+      type: 'uuid',
+      comment: 'Main AI conversation session id when this span comes from native plugin-ai.',
+    },
+    {
+      name: 'subSessionId',
+      type: 'uuid',
+      comment: 'Sub-agent AI conversation session id when this span comes from native plugin-ai.',
+    },
+    {
+      name: 'toolCallId',
+      type: 'string',
+      length: 200,
+      comment: 'Native AI tool call id associated with this span.',
+    },
     {
       name: 'type',
       type: 'string',
@@ -143,11 +165,26 @@ export default defineCollection({
     {
       fields: ['parentSpanId'],
     },
+    {
+      fields: ['source'],
+    },
+    {
+      fields: ['parentSessionId'],
+    },
+    {
+      fields: ['subSessionId'],
+    },
+    {
+      fields: ['toolCallId'],
+    },
     {
       fields: ['type'],
     },
     {
       fields: ['status'],
     },
+    {
+      fields: ['userId'],
+    },
   ],
 });

package/src/server/collections/agent-harness-profiles.ts

@@ -1,59 +1,59 @@
-import { defineCollection } from '@nocobase/database';
-
-export default defineCollection({
-  name: 'agentHarnessProfiles',
-  title: 'Agent Harness Profiles',
-  fields: [
-    {
-      name: 'id',
-      type: 'bigInt',
-      autoIncrement: true,
-      primaryKey: true,
-    },
-    {
-      name: 'tag',
-      type: 'string',
-      length: 100,
-      allowNull: false,
-      unique: true,
-      comment: 'Stable harness profile tag used by orchestration rules and agent loop runs.',
-    },
-    {
-      name: 'title',
-      type: 'string',
-      length: 200,
-    },
-    {
-      name: 'description',
-      type: 'text',
-    },
-    {
-      name: 'enabled',
-      type: 'boolean',
-      defaultValue: true,
-    },
-    {
-      name: 'settings',
-      type: 'json',
-      defaultValue: {},
-      comment: 'Harness limits and behavior settings such as max parallel sub-agents, approval mode, and tool policy.',
-    },
-    {
-      name: 'createdAt',
-      type: 'date',
-    },
-    {
-      name: 'updatedAt',
-      type: 'date',
-    },
-  ],
-  indexes: [
-    {
-      unique: true,
-      fields: ['tag'],
-    },
-    {
-      fields: ['enabled'],
-    },
-  ],
-});
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'agentHarnessProfiles',
+  title: 'Agent Harness Profiles',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'tag',
+      type: 'string',
+      length: 100,
+      allowNull: false,
+      unique: true,
+      comment: 'Stable policy profile tag used by native sub-agent observer and context injection.',
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 200,
+    },
+    {
+      name: 'description',
+      type: 'text',
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: true,
+    },
+    {
+      name: 'settings',
+      type: 'json',
+      defaultValue: {},
+      comment: 'Policy settings such as native observer enablement, memory scopes, and tracing retention.',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      unique: true,
+      fields: ['tag'],
+    },
+    {
+      fields: ['enabled'],
+    },
+  ],
+});

package/src/server/collections/agent-loop-events.ts

@@ -1,71 +1,71 @@
-import { defineCollection } from '@nocobase/database';
-
-export default defineCollection({
-  name: 'agentLoopEvents',
-  title: 'Agent Loop Events',
-  fields: [
-    {
-      name: 'id',
-      type: 'bigInt',
-      autoIncrement: true,
-      primaryKey: true,
-    },
-    {
-      name: 'run',
-      type: 'belongsTo',
-      target: 'agentLoopRuns',
-      foreignKey: 'runId',
-    },
-    {
-      name: 'step',
-      type: 'belongsTo',
-      target: 'agentLoopSteps',
-      foreignKey: 'stepId',
-    },
-    {
-      name: 'type',
-      type: 'string',
-      length: 80,
-    },
-    {
-      name: 'title',
-      type: 'string',
-      length: 500,
-    },
-    {
-      name: 'content',
-      type: 'text',
-    },
-    {
-      name: 'status',
-      type: 'string',
-      length: 30,
-    },
-    {
-      name: 'payload',
-      type: 'json',
-      defaultValue: {},
-    },
-    {
-      name: 'user',
-      type: 'belongsTo',
-      target: 'users',
-      foreignKey: 'userId',
-    },
-    {
-      name: 'createdAt',
-      type: 'date',
-    },
-  ],
-  indexes: [
-    {
-      fields: ['runId'],
-    },
-    {
-      fields: ['stepId'],
-    },
-    {
-      fields: ['type'],
-    },
-  ],
-});
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'agentLoopEvents',
+  title: 'Agent Loop Events',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'run',
+      type: 'belongsTo',
+      target: 'agentLoopRuns',
+      foreignKey: 'runId',
+    },
+    {
+      name: 'step',
+      type: 'belongsTo',
+      target: 'agentLoopSteps',
+      foreignKey: 'stepId',
+    },
+    {
+      name: 'type',
+      type: 'string',
+      length: 80,
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'content',
+      type: 'text',
+    },
+    {
+      name: 'status',
+      type: 'string',
+      length: 30,
+    },
+    {
+      name: 'payload',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'user',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'userId',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['runId'],
+    },
+    {
+      fields: ['stepId'],
+    },
+    {
+      fields: ['type'],
+    },
+  ],
+});