plugin-agent-orchestrator 1.0.6 → 1.0.14

package/dist/server/migrations/20260429000000-add-llm-fields.js

@@ -0,0 +1,68 @@
+/**
+ * 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 add_llm_fields_exports = {};
+__export(add_llm_fields_exports, {
+  default: () => AddLlmFieldsToOrchestratorConfig
+});
+module.exports = __toCommonJS(add_llm_fields_exports);
+var import_server = require("@nocobase/server");
+class AddLlmFieldsToOrchestratorConfig extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.db.options.tablePrefix || "";
+    const tableName = `${tablePrefix}orchestratorConfig`;
+    const tableExists = await queryInterface.tableExists(tableName);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc["llmService"]) {
+      await queryInterface.addColumn(tableName, "llmService", {
+        type: "VARCHAR(255)",
+        allowNull: true
+      });
+      console.log(`[AgentOrchestrator] Added llmService column to ${tableName}`);
+    }
+    if (!tableDesc["model"]) {
+      await queryInterface.addColumn(tableName, "model", {
+        type: "VARCHAR(255)",
+        allowNull: true
+      });
+      console.log(`[AgentOrchestrator] Added model column to ${tableName}`);
+    }
+    if (!tableDesc["recursionLimit"]) {
+      await queryInterface.addColumn(tableName, "recursionLimit", {
+        type: "INTEGER",
+        allowNull: true,
+        defaultValue: 50
+      });
+      console.log(`[AgentOrchestrator] Added recursionLimit column to ${tableName}`);
+    }
+  }
+  async down() {
+  }
+}

package/dist/server/migrations/20260429000000-fix-inputargs-json-to-text.d.ts

@@ -0,0 +1,16 @@
+import { Migration } from '@nocobase/server';
+/**
+ * Fix: inputArgs column in skillExecutions was json type but should be text.
+ *
+ * Root cause: The column was created as `json` from an older schema version,
+ * but the collection defines it as `text`. The `stringifyJsonText()` utility
+ * wraps values in markdown code fences (```json\n...\n```) which PostgreSQL
+ * rejects as invalid JSON syntax, causing SequelizeDatabaseError on every
+ * skill execution attempt.
+ */
+export default class FixInputArgsJsonToText extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/dist/server/migrations/20260429000000-fix-inputargs-json-to-text.js

@@ -0,0 +1,51 @@
+/**
+ * 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 fix_inputargs_json_to_text_exports = {};
+__export(fix_inputargs_json_to_text_exports, {
+  default: () => FixInputArgsJsonToText
+});
+module.exports = __toCommonJS(fix_inputargs_json_to_text_exports);
+var import_server = require("@nocobase/server");
+class FixInputArgsJsonToText extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tableDesc = await queryInterface.describeTable("skillExecutions").catch(() => null);
+    if (!tableDesc) return;
+    const col = tableDesc["inputArgs"];
+    if (!col) return;
+    if (col.type && col.type.toLowerCase().includes("json")) {
+      await this.db.sequelize.query(
+        `ALTER TABLE "skillExecutions" ALTER COLUMN "inputArgs" TYPE text USING "inputArgs"::text`
+      );
+      console.log("[skill-hub] Migration: converted skillExecutions.inputArgs from json to text");
+    }
+  }
+  async down() {
+  }
+}

package/dist/server/migrations/20260503000000-add-orchestrator-trace-fields.d.ts

@@ -0,0 +1,7 @@
+import { Migration } from '@nocobase/server';
+export default class AddOrchestratorTraceFieldsToSkillExecutions extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/dist/server/migrations/20260503000000-add-orchestrator-trace-fields.js

@@ -0,0 +1,57 @@
+/**
+ * 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 add_orchestrator_trace_fields_exports = {};
+__export(add_orchestrator_trace_fields_exports, {
+  default: () => AddOrchestratorTraceFieldsToSkillExecutions
+});
+module.exports = __toCommonJS(add_orchestrator_trace_fields_exports);
+var import_server = require("@nocobase/server");
+class AddOrchestratorTraceFieldsToSkillExecutions extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.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) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, {
+        type: "VARCHAR(100)",
+        allowNull: true
+      });
+    };
+    await addIfMissing("orchestratorRootRunId");
+    await addIfMissing("orchestratorSpanId");
+    await addIfMissing("orchestratorParentSpanId");
+    await addIfMissing("orchestratorToolCallId");
+  }
+  async down() {
+  }
+}

package/dist/server/plugin.d.ts

@@ -1,5 +1,7 @@
 import { Plugin } from '@nocobase/server';
+import SkillHubSubFeature from './skill-hub/plugin';
 export declare class PluginAgentOrchestratorServer extends Plugin {
+    skillHub: SkillHubSubFeature;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;
@@ -7,5 +9,6 @@ export declare class PluginAgentOrchestratorServer extends Plugin {
     afterEnable(): Promise<void>;
     afterDisable(): Promise<void>;
     remove(): Promise<void>;
+    beforeStop(): Promise<void>;
 }
 export default PluginAgentOrchestratorServer;

package/dist/server/plugin.js

@@ -44,22 +44,55 @@ var import_server = require("@nocobase/server");
 var import_path = __toESM(require("path"));
 var import_delegate_task = require("./tools/delegate-task");
 var import_tracing = require("./resources/tracing");
+var import_plugin = __toESM(require("./skill-hub/plugin"));
 class PluginAgentOrchestratorServer extends import_server.Plugin {
+  skillHub;
   async afterAdd() {
+    this.skillHub = new import_plugin.default(this);
   }
   async beforeLoad() {
     this.db.import({ directory: import_path.default.resolve(__dirname, "collections") });
+    this.db.addMigrations({
+      namespace: this.name,
+      directory: import_path.default.resolve(__dirname, "migrations"),
+      context: { plugin: this }
+    });
   }
   async load() {
+    await this.skillHub.load();
     this.app.acl.registerSnippet({
       name: `pm.${this.name}`,
-      actions: ["orchestratorConfig:*"]
+      actions: ["orchestratorConfig:*", "orchestratorTracing:*", "agentExecutionSpans:*", "skillDefinitions:*", "skillExecutions:*", "skillHub:*", "skillWorkerConfigs:*"]
     });
     const toolsManager = this.app.aiManager.toolsManager;
     toolsManager.registerDynamicTools((0, import_delegate_task.createDelegateToolsProvider)(this));
     (0, import_tracing.registerTracingResource)(this);
+    this.app.cronJobManager.addJob({
+      cronTime: "0 30 2 * * *",
+      onTick: async () => {
+        try {
+          const days = Number(process.env.ORCHESTRATOR_LOG_RETENTION_DAYS || 30);
+          if (!Number.isFinite(days) || days <= 0) return;
+          const cutoff = new Date(Date.now() - days * 864e5);
+          const repo = this.db.getRepository("orchestratorLogs");
+          const spansRepo = this.db.getRepository("agentExecutionSpans");
+          const deletedLogs = repo ? await repo.destroy({
+            filter: { createdAt: { $lt: cutoff.toISOString() } }
+          }) : 0;
+          const deletedSpans = spansRepo ? await spansRepo.destroy({
+            filter: { createdAt: { $lt: cutoff.toISOString() } }
+          }) : 0;
+          this.app.log.info(
+            `[AgentOrchestrator] Pruned ${deletedLogs} orchestratorLogs and ${deletedSpans} agentExecutionSpans rows older than ${days} day(s).`
+          );
+        } catch (e) {
+          this.app.log.error("[AgentOrchestrator] Log retention job failed", e);
+        }
+      }
+    });
   }
   async install() {
+    await this.skillHub.install();
   }
   async afterEnable() {
   }
@@ -67,6 +100,9 @@ class PluginAgentOrchestratorServer extends import_server.Plugin {
   }
   async remove() {
   }
+  async beforeStop() {
+    await this.skillHub.beforeStop();
+  }
 }
 var plugin_default = PluginAgentOrchestratorServer;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/resources/tracing.js

@@ -29,6 +29,94 @@ __export(tracing_exports, {
   registerTracingResource: () => registerTracingResource
 });
 module.exports = __toCommonJS(tracing_exports);
+function toPlain(row) {
+  var _a;
+  return ((_a = row == null ? void 0 : row.toJSON) == null ? void 0 : _a.call(row)) || row;
+}
+function normalizeSpanFilter(filter = {}) {
+  const next = { ...filter };
+  if (next.subAgentUsername) {
+    next.employeeUsername = next.subAgentUsername;
+    delete next.subAgentUsername;
+  }
+  return next;
+}
+function spanTitle(row) {
+  if (row.title) return row.title;
+  if (row.type === "sub_agent") return `${row.leaderUsername || "-"} -> ${row.employeeUsername || "-"}`;
+  return row.toolName || row.type || "span";
+}
+function formatSpanListRow(raw) {
+  const row = toPlain(raw);
+  const metadata = row.metadata || {};
+  const input = row.input || {};
+  return {
+    id: row.id,
+    rootRunId: row.rootRunId,
+    parentSpanId: row.parentSpanId,
+    type: row.type,
+    leaderUsername: row.leaderUsername,
+    subAgentUsername: row.employeeUsername,
+    employeeUsername: row.employeeUsername,
+    toolName: row.toolName,
+    task: input.task || metadata.task || row.title || "",
+    context: input.context || "",
+    result: row.output,
+    status: row.status,
+    depth: metadata.depth ?? 0,
+    durationMs: row.durationMs,
+    error: row.error,
+    userId: row.userId,
+    createdAt: row.createdAt || row.startedAt,
+    traceCount: metadata.traceCount || 0,
+    messageCount: Array.isArray(metadata.messages) ? metadata.messages.length : metadata.messageCount || 0,
+    hasUnifiedTrace: true
+  };
+}
+function buildSpanTree(rows) {
+  const plainRows = rows.map(toPlain);
+  const byId = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const row of plainRows) {
+    const node = { ...row, children: [] };
+    byId.set(String(row.id), node);
+  }
+  for (const row of byId.values()) {
+    if (row.parentSpanId && byId.has(String(row.parentSpanId))) {
+      byId.get(String(row.parentSpanId)).children.push(row);
+    } else {
+      roots.push(row);
+    }
+  }
+  const sortTree = (items) => {
+    items.sort(
+      (a, b) => new Date(a.startedAt || a.createdAt || 0).getTime() - new Date(b.startedAt || b.createdAt || 0).getTime()
+    );
+    for (const item of items) sortTree(item.children || []);
+  };
+  sortTree(roots);
+  return roots;
+}
+function flattenSpanTimeline(rows) {
+  return rows.map(toPlain).sort(
+    (a, b) => new Date(a.startedAt || a.createdAt || 0).getTime() - new Date(b.startedAt || b.createdAt || 0).getTime()
+  ).map((row) => {
+    const input = row.input || {};
+    const metadata = row.metadata || {};
+    return {
+      type: row.type,
+      at: row.startedAt || row.createdAt,
+      title: spanTitle(row),
+      toolName: row.toolName,
+      args: row.type === "tool" || row.type === "skill" ? input : void 0,
+      status: row.status,
+      content: row.output || row.error || input.task || metadata.summary || "",
+      spanId: row.id,
+      parentSpanId: row.parentSpanId,
+      skillExecutionId: row.skillExecutionId
+    };
+  });
+}
 function registerTracingResource(plugin) {
   const app = plugin.app;
   app.resource({
@@ -38,10 +126,38 @@ function registerTracingResource(plugin) {
        * List all delegation execution logs.
        */
       async list(ctx, next) {
-        const repo = ctx.db.getRepository("orchestratorLogs");
-        const { page = 1, pageSize = 50, sort = ["-createdAt"] } = ctx.action.params;
+        const { page = 1, pageSize = 50, sort = ["-createdAt"], filter = {} } = ctx.action.params;
         try {
+          const spanRepo = ctx.db.getRepository("agentExecutionSpans");
+          if (spanRepo) {
+            const spanFilter = {
+              ...normalizeSpanFilter(filter),
+              parentSpanId: null,
+              type: "sub_agent"
+            };
+            const [spanRows, spanCount] = await spanRepo.findAndCount({
+              filter: spanFilter,
+              sort,
+              offset: (Number(page) - 1) * Number(pageSize),
+              limit: Number(pageSize)
+            });
+            if (spanCount > 0) {
+              ctx.body = {
+                data: spanRows.map(formatSpanListRow),
+                meta: {
+                  count: spanCount,
+                  page: Number(page),
+                  pageSize: Number(pageSize),
+                  totalPage: Math.ceil(spanCount / Number(pageSize))
+                }
+              };
+              await next();
+              return;
+            }
+          }
+          const repo = ctx.db.getRepository("orchestratorLogs");
           const [rows, count] = await repo.findAndCount({
+            filter,
             sort,
             offset: (Number(page) - 1) * Number(pageSize),
             limit: Number(pageSize)
@@ -53,13 +169,17 @@ function registerTracingResource(plugin) {
               subAgentUsername: row.subAgentUsername,
               toolName: row.toolName,
               task: row.task,
+              context: row.context,
               result: row.result,
               status: row.status,
               depth: row.depth,
               durationMs: row.durationMs,
               error: row.error,
               userId: row.userId,
-              createdAt: row.createdAt
+              createdAt: row.createdAt,
+              traceCount: Array.isArray(row.trace) ? row.trace.length : 0,
+              messageCount: Array.isArray(row.messages) ? row.messages.length : 0,
+              hasUnifiedTrace: false
             })),
             meta: {
               count,
@@ -70,7 +190,7 @@ function registerTracingResource(plugin) {
           };
         } catch (e) {
           ctx.log.error("[AgentOrchestrator] Tracing list error", e);
-          ctx.body = { data: [], meta: { count: 0 } };
+          ctx.throw(500, (e == null ? void 0 : e.message) || "Failed to load tracing logs");
         }
         await next();
       },
@@ -78,29 +198,57 @@ function registerTracingResource(plugin) {
        * Get a single delegation log by ID.
        */
       async get(ctx, next) {
-        const { filterByTk } = ctx.action.params;
+        var _a;
+        const { filterByTk, source } = ctx.action.params;
         if (!filterByTk) {
           ctx.throw(400, "id is required");
           return;
         }
         try {
+          const spanRepo = ctx.db.getRepository("agentExecutionSpans");
+          if (spanRepo && source !== "log") {
+            const span = await spanRepo.findOne({
+              filter: { id: filterByTk }
+            });
+            if (span) {
+              const plainSpan = toPlain(span);
+              const rows = await spanRepo.find({
+                filter: { rootRunId: plainSpan.rootRunId },
+                sort: ["createdAt"]
+              });
+              const tree = buildSpanTree(rows);
+              const timeline = flattenSpanTimeline(rows);
+              const rootRow = formatSpanListRow(plainSpan);
+              const metadata = plainSpan.metadata || {};
+              ctx.body = {
+                data: {
+                  ...rootRow,
+                  input: plainSpan.input,
+                  output: plainSpan.output,
+                  metadata,
+                  trace: timeline,
+                  messages: metadata.messages || [],
+                  children: tree
+                }
+              };
+              await next();
+              return;
+            }
+          }
           const repo = ctx.db.getRepository("orchestratorLogs");
-          const log = await repo.findOne({
+          const log = source === "span" ? null : await repo.findOne({
             filter: { id: filterByTk }
           });
-          ctx.body = { data: log };
+          const plainLog = ((_a = log == null ? void 0 : log.toJSON) == null ? void 0 : _a.call(log)) || log;
+          ctx.body = { data: plainLog ? { ...plainLog, hasUnifiedTrace: false } : null };
         } catch (e) {
           ctx.log.error("[AgentOrchestrator] Tracing get error", e);
-          ctx.body = { data: null };
+          ctx.throw(500, (e == null ? void 0 : e.message) || "Failed to load tracing log");
         }
         await next();
       }
     }
   });
-  app.acl.registerSnippet({
-    name: `pm.${plugin.name}.tracing`,
-    actions: ["orchestratorTracing:list", "orchestratorTracing:get"]
-  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -0,0 +1,32 @@
+export declare class CodeValidator {
+    /**
+     * Check code against forbidden patterns (dangerous modules/functions).
+     * @throws CodeValidationError if a forbidden pattern is found.
+     */
+    validate(code: string, language: 'node' | 'python'): void;
+    /**
+     * Validate that code only imports packages in the whitelist.
+     * Called after the basic forbidden pattern check.
+     * Skips validation if whitelist is empty (env not initialized yet).
+     *
+     * @param code - The code to validate
+     * @param language - 'node' or 'python'
+     * @param whitelist - Array of allowed package names (from skillWorkerConfigs.packageWhitelist)
+     */
+    validateImports(code: string, language: 'node' | 'python', whitelist: string[]): void;
+    /**
+     * Check Node.js require() calls against the whitelist.
+     * Built-in modules (fs, path, etc.) are always allowed.
+     */
+    private validateNodeImports;
+    /**
+     * Check Python import/from statements against the whitelist.
+     * Built-in modules (os, sys, json, etc.) are always allowed.
+     * Handles PyPI→import name mapping (e.g., python-docx → docx, Pillow → PIL).
+     */
+    private validatePythonImports;
+}
+export declare class CodeValidationError extends Error {
+    matchedPattern: string;
+    constructor(message: string, matchedPattern: string);
+}