plugin-agent-orchestrator 1.0.17 → 1.0.18

package/dist/server/plugin.js

@@ -44,12 +44,17 @@ var import_server = require("@nocobase/server");
 var import_path = __toESM(require("path"));
 var import_delegate_task = require("./tools/delegate-task");
 var import_external_rag_search = require("./tools/external-rag-search");
+var import_orchestrator_plan = require("./tools/orchestrator-plan");
 var import_tracing = require("./resources/tracing");
+var import_agent_loop = require("./resources/agent-loop");
 var import_plugin = __toESM(require("./skill-hub/plugin"));
+var import_AgentLoopService = require("./services/AgentLoopService");
 class PluginAgentOrchestratorServer extends import_server.Plugin {
   skillHub;
+  agentLoopService;
   async afterAdd() {
     this.skillHub = new import_plugin.default(this);
+    this.agentLoopService = new import_AgentLoopService.AgentLoopService(this);
   }
   async beforeLoad() {
     this.db.import({ directory: import_path.default.resolve(__dirname, "collections") });
@@ -66,16 +71,24 @@ class PluginAgentOrchestratorServer extends import_server.Plugin {
       actions: [
         "orchestratorConfig:*",
         "orchestratorTracing:*",
+        "agentLoops:*",
+        "agentLoopRuns:*",
+        "agentLoopSteps:*",
+        "agentLoopEvents:*",
+        "agentHarnessProfiles:*",
         "agentExecutionSpans:*",
         "skillDefinitions:*",
         "skillExecutions:*",
+        "skillLoopConfigs:*",
         "skillHub:*",
         "skillWorkerConfigs:*"
       ]
     });
     const toolsManager = this.app.aiManager.toolsManager;
+    toolsManager.registerTools((0, import_orchestrator_plan.createOrchestratorPlanTools)(this, this.agentLoopService));
     toolsManager.registerTools((0, import_external_rag_search.createExternalRagSearchTool)(this));
     toolsManager.registerDynamicTools((0, import_delegate_task.createDelegateToolsProvider)(this));
+    (0, import_agent_loop.registerAgentLoopResource)(this, this.agentLoopService);
     (0, import_tracing.registerTracingResource)(this);
     this.app.cronJobManager.addJob({
       cronTime: "0 30 2 * * *",

package/dist/server/resources/agent-loop.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@nocobase/server';
+import { AgentLoopService } from '../services/AgentLoopService';
+export declare function registerAgentLoopResource(plugin: Plugin, service: AgentLoopService): void;

package/dist/server/resources/agent-loop.js

@@ -0,0 +1,205 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_loop_exports = {};
+__export(agent_loop_exports, {
+  registerAgentLoopResource: () => registerAgentLoopResource
+});
+module.exports = __toCommonJS(agent_loop_exports);
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+function currentUserId(ctx) {
+  var _a, _b, _c, _d;
+  return ((_b = (_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentUser) == null ? void 0 : _b.id) || ((_d = (_c = ctx == null ? void 0 : ctx.auth) == null ? void 0 : _c.user) == null ? void 0 : _d.id);
+}
+function values(ctx) {
+  var _a, _b, _c;
+  return ((_a = ctx.request) == null ? void 0 : _a.body) || ((_c = (_b = ctx.action) == null ? void 0 : _b.params) == null ? void 0 : _c.values) || {};
+}
+function formatRunRow(raw) {
+  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
+  };
+}
+function registerAgentLoopResource(plugin, service) {
+  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();
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerAgentLoopResource
+});

package/dist/server/resources/tracing.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '@nocobase/server';
+/**
+ * Custom resource for the Swarm Tracing admin UI (Phase 5).
+ * Queries the dedicated orchestratorLogs collection instead of
+ * filtering aiConversations by JSONB (P2 fix: DB-engine agnostic).
+ */
+export declare function registerTracingResource(plugin: Plugin): void;

package/dist/server/services/AgentHarness.d.ts

@@ -0,0 +1,42 @@
+import { AgentRegistryService } from './AgentRegistryService';
+export declare class AgentHarness {
+    private readonly plugin;
+    private readonly registryService;
+    private readonly spanService;
+    constructor(plugin: any, registryService: AgentRegistryService);
+    get db(): any;
+    get app(): any;
+    executeStep(run: any, step: any, options?: {
+        userId?: string | number;
+        ctx?: any;
+    }): Promise<any>;
+    private invokeSubAgentStep;
+    private invokeNamedTool;
+    runSubAgent(ctx: any, options: {
+        leaderUsername: string;
+        subAgentUsername: string;
+        subAgentEmployee: any;
+        task: string;
+        context?: string;
+        currentDepth?: number;
+        currentPath?: string[];
+        maxDepth: number;
+        timeout: number;
+        toolCallId: string;
+        toolName: string;
+        llmService?: string;
+        model?: string;
+        recursionLimit?: number;
+        rootRunId?: string;
+        parentSpanId?: string;
+        agentLoopRunId?: string;
+        agentLoopStepId?: string;
+    }): Promise<{
+        status: "success";
+        content: string;
+    } | {
+        status: "error";
+        content: any;
+    }>;
+    private logDelegation;
+}