plugin-agent-orchestrator 1.0.6 → 1.0.14

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

@@ -26,110 +26,640 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var delegate_task_exports = {};
 __export(delegate_task_exports, {
-  createDelegateToolsProvider: () => createDelegateToolsProvider
+  createDelegateToolsProvider: () => createDelegateToolsProvider,
+  invalidateDelegateToolsCache: () => invalidateDelegateToolsCache
 });
 module.exports = __toCommonJS(delegate_task_exports);
 var import_zod = require("zod");
+var import_crypto = require("crypto");
 var import_prebuilt = require("@langchain/langgraph/prebuilt");
 var import_tools = require("@langchain/core/tools");
 var import_messages = require("@langchain/core/messages");
+var import_ExecutionSpanService = require("../services/ExecutionSpanService");
 const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
+const MAX_DISPATCH_CONCURRENCY = 5;
+const MAX_DISPATCH_TASKS = 20;
+const MAX_TOOL_NAME_LENGTH = 64;
+function sanitizeToolPart(value) {
+  return (value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function buildDelegateToolName(leaderUsername, subAgentUsername) {
+  return `delegate_${sanitizeToolPart(leaderUsername)}_to_${sanitizeToolPart(subAgentUsername)}`;
+}
+function buildDispatchToolName(leaderUsername) {
+  return `dispatch_subagents_${sanitizeToolPart(leaderUsername)}`;
+}
+function createRootRunId(seed = "") {
+  const hash = (0, import_crypto.createHash)("sha1").update(`${Date.now()}::${Math.random()}::${seed}`).digest("hex").slice(0, 10);
+  return `run_${Date.now()}_${hash}`;
+}
+let registeredDelegateNamesByPlugin = /* @__PURE__ */ new WeakMap();
+function isDelegateToolName(plugin, toolName) {
+  var _a;
+  return ((_a = registeredDelegateNamesByPlugin.get(plugin)) == null ? void 0 : _a.has(toolName)) ?? false;
+}
+async function runWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (cursor < items.length) {
+      const i = cursor;
+      cursor += 1;
+      results[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function createDelegateToolOptions(plugin, options) {
+  const {
+    leaderUsername,
+    subAgentUsername,
+    subAgentEmployee,
+    maxDepth,
+    timeout,
+    toolName,
+    legacyAlias,
+    llmService,
+    model,
+    recursionLimit
+  } = options;
+  const dispatchToolName = buildDispatchToolName(leaderUsername);
+  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.",
+    `For multiple INDEPENDENT sub-tasks, prefer "${dispatchToolName}" to fan-out in one call (up to ${MAX_DISPATCH_CONCURRENCY} run in parallel), or emit several delegate_* calls in the SAME assistant turn so they run concurrently.`
+  ].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 = await resolveCallingEmployee(ctx, plugin);
+      if (!callingEmployee) {
+        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: `Cannot determine calling AI employee for delegation tool "${toolName}".`
+        });
+        return {
+          status: "error",
+          content: `Cannot determine calling AI employee for "${toolName}". Start the request from an AI Employee conversation so leader scoping can be enforced.`
+        };
+      }
+      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,
+        recursionLimit
+      });
+    }
+  };
+}
+function formatDispatchResults(results, rulesBySubAgent) {
+  var _a;
+  const total = results.length;
+  const ok = results.filter((r) => r.status === "success").length;
+  const lines = [
+    `Dispatched ${total} sub-task(s) \u2014 ${ok} succeeded, ${total - ok} failed (max ${MAX_DISPATCH_CONCURRENCY} ran in parallel).`,
+    ""
+  ];
+  for (const r of results) {
+    const employee = (_a = rulesBySubAgent.get(r.subAgent)) == null ? void 0 : _a.employee;
+    const displayName = (employee == null ? void 0 : employee.nickname) || r.subAgent;
+    const dur = `${(r.durationMs / 1e3).toFixed(1)}s`;
+    lines.push(`--- [${r.index + 1}] ${displayName} (${r.subAgent}) [${r.status}] (${dur}) ---`);
+    lines.push(r.content || "(empty)");
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function createDispatchToolOptions(plugin, options) {
+  const { leaderUsername, rulesBySubAgent } = options;
+  const toolName = buildDispatchToolName(leaderUsername);
+  const subAgentNames = Array.from(rulesBySubAgent.keys());
+  const subAgentList = subAgentNames.map((username) => {
+    var _a, _b;
+    const entry = rulesBySubAgent.get(username);
+    if (!entry) return `- ${username}`;
+    const profile = ((_a = entry.employee) == null ? void 0 : _a.about) ? ` \u2014 ${String(entry.employee.about).substring(0, 120)}` : "";
+    const display = ((_b = entry.employee) == null ? void 0 : _b.nickname) ? ` (${entry.employee.nickname})` : "";
+    return `- ${username}${display}${profile}`;
+  }).join("\n");
+  const description = [
+    `Dispatch multiple tasks from "${leaderUsername}" to its configured sub-agents in one call.`,
+    `At most ${MAX_DISPATCH_CONCURRENCY} sub-tasks run in parallel; up to ${MAX_DISPATCH_TASKS} tasks per call.`,
+    "Use this when you have already planned independent sub-tasks and want to fan-out, then aggregate the results.",
+    `Available sub-agents:
+${subAgentList}`
+  ].join(" ");
+  return {
+    scope: "CUSTOM",
+    execution: "backend",
+    defaultPermission: "ALLOW",
+    silence: false,
+    introduction: {
+      title: `[${leaderUsername}] Dispatch sub-agents`,
+      about: description
+    },
+    definition: {
+      name: toolName,
+      description,
+      schema: import_zod.z.object({
+        tasks: import_zod.z.array(
+          import_zod.z.object({
+            subAgent: import_zod.z.enum(subAgentNames).describe("Username of the sub-agent that should execute this task."),
+            task: import_zod.z.string().describe("Detailed task description for the sub-agent."),
+            context: import_zod.z.string().optional().describe("Optional additional context for the sub-agent.")
+          })
+        ).min(1).max(MAX_DISPATCH_TASKS).describe(`List of sub-tasks to dispatch concurrently. Up to ${MAX_DISPATCH_CONCURRENCY} run in parallel.`)
+      })
+    },
+    invoke: async (ctx, args, id) => {
+      var _a;
+      const callingEmployee = await resolveCallingEmployee(ctx, plugin);
+      if (!callingEmployee) {
+        const distinctSubs = Array.from(new Set((args.tasks ?? []).map((t) => t.subAgent).filter(Boolean)));
+        const reportedSub = distinctSubs.length === 1 ? distinctSubs[0] : "(multiple)";
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername: reportedSub,
+          toolName,
+          task: truncateText(args.tasks ?? [], 2e3),
+          result: "",
+          status: "error",
+          depth: ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Cannot determine calling AI employee for dispatch tool "${toolName}". Targets: ${distinctSubs.join(", ") || "(empty)"}.`
+        });
+        return {
+          status: "error",
+          content: `Cannot determine calling AI employee for "${toolName}". Start the request from an AI Employee conversation so leader scoping can be enforced.`
+        };
+      }
+      if (callingEmployee && callingEmployee !== leaderUsername) {
+        const distinctSubs = Array.from(new Set((args.tasks ?? []).map((t) => t.subAgent).filter(Boolean)));
+        const reportedSub = distinctSubs.length === 1 ? distinctSubs[0] : "(multiple)";
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername: reportedSub,
+          toolName,
+          task: truncateText(args.tasks ?? [], 2e3),
+          result: "",
+          status: "error",
+          depth: ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Employee "${callingEmployee}" is not authorized to dispatch sub-agents for leader "${leaderUsername}". Targets: ${distinctSubs.join(", ") || "(empty)"}.`
+        });
+        return {
+          status: "error",
+          content: `Employee "${callingEmployee}" is not authorized to dispatch sub-agents for leader "${leaderUsername}".`
+        };
+      }
+      const tasks = args.tasks ?? [];
+      if (!tasks.length) {
+        return {
+          status: "error",
+          content: "No tasks provided. Pass at least one item in `tasks`."
+        };
+      }
+      const dispatchRootRunId = ((_a = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx)) == null ? void 0 : _a.rootRunId) || createRootRunId(`${leaderUsername}:dispatch`);
+      const results = await runWithConcurrency(tasks, MAX_DISPATCH_CONCURRENCY, async (item, i) => {
+        const startedAt = Date.now();
+        const entry = rulesBySubAgent.get(item.subAgent);
+        if (!entry) {
+          return {
+            index: i,
+            subAgent: item.subAgent,
+            status: "error",
+            content: `Unknown sub-agent "${item.subAgent}". Allowed: ${subAgentNames.join(", ")}.`,
+            durationMs: 0
+          };
+        }
+        try {
+          const res = await invokeDelegateTask(ctx, plugin, {
+            leaderUsername,
+            subAgentUsername: item.subAgent,
+            subAgentEmployee: entry.employee,
+            task: item.task,
+            context: item.context,
+            maxDepth: entry.rule.maxDepth ?? 1,
+            timeout: entry.rule.timeout ?? 12e4,
+            toolCallId: `${id}-${i}`,
+            toolName,
+            llmService: entry.rule.llmService,
+            model: entry.rule.model,
+            recursionLimit: entry.rule.recursionLimit,
+            rootRunId: dispatchRootRunId
+          });
+          return {
+            index: i,
+            subAgent: item.subAgent,
+            status: res.status,
+            content: res.content,
+            durationMs: Date.now() - startedAt
+          };
+        } catch (e) {
+          return {
+            index: i,
+            subAgent: item.subAgent,
+            status: "error",
+            content: (e == null ? void 0 : e.message) || String(e),
+            durationMs: Date.now() - startedAt
+          };
+        }
+      });
+      const successCount = results.filter((r) => r.status === "success").length;
+      return {
+        status: successCount > 0 ? "success" : "error",
+        content: formatDispatchResults(results, rulesBySubAgent)
+      };
+    }
+  };
+}
+function captureCtxSnapshot(ctx) {
+  var _a, _b, _c, _d;
+  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 {
+  }
+  return { userId };
+}
+function normalizeEmployeeUsername(raw) {
+  if (!raw) return null;
+  if (typeof raw === "string") return raw;
+  return raw.username || raw.aiEmployeeUsername || raw.name || null;
+}
+async function resolveCallingEmployee(ctx, plugin) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const values = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) || {};
+  const raw = ctx._currentAIEmployee || ((_c = ctx.state) == null ? void 0 : _c.currentAIEmployee) || ((_e = (_d = ctx.runtime) == null ? void 0 : _d.context) == null ? void 0 : _e.currentAIEmployee) || values.aiEmployee;
+  const direct = normalizeEmployeeUsername(raw);
+  if (direct) return direct;
+  const sessionId = values.sessionId || ((_g = (_f = ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.sessionId);
+  if (!sessionId) return null;
+  try {
+    const repo = ((_i = (_h = ctx.db) == null ? void 0 : _h.getRepository) == null ? void 0 : _i.call(_h, "aiConversations")) || plugin.db.getRepository("aiConversations");
+    const conversation = await repo.findOne({
+      filter: { sessionId }
+    });
+    return normalizeEmployeeUsername((conversation == null ? void 0 : conversation.aiEmployeeUsername) || ((_j = conversation == null ? void 0 : conversation.get) == null ? void 0 : _j.call(conversation, "aiEmployeeUsername")));
+  } catch (e) {
+    plugin.app.log.warn(`[AgentOrchestrator] Failed to resolve AI employee for session "${sessionId}"`, e);
+    return null;
+  }
+}
+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 hasModelSettings(value) {
+  return Boolean((value == null ? void 0 : value.llmService) && (value == null ? void 0 : value.model));
+}
+const TOOLS_CACHE_TTL_MS = 3e4;
+let toolsCacheByPlugin = /* @__PURE__ */ new WeakMap();
+let hooksAttached = null;
+function attachInvalidationHooks(plugin) {
+  if (!hooksAttached) hooksAttached = /* @__PURE__ */ new WeakSet();
+  if (hooksAttached.has(plugin)) return;
+  hooksAttached.add(plugin);
+  const invalidate = () => {
+    toolsCacheByPlugin.delete(plugin);
+    registeredDelegateNamesByPlugin.delete(plugin);
+  };
+  plugin.db.on("orchestratorConfig.afterCreate", invalidate);
+  plugin.db.on("orchestratorConfig.afterUpdate", invalidate);
+  plugin.db.on("orchestratorConfig.afterDestroy", invalidate);
+  plugin.db.on("aiEmployees.afterCreate", invalidate);
+  plugin.db.on("aiEmployees.afterUpdate", invalidate);
+  plugin.db.on("aiEmployees.afterDestroy", invalidate);
+}
+async function buildDelegateTools(plugin) {
+  const configRepo = plugin.db.getRepository("orchestratorConfig");
+  if (!configRepo) {
+    registeredDelegateNamesByPlugin.set(plugin, /* @__PURE__ */ new Set());
+    return [];
+  }
+  const configs = await configRepo.find({
+    filter: { enabled: true }
+  });
+  if (!(configs == null ? void 0 : configs.length)) {
+    registeredDelegateNamesByPlugin.set(plugin, /* @__PURE__ */ new Set());
+    return [];
+  }
+  const employeeCache = /* @__PURE__ */ new Map();
+  const tools = [];
+  const generatedNames = /* @__PURE__ */ new Map();
+  const configsBySubAgent = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    const items = configsBySubAgent.get(config.subAgentUsername) || [];
+    items.push(config);
+    configsBySubAgent.set(config.subAgentUsername, items);
+  }
+  for (const config of configs) {
+    const { leaderUsername, subAgentUsername, maxDepth, timeout, recursionLimit } = config;
+    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);
+    if (toolName.length > MAX_TOOL_NAME_LENGTH) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Tool name "${toolName}" exceeds the ${MAX_TOOL_NAME_LENGTH}-char limit enforced by most LLM providers. Skipping rule (${leaderUsername} \u2192 ${subAgentUsername}). Shorten one of the usernames.`
+      );
+      continue;
+    }
+    const existing = generatedNames.get(toolName);
+    if (existing) {
+      const suffix = (0, import_crypto.createHash)("sha1").update(`${leaderUsername}::${subAgentUsername}`).digest("hex").slice(0, 6);
+      plugin.app.log.error(
+        `[AgentOrchestrator] Tool-name collision: rule (${leaderUsername} \u2192 ${subAgentUsername}) sanitizes to "${toolName}", same as (${existing.leader} \u2192 ${existing.sub}). Skipping duplicate registration. Rename one of the usernames or apply suffix "_${suffix}" manually.`
+      );
+      continue;
+    }
+    generatedNames.set(toolName, { leader: leaderUsername, sub: subAgentUsername });
+    tools.push(
+      createDelegateToolOptions(plugin, {
+        leaderUsername,
+        subAgentUsername,
+        subAgentEmployee,
+        maxDepth,
+        timeout,
+        toolName,
+        llmService: config.llmService,
+        model: config.model,
+        recursionLimit
+      })
+    );
+  }
+  for (const [subAgentUsername, items] of configsBySubAgent.entries()) {
+    if (items.length !== 1) {
+      const leaders = items.map((c) => c.leaderUsername).join(", ");
+      plugin.app.log.warn(
+        `[AgentOrchestrator] Legacy alias "delegate_to_${sanitizeToolPart(
+          subAgentUsername
+        )}" is NOT registered for sub-agent "${subAgentUsername}" because it has multiple leaders (${leaders}). Leaders must use the per-rule "delegate_<leader>_to_<sub>" tool name.`
+      );
+      continue;
+    }
+    const config = items[0];
+    const subAgentEmployee = employeeCache.get(subAgentUsername);
+    if (!subAgentEmployee) continue;
+    const legacyToolName = `delegate_to_${sanitizeToolPart(subAgentUsername)}`;
+    if (legacyToolName.length > MAX_TOOL_NAME_LENGTH) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Legacy alias "${legacyToolName}" exceeds the ${MAX_TOOL_NAME_LENGTH}-char limit. Skipping alias for sub-agent "${subAgentUsername}".`
+      );
+      continue;
+    }
+    const aliasExisting = generatedNames.get(legacyToolName);
+    if (aliasExisting) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Legacy alias "${legacyToolName}" collides with another rule (${aliasExisting.leader} \u2192 ${aliasExisting.sub}). Skipping alias registration.`
+      );
+      continue;
+    }
+    generatedNames.set(legacyToolName, {
+      leader: config.leaderUsername,
+      sub: subAgentUsername
+    });
+    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,
+        recursionLimit: config.recursionLimit
+      })
+    );
+  }
+  const rulesByLeader = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    const subAgentEmployee = employeeCache.get(config.subAgentUsername);
+    if (!subAgentEmployee) continue;
+    let bucket = rulesByLeader.get(config.leaderUsername);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      rulesByLeader.set(config.leaderUsername, bucket);
+    }
+    bucket.set(config.subAgentUsername, { rule: config, employee: subAgentEmployee });
+  }
+  for (const [leaderUsername, rulesBySubAgent] of rulesByLeader.entries()) {
+    if (!rulesBySubAgent.size) continue;
+    const dispatchToolName = buildDispatchToolName(leaderUsername);
+    if (dispatchToolName.length > MAX_TOOL_NAME_LENGTH) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Dispatch tool "${dispatchToolName}" exceeds the ${MAX_TOOL_NAME_LENGTH}-char limit. Skipping for leader "${leaderUsername}".`
+      );
+      continue;
+    }
+    const dispatchExisting = generatedNames.get(dispatchToolName);
+    if (dispatchExisting) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Dispatch tool "${dispatchToolName}" collides with another generated tool (${dispatchExisting.leader} \u2192 ${dispatchExisting.sub}). Skipping dispatch registration for leader "${leaderUsername}".`
+      );
+      continue;
+    }
+    generatedNames.set(dispatchToolName, { leader: leaderUsername, sub: "(dispatch)" });
+    tools.push(createDispatchToolOptions(plugin, { leaderUsername, rulesBySubAgent }));
+  }
+  registeredDelegateNamesByPlugin.set(plugin, new Set(generatedNames.keys()));
+  return tools;
+}
 function createDelegateToolsProvider(plugin) {
+  attachInvalidationHooks(plugin);
   return async (register) => {
     try {
-      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());
-        }
-        leadersByTool.get(toolName).add(config.leaderUsername);
+      let toolsCache = toolsCacheByPlugin.get(plugin);
+      if (!toolsCache || toolsCache.expiresAt <= Date.now()) {
+        const tools = await buildDelegateTools(plugin);
+        toolsCache = { tools, expiresAt: Date.now() + TOOLS_CACHE_TTL_MS };
+        toolsCacheByPlugin.set(plugin, toolsCache);
       }
-      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
-            });
-          }
-        });
+      if (toolsCache.tools.length) {
+        register.registerTools(toolsCache.tools);
       }
     } catch (e) {
       plugin.app.log.error("[AgentOrchestrator] Failed to register delegate tools", e);
     }
   };
 }
+function invalidateDelegateToolsCache() {
+  toolsCacheByPlugin = /* @__PURE__ */ new WeakMap();
+  registeredDelegateNamesByPlugin = /* @__PURE__ */ new WeakMap();
+}
 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,
+    recursionLimit,
+    rootRunId: providedRootRunId,
+    parentSpanId: providedParentSpanId
+  } = options;
+  const ctxSnapshot = captureCtxSnapshot(ctx);
   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}).`,
+      snapshot: ctxSnapshot
+    });
     return {
       status: "error",
       content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`
     };
   }
+  const spanService = new import_ExecutionSpanService.ExecutionSpanService(plugin);
+  const upstreamTraceContext = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx);
+  const rootRunId = providedRootRunId || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.rootRunId) || createRootRunId(`${leaderUsername}:${subAgentUsername}`);
+  const parentSpanId = providedParentSpanId || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.spanId) || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.parentSpanId);
   const startTime = Date.now();
+  const trace = [
+    {
+      type: "start",
+      at: nowIso(),
+      title: `Delegation started: ${leaderUsername} -> ${subAgentUsername}`,
+      content: task
+    }
+  ];
+  const executionSpan = await spanService.create({
+    rootRunId,
+    parentSpanId,
+    type: "sub_agent",
+    status: "running",
+    leaderUsername,
+    employeeUsername: subAgentUsername,
+    title: `Delegation: ${leaderUsername} -> ${subAgentUsername}`,
+    input: { task, context },
+    metadata: {
+      depth: currentDepth,
+      maxDepth,
+      toolName,
+      recursionLimit,
+      llmOverride: llmService && model ? { llmService, model } : void 0
+    },
+    userId: ctxSnapshot.userId
+  });
+  const executionSpanId = (executionSpan == null ? void 0 : executionSpan.id) ? String(executionSpan.id) : void 0;
+  const logRecord = await logDelegation(ctx, plugin, {
+    leaderUsername,
+    subAgentUsername,
+    toolName,
+    task,
+    context,
+    result: "",
+    status: "running",
+    depth: currentDepth,
+    durationMs: 0,
+    trace,
+    snapshot: ctxSnapshot
+  });
+  if (executionSpanId && (logRecord == null ? void 0 : logRecord.id)) {
+    await spanService.update(executionSpanId, { orchestratorLogId: logRecord.id });
+  }
   try {
     const aiPlugin = ctx.app.pm.get("ai");
     if (!aiPlugin) {
       throw new Error("Plugin AI is not installed or enabled");
     }
-    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.`);
+    let modelSettings = hasModelSettings(subAgentEmployee.modelSettings) ? subAgentEmployee.modelSettings : void 0;
+    if (llmService && model) {
+      modelSettings = { llmService, model };
+    }
+    if (!hasModelSettings(modelSettings)) {
+      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 = hasModelSettings(leaderEmployee == null ? void 0 : leaderEmployee.modelSettings) ? leaderEmployee.modelSettings : hasModelSettings(dynamicModel) ? dynamicModel : void 0;
+      if (!hasModelSettings(modelSettings)) {
+        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 +668,100 @@ 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" ? { name: s, autoCall: false } : { name: s == null ? void 0 : s.name, autoCall: (s == null ? void 0 : s.autoCall) === true }
+    ).filter((s) => Boolean(s.name));
+    const employeeSkillMap = new Map(employeeSkills.map((skill) => [skill.name, skill]));
     const langchainTools = [];
     for (const toolEntry of allTools) {
-      const toolName = toolEntry.definition.name;
-      if (!toolName) continue;
-      if (!employeeSkills.includes(toolName) || toolName.startsWith("delegate_to_")) {
+      const entryName = toolEntry.definition.name;
+      if (!entryName) continue;
+      const employeeSkill = employeeSkillMap.get(entryName);
+      if (!employeeSkill || isDelegateToolName(plugin, entryName) || employeeSkill.autoCall !== true || toolEntry.defaultPermission !== "ALLOW") {
         continue;
       }
       langchainTools.push(
         new import_tools.DynamicStructuredTool({
-          name: toolName.replace(/[^a-zA-Z0-9_-]/g, "_"),
-          description: toolEntry.definition.description || toolName,
+          name: entryName.replace(/[^a-zA-Z0-9_-]/g, "_"),
+          description: toolEntry.definition.description || entryName,
           schema: toolEntry.definition.schema || import_zod.z.object({}),
           func: async (toolArgs) => {
+            var _a2;
             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}`);
+            const toolStartedAt = Date.now();
+            const isSkillHubTool = entryName === "skill_hub_execute" || entryName.startsWith("skill_hub_");
+            const toolSpan = await spanService.create({
+              rootRunId,
+              parentSpanId: executionSpanId,
+              type: isSkillHubTool ? "skill" : "tool",
+              status: "running",
+              leaderUsername,
+              employeeUsername: subAgentUsername,
+              toolName: toolEntry.definition.name,
+              title: isSkillHubTool ? `Skill: ${toolEntry.definition.name}` : `Tool: ${toolEntry.definition.name}`,
+              input: toolArgs,
+              metadata: {
+                depth: currentDepth + 1,
+                toolCallId: `orch-${toolCallId}`,
+                defaultPermission: toolEntry.defaultPermission
+              },
+              userId: ctxSnapshot.userId
+            });
+            const toolSpanId = (toolSpan == null ? void 0 : toolSpan.id) ? String(toolSpan.id) : void 0;
+            (0, import_ExecutionSpanService.setOrchestratorTraceContext)(invokeCtx, {
+              rootRunId,
+              spanId: toolSpanId,
+              parentSpanId: executionSpanId,
+              toolCallId: `orch-${toolCallId}`,
+              leaderUsername,
+              employeeUsername: subAgentUsername,
+              toolName: toolEntry.definition.name
+            });
+            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}`);
+              const output = truncateText((res == null ? void 0 : res.content) ?? (res == null ? void 0 : res.result) ?? res, 5e4);
+              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(output, 2e3)
+              });
+              if ((res == null ? void 0 : res.status) === "error") {
+                await spanService.finish(toolSpanId, "error", toolStartedAt, {
+                  output,
+                  error: truncateText(res.content || output, 1e4)
+                });
+                throw new Error(`Tool <${toolEntry.definition.name}> failed: ${res.content}`);
+              }
+              await spanService.finish(toolSpanId, "success", toolStartedAt, {
+                output,
+                skillExecutionId: ((_a2 = res == null ? void 0 : res.result) == null ? void 0 : _a2.execId) || (res == null ? void 0 : res.execId)
+              });
+              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
+              });
+              await spanService.finish(toolSpanId, "error", toolStartedAt, {
+                error: truncateText(e.message, 1e4)
+              });
+              throw e;
             }
-            return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
           }
         })
       );
@@ -168,25 +771,59 @@ 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:
 ${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.";
+    const effectiveRecursionLimit = Number.isFinite(recursionLimit) && recursionLimit > 0 ? recursionLimit : 50;
+    const invokePromise = executeAgent(
+      executor,
+      systemPrompt,
+      combinedTask,
+      abortController.signal,
+      effectiveRecursionLimit
+    );
+    const timeoutHandle = createTimeout(timeout, subAgentUsername, abortController);
+    let result;
+    try {
+      result = await Promise.race([invokePromise, timeoutHandle.promise]);
+    } finally {
+      timeoutHandle.cancel();
+    }
+    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,
+      snapshot: ctxSnapshot
+    });
+    await spanService.finish(executionSpanId, "success", startTime, {
+      output: content,
+      metadata: {
+        depth: currentDepth,
+        maxDepth,
+        toolName,
+        recursionLimit,
+        messages: result.messages,
+        traceCount: trace.length
+      }
     });
     return {
       status: "success",
@@ -195,15 +832,40 @@ ${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
+        }
+      ],
+      snapshot: ctxSnapshot
+    }).catch((logErr) => {
+      plugin.app.log.warn("[AgentOrchestrator] Failed to save error log for delegation", logErr);
+    });
+    await spanService.finish(executionSpanId, "error", startTime, {
+      error: truncateText(e.message, 1e4),
+      metadata: {
+        depth: currentDepth,
+        maxDepth,
+        toolName,
+        recursionLimit,
+        traceCount: trace.length + 1
+      }
     });
     return {
       status: "error",
@@ -212,30 +874,56 @@ ${context}` : `Task: ${task}`;
   }
 }
 async function logDelegation(ctx, plugin, data) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e, _f;
   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 = (_a = data.snapshot) == null ? void 0 : _a.userId;
+    if (userId == null) {
+      try {
+        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 {
+      }
+    }
+    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: (data.error || "").substring(0, 2e3),
-        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)
+        ...values,
+        createdAt: /* @__PURE__ */ new Date()
       }
     });
+    return ((_f = record == null ? void 0 : record.toJSON) == null ? void 0 : _f.call(record)) || record;
   } catch (e) {
     plugin.app.log.warn("[AgentOrchestrator] Failed to log delegation event", e);
   }
 }
-async function executeAgent(executor, systemPrompt, task, signal) {
-  const config = { recursionLimit: 50 };
+async function executeAgent(executor, systemPrompt, task, signal, recursionLimit = 50) {
+  const config = { recursionLimit };
   if (signal) {
     config.signal = signal;
   }
@@ -248,25 +936,50 @@ async function executeAgent(executor, systemPrompt, task, signal) {
   const messages = (finalState == null ? void 0 : finalState.messages) || [];
   const lastAIMessage = [...messages].reverse().find((m) => m.getType() === "ai");
   if (!lastAIMessage || !lastAIMessage.content) {
-    return "";
+    return { content: "", messages: serializeMessages(messages) };
   }
+  let content = "";
   if (typeof lastAIMessage.content === "string") {
-    return lastAIMessage.content;
+    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);
   }
-  if (Array.isArray(lastAIMessage.content)) {
-    return lastAIMessage.content.map((c) => c.text || JSON.stringify(c)).join("\n");
-  }
-  return String(lastAIMessage.content);
+  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(
-    (_, reject) => setTimeout(() => {
+  let timer;
+  const promise = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
       abortController == null ? void 0 : abortController.abort();
       reject(new Error(`Sub-agent "${agentName}" timed out after ${ms / 1e3}s`));
-    }, ms)
-  );
+    }, ms);
+  });
+  return {
+    promise,
+    cancel: () => {
+      if (timer) clearTimeout(timer);
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDelegateToolsProvider
+  createDelegateToolsProvider,
+  invalidateDelegateToolsCache
 });