plugin-agent-orchestrator 1.0.27 → 1.0.32

package/src/server/migrations/20260524001000-add-plan-approval-and-harness-profiles.ts

@@ -1,142 +1,145 @@
-import { DataTypes } from '@nocobase/database';
-import { Migration } from '@nocobase/server';
-
-export default class AddPlanApprovalAndHarnessProfiles extends Migration {
-  on = 'afterLoad';
-  appVersion = '>=0.1.0';
-
-  async up() {
-    const db = (this as any).db;
-    const queryInterface = db.sequelize.getQueryInterface();
-    const tablePrefix = db.options.tablePrefix || '';
-
-    await this.addRunColumns(queryInterface, `${tablePrefix}agentLoopRuns`);
-    await this.addStepColumns(queryInterface, `${tablePrefix}agentLoopSteps`);
-    await this.addConfigColumns(queryInterface, `${tablePrefix}orchestratorConfig`);
-    await this.ensureHarnessProfiles(queryInterface, `${tablePrefix}agentHarnessProfiles`);
-    await this.seedDefaultProfiles();
-  }
-
-  async addRunColumns(queryInterface: any, tableName: string) {
-    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
-    if (!tableExists) return;
-    const tableDesc = await queryInterface.describeTable(tableName);
-    const addIfMissing = async (name: string, spec: any) => {
-      if (tableDesc[name]) return;
-      await queryInterface.addColumn(tableName, name, spec);
-    };
-
-    await addIfMissing('approvalStatus', { type: DataTypes.STRING(30), allowNull: true, defaultValue: 'none' });
-    await addIfMissing('approvedById', { type: DataTypes.BIGINT, allowNull: true });
-    await addIfMissing('approvedAt', { type: DataTypes.DATE, allowNull: true });
-    await addIfMissing('rejectionReason', { type: DataTypes.TEXT, allowNull: true });
-    await addIfMissing('changeRequest', { type: DataTypes.TEXT, allowNull: true });
-    await addIfMissing('planVersion', { type: DataTypes.INTEGER, allowNull: true, defaultValue: 1 });
-    await addIfMissing('planSource', { type: DataTypes.STRING(50), allowNull: true });
-    await addIfMissing('plannerModel', { type: DataTypes.STRING(100), allowNull: true });
-    await addIfMissing('lockedBy', { type: DataTypes.STRING(100), allowNull: true });
-    await addIfMissing('lockedUntil', { type: DataTypes.DATE, allowNull: true });
-  }
-
-  async addStepColumns(queryInterface: any, tableName: string) {
-    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
-    if (!tableExists) return;
-    const tableDesc = await queryInterface.describeTable(tableName);
-    if (!tableDesc.dependencyPolicy) {
-      await queryInterface.addColumn(tableName, 'dependencyPolicy', {
-        type: DataTypes.STRING(30),
-        allowNull: true,
-        defaultValue: 'require_success',
-      });
-    }
-  }
-
-  async addConfigColumns(queryInterface: any, tableName: string) {
-    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
-    if (!tableExists) return;
-    const tableDesc = await queryInterface.describeTable(tableName);
-    if (!tableDesc.harnessTag) {
-      await queryInterface.addColumn(tableName, 'harnessTag', {
-        type: DataTypes.STRING(100),
-        allowNull: true,
-        defaultValue: 'default',
-      });
-    }
-  }
-
-  async ensureHarnessProfiles(queryInterface: any, tableName: string) {
-    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
-    if (tableExists) return;
-    await queryInterface.createTable(tableName, {
-      id: { type: DataTypes.BIGINT, primaryKey: true, autoIncrement: true },
-      tag: { type: DataTypes.STRING(100), allowNull: false, unique: true },
-      title: { type: DataTypes.STRING(200), allowNull: true },
-      description: { type: DataTypes.TEXT, allowNull: true },
-      enabled: { type: DataTypes.BOOLEAN, allowNull: true, defaultValue: true },
-      settings: { type: DataTypes.JSON, allowNull: true, defaultValue: {} },
-      createdAt: { type: DataTypes.DATE, allowNull: true },
-      updatedAt: { type: DataTypes.DATE, allowNull: true },
-    });
-  }
-
-  async seedDefaultProfiles() {
-    const repo = (this as any).db.getRepository('agentHarnessProfiles');
-    if (!repo) return;
-    const profiles = [
-      {
-        tag: 'default',
-        title: 'Default',
-        description: 'Balanced profile for normal multi-agent work.',
-        settings: {
-          requirePlanApproval: true,
-          allowSubAgents: true,
-          allowToolCalls: true,
-          maxParallelSubAgents: 3,
-          maxControllerSteps: 100,
-        },
-      },
-      {
-        tag: 'safe',
-        title: 'Safe',
-        description: 'Strict approval-first profile for higher-risk work.',
-        settings: {
-          requirePlanApproval: true,
-          allowSubAgents: true,
-          allowToolCalls: true,
-          maxParallelSubAgents: 1,
-          maxControllerSteps: 50,
-          requireVerification: true,
-        },
-      },
-      {
-        tag: 'file-heavy',
-        title: 'File Heavy',
-        description: 'Profile for tasks that inspect or transform many attachments/files.',
-        settings: {
-          requirePlanApproval: true,
-          allowSubAgents: true,
-          allowToolCalls: true,
-          maxParallelSubAgents: 2,
-          maxControllerSteps: 120,
-          preferFileTools: true,
-        },
-      },
-    ];
-    for (const profile of profiles) {
-      const existing = await repo.findOne({ filter: { tag: profile.tag } });
-      if (existing) continue;
-      await repo.create({
-        values: {
-          ...profile,
-          enabled: true,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        },
-      });
-    }
-  }
-
-  async down() {
-    // No rollback: new nullable columns and the profile table are backward compatible.
-  }
-}
+import { DataTypes } from '@nocobase/database';
+import { Migration } from '@nocobase/server';
+
+export default class AddPlanApprovalAndHarnessProfiles extends Migration {
+  on = 'afterLoad';
+  appVersion = '>=0.1.0';
+
+  async up() {
+    const db = (this as any).db;
+    const queryInterface = db.sequelize.getQueryInterface();
+    const tablePrefix = db.options.tablePrefix || '';
+
+    await this.addRunColumns(queryInterface, `${tablePrefix}agentLoopRuns`);
+    await this.addStepColumns(queryInterface, `${tablePrefix}agentLoopSteps`);
+    await this.addConfigColumns(queryInterface, `${tablePrefix}orchestratorConfig`);
+    await this.ensureHarnessProfiles(queryInterface, `${tablePrefix}agentHarnessProfiles`);
+    await this.seedDefaultProfiles();
+  }
+
+  async addRunColumns(queryInterface: any, tableName: string) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name: string, spec: any) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, spec);
+    };
+
+    await addIfMissing('approvalStatus', { type: DataTypes.STRING(30), allowNull: true, defaultValue: 'none' });
+    await addIfMissing('approvedById', { type: DataTypes.BIGINT, allowNull: true });
+    await addIfMissing('approvedAt', { type: DataTypes.DATE, allowNull: true });
+    await addIfMissing('rejectionReason', { type: DataTypes.TEXT, allowNull: true });
+    await addIfMissing('changeRequest', { type: DataTypes.TEXT, allowNull: true });
+    await addIfMissing('planVersion', { type: DataTypes.INTEGER, allowNull: true, defaultValue: 1 });
+    await addIfMissing('planSource', { type: DataTypes.STRING(50), allowNull: true });
+    await addIfMissing('plannerModel', { type: DataTypes.STRING(100), allowNull: true });
+    await addIfMissing('lockedBy', { type: DataTypes.STRING(100), allowNull: true });
+    await addIfMissing('lockedUntil', { type: DataTypes.DATE, allowNull: true });
+  }
+
+  async addStepColumns(queryInterface: any, tableName: string) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc.dependencyPolicy) {
+      await queryInterface.addColumn(tableName, 'dependencyPolicy', {
+        type: DataTypes.STRING(30),
+        allowNull: true,
+        defaultValue: 'require_success',
+      });
+    }
+  }
+
+  async addConfigColumns(queryInterface: any, tableName: string) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc.harnessTag) {
+      await queryInterface.addColumn(tableName, 'harnessTag', {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        defaultValue: 'default',
+      });
+    }
+  }
+
+  async ensureHarnessProfiles(queryInterface: any, tableName: string) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (tableExists) return;
+    await queryInterface.createTable(tableName, {
+      id: { type: DataTypes.BIGINT, primaryKey: true, autoIncrement: true },
+      tag: { type: DataTypes.STRING(100), allowNull: false, unique: true },
+      title: { type: DataTypes.STRING(200), allowNull: true },
+      description: { type: DataTypes.TEXT, allowNull: true },
+      enabled: { type: DataTypes.BOOLEAN, allowNull: true, defaultValue: true },
+      settings: { type: DataTypes.JSON, allowNull: true, defaultValue: {} },
+      createdAt: { type: DataTypes.DATE, allowNull: true },
+      updatedAt: { type: DataTypes.DATE, allowNull: true },
+    });
+  }
+
+  async seedDefaultProfiles() {
+    const repo = (this as any).db.getRepository('agentHarnessProfiles');
+    if (!repo) return;
+    const profiles = [
+      {
+        tag: 'default',
+        title: 'Default',
+        description: 'Default native observer and memory policy for normal AI employee work.',
+        settings: {
+          nativeObserverEnabled: true,
+          memoryInjectionEnabled: true,
+          memoryScopes: ['public', 'user', 'agent_user'],
+          knowledgeScopes: ['public', 'private'],
+          maxMemoryContextChars: 6000,
+          tracingRetentionDays: 30,
+        },
+      },
+      {
+        tag: 'safe',
+        title: 'Safe',
+        description:
+          'Conservative native observer policy with private context enabled only for matching user/agent pairs.',
+        settings: {
+          nativeObserverEnabled: true,
+          memoryInjectionEnabled: true,
+          memoryScopes: ['public', 'user', 'agent_user'],
+          knowledgeScopes: ['public', 'private'],
+          maxMemoryContextChars: 4000,
+          tracingRetentionDays: 14,
+        },
+      },
+      {
+        tag: 'file-heavy',
+        title: 'File Heavy',
+        description: 'Native observer policy for agents that need more context while working with files and artifacts.',
+        settings: {
+          nativeObserverEnabled: true,
+          memoryInjectionEnabled: true,
+          memoryScopes: ['public', 'user', 'agent_user'],
+          knowledgeScopes: ['public', 'private'],
+          maxMemoryContextChars: 8000,
+          tracingRetentionDays: 30,
+          preferFileTools: true,
+        },
+      },
+    ];
+    for (const profile of profiles) {
+      const existing = await repo.findOne({ filter: { tag: profile.tag } });
+      if (existing) continue;
+      await repo.create({
+        values: {
+          ...profile,
+          enabled: true,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      });
+    }
+  }
+
+  async down() {
+    // No rollback: new nullable columns and the profile table are backward compatible.
+  }
+}

package/src/server/migrations/20260615000000-normalize-ai-employee-tool-bindings.ts

@@ -33,7 +33,7 @@ export default class NormalizeAIEmployeeToolBindings extends Migration {
   }
 
   async down() {
-    // No rollback: this only moves tool-shaped entries from skillSettings.skills
-    // into the current NocoBase skillSettings.tools shape.
+    // No rollback: this only normalizes current tool-shaped entries and removes
+    // retired custom orchestrator tools that are no longer registered.
   }
 }

package/src/server/migrations/20260621000000-native-policy-profile-defaults.ts

@@ -0,0 +1,193 @@
+import { DataTypes } from '@nocobase/database';
+import { Migration } from '@nocobase/server';
+import { normalizeAIEmployeeSkillSettings } from '../utils/skill-settings';
+
+type ProfileSeed = {
+  tag: string;
+  title: string;
+  description: string;
+  settings: Record<string, unknown>;
+};
+
+const nativePolicyProfiles: ProfileSeed[] = [
+  {
+    tag: 'default',
+    title: 'Default',
+    description: 'Default native observer and memory policy for normal AI employee work.',
+    settings: {
+      nativeObserverEnabled: true,
+      memoryInjectionEnabled: true,
+      memoryScopes: ['public', 'user', 'agent_user'],
+      knowledgeScopes: ['public', 'private'],
+      maxMemoryContextChars: 6000,
+      tracingRetentionDays: 30,
+    },
+  },
+  {
+    tag: 'safe',
+    title: 'Safe',
+    description: 'Conservative native observer policy with private context enabled only for matching user/agent pairs.',
+    settings: {
+      nativeObserverEnabled: true,
+      memoryInjectionEnabled: true,
+      memoryScopes: ['public', 'user', 'agent_user'],
+      knowledgeScopes: ['public', 'private'],
+      maxMemoryContextChars: 4000,
+      tracingRetentionDays: 14,
+    },
+  },
+  {
+    tag: 'file-heavy',
+    title: 'File Heavy',
+    description: 'Native observer policy for agents that need more context while working with files and artifacts.',
+    settings: {
+      nativeObserverEnabled: true,
+      memoryInjectionEnabled: true,
+      memoryScopes: ['public', 'user', 'agent_user'],
+      knowledgeScopes: ['public', 'private'],
+      maxMemoryContextChars: 8000,
+      tracingRetentionDays: 30,
+      preferFileTools: true,
+    },
+  },
+];
+
+function readModelValue(record: unknown, key: string) {
+  const model = record as { get?: (name: string) => unknown; [key: string]: unknown };
+  return typeof model?.get === 'function' ? model.get(key) : model?.[key];
+}
+
+function asObject(value: unknown) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function dropRetiredPolicyKeys(settings: Record<string, unknown>) {
+  const retired = new Set([
+    'requirePlanApproval',
+    'allowSubAgents',
+    'allowToolCalls',
+    'maxParallelSubAgents',
+    'maxControllerSteps',
+    'requireVerification',
+  ]);
+  return Object.fromEntries(Object.entries(settings).filter(([key]) => !retired.has(key)));
+}
+
+function normalizeOptionalString(value: unknown) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function buildContextKey(record: Record<string, unknown>) {
+  const scope = normalizeOptionalString(record.scope);
+  const userPart = scope === 'public' ? 'public' : String(record.userId || '');
+  const agentPart = normalizeOptionalString(record.aiEmployeeUsername) || '*';
+  return `${scope}:${userPart}:${agentPart}`;
+}
+
+export default class NativePolicyProfileDefaults extends Migration {
+  on = 'afterLoad';
+  appVersion = '>=0.1.0';
+
+  async up() {
+    await this.ensureNativePolicyProfiles();
+    await this.ensureAgentMemoryContextKeys();
+    await this.normalizeAIEmployeeToolBindings();
+  }
+
+  private async ensureNativePolicyProfiles() {
+    const repo = (this as unknown as { db: { getRepository: (name: string) => any } }).db.getRepository(
+      'agentHarnessProfiles',
+    );
+    if (!repo) return;
+
+    for (const profile of nativePolicyProfiles) {
+      const existing = await repo.findOne({ filter: { tag: profile.tag } });
+      if (!existing) {
+        await repo.create({
+          values: {
+            ...profile,
+            enabled: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+        });
+        continue;
+      }
+
+      const currentSettings = asObject(readModelValue(existing, 'settings'));
+      const nextSettings = {
+        ...profile.settings,
+        ...dropRetiredPolicyKeys(currentSettings),
+      };
+      await existing.update({
+        settings: nextSettings,
+        updatedAt: new Date(),
+      });
+    }
+  }
+
+  private async ensureAgentMemoryContextKeys() {
+    const db = (this as any).db;
+    const queryInterface = db.sequelize.getQueryInterface();
+    const tableName = `${db.options.tablePrefix || ''}agentMemoryContexts`;
+    const tableExists = await queryInterface
+      .describeTable(tableName)
+      .then(() => true)
+      .catch(() => false);
+    if (!tableExists) return;
+
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc.contextKey) {
+      await queryInterface.addColumn(tableName, 'contextKey', {
+        type: DataTypes.STRING(300),
+        allowNull: true,
+      });
+    }
+
+    const repo = db.getRepository('agentMemoryContexts');
+    const rows = await repo.find({});
+    for (const row of rows) {
+      const data = row.toJSON?.() || row;
+      if (!normalizeOptionalString(data.scope)) continue;
+      const contextKey = normalizeOptionalString(data.contextKey) || buildContextKey(data);
+      if (!contextKey) continue;
+      if (contextKey !== data.contextKey) {
+        await row.update({ contextKey });
+      }
+    }
+
+    await queryInterface
+      .changeColumn(tableName, 'contextKey', {
+        type: DataTypes.STRING(300),
+        allowNull: false,
+      })
+      .catch(() => {});
+
+    await queryInterface
+      .addIndex(tableName, ['contextKey'], {
+        unique: true,
+        name: `${tableName}_contextKey_unique`,
+      })
+      .catch(() => {});
+  }
+
+  private async normalizeAIEmployeeToolBindings() {
+    const repo = (this as unknown as { db: { getRepository: (name: string) => any } }).db.getRepository('aiEmployees');
+    if (!repo) return;
+
+    const rows = await repo.find({});
+    for (const row of rows) {
+      const skillSettings = row.get?.('skillSettings') ?? row.skillSettings;
+      const normalized = normalizeAIEmployeeSkillSettings(skillSettings);
+      if (!normalized.changed) continue;
+      await row.update({
+        skillSettings: normalized.skillSettings,
+      });
+    }
+  }
+
+  async down() {
+    // No rollback: these defaults only add native policy keys and normalize
+    // context keys required by the current unique constraint.
+  }
+}