plugin-agent-orchestrator 1.0.17 → 1.0.18

package/src/server/collections/skill-executions.ts

@@ -1,55 +1,55 @@
-import { CollectionOptions } from '@nocobase/database';
-
-export default {
-  name: 'skillExecutions',
-  title: 'Skill Executions',
-  fields: [
-    {
-      name: 'id',
-      type: 'bigInt',
-      autoIncrement: true,
-      primaryKey: true,
-    },
-    {
-      name: 'skill',
-      type: 'belongsTo',
-      target: 'skillDefinitions',
-      foreignKey: 'skillId',
-    },
-    {
-      // 'pending' | 'running' | 'succeeded' | 'failed' | 'canceled' | 'timeout'
-      name: 'status',
-      type: 'string',
-      length: 20,
-      defaultValue: 'pending',
-    },
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'skillExecutions',
+  title: 'Skill Executions',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'skill',
+      type: 'belongsTo',
+      target: 'skillDefinitions',
+      foreignKey: 'skillId',
+    },
+    {
+      // 'pending' | 'running' | 'succeeded' | 'failed' | 'canceled' | 'timeout'
+      name: 'status',
+      type: 'string',
+      length: 20,
+      defaultValue: 'pending',
+    },
     {
       name: 'inputArgs',
       type: 'text',
     },
-    {
-      // Final code after template rendering
-      name: 'executedCode',
-      type: 'text',
-    },
-    {
-      name: 'stdout',
-      type: 'text',
-    },
-    {
-      name: 'stderr',
-      type: 'text',
-    },
+    {
+      // Final code after template rendering
+      name: 'executedCode',
+      type: 'text',
+    },
+    {
+      name: 'stdout',
+      type: 'text',
+    },
+    {
+      name: 'stderr',
+      type: 'text',
+    },
     {
       // [{ name, size, mimeType }]
       name: 'outputFiles',
       type: 'text',
       defaultValue: null,
     },
-    {
-      name: 'durationMs',
-      type: 'integer',
-    },
+    {
+      name: 'durationMs',
+      type: 'integer',
+    },
     {
       name: 'sessionId',
       type: 'string',
@@ -80,15 +80,27 @@ export default {
       length: 100,
       allowNull: true,
     },
+    {
+      name: 'agentLoopRunId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
+    {
+      name: 'agentLoopStepId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
     {
       name: 'triggeredBy',
       type: 'belongsTo',
-      target: 'users',
-      foreignKey: 'triggeredById',
-    },
-    {
-      name: 'createdAt',
-      type: 'date',
-    },
-  ],
-} as CollectionOptions;
+      target: 'users',
+      foreignKey: 'triggeredById',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+  ],
+} as CollectionOptions;

package/src/server/collections/skill-loop-configs.ts

@@ -0,0 +1,65 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'skillLoopConfigs',
+  title: 'Skill Loop Configs',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'skill',
+      type: 'belongsTo',
+      target: 'skillDefinitions',
+      foreignKey: 'skillId',
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: true,
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 200,
+    },
+    {
+      name: 'templateKey',
+      type: 'string',
+      length: 80,
+      defaultValue: 'confirm',
+    },
+    {
+      name: 'prompt',
+      type: 'text',
+    },
+    {
+      // Resolved interaction schema consumed by the generic Skill Hub UI card.
+      name: 'schema',
+      type: 'text',
+    },
+    {
+      // Optional template-specific state for future loop renderers.
+      name: 'config',
+      type: 'text',
+      defaultValue: null,
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+    {
+      name: 'createdBy',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'createdById',
+    },
+  ],
+} as CollectionOptions;

package/src/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.ts

@@ -0,0 +1,30 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddAgentLoopFieldsToSkillExecutions extends Migration {
+  on = 'afterLoad';
+  appVersion = '>=0.1.0';
+
+  async up() {
+    const queryInterface = (this as any).db.sequelize.getQueryInterface();
+    const tablePrefix = (this as any).db.options.tablePrefix || '';
+    const tableName = `${tablePrefix}skillExecutions`;
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+
+    const tableDesc = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name: string) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, {
+        type: 'VARCHAR(100)',
+        allowNull: true,
+      });
+    };
+
+    await addIfMissing('agentLoopRunId');
+    await addIfMissing('agentLoopStepId');
+  }
+
+  async down() {
+    // No rollback: these nullable trace-link columns are backward compatible.
+  }
+}

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

@@ -0,0 +1,142 @@
+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.
+  }
+}

package/src/server/plugin.ts

@@ -2,14 +2,19 @@ import { Plugin } from '@nocobase/server';
 import path from 'path';
 import { createDelegateToolsProvider } from './tools/delegate-task';
 import { createExternalRagSearchTool } from './tools/external-rag-search';
+import { createOrchestratorPlanTools } from './tools/orchestrator-plan';
 import { registerTracingResource } from './resources/tracing';
+import { registerAgentLoopResource } from './resources/agent-loop';
 import SkillHubSubFeature from './skill-hub/plugin';
+import { AgentLoopService } from './services/AgentLoopService';
 
 export class PluginAgentOrchestratorServer extends Plugin {
   skillHub: SkillHubSubFeature;
+  agentLoopService: AgentLoopService;
 
   async afterAdd() {
     this.skillHub = new SkillHubSubFeature(this);
+    this.agentLoopService = new AgentLoopService(this);
   }
 
   async beforeLoad() {
@@ -32,9 +37,15 @@ export class PluginAgentOrchestratorServer extends Plugin {
       actions: [
         'orchestratorConfig:*',
         'orchestratorTracing:*',
+        'agentLoops:*',
+        'agentLoopRuns:*',
+        'agentLoopSteps:*',
+        'agentLoopEvents:*',
+        'agentHarnessProfiles:*',
         'agentExecutionSpans:*',
         'skillDefinitions:*',
         'skillExecutions:*',
+        'skillLoopConfigs:*',
         'skillHub:*',
         'skillWorkerConfigs:*',
       ],
@@ -45,9 +56,13 @@ export class PluginAgentOrchestratorServer extends Plugin {
     // Uses createReactAgent (LangGraph public API) instead of private AIEmployee class.
     // Tools are registered via app.aiManager.toolsManager (public API from @nocobase/ai core).
     const toolsManager = (this as any).app.aiManager.toolsManager;
+    toolsManager.registerTools(createOrchestratorPlanTools(this, this.agentLoopService));
     toolsManager.registerTools(createExternalRagSearchTool(this));
     toolsManager.registerDynamicTools(createDelegateToolsProvider(this));
 
+    // --- Register Agent Loop Resource ---
+    registerAgentLoopResource(this, this.agentLoopService);
+
     // --- Register Tracing Resource (Phase 5) ---
     // Custom read-only resource for the Swarm Tracing admin page.
     registerTracingResource(this);

package/src/server/resources/agent-loop.ts

@@ -0,0 +1,183 @@
+import { Plugin } from '@nocobase/server';
+import { AgentLoopService } from '../services/AgentLoopService';
+
+function toPlain(record: any) {
+  return record?.toJSON?.() || record;
+}
+
+function currentUserId(ctx: any) {
+  return ctx?.state?.currentUser?.id || ctx?.auth?.user?.id;
+}
+
+function values(ctx: any) {
+  return ctx.request?.body || ctx.action?.params?.values || {};
+}
+
+function formatRunRow(raw: any) {
+  const row = toPlain(raw);
+  return {
+    id: row.id,
+    rootRunId: row.rootRunId,
+    sessionId: row.sessionId,
+    messageId: row.messageId,
+    leaderUsername: row.leaderUsername,
+    goal: row.goal,
+    status: row.status,
+    approvalStatus: row.approvalStatus,
+    planVersion: row.planVersion,
+    planSource: row.planSource,
+    plannerModel: row.plannerModel,
+    approvedById: row.approvedById,
+    approvedAt: row.approvedAt,
+    rejectionReason: row.rejectionReason,
+    changeRequest: row.changeRequest,
+    currentStepId: row.currentStepId,
+    iterationCount: row.iterationCount || 0,
+    finalAnswer: row.finalAnswer,
+    summary: row.summary,
+    userId: row.userId,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export function registerAgentLoopResource(plugin: Plugin, service: AgentLoopService) {
+  const app = plugin.app;
+
+  app.resource({
+    name: 'agentLoops',
+    actions: {
+      async list(ctx, next) {
+        const { page = 1, pageSize = 20, sort = ['-createdAt'], filter = {} } = ctx.action.params;
+        const repo = ctx.db.getRepository('agentLoopRuns');
+        const [rows, count] = await repo.findAndCount({
+          filter,
+          sort,
+          offset: (Number(page) - 1) * Number(pageSize),
+          limit: Number(pageSize),
+        });
+
+        ctx.body = {
+          data: rows.map(formatRunRow),
+          meta: {
+            count,
+            page: Number(page),
+            pageSize: Number(pageSize),
+            totalPage: Math.ceil(count / Number(pageSize)),
+          },
+        };
+        await next();
+      },
+
+      async get(ctx, next) {
+        const { filterByTk } = ctx.action.params;
+        if (!filterByTk) {
+          ctx.throw(400, 'run id is required');
+          return;
+        }
+        ctx.body = { data: await service.getRunDetail(filterByTk) };
+        await next();
+      },
+
+      async resume(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, 'runId is required');
+          return;
+        }
+        ctx.body = {
+          data: await service.resumeRun(runId, {
+            stepId: body.stepId,
+            approved: body.approved !== false,
+            editedInput: body.editedInput,
+            userId: currentUserId(ctx),
+            ctx,
+          }),
+        };
+        await next();
+      },
+
+      async approvePlan(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, 'runId is required');
+          return;
+        }
+        ctx.body = {
+          data: await service.approvePlanAndExecute(runId, {
+            userId: currentUserId(ctx),
+            ctx,
+            reason: body.reason,
+          }),
+        };
+        await next();
+      },
+
+      async rejectPlan(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, 'runId is required');
+          return;
+        }
+        ctx.body = {
+          data: await service.rejectPlan(runId, {
+            reason: body.reason,
+            userId: currentUserId(ctx),
+          }),
+        };
+        await next();
+      },
+
+      async requestPlanChanges(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, 'runId is required');
+          return;
+        }
+        ctx.body = {
+          data: await service.requestPlanChanges(runId, {
+            feedback: body.feedback,
+            userId: currentUserId(ctx),
+          }),
+        };
+        await next();
+      },
+
+      async cancel(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, 'runId is required');
+          return;
+        }
+        ctx.body = {
+          data: await service.cancelRun(runId, {
+            reason: body.reason,
+            userId: currentUserId(ctx),
+          }),
+        };
+        await next();
+      },
+
+      async retryStep(ctx, next) {
+        const body = values(ctx);
+        if (!body.stepId) {
+          ctx.throw(400, 'stepId is required');
+          return;
+        }
+        ctx.body = {
+          data: await service.retryStep(body.stepId, {
+            userId: currentUserId(ctx),
+          }),
+        };
+        await next();
+      },
+    },
+  });
+}