plugin-agent-orchestrator 1.0.27 → 1.0.32

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

@@ -26,23 +26,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var delegate_task_exports = {};
 __export(delegate_task_exports, {
+  buildDelegateToolName: () => buildDelegateToolName,
+  buildDispatchToolName: () => buildDispatchToolName,
   createDelegateToolsProvider: () => createDelegateToolsProvider,
   invalidateDelegateToolsCache: () => invalidateDelegateToolsCache
 });
 module.exports = __toCommonJS(delegate_task_exports);
-var import_zod = require("zod");
-var import_crypto = require("crypto");
-var import_ExecutionSpanService = require("../services/ExecutionSpanService");
-var import_ctx_utils = require("../utils/ctx-utils");
-var import_logging = require("../utils/logging");
-const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
-const ORCHESTRATOR_PATH_KEY = "__orchestratorPath";
-const MAX_DISPATCH_CONCURRENCY = 5;
-const MAX_DISPATCH_TASKS = 20;
-const MAX_TOOL_NAME_LENGTH = 64;
-function getToolCallId(runtime) {
-  return typeof runtime === "string" ? runtime : runtime == null ? void 0 : runtime.toolCallId;
-}
 function sanitizeToolPart(value) {
   return (value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
 }
@@ -52,588 +41,21 @@ function buildDelegateToolName(leaderUsername, 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: "ASK",
-    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, runtime) => {
-      const id = getToolCallId(runtime) || `delegate-${Date.now()}`;
-      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: "ASK",
-    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, runtime) => {
-      var _a;
-      const id = getToolCallId(runtime) || `dispatch-${Date.now()}`;
-      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: (0, import_ctx_utils.trimText)(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: (0, import_ctx_utils.trimText)(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)
-      };
-    }
-  };
-}
-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 = (0, import_ctx_utils.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 (0, import_ctx_utils.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 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 invalidateDelegateToolsCache() {
 }
 function createDelegateToolsProvider(plugin) {
-  attachInvalidationHooks(plugin);
-  return async (register) => {
-    try {
-      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);
-      }
-      if (toolsCache.tools.length) {
-        register.registerTools(toolsCache.tools);
-      }
-    } catch (e) {
-      plugin.app.log.error("[AgentOrchestrator] Failed to register delegate tools", e);
-    }
+  return async () => {
+    var _a, _b, _c;
+    (_c = (_b = (_a = plugin.app) == null ? void 0 : _a.logger) == null ? void 0 : _b.info) == null ? void 0 : _c.call(
+      _b,
+      "[AgentOrchestrator] Legacy delegate_* tools are retired; native dispatch-sub-agent-task is used instead."
+    );
   };
 }
-function invalidateDelegateToolsCache() {
-  toolsCacheByPlugin = /* @__PURE__ */ new WeakMap();
-  registeredDelegateNamesByPlugin = /* @__PURE__ */ new WeakMap();
-}
-async function invokeDelegateTask(ctx, plugin, options) {
-  const {
-    leaderUsername,
-    subAgentUsername,
-    subAgentEmployee,
-    task,
-    context,
-    maxDepth,
-    timeout,
-    toolCallId,
-    toolName,
-    llmService,
-    model,
-    recursionLimit,
-    rootRunId: providedRootRunId,
-    parentSpanId: providedParentSpanId
-  } = options;
-  const ctxSnapshot = (0, import_ctx_utils.captureCtxSnapshot)(ctx);
-  const currentDepth = ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0;
-  const currentPath = ctx[ORCHESTRATOR_PATH_KEY] ?? [leaderUsername];
-  if (currentPath.includes(subAgentUsername)) {
-    const loopChain = [...currentPath, subAgentUsername].join(" -> ");
-    await logDelegation(ctx, plugin, {
-      leaderUsername,
-      subAgentUsername,
-      toolName,
-      task,
-      context,
-      result: "",
-      status: "error",
-      depth: currentDepth,
-      durationMs: 0,
-      error: `Circular delegation detected: ${loopChain}.`,
-      snapshot: ctxSnapshot
-    });
-    return {
-      status: "error",
-      content: `Circular delegation detected: ${loopChain}. Execution aborted to prevent infinite reasoning loops.`
-    };
-  }
-  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 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 agentLoopRunId = upstreamTraceContext == null ? void 0 : upstreamTraceContext.agentLoopRunId;
-  const agentLoopStepId = upstreamTraceContext == null ? void 0 : upstreamTraceContext.agentLoopStepId;
-  return plugin.agentLoopService.harness.runSubAgent(ctx, {
-    leaderUsername,
-    subAgentUsername,
-    subAgentEmployee,
-    task,
-    context,
-    currentDepth,
-    currentPath,
-    maxDepth,
-    timeout,
-    toolCallId,
-    toolName,
-    llmService,
-    model,
-    recursionLimit,
-    rootRunId,
-    parentSpanId,
-    agentLoopRunId,
-    agentLoopStepId
-  });
-}
-async function logDelegation(ctx, plugin, data) {
-  var _a, _b, _c, _d, _e;
-  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 {
-    }
-  }
-  return (0, import_logging.logDelegation)(ctx, plugin, { ...data, userId });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildDelegateToolName,
+  buildDispatchToolName,
   createDelegateToolsProvider,
   invalidateDelegateToolsCache
 });

package/dist/server/utils/skill-settings.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var skill_settings_exports = {};
 __export(skill_settings_exports, {
   isOrchestratorToolName: () => isOrchestratorToolName,
+  isRetiredOrchestratorToolName: () => isRetiredOrchestratorToolName,
   normalizeAIEmployeeSkillSettings: () => normalizeAIEmployeeSkillSettings
 });
 module.exports = __toCommonJS(skill_settings_exports);
@@ -34,7 +35,10 @@ function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isOrchestratorToolName(name) {
-  return name === "orchestrator_plan_goal" || name === "orchestrator_execute_plan" || name === "orchestrator_status" || name === "orchestrator_cancel" || name === "external_rag_search" || name === "skill_hub_execute" || name.startsWith("delegate_") || name.startsWith("dispatch_subagents_") || name.startsWith("skill_hub_") || name.startsWith("browser_") || name.startsWith("drawio-");
+  return name === "dispatch-sub-agent-task" || name === "external_rag_search" || name === "skill_hub_execute" || name.startsWith("skill_hub_") || name.startsWith("browser_") || name.startsWith("drawio-");
+}
+function isRetiredOrchestratorToolName(name) {
+  return name === "orchestrator_plan_goal" || name === "orchestrator_execute_plan" || name === "orchestrator_status" || name === "orchestrator_cancel" || name.startsWith("delegate_") || name.startsWith("dispatch_subagents_");
 }
 function toToolBinding(value) {
   if (typeof value === "string") {
@@ -69,6 +73,10 @@ function normalizeAIEmployeeSkillSettings(value) {
     for (const item of sourceTools) {
       const binding = toToolBinding(item);
       if (binding) {
+        if (isRetiredOrchestratorToolName(binding.name)) {
+          changed = true;
+          continue;
+        }
         addToolBinding(toolsByName, binding);
         if (typeof item === "string") {
           changed = true;
@@ -87,6 +95,10 @@ function normalizeAIEmployeeSkillSettings(value) {
           changed = true;
           continue;
         }
+        if (isRetiredOrchestratorToolName(name)) {
+          changed = true;
+          continue;
+        }
         if (isOrchestratorToolName(name)) {
           addToolBinding(toolsByName, { name, autoCall: false });
           changed = true;
@@ -100,6 +112,10 @@ function normalizeAIEmployeeSkillSettings(value) {
       }
       const legacyToolBinding = toToolBinding(item);
       if (legacyToolBinding) {
+        if (isRetiredOrchestratorToolName(legacyToolBinding.name)) {
+          changed = true;
+          continue;
+        }
         addToolBinding(toolsByName, legacyToolBinding);
       }
       changed = true;
@@ -118,5 +134,6 @@ function normalizeAIEmployeeSkillSettings(value) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isOrchestratorToolName,
+  isRetiredOrchestratorToolName,
   normalizeAIEmployeeSkillSettings
 });