plugin-agent-orchestrator 1.0.19 → 1.0.21

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

@@ -1,142 +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.
-  }
-}
+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/migrations/20260601000000-add-token-fields.ts

@@ -0,0 +1,89 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddTokenFieldsMigration extends Migration {
+  on = 'afterLoad';
+  appVersion = '<=2.x';
+
+  async up() {
+    const queryInterface = (this as any).db.sequelize.getQueryInterface();
+    const DataTypes = (this as any).db.sequelize.constructor['DataTypes'];
+    const prefix = (this as any).db.options.tablePrefix || '';
+
+    // ── agentExecutionSpans ──
+    const spansTable = `${prefix}agentExecutionSpans`;
+    const spansExists = await queryInterface
+      .describeTable(spansTable)
+      .then(() => true)
+      .catch(() => false);
+    if (spansExists) {
+      const spansCols = await queryInterface.describeTable(spansTable);
+      const addSpanIfMissing = async (name: string, definition: any) => {
+        if (!spansCols[name]) {
+          await queryInterface.addColumn(spansTable, name, definition);
+        }
+      };
+      await addSpanIfMissing('inputTokens', { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 });
+      await addSpanIfMissing('outputTokens', { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 });
+      await addSpanIfMissing('totalTokens', { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 });
+      await addSpanIfMissing('cost', { type: DataTypes.FLOAT, allowNull: false, defaultValue: 0 });
+    }
+
+    // ── agentLoopRuns ──
+    const runsTable = `${prefix}agentLoopRuns`;
+    const runsExists = await queryInterface
+      .describeTable(runsTable)
+      .then(() => true)
+      .catch(() => false);
+    if (runsExists) {
+      const runsCols = await queryInterface.describeTable(runsTable);
+      const addRunIfMissing = async (name: string, definition: any) => {
+        if (!runsCols[name]) {
+          await queryInterface.addColumn(runsTable, name, definition);
+        }
+      };
+      await addRunIfMissing('totalInputTokens', { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 });
+      await addRunIfMissing('totalOutputTokens', { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 });
+      await addRunIfMissing('totalTokens', { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 });
+      await addRunIfMissing('totalCost', { type: DataTypes.FLOAT, allowNull: false, defaultValue: 0 });
+      await addRunIfMissing('budgetMaxTokens', { type: DataTypes.INTEGER, allowNull: true });
+      await addRunIfMissing('budgetMaxCost', { type: DataTypes.FLOAT, allowNull: true });
+    }
+
+    // ── orchestratorConfig ──
+    const configTable = `${prefix}orchestratorConfig`;
+    const configExists = await queryInterface
+      .describeTable(configTable)
+      .then(() => true)
+      .catch(() => false);
+    if (configExists) {
+      const configCols = await queryInterface.describeTable(configTable);
+      const addConfigIfMissing = async (name: string, definition: any) => {
+        if (!configCols[name]) {
+          await queryInterface.addColumn(configTable, name, definition);
+        }
+      };
+      await addConfigIfMissing('budgetMaxTokens', { type: DataTypes.INTEGER, allowNull: true, defaultValue: 0 });
+      await addConfigIfMissing('budgetMaxCost', { type: DataTypes.FLOAT, allowNull: true, defaultValue: 0 });
+    }
+  }
+
+  async down() {
+    const queryInterface = (this as any).db.sequelize.getQueryInterface();
+    const prefix = (this as any).db.options.tablePrefix || '';
+
+    const tables = [
+      { name: `${prefix}agentExecutionSpans`, cols: ['inputTokens', 'outputTokens', 'totalTokens', 'cost'] },
+      {
+        name: `${prefix}agentLoopRuns`,
+        cols: ['totalInputTokens', 'totalOutputTokens', 'totalTokens', 'totalCost', 'budgetMaxTokens', 'budgetMaxCost'],
+      },
+      { name: `${prefix}orchestratorConfig`, cols: ['budgetMaxTokens', 'budgetMaxCost'] },
+    ];
+
+    for (const { name, cols } of tables) {
+      for (const col of cols) {
+        await queryInterface.removeColumn(name, col).catch(() => {});
+      }
+    }
+  }
+}

package/src/server/plugin.ts

@@ -5,6 +5,7 @@ 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 { getRunEventBus } from './services/RunEventBus';
 import SkillHubSubFeature from './skill-hub/plugin';
 import { AgentLoopService } from './services/AgentLoopService';
 
@@ -41,6 +42,7 @@ export class PluginAgentOrchestratorServer extends Plugin {
         'agentLoopRuns:*',
         'agentLoopSteps:*',
         'agentLoopEvents:*',
+        'agentLoopEventsStream:*',
         'agentHarnessProfiles:*',
         'agentExecutionSpans:*',
         'skillDefinitions:*',
@@ -63,6 +65,57 @@ export class PluginAgentOrchestratorServer extends Plugin {
     // --- Register Agent Loop Resource ---
     registerAgentLoopResource(this, this.agentLoopService);
 
+    // --- Register SSE Event Stream Resource (Phase 6) ---
+    (this as any).app.resource({
+      name: 'agentLoopEventsStream',
+      actions: {
+        async stream(ctx, next) {
+          const runId = ctx.action.params?.runId || ctx.query?.runId || ctx.request.query?.runId;
+          if (!runId) {
+            ctx.throw(400, 'runId query parameter is required.');
+            return;
+          }
+
+          ctx.type = 'text/event-stream';
+          ctx.set('Cache-Control', 'no-cache');
+          ctx.set('Connection', 'keep-alive');
+          ctx.set('X-Accel-Buffering', 'no');
+
+          const unsubscribe = getRunEventBus().subscribe(runId, (event: any) => {
+            try {
+              ctx.res.write(`data: ${JSON.stringify(event)}\n\n`);
+            } catch {
+              unsubscribe();
+            }
+          });
+
+          const keepalive = setInterval(() => {
+            try {
+              ctx.res.write(': keepalive\n\n');
+            } catch {
+              clearInterval(keepalive);
+              unsubscribe();
+            }
+          }, 15000);
+
+          ctx.req.on('close', () => {
+            clearInterval(keepalive);
+            unsubscribe();
+          });
+
+          ctx.req.on('error', () => {
+            clearInterval(keepalive);
+            unsubscribe();
+          });
+
+          ctx.res.writeHead(200);
+          ctx.res.write(': connected\n\n');
+
+          await next();
+        },
+      },
+    });
+
     // --- Register Tracing Resource (Phase 5) ---
     // Custom read-only resource for the Swarm Tracing admin page.
     registerTracingResource(this);

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

@@ -1,17 +1,6 @@
 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 || {};
-}
+import { toPlain, currentUserId, valuesFromCtx as values } from '../utils/ctx-utils';
 
 function formatRunRow(raw: any) {
   const row = toPlain(raw);
@@ -178,6 +167,26 @@ export function registerAgentLoopResource(plugin: Plugin, service: AgentLoopServ
         };
         await next();
       },
+
+      async stepFeedback(ctx, next) {
+        const body = values(ctx);
+        if (!body.stepId || !body.rating) {
+          ctx.throw(400, 'stepId and rating are required');
+          return;
+        }
+        if (!['positive', 'negative'].includes(body.rating)) {
+          ctx.throw(400, 'rating must be "positive" or "negative"');
+          return;
+        }
+        ctx.body = {
+          data: await service.stepFeedback(
+            body.stepId,
+            { rating: body.rating, comment: body.comment, category: body.category },
+            { userId: currentUserId(ctx) },
+          ),
+        };
+        await next();
+      },
     },
   });
 }

package/src/server/resources/tracing.ts

@@ -1,8 +1,6 @@
 import { Plugin } from '@nocobase/server';
 
-function toPlain(row: any) {
-  return row?.toJSON?.() || row;
-}
+import { toPlain } from '../utils/ctx-utils';
 
 function normalizeSpanFilter(filter: any = {}) {
   const next = { ...filter };
@@ -68,8 +66,7 @@ function buildSpanTree(rows: any[]) {
   const sortTree = (items: any[]) => {
     items.sort(
       (a, b) =>
-        new Date(a.startedAt || a.createdAt || 0).getTime() -
-        new Date(b.startedAt || b.createdAt || 0).getTime(),
+        new Date(a.startedAt || a.createdAt || 0).getTime() - new Date(b.startedAt || b.createdAt || 0).getTime(),
     );
     for (const item of items) sortTree(item.children || []);
   };
@@ -82,8 +79,7 @@ function flattenSpanTimeline(rows: any[]) {
     .map(toPlain)
     .sort(
       (a, b) =>
-        new Date(a.startedAt || a.createdAt || 0).getTime() -
-        new Date(b.startedAt || b.createdAt || 0).getTime(),
+        new Date(a.startedAt || a.createdAt || 0).getTime() - new Date(b.startedAt || b.createdAt || 0).getTime(),
     )
     .map((row) => {
       const input = row.input || {};