plugin-agent-orchestrator 1.0.5 → 1.0.13

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

@@ -34,6 +34,90 @@ 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 sanitizeToolPart(value) {
+  return (value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function buildDelegateToolName(leaderUsername, subAgentUsername) {
+  return `delegate_${sanitizeToolPart(leaderUsername)}_to_${sanitizeToolPart(subAgentUsername)}`;
+}
+function isDelegateToolName(toolName) {
+  return toolName.startsWith("delegate_to_") || toolName.startsWith("delegate_") && toolName.includes("_to_");
+}
+function createDelegateToolOptions(plugin, options) {
+  const { leaderUsername, subAgentUsername, subAgentEmployee, maxDepth, timeout, toolName, legacyAlias, llmService, model } = options;
+  const toolDescription = [
+    `Delegate a task from "${leaderUsername}" to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
+    legacyAlias ? "This is a backward-compatible alias for existing skill assignments." : "",
+    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(" ");
+  return {
+    scope: "CUSTOM",
+    execution: "backend",
+    defaultPermission: "ALLOW",
+    silence: false,
+    introduction: {
+      title: `[${leaderUsername}] ${subAgentEmployee.nickname || subAgentUsername}${legacyAlias ? " (legacy)" : ""}`,
+      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) => {
+      const callingEmployee = resolveCallingEmployee(ctx);
+      if (callingEmployee && callingEmployee !== leaderUsername) {
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername,
+          toolName,
+          task: args.task,
+          context: args.context,
+          result: "",
+          status: "error",
+          depth: ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Employee "${callingEmployee}" is not authorized to use this delegation rule.`
+        });
+        return {
+          status: "error",
+          content: `Employee "${callingEmployee}" is not authorized to delegate to "${subAgentUsername}". Configure an orchestration rule first.`
+        };
+      }
+      return invokeDelegateTask(ctx, plugin, {
+        leaderUsername,
+        subAgentUsername,
+        subAgentEmployee,
+        task: args.task,
+        context: args.context,
+        maxDepth: maxDepth ?? 1,
+        timeout: timeout ?? 12e4,
+        toolCallId: id,
+        toolName,
+        llmService,
+        model
+      });
+    }
+  };
+}
+function resolveCallingEmployee(ctx) {
+  var _a, _b, _c;
+  const raw = ctx._currentAIEmployee || ((_a = ctx.state) == null ? void 0 : _a.currentAIEmployee) || ((_c = (_b = ctx.runtime) == null ? void 0 : _b.context) == null ? void 0 : _c.currentAIEmployee);
+  if (!raw) return null;
+  return typeof raw === "string" ? raw : raw.username;
+}
+function truncateText(value, maxLen) {
+  const text = typeof value === "string" ? value : value == null ? "" : JSON.stringify(value);
+  return text.length > maxLen ? `${text.slice(0, maxLen)}
+...[truncated]` : text;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
 function createDelegateToolsProvider(plugin) {
   return async (register) => {
     try {
@@ -43,68 +127,59 @@ function createDelegateToolsProvider(plugin) {
         filter: { enabled: true }
       });
       if (!(configs == null ? void 0 : configs.length)) return;
-      const leadersByTool = /* @__PURE__ */ new Map();
+      const employeeCache = /* @__PURE__ */ new Map();
+      const tools = [];
+      const configsBySubAgent = /* @__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());
-        }
-        leadersByTool.get(toolName).add(config.leaderUsername);
+        const items = configsBySubAgent.get(config.subAgentUsername) || [];
+        items.push(config);
+        configsBySubAgent.set(config.subAgentUsername, items);
       }
-      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 }
-        });
-        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.`
-              };
-            }
-            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
-            });
+        let subAgentEmployee = employeeCache.get(subAgentUsername);
+        if (!subAgentEmployee) {
+          subAgentEmployee = await plugin.db.getRepository("aiEmployees").findOne({
+            filter: { username: subAgentUsername }
+          });
+          if (subAgentEmployee) {
+            employeeCache.set(subAgentUsername, subAgentEmployee);
           }
-        });
+        }
+        if (!subAgentEmployee) continue;
+        const toolName = buildDelegateToolName(leaderUsername, subAgentUsername);
+        tools.push(createDelegateToolOptions(plugin, {
+          leaderUsername,
+          subAgentUsername,
+          subAgentEmployee,
+          maxDepth,
+          timeout,
+          toolName,
+          llmService: config.llmService,
+          model: config.model
+        }));
+      }
+      for (const [subAgentUsername, items] of configsBySubAgent.entries()) {
+        if (items.length !== 1) continue;
+        const config = items[0];
+        const subAgentEmployee = employeeCache.get(subAgentUsername);
+        if (!subAgentEmployee) continue;
+        const legacyToolName = `delegate_to_${sanitizeToolPart(subAgentUsername)}`;
+        if (tools.some((tool) => tool.definition.name === legacyToolName)) continue;
+        tools.push(createDelegateToolOptions(plugin, {
+          leaderUsername: config.leaderUsername,
+          subAgentUsername,
+          subAgentEmployee,
+          maxDepth: config.maxDepth,
+          timeout: config.timeout,
+          toolName: legacyToolName,
+          legacyAlias: true,
+          llmService: config.llmService,
+          model: config.model
+        }));
+      }
+      if (tools.length) {
+        register.registerTools(tools);
       }
     } catch (e) {
       plugin.app.log.error("[AgentOrchestrator] Failed to register delegate tools", e);
@@ -112,24 +187,66 @@ function createDelegateToolsProvider(plugin) {
   };
 }
 async function invokeDelegateTask(ctx, plugin, options) {
-  var _a, _b;
-  const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId } = options;
+  var _a, _b, _c, _d, _e;
+  const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId, toolName, llmService, model } = options;
   const currentDepth = ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0;
   if (currentDepth >= maxDepth) {
+    await logDelegation(ctx, plugin, {
+      leaderUsername,
+      subAgentUsername,
+      toolName,
+      task,
+      context,
+      result: "",
+      status: "error",
+      depth: currentDepth,
+      durationMs: 0,
+      error: `Delegation depth limit reached (${currentDepth}/${maxDepth}).`
+    });
     return {
       status: "error",
       content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`
     };
   }
   const startTime = Date.now();
+  const trace = [
+    {
+      type: "start",
+      at: nowIso(),
+      title: `Delegation started: ${leaderUsername} -> ${subAgentUsername}`,
+      content: task
+    }
+  ];
+  const logRecord = await logDelegation(ctx, plugin, {
+    leaderUsername,
+    subAgentUsername,
+    toolName,
+    task,
+    context,
+    result: "",
+    status: "running",
+    depth: currentDepth,
+    durationMs: 0,
+    trace
+  });
   try {
     const aiPlugin = ctx.app.pm.get("ai");
     if (!aiPlugin) {
       throw new Error("Plugin AI is not installed or enabled");
     }
-    const modelSettings = subAgentEmployee.modelSettings;
+    let modelSettings = subAgentEmployee.modelSettings;
+    if (llmService && model) {
+      modelSettings = { llmService, model };
+    }
     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 leaderEmployee = await plugin.db.getRepository("aiEmployees").findOne({
+        filter: { username: leaderUsername }
+      });
+      const dynamicModel = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.model;
+      modelSettings = (leaderEmployee == null ? void 0 : leaderEmployee.modelSettings) || dynamicModel;
+      if (!(modelSettings == null ? void 0 : modelSettings.llmService) || !(modelSettings == null ? void 0 : modelSettings.model)) {
+        throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured (and leader fallback failed). Please configure a model in the Orchestrator Config or AI Employee settings.`);
+      }
     }
     const { provider } = await aiPlugin.aiManager.getLLMService({
       llmService: modelSettings.llmService,
@@ -138,27 +255,54 @@ async function invokeDelegateTask(ctx, plugin, options) {
     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 employeeSkills = (((_d = subAgentEmployee.skillSettings) == null ? void 0 : _d.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_")) {
+      const toolName2 = toolEntry.definition.name;
+      if (!toolName2) continue;
+      if (!employeeSkills.includes(toolName2) || isDelegateToolName(toolName2)) {
         continue;
       }
       langchainTools.push(
         new import_tools.DynamicStructuredTool({
-          name: toolName.replace(/[^a-zA-Z0-9_-]/g, "_"),
-          description: toolEntry.definition.description || toolName,
+          name: toolName2.replace(/[^a-zA-Z0-9_-]/g, "_"),
+          description: toolEntry.definition.description || toolName2,
           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}`);
+            trace.push({
+              type: "tool_call",
+              at: nowIso(),
+              title: `Calling tool: ${toolEntry.definition.name}`,
+              toolName: toolEntry.definition.name,
+              args: toolArgs
+            });
+            try {
+              const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
+              trace.push({
+                type: "tool_result",
+                at: nowIso(),
+                title: `Tool finished: ${toolEntry.definition.name}`,
+                toolName: toolEntry.definition.name,
+                status: (res == null ? void 0 : res.status) || "success",
+                content: truncateText((res == null ? void 0 : res.content) ?? res, 2e3)
+              });
+              if ((res == null ? void 0 : res.status) === "error") {
+                throw new Error(`Tool <${toolEntry.definition.name}> failed: ${res.content}`);
+              }
+              return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
+            } catch (e) {
+              trace.push({
+                type: "tool_error",
+                at: nowIso(),
+                title: `Tool failed: ${toolEntry.definition.name}`,
+                toolName: toolEntry.definition.name,
+                status: "error",
+                content: e.message
+              });
+              throw e;
             }
-            return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
           }
         })
       );
@@ -168,7 +312,7 @@ async function invokeDelegateTask(ctx, plugin, options) {
       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 systemPrompt = ((_e = subAgentEmployee.chatSettings) == null ? void 0 : _e.systemPrompt) || subAgentEmployee.bio || `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${subAgentEmployee.about || ""}`;
     const combinedTask = context ? `Task: ${task}
 
 Context Provided:
@@ -178,15 +322,27 @@ ${context}` : `Task: ${task}`;
       invokePromise,
       createTimeout(timeout, subAgentUsername, abortController)
     ]);
-    const content = result || "Sub-agent completed the task but produced no output.";
+    const content = result.content || "Sub-agent completed the task but produced no output.";
+    trace.push({
+      type: "finish",
+      at: nowIso(),
+      title: `Delegation finished: ${subAgentUsername}`,
+      status: "success",
+      content: truncateText(content, 2e3)
+    });
     await logDelegation(ctx, plugin, {
+      id: logRecord == null ? void 0 : logRecord.id,
       leaderUsername,
       subAgentUsername,
+      toolName,
       task,
+      context,
       result: content,
       status: "success",
       depth: currentDepth,
-      durationMs: Date.now() - startTime
+      durationMs: Date.now() - startTime,
+      trace,
+      messages: result.messages
     });
     return {
       status: "success",
@@ -195,15 +351,29 @@ ${context}` : `Task: ${task}`;
   } catch (e) {
     plugin.app.log.error(`[AgentOrchestrator] Sub-agent ${subAgentUsername} failed`, e);
     await logDelegation(ctx, plugin, {
+      id: logRecord == null ? void 0 : logRecord.id,
       leaderUsername,
       subAgentUsername,
+      toolName,
       task,
+      context,
       result: "",
       status: "error",
       depth: currentDepth,
       durationMs: Date.now() - startTime,
-      error: e.message
-    }).catch(() => {
+      error: e.message,
+      trace: [
+        ...trace,
+        {
+          type: "error",
+          at: nowIso(),
+          title: `Delegation failed: ${subAgentUsername}`,
+          status: "error",
+          content: e.message
+        }
+      ]
+    }).catch((logErr) => {
+      plugin.app.log.warn("[AgentOrchestrator] Failed to save error log for delegation", logErr);
     });
     return {
       status: "error",
@@ -215,45 +385,89 @@ 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({
+    if (!logsRepo) {
+      plugin.app.log.warn("[AgentOrchestrator] orchestratorLogs repository not found \u2014 skipping log");
+      return;
+    }
+    let userId;
+    try {
+      userId = ((_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id) || ((_d = (_c = ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id);
+    } catch {
+    }
+    const values = {
+      leaderUsername: data.leaderUsername,
+      subAgentUsername: data.subAgentUsername,
+      toolName: data.toolName,
+      task: truncateText(data.task, 1e4),
+      context: truncateText(data.context || "", 1e4),
+      result: truncateText(data.result || "", 5e4),
+      status: data.status,
+      depth: data.depth,
+      durationMs: data.durationMs,
+      error: truncateText(data.error || "", 1e4),
+      trace: data.trace || [],
+      messages: data.messages || [],
+      userId,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (data.id) {
+      await logsRepo.update({
+        filterByTk: data.id,
+        values
+      });
+      return { id: data.id };
+    }
+    const record = 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)
+        ...values,
+        createdAt: /* @__PURE__ */ new Date()
       }
     });
+    return ((_e = record == null ? void 0 : record.toJSON) == null ? void 0 : _e.call(record)) || record;
   } catch (e) {
     plugin.app.log.warn("[AgentOrchestrator] Failed to log delegation event", e);
   }
 }
 async function executeAgent(executor, systemPrompt, task, signal) {
-  const streamOptions = { recursionLimit: 50, streamMode: "messages" };
+  const config = { recursionLimit: 50 };
   if (signal) {
-    streamOptions.signal = signal;
+    config.signal = signal;
   }
-  const stream = await executor.stream(
+  const finalState = await executor.invoke(
     {
       messages: [new import_messages.SystemMessage(systemPrompt), new import_messages.HumanMessage(task)]
     },
-    streamOptions
+    config
   );
-  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();
-    }
+  const messages = (finalState == null ? void 0 : finalState.messages) || [];
+  const lastAIMessage = [...messages].reverse().find((m) => m.getType() === "ai");
+  if (!lastAIMessage || !lastAIMessage.content) {
+    return { content: "", messages: serializeMessages(messages) };
+  }
+  let content = "";
+  if (typeof lastAIMessage.content === "string") {
+    content = lastAIMessage.content;
+  } else if (Array.isArray(lastAIMessage.content)) {
+    content = lastAIMessage.content.map((c) => c.text || JSON.stringify(c)).join("\n");
+  } else {
+    content = String(lastAIMessage.content);
   }
-  return aiContentCache || "";
+  return { content, messages: serializeMessages(messages) };
+}
+function serializeMessages(messages) {
+  return (messages || []).map((message, index) => {
+    const type = typeof message.getType === "function" ? message.getType() : message.type;
+    return {
+      index,
+      type,
+      name: message.name,
+      content: truncateText(message.content, 1e4),
+      toolCalls: message.tool_calls || message.toolCalls || [],
+      toolCallId: message.tool_call_id,
+      additionalKwargs: message.additional_kwargs,
+      responseMetadata: message.response_metadata
+    };
+  });
 }
 function createTimeout(ms, agentName, abortController) {
   return new Promise(

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