plugin-agent-orchestrator 1.0.0 → 1.0.5

package/dist/server/tools/delegate-task.js

@@ -1,317 +1,269 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDelegateToolsProvider = void 0;
-const zod_1 = require("zod");
-// @ts-ignore - subpath export types resolve at build time via NocoBase bundler
-const prebuilt_1 = require("@langchain/langgraph/prebuilt");
-const tools_1 = require("@langchain/core/tools");
-const messages_1 = require("@langchain/core/messages");
 /**
- * Maximum delegation depth key stored in ctx metadata.
- * Used to prevent circular/recursive delegation chains.
- */
-const ORCHESTRATOR_DEPTH_KEY = '__orchestratorDepth';
-/**
- * Creates one dynamic tool per configured sub-agent for a given leader.
- * Uses Strategy B (Per-SubAgent Tool): each sub-agent becomes a separate tool
- * with its own name and description, making LLM tool selection natural.
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
  *
- * Architecture:
- * - Uses createReactAgent (public LangGraph API) for agent execution
- * - Uses plugin-ai's getLLMService() for LLM model resolution
- * - Uses core app.aiManager.toolsManager.listTools() for tool resolution
- *   (same manager that AIEmployee uses — see ai-employee.ts:1286)
- * - Depth enforcement via ctx metadata tracking
- * - Per-leader scoping via invoke-time check (core ToolsOptions has no
- *   leaderUsername field, so scoping is enforced in the invoke callback)
+ * 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 delegate_task_exports = {};
+__export(delegate_task_exports, {
+  createDelegateToolsProvider: () => createDelegateToolsProvider
+});
+module.exports = __toCommonJS(delegate_task_exports);
+var import_zod = require("zod");
+var import_prebuilt = require("@langchain/langgraph/prebuilt");
+var import_tools = require("@langchain/core/tools");
+var import_messages = require("@langchain/core/messages");
+const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
 function createDelegateToolsProvider(plugin) {
-    return async (register) => {
-        try {
-            const configRepo = plugin.db.getRepository('orchestratorConfig');
-            if (!configRepo)
-                return;
-            const configs = await configRepo.find({
-                filter: { enabled: true },
-            });
-            if (!configs?.length)
-                return;
-            // Build a lookup: which leaders are allowed to use each delegate tool
-            // Multiple leaders may share the same sub-agent, but each leader must
-            // have an explicit rule.
-            const leadersByTool = new Map();
-            for (const config of configs) {
-                const toolName = `delegate_to_${config.subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
-                if (!leadersByTool.has(toolName)) {
-                    leadersByTool.set(toolName, new Set());
-                }
-                leadersByTool.get(toolName).add(config.leaderUsername);
-            }
-            // De-duplicate: register one tool per sub-agent (not per config row)
-            const seenSubAgents = new Set();
-            for (const config of configs) {
-                const { leaderUsername, subAgentUsername, maxDepth, timeout } = config;
-                // Skip if we already registered this sub-agent's tool
-                if (seenSubAgents.has(subAgentUsername))
-                    continue;
-                seenSubAgents.add(subAgentUsername);
-                // Fetch the sub-agent employee model for its description and LLM config
-                const subAgentEmployee = await plugin.db.getRepository('aiEmployees').findOne({
-                    filter: { username: subAgentUsername },
-                });
-                if (!subAgentEmployee)
-                    continue;
-                const toolName = `delegate_to_${subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
-                const toolDescription = [
-                    `Delegate a task to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
-                    subAgentEmployee.about ? `Specialist profile: ${subAgentEmployee.about.substring(0, 200)}` : '',
-                    'The sub-agent will execute the task independently and return its final answer.',
-                ].filter(Boolean).join(' ');
-                // Capture the allowed leaders for this tool (for invoke-time scoping)
-                const allowedLeaders = leadersByTool.get(toolName);
-                register.registerTools({
-                    scope: 'CUSTOM',
-                    execution: 'backend',
-                    defaultPermission: 'ALLOW',
-                    silence: false,
-                    introduction: {
-                        title: `[Sub-Agent] ${subAgentEmployee.nickname || subAgentUsername}`,
-                        about: toolDescription,
-                    },
-                    definition: {
-                        name: toolName,
-                        description: toolDescription,
-                        schema: zod_1.z.object({
-                            task: zod_1.z.string().describe('The detailed task description for the sub-agent to execute.'),
-                            context: zod_1.z.string().optional().describe('Optional additional context to help the sub-agent understand the task better.'),
-                        }),
-                    },
-                    invoke: async (ctx, args, id) => {
-                        // --- P2 FIX: Per-leader scoping at invoke time ---
-                        // Core ToolsOptions doesn't support leaderUsername field, so
-                        // we enforce scoping here by checking the calling employee.
-                        const callingEmployee = ctx._currentAIEmployee?.username
-                            || ctx.state?.currentAIEmployee;
-                        if (callingEmployee && !allowedLeaders.has(callingEmployee)) {
-                            return {
-                                status: 'error',
-                                content: `Employee "${callingEmployee}" is not authorized to delegate to "${subAgentUsername}". Configure an orchestration rule first.`,
-                            };
-                        }
-                        return invokeDelegateTask(ctx, plugin, {
-                            leaderUsername: callingEmployee || Array.from(allowedLeaders)[0] || '',
-                            subAgentUsername,
-                            subAgentEmployee,
-                            task: args.task,
-                            context: args.context,
-                            maxDepth: maxDepth ?? 1,
-                            timeout: timeout ?? 120000,
-                            toolCallId: id,
-                        });
-                    },
-                });
-            }
-        }
-        catch (e) {
-            plugin.app.log.error('[AgentOrchestrator] Failed to register delegate tools', e);
-        }
-    };
-}
-exports.createDelegateToolsProvider = createDelegateToolsProvider;
-/**
- * Core execution logic using createReactAgent (public LangGraph API).
- *
- * This approach mirrors plugin-sub-agent's proven pattern:
- *  1. Get LLM model via aiPlugin.aiManager.getLLMService()
- *  2. Resolve sub-agent's tools via core app.aiManager.toolsManager.listTools()
- *  3. Build a standalone createReactAgent with the model + tools
- *  4. Stream results and extract final AI message
- *
- * Tool resolution uses the CORE toolsManager (app.aiManager.toolsManager) —
- * the same manager that AIEmployee.getToolsMap() uses (see ai-employee.ts:1286).
- * This ensures tool names in skillSettings.skills[].name match correctly.
- *
- * skillSettings.skills shape (verified against ai-employee.ts:1028):
- *   { name: string, autoCall: boolean }[]
- */
-async function invokeDelegateTask(ctx, plugin, options) {
-    const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId } = options;
-    // --- P1: Depth enforcement ---
-    const currentDepth = ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0;
-    if (currentDepth >= maxDepth) {
-        return {
-            status: 'error',
-            content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`,
-        };
-    }
-    const startTime = Date.now();
+  return async (register) => {
     try {
-        const aiPlugin = ctx.app.pm.get('ai');
-        if (!aiPlugin) {
-            throw new Error('Plugin AI is not installed or enabled');
-        }
-        // --- Step 1: Resolve LLM model from sub-agent's employee config ---
-        const modelSettings = subAgentEmployee.modelSettings;
-        if (!modelSettings?.llmService || !modelSettings?.model) {
-            throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured. Please configure a model in the AI Employee settings.`);
+      const configRepo = plugin.db.getRepository("orchestratorConfig");
+      if (!configRepo) return;
+      const configs = await configRepo.find({
+        filter: { enabled: true }
+      });
+      if (!(configs == null ? void 0 : configs.length)) return;
+      const leadersByTool = /* @__PURE__ */ new Map();
+      for (const config of configs) {
+        const toolName = `delegate_to_${config.subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+        if (!leadersByTool.has(toolName)) {
+          leadersByTool.set(toolName, /* @__PURE__ */ new Set());
         }
-        const { provider } = await aiPlugin.aiManager.getLLMService({
-            llmService: modelSettings.llmService,
-            model: modelSettings.model,
+        leadersByTool.get(toolName).add(config.leaderUsername);
+      }
+      const seenSubAgents = /* @__PURE__ */ new Set();
+      for (const config of configs) {
+        const { leaderUsername, subAgentUsername, maxDepth, timeout } = config;
+        if (seenSubAgents.has(subAgentUsername)) continue;
+        seenSubAgents.add(subAgentUsername);
+        const subAgentEmployee = await plugin.db.getRepository("aiEmployees").findOne({
+          filter: { username: subAgentUsername }
         });
-        const chatModel = provider.createModel();
-        // --- Step 2: Resolve tools via CORE toolsManager ---
-        // Uses app.aiManager.toolsManager (same as AIEmployee.getToolsMap at ai-employee.ts:1286)
-        // NOT plugin-ai's local toolManager (which has a different grouped format).
-        const coreToolsManager = ctx.app.aiManager.toolsManager;
-        const allTools = await coreToolsManager.listTools();
-        // skillSettings.skills is { name: string, autoCall: boolean }[]
-        // (verified at ai-employee.ts:1028-1029)
-        const employeeSkills = (subAgentEmployee.skillSettings?.skills ?? [])
-            .map((s) => (typeof s === 'string' ? s : s.name))
-            .filter(Boolean);
-        const langchainTools = [];
-        for (const toolEntry of allTools) {
-            const toolName = toolEntry.definition.name;
-            if (!toolName)
-                continue;
-            // Only include tools that the sub-agent employee is configured to use.
-            // Also skip our own delegate_to_* tools to prevent circular delegation
-            // (belt-and-suspenders with the depth check above).
-            if (!employeeSkills.includes(toolName) || toolName.startsWith('delegate_to_')) {
-                continue;
+        if (!subAgentEmployee) continue;
+        const toolName = `delegate_to_${subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+        const toolDescription = [
+          `Delegate a task to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
+          subAgentEmployee.about ? `Specialist profile: ${subAgentEmployee.about.substring(0, 200)}` : "",
+          "The sub-agent will execute the task independently and return its final answer."
+        ].filter(Boolean).join(" ");
+        const allowedLeaders = leadersByTool.get(toolName);
+        register.registerTools({
+          scope: "CUSTOM",
+          execution: "backend",
+          defaultPermission: "ALLOW",
+          silence: false,
+          introduction: {
+            title: `[Sub-Agent] ${subAgentEmployee.nickname || subAgentUsername}`,
+            about: toolDescription
+          },
+          definition: {
+            name: toolName,
+            description: toolDescription,
+            schema: import_zod.z.object({
+              task: import_zod.z.string().describe("The detailed task description for the sub-agent to execute."),
+              context: import_zod.z.string().optional().describe("Optional additional context to help the sub-agent understand the task better.")
+            })
+          },
+          invoke: async (ctx, args, id) => {
+            var _a, _b;
+            const callingEmployee = ((_a = ctx._currentAIEmployee) == null ? void 0 : _a.username) || ((_b = ctx.state) == null ? void 0 : _b.currentAIEmployee);
+            if (callingEmployee && !allowedLeaders.has(callingEmployee)) {
+              return {
+                status: "error",
+                content: `Employee "${callingEmployee}" is not authorized to delegate to "${subAgentUsername}". Configure an orchestration rule first.`
+              };
             }
-            langchainTools.push(new tools_1.DynamicStructuredTool({
-                name: toolName.replace(/[^a-zA-Z0-9_-]/g, '_'),
-                description: toolEntry.definition.description || toolName,
-                schema: (toolEntry.definition.schema || zod_1.z.object({})),
-                func: async (toolArgs) => {
-                    // Forward the invoke with depth tracking
-                    const invokeCtx = Object.create(ctx);
-                    invokeCtx[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
-                    const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
-                    if (res?.status === 'error') {
-                        throw new Error(`Tool <${toolName}> failed: ${res.content}`);
-                    }
-                    return typeof res?.content === 'string' ? res.content : JSON.stringify(res);
-                },
-            }));
-        }
-        // --- Step 3: Build the agent ---
-        const abortController = new AbortController();
-        const executor = (0, prebuilt_1.createReactAgent)({
-            llm: chatModel,
-            tools: langchainTools,
-        });
-        // --- Step 4: Construct messages ---
-        const systemPrompt = subAgentEmployee.chatSettings?.systemPrompt
-            || subAgentEmployee.bio
-            || `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${subAgentEmployee.about || ''}`;
-        const combinedTask = context
-            ? `Task: ${task}\n\nContext Provided:\n${context}`
-            : `Task: ${task}`;
-        // --- Step 5: Execute with timeout + abort ---
-        // P3 FIX: AbortController signal cancels the in-flight stream on timeout,
-        // preventing continued token consumption after the timeout fires.
-        const invokePromise = executeAgent(executor, systemPrompt, combinedTask, abortController.signal);
-        const result = await Promise.race([
-            invokePromise,
-            createTimeout(timeout, subAgentUsername, abortController),
-        ]);
-        const content = result || 'Sub-agent completed the task but produced no output.';
-        // Log successful execution for tracing
-        await logDelegation(ctx, plugin, {
-            leaderUsername,
-            subAgentUsername,
-            task,
-            result: content,
-            status: 'success',
-            depth: currentDepth,
-            durationMs: Date.now() - startTime,
+            return invokeDelegateTask(ctx, plugin, {
+              leaderUsername: callingEmployee || Array.from(allowedLeaders)[0] || "",
+              subAgentUsername,
+              subAgentEmployee,
+              task: args.task,
+              context: args.context,
+              maxDepth: maxDepth ?? 1,
+              timeout: timeout ?? 12e4,
+              toolCallId: id
+            });
+          }
         });
-        return {
-            status: 'success',
-            content,
-        };
-    }
-    catch (e) {
-        plugin.app.log.error(`[AgentOrchestrator] Sub-agent ${subAgentUsername} failed`, e);
-        // Log failed execution for tracing
-        await logDelegation(ctx, plugin, {
-            leaderUsername,
-            subAgentUsername,
-            task,
-            result: '',
-            status: 'error',
-            depth: currentDepth,
-            durationMs: Date.now() - startTime,
-            error: e.message,
-        }).catch(() => { }); // Don't let logging errors mask the real error
-        return {
-            status: 'error',
-            content: `Sub-agent "${subAgentUsername}" failed: ${e.message}`,
-        };
+      }
+    } catch (e) {
+      plugin.app.log.error("[AgentOrchestrator] Failed to register delegate tools", e);
     }
+  };
 }
-/**
- * Log a delegation event to the orchestratorLogs collection for observability.
- */
-async function logDelegation(ctx, plugin, data) {
-    try {
-        const logsRepo = plugin.db.getRepository('orchestratorLogs');
-        if (!logsRepo)
-            return;
-        await logsRepo.create({
-            values: {
-                leaderUsername: data.leaderUsername,
-                subAgentUsername: data.subAgentUsername,
-                toolName: `delegate_to_${data.subAgentUsername}`,
-                task: data.task.substring(0, 2000),
-                result: data.result.substring(0, 5000),
-                status: data.status,
-                depth: data.depth,
-                durationMs: data.durationMs,
-                error: data.error?.substring(0, 2000),
-                userId: ctx.auth?.user?.id || ctx.state?.currentUser?.id,
-            },
-        });
+async function invokeDelegateTask(ctx, plugin, options) {
+  var _a, _b;
+  const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId } = options;
+  const currentDepth = ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0;
+  if (currentDepth >= maxDepth) {
+    return {
+      status: "error",
+      content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`
+    };
+  }
+  const startTime = Date.now();
+  try {
+    const aiPlugin = ctx.app.pm.get("ai");
+    if (!aiPlugin) {
+      throw new Error("Plugin AI is not installed or enabled");
     }
-    catch (e) {
-        plugin.app.log.warn('[AgentOrchestrator] Failed to log delegation event', e);
+    const modelSettings = subAgentEmployee.modelSettings;
+    if (!(modelSettings == null ? void 0 : modelSettings.llmService) || !(modelSettings == null ? void 0 : modelSettings.model)) {
+      throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured. Please configure a model in the AI Employee settings.`);
+    }
+    const { provider } = await aiPlugin.aiManager.getLLMService({
+      llmService: modelSettings.llmService,
+      model: modelSettings.model
+    });
+    const chatModel = provider.createModel();
+    const coreToolsManager = ctx.app.aiManager.toolsManager;
+    const allTools = await coreToolsManager.listTools();
+    const employeeSkills = (((_a = subAgentEmployee.skillSettings) == null ? void 0 : _a.skills) ?? []).map((s) => typeof s === "string" ? s : s.name).filter(Boolean);
+    const langchainTools = [];
+    for (const toolEntry of allTools) {
+      const toolName = toolEntry.definition.name;
+      if (!toolName) continue;
+      if (!employeeSkills.includes(toolName) || toolName.startsWith("delegate_to_")) {
+        continue;
+      }
+      langchainTools.push(
+        new import_tools.DynamicStructuredTool({
+          name: toolName.replace(/[^a-zA-Z0-9_-]/g, "_"),
+          description: toolEntry.definition.description || toolName,
+          schema: toolEntry.definition.schema || import_zod.z.object({}),
+          func: async (toolArgs) => {
+            const invokeCtx = Object.create(ctx);
+            invokeCtx[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
+            const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
+            if ((res == null ? void 0 : res.status) === "error") {
+              throw new Error(`Tool <${toolName}> failed: ${res.content}`);
+            }
+            return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
+          }
+        })
+      );
     }
+    const abortController = new AbortController();
+    const executor = (0, import_prebuilt.createReactAgent)({
+      llm: chatModel,
+      tools: langchainTools
+    });
+    const systemPrompt = ((_b = subAgentEmployee.chatSettings) == null ? void 0 : _b.systemPrompt) || subAgentEmployee.bio || `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${subAgentEmployee.about || ""}`;
+    const combinedTask = context ? `Task: ${task}
+
+Context Provided:
+${context}` : `Task: ${task}`;
+    const invokePromise = executeAgent(executor, systemPrompt, combinedTask, abortController.signal);
+    const result = await Promise.race([
+      invokePromise,
+      createTimeout(timeout, subAgentUsername, abortController)
+    ]);
+    const content = result || "Sub-agent completed the task but produced no output.";
+    await logDelegation(ctx, plugin, {
+      leaderUsername,
+      subAgentUsername,
+      task,
+      result: content,
+      status: "success",
+      depth: currentDepth,
+      durationMs: Date.now() - startTime
+    });
+    return {
+      status: "success",
+      content
+    };
+  } catch (e) {
+    plugin.app.log.error(`[AgentOrchestrator] Sub-agent ${subAgentUsername} failed`, e);
+    await logDelegation(ctx, plugin, {
+      leaderUsername,
+      subAgentUsername,
+      task,
+      result: "",
+      status: "error",
+      depth: currentDepth,
+      durationMs: Date.now() - startTime,
+      error: e.message
+    }).catch(() => {
+    });
+    return {
+      status: "error",
+      content: `Sub-agent "${subAgentUsername}" failed: ${e.message}`
+    };
+  }
+}
+async function logDelegation(ctx, plugin, data) {
+  var _a, _b, _c, _d, _e;
+  try {
+    const logsRepo = plugin.db.getRepository("orchestratorLogs");
+    if (!logsRepo) return;
+    await logsRepo.create({
+      values: {
+        leaderUsername: data.leaderUsername,
+        subAgentUsername: data.subAgentUsername,
+        toolName: `delegate_to_${data.subAgentUsername}`,
+        task: data.task.substring(0, 2e3),
+        result: data.result.substring(0, 5e3),
+        status: data.status,
+        depth: data.depth,
+        durationMs: data.durationMs,
+        error: (_a = data.error) == null ? void 0 : _a.substring(0, 2e3),
+        userId: ((_c = (_b = ctx.auth) == null ? void 0 : _b.user) == null ? void 0 : _c.id) || ((_e = (_d = ctx.state) == null ? void 0 : _d.currentUser) == null ? void 0 : _e.id)
+      }
+    });
+  } catch (e) {
+    plugin.app.log.warn("[AgentOrchestrator] Failed to log delegation event", e);
+  }
 }
-/**
- * Execute the agent and extract the final AI message content.
- * Uses stream mode to collect all chunks, similar to plugin-sub-agent.
- * Accepts an AbortSignal so the stream can be cancelled on timeout.
- */
 async function executeAgent(executor, systemPrompt, task, signal) {
-    const streamOptions = { recursionLimit: 50, streamMode: 'messages' };
-    if (signal) {
-        streamOptions.signal = signal;
-    }
-    const stream = await executor.stream({
-        messages: [new messages_1.SystemMessage(systemPrompt), new messages_1.HumanMessage(task)],
-    }, streamOptions);
-    let aiContentCache = '';
-    for await (const chunk of stream) {
-        // Check abort between chunks
-        if (signal?.aborted)
-            break;
-        const [message] = chunk;
-        if (message.getType() === 'ai' && message.content) {
-            aiContentCache += message.content.toString();
-        }
+  const streamOptions = { recursionLimit: 50, streamMode: "messages" };
+  if (signal) {
+    streamOptions.signal = signal;
+  }
+  const stream = await executor.stream(
+    {
+      messages: [new import_messages.SystemMessage(systemPrompt), new import_messages.HumanMessage(task)]
+    },
+    streamOptions
+  );
+  let aiContentCache = "";
+  for await (const chunk of stream) {
+    if (signal == null ? void 0 : signal.aborted) break;
+    const [message] = chunk;
+    if (message.getType() === "ai" && message.content) {
+      aiContentCache += message.content.toString();
     }
-    return aiContentCache || '';
+  }
+  return aiContentCache || "";
 }
-/**
- * Create a timeout promise that rejects after the specified duration.
- * P3 FIX: Also triggers AbortController to cancel the in-flight stream.
- */
 function createTimeout(ms, agentName, abortController) {
-    return new Promise((_, reject) => setTimeout(() => {
-        abortController?.abort();
-        reject(new Error(`Sub-agent "${agentName}" timed out after ${ms / 1000}s`));
-    }, ms));
+  return new Promise(
+    (_, reject) => setTimeout(() => {
+      abortController == null ? void 0 : abortController.abort();
+      reject(new Error(`Sub-agent "${agentName}" timed out after ${ms / 1e3}s`));
+    }, ms)
+  );
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDelegateToolsProvider
+});

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.0",
+  "version": "1.0.5",
   "license": "Apache-2.0",
   "main": "dist/server/index.js",
   "keywords": [

package/src/client/OrchestratorSettings.tsx

@@ -5,37 +5,21 @@ import { RulesTab } from './RulesTab';
 import { TracingTab } from './TracingTab';
 import { AIEmployeesProvider } from './AIEmployeesContext';
 
-/**
- * Main settings page for the Agent Orchestrator plugin.
- * Contains two tabs:
- * - Rules: Configure which AI Employees can delegate tasks to others
- * - Tracing: View and debug delegation execution logs
- *
- * P3 FIX: Wraps with AIEmployeesProvider so both tabs share one API call.
- */
 export 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 /> Swarm Tracing</span>,
               children: <TracingTab />,
             },
           ]}