plugin-agent-orchestrator 1.0.13 → 1.0.15

package/dist/server/tools/skill-execute.d.ts

@@ -0,0 +1,36 @@
+export declare function createSkillExecuteTool(plugin: any): {
+    scope: string;
+    execution: string;
+    defaultPermission: string;
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                skillName: {
+                    type: string;
+                    description: string;
+                };
+                input: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    invoke(args: Record<string, any>, options?: any): Promise<{
+        status: string;
+        content: string;
+    }>;
+};

package/dist/server/tools/skill-execute.js

@@ -0,0 +1,167 @@
+/**
+ * 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 skill_execute_exports = {};
+__export(skill_execute_exports, {
+  createSkillExecuteTool: () => createSkillExecuteTool
+});
+module.exports = __toCommonJS(skill_execute_exports);
+var import_json_fields = require("../skill-hub/utils/json-fields");
+function createSkillExecuteTool(plugin) {
+  return {
+    scope: "CUSTOM",
+    execution: "backend",
+    defaultPermission: "ASK",
+    introduction: {
+      title: "Skill Hub - Universal Skill Executor",
+      about: "A universal gateway to execute predefined specialized skills (data processing, complex calculations, file generation, etc.) inside a secure Python/Node.js sandbox."
+    },
+    definition: {
+      name: "skill_hub_execute",
+      description: `A universal gateway to execute various predefined specialized skills (e.g., data transformation, calculations, document/presentation generation) in an isolated sandbox.
+HOW TO USE THIS TOOL:
+1. If you don't know the exact 'skillName' or its required 'input' schema, first call this tool with { "action": "list" } to discover all available skills.
+2. For complex workflow skills, call { "action": "describe", "skillName": "<exact_skill_name>" } to load the full instructions before execution.
+3. To run a skill, call this tool with { "action": "execute", "skillName": "<exact_skill_name>", "input": { <parameters> } }.
+CRITICAL: Do NOT guess or hallucinate the 'input' object. You MUST strictly provide the parameters matching the JSON schema defined for that specific skill.
+The skill's output may contain text results, structured JSON data, or download URLs for generated files.
+IMPORTANT: If the skill returns file download URLs, you MUST format them as clickable Markdown links (e.g., [Download filename.ext](/api/attachments/...)) in your final response to the user.`,
+      schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "describe", "execute"],
+            description: '"list" to see available skills, "describe" to load full instructions, "execute" to run one'
+          },
+          skillName: {
+            type: "string",
+            description: 'Skill name (required for "execute" action)'
+          },
+          input: {
+            type: "object",
+            description: "Input parameters matching the skill inputSchema"
+          }
+        },
+        required: ["action"]
+      }
+    },
+    async invoke(args, options) {
+      var _a;
+      const ctx = options == null ? void 0 : options.context;
+      plugin.app.logger.info(`[skill-execute] Tool invoked with action: ${args.action}, skillName: ${args.skillName}`);
+      if (args.action === "list") {
+        const skills = await plugin.db.getRepository("skillDefinitions").find({
+          filter: { enabled: true },
+          fields: ["name", "title", "description", "language", "inputSchema", "instructions", "storageType"]
+        });
+        const skillList = skills.map((s) => ({
+          name: s.get("name"),
+          title: s.get("title"),
+          description: s.get("description"),
+          language: s.get("language"),
+          inputSchema: (0, import_json_fields.parseJsonText)(s.get("inputSchema"), null),
+          hasInstructions: !!s.get("instructions") || s.get("storageType") === "plugin",
+          storageType: s.get("storageType")
+        }));
+        return {
+          status: "success",
+          content: JSON.stringify({ skills: skillList })
+        };
+      }
+      if (args.action === "describe") {
+        if (!args.skillName) {
+          return { status: "error", content: "Missing skillName parameter" };
+        }
+        const skill = await plugin.db.getRepository("skillDefinitions").findOne({
+          filter: { name: args.skillName, enabled: true }
+        });
+        if (!skill) {
+          return {
+            status: "error",
+            content: `Skill "${args.skillName}" not found or disabled`
+          };
+        }
+        const instructions = typeof plugin.getSkillInstructions === "function" ? await plugin.getSkillInstructions(skill) : skill.get("instructions");
+        return {
+          status: "success",
+          content: JSON.stringify({
+            name: skill.get("name"),
+            title: skill.get("title"),
+            description: skill.get("description"),
+            language: skill.get("language"),
+            inputSchema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), null),
+            packages: (0, import_json_fields.parseJsonText)(skill.get("packages"), []),
+            storageType: skill.get("storageType"),
+            storageUrl: skill.get("storageUrl"),
+            instructions
+          })
+        };
+      }
+      if (args.action === "execute") {
+        if (!args.skillName) {
+          return { status: "error", content: "Missing skillName parameter" };
+        }
+        const skill = await plugin.db.getRepository("skillDefinitions").findOne({
+          filter: { name: args.skillName, enabled: true }
+        });
+        if (!skill) {
+          return {
+            status: "error",
+            content: `Skill "${args.skillName}" not found or disabled`
+          };
+        }
+        try {
+          const result = await plugin.executeSkill(skill, args.input || {}, ctx);
+          return {
+            status: result.status === "succeeded" ? "success" : "error",
+            content: JSON.stringify({
+              message: result.status === "succeeded" ? `Executed successfully. ${((_a = result.files) == null ? void 0 : _a.length) || 0} file(s) generated.` : `Failed: ${result.stderr}`,
+              stdout: result.stdout,
+              stderr: result.stderr,
+              files: result.files,
+              execId: result.execId,
+              durationMs: result.durationMs
+            })
+          };
+        } catch (error) {
+          return {
+            status: "error",
+            content: `Execution error: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+      return {
+        status: "error",
+        content: `Unknown action "${args.action}". Use "list", "describe", or "execute".`
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSkillExecuteTool
+});

package/package.json

@@ -4,7 +4,7 @@
   "displayName.zh-CN": "代理协调器",
   "displayName.vi-VN": "Điều phối Agent",
   "description": "Hierarchical Multi-Agent orchestration for NocoBase AI Employees. Enables Leader agents to delegate tasks to Sub-Agent employees without modifying core plugin-ai.",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "license": "Apache-2.0",
   "main": "dist/server/index.js",
   "keywords": [
@@ -31,6 +31,8 @@
   "dependencies": {
     "@langchain/core": "^0.3.0",
     "@langchain/langgraph": "^0.2.0",
+    "adm-zip": "^0.5.10",
+    "simple-git": "^3.22.0",
     "zod": "^3.23.0"
   },
   "peerDependencies": {

package/src/client/AIEmployeeSelect.tsx

@@ -39,9 +39,7 @@ export const AIEmployeeSelect: React.FC<{
       optionRender={(option) => (
         <div>
           <div style={{ fontWeight: 500 }}>{option.label}</div>
-          {option.data.description && (
-            <div style={{ fontSize: 12, color: '#888' }}>{option.data.description}</div>
-          )}
+          {option.data.description && <div style={{ fontSize: 12, color: '#888' }}>{option.data.description}</div>}
         </div>
       )}
     />

package/src/client/AIEmployeesContext.tsx

@@ -5,51 +5,66 @@ interface AIEmployeeInfo {
   username: string;
   nickname: string;
   about?: string;
+  skills: string[];
 }
 
 interface AIEmployeesContextType {
   employees: AIEmployeeInfo[];
   employeeMap: Map<string, string>;
+  skillsMap: Map<string, Set<string>>;
   loading: boolean;
+  refresh: () => void;
 }
 
 const AIEmployeesContext = createContext<AIEmployeesContextType>({
   employees: [],
   employeeMap: new Map(),
+  skillsMap: new Map(),
   loading: false,
+  refresh: () => {},
 });
 
 /**
  * P3 FIX: Shared context provider that fetches aiEmployees once
  * and shares the data across RulesTab, TracingTab, and AIEmployeeSelect.
+ *
+ * Also exposes each employee's configured skills so RulesTab can warn when
+ * a delegation rule exists but the leader hasn't added the corresponding
+ * delegate_<leader>_to_<sub> tool to its skillSettings.
  */
 export const AIEmployeesProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-  const { data, loading } = useRequest({
+  const { data, loading, refresh } = useRequest({
     url: 'aiEmployees:list',
     params: { pageSize: 200 },
   });
 
   const value = React.useMemo(() => {
     const rawEmployees = (data as any)?.data || [];
-    const employees: AIEmployeeInfo[] = rawEmployees.map((emp: any) => ({
-      username: emp.username,
-      nickname: emp.nickname || emp.username,
-      about: emp.about?.substring(0, 80),
-    }));
+    const employees: AIEmployeeInfo[] = rawEmployees.map((emp: any) => {
+      const skills = Array.isArray(emp.skillSettings?.skills)
+        ? emp.skillSettings.skills
+            .map((s: any) => (typeof s === 'string' ? s : s?.name))
+            .filter((name: any): name is string => typeof name === 'string' && name.length > 0)
+        : [];
+      return {
+        username: emp.username,
+        nickname: emp.nickname || emp.username,
+        about: emp.about?.substring(0, 80),
+        skills,
+      };
+    });
 
     const employeeMap = new Map<string, string>();
+    const skillsMap = new Map<string, Set<string>>();
     for (const emp of employees) {
       employeeMap.set(emp.username, emp.nickname);
+      skillsMap.set(emp.username, new Set(emp.skills));
     }
 
-    return { employees, employeeMap, loading };
-  }, [data, loading]);
+    return { employees, employeeMap, skillsMap, loading, refresh };
+  }, [data, loading, refresh]);
 
-  return (
-    <AIEmployeesContext.Provider value={value}>
-      {children}
-    </AIEmployeesContext.Provider>
-  );
+  return <AIEmployeesContext.Provider value={value}>{children}</AIEmployeesContext.Provider>;
 };
 
 /**

package/src/client/OrchestratorSettings.tsx

@@ -1,30 +1,68 @@
 import React from 'react';
 import { Tabs } from 'antd';
-import { ApartmentOutlined, MonitorOutlined } from '@ant-design/icons';
+import { ApartmentOutlined, BarChartOutlined, CodeOutlined, HistoryOutlined, MonitorOutlined } from '@ant-design/icons';
 import { RulesTab } from './RulesTab';
 import { TracingTab } from './TracingTab';
 import { AIEmployeesProvider } from './AIEmployeesContext';
+import { SkillManager, ExecutionHistory, SkillMetrics } from './skill-hub';
 
-export const OrchestratorSettings: React.FC = () => {
+const OrchestratorSettings: React.FC = () => {
   return (
     <AIEmployeesProvider>
       <div style={{ padding: '0 24px 24px' }}>
-        <Tabs 
+        <Tabs
           defaultActiveKey="rules"
           items={[
             {
               key: 'rules',
-              label: <span><ApartmentOutlined /> Orchestration Rules</span>,
+              label: (
+                <span>
+                  <ApartmentOutlined /> Orchestration Rules
+                </span>
+              ),
               children: <RulesTab />,
             },
             {
               key: 'tracing',
-              label: <span><MonitorOutlined /> Swarm Tracing</span>,
+              label: (
+                <span>
+                  <MonitorOutlined /> Execution Tracing
+                </span>
+              ),
               children: <TracingTab />,
             },
+            {
+              key: 'skill-definitions',
+              label: (
+                <span>
+                  <CodeOutlined /> Skill Hub Definitions
+                </span>
+              ),
+              children: <SkillManager />,
+            },
+            {
+              key: 'skill-executions',
+              label: (
+                <span>
+                  <HistoryOutlined /> Execution History
+                </span>
+              ),
+              children: <ExecutionHistory />,
+            },
+            {
+              key: 'skill-metrics',
+              label: (
+                <span>
+                  <BarChartOutlined /> Metrics
+                </span>
+              ),
+              children: <SkillMetrics />,
+            },
           ]}
         />
       </div>
     </AIEmployeesProvider>
   );
 };
+
+export { OrchestratorSettings };