@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-2O4MCSQS.js

@@ -0,0 +1,780 @@
+import {
+  Profiles
+} from "./chunk-6HZBHFOL.js";
+import {
+  createLocalDispatchRuntime
+} from "./chunk-SSFBF3US.js";
+import {
+  Tool
+} from "./chunk-Q742PSH3.js";
+
+// src/subagents/types.ts
+var DEFAULT_SUBAGENT_CONCURRENCY = 6;
+var DEFAULT_SUBAGENT_DEPTH = 2;
+var DEFAULT_SUBAGENT_SESSION_PREFIX = "Subagent";
+
+// src/subagents/tool-factories.ts
+import { z } from "zod";
+
+// src/subagents/results.ts
+function formatUsageLine(result) {
+  return result.usage ? `
+Tokens: ${result.usage.inputTokens} in / ${result.usage.outputTokens} out` : "";
+}
+function formatToolCallsLine(result) {
+  return result.toolCalls.length > 0 ? `
+Tool calls: ${result.toolCalls.map((tool) => tool.name).join(", ")}` : "";
+}
+function formatInvalidAgentTypeResult(roleName, validNames) {
+  return {
+    title: "Invalid role",
+    output: `Unknown role "${roleName}".
+
+Available roles: ${validNames.join(", ")}`,
+    metadata: {}
+  };
+}
+function formatSpawnBlockedResult(message) {
+  return {
+    title: "Cannot start subagent dispatch",
+    output: message,
+    metadata: {}
+  };
+}
+function formatSyncSubAgentResult(roleName, result) {
+  return {
+    title: `${roleName} completed`,
+    output: `<agent_result role="${roleName}" session="${result.sessionId}">
+` + result.response + `
+</agent_result>` + formatUsageLine(result) + formatToolCallsLine(result),
+    metadata: {
+      sessionId: result.sessionId,
+      role: roleName,
+      toolCalls: result.toolCalls.length
+    }
+  };
+}
+function formatSyncSubAgentErrorResult(roleName, error) {
+  return {
+    title: `${roleName} failed`,
+    output: `Subagent "${roleName}" encountered an error:
+` + (error instanceof Error ? error.message : String(error)) + `
+
+Consider handling the task directly.`,
+    metadata: { role: roleName, error: true }
+  };
+}
+function formatAsyncSpawnedResult(agentId, roleName, sessionId) {
+  return {
+    title: `Spawned ${roleName}`,
+    output: `Subagent started successfully.
+
+ID: ${agentId}
+Role: ${roleName}
+` + (sessionId ? `Session: ${sessionId}
+
+` : "\n") + `Use wait_agent with this ID to collect the result later.`,
+    metadata: { agentId, role: roleName, sessionId }
+  };
+}
+function formatWaitResult(agentId, roleName, result) {
+  return {
+    title: `${roleName} finished`,
+    output: `<agent_result id="${agentId}" role="${roleName}" session="${result.sessionId}">
+` + result.response + `
+</agent_result>` + formatUsageLine(result) + formatToolCallsLine(result),
+    metadata: {
+      agentId,
+      role: roleName,
+      sessionId: result.sessionId,
+      toolCalls: result.toolCalls.length
+    }
+  };
+}
+function formatWaitTimeoutResult(timeoutMs, runningIds) {
+  return {
+    title: "Wait timed out",
+    output: `Timed out waiting after ${timeoutMs}ms.
+
+` + (runningIds.length > 0 ? `Still running: ${runningIds.join(", ")}` : "No requested subagents are still running."),
+    metadata: { timeoutMs, runningIds }
+  };
+}
+function formatWaitErrorResult(error) {
+  return {
+    title: "Wait failed",
+    output: error instanceof Error ? error.message : String(error),
+    metadata: { error: true }
+  };
+}
+function formatMissingAgentsResult(ids) {
+  return {
+    title: "Unknown subagent IDs",
+    output: `No tracked subagents found for: ${ids.join(", ")}`,
+    metadata: { missing: ids }
+  };
+}
+function formatCloseMissingAgentResult(id) {
+  return {
+    title: "Unknown subagent ID",
+    output: `No tracked subagent found for "${id}".`,
+    metadata: { id, missing: true }
+  };
+}
+function formatCloseAlreadyResolvedResult(id, state) {
+  return {
+    title: "Subagent already resolved",
+    output: `Subagent "${id}" is already ${state}.`,
+    metadata: { id, state }
+  };
+}
+function formatCancelledAgentResult(id, roleName) {
+  return {
+    title: `Cancelled ${roleName}`,
+    output: `Subagent "${id}" was cancelled.`,
+    metadata: { id, role: roleName, cancelled: true }
+  };
+}
+
+// src/subagents/tool-factories.ts
+var SUBAGENT_TOOL_IDS = [
+  "invoke_agent",
+  "wait_agent",
+  "close_agent"
+];
+function getRoleNames(roles) {
+  return roles.map((role) => role.name);
+}
+function findRole(roles, roleName) {
+  return roles.find((role) => role.name === roleName);
+}
+function buildInvokeDescription(roles, isAsync) {
+  const roleList = roles.map((role) => `  - "${role.name}": ${role.description}`).join("\n");
+  const modeNote = isAsync ? "Returns an agent ID immediately. For parallel work, launch all needed subagents first, then use `wait_agent` to collect the results." : "Blocks until the subagent completes and returns the result directly.";
+  return `Delegate a focused task to a specialized subagent.
+
+Available roles:
+${roleList}
+
+${modeNote}
+
+Guidelines:
+- Use subagents for well-scoped, independent tasks
+- Provide clear, self-contained instructions \u2014 the subagent has a fresh context
+- Include any relevant file paths, function names, or context the subagent needs
+- Mention the working directory structure if known (for example, "code is in packages/agent-core/src")
+- For parallel work, invoke multiple subagents before waiting for results
+- Subagents will retry on errors and explore alternatives`;
+}
+function toCompletedResult(record) {
+  if (!record.result || !record.sessionId) {
+    throw new Error(`Dispatch "${record.id}" did not produce a completed result.`);
+  }
+  return {
+    response: record.result.response,
+    sessionId: record.sessionId,
+    usage: record.result.usage,
+    toolCalls: record.result.toolCalls
+  };
+}
+async function waitForTerminalDispatch(runtime, id) {
+  for (; ; ) {
+    const record = await runtime.check(id, { waitMs: 1e3 });
+    if (!record) {
+      throw new Error(`Subagent dispatch "${id}" was not found.`);
+    }
+    if (record.status !== "running") {
+      return record;
+    }
+  }
+}
+function formatTerminalFailure(record) {
+  if (record.status === "failed") {
+    return formatWaitErrorResult(
+      new Error(record.error ?? `Subagent "${record.id}" failed.`)
+    );
+  }
+  if (record.status === "cancelled") {
+    return formatWaitErrorResult(
+      new Error(record.error ?? `Subagent "${record.id}" was cancelled.`)
+    );
+  }
+  return formatWaitErrorResult(
+    new Error(`Subagent "${record.id}" is in unexpected state "${record.status}".`)
+  );
+}
+function createInvokeAgentTool(runtime, roles, options) {
+  const isAsync = options?.async ?? false;
+  const titlePrefix = options?.sessionTitlePrefix ?? DEFAULT_SUBAGENT_SESSION_PREFIX;
+  const validNames = getRoleNames(roles);
+  return Tool.define("invoke_agent", () => ({
+    description: buildInvokeDescription(roles, isAsync),
+    parameters: z.object({
+      role: z.string().describe(
+        `The specialized role to use. Must be one of: ${validNames.join(", ")}`
+      ),
+      task: z.string().describe(
+        "A detailed, self-contained description of the task. Include all context the subagent needs."
+      ),
+      title: z.string().optional().describe("Short title for tracking (3-5 words)")
+    }),
+    execute: async (params, ctx) => {
+      const role = findRole(roles, params.role);
+      if (!role) {
+        return formatInvalidAgentTypeResult(params.role, validNames);
+      }
+      let started;
+      try {
+        started = await runtime.start({
+          targetType: role.name,
+          brief: params.task,
+          title: params.title ?? `${titlePrefix}: ${role.name}`,
+          parentSessionId: ctx.sessionID,
+          abort: ctx.abort
+        });
+      } catch (error) {
+        return formatSpawnBlockedResult(
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      if (isAsync) {
+        return formatAsyncSpawnedResult(started.id, role.name, started.sessionId);
+      }
+      try {
+        const finished = await waitForTerminalDispatch(runtime, started.id);
+        if (finished.status === "completed") {
+          return formatSyncSubAgentResult(
+            role.name,
+            toCompletedResult(finished)
+          );
+        }
+        return formatSyncSubAgentErrorResult(
+          role.name,
+          finished.error ?? `Subagent finished with status "${finished.status}".`
+        );
+      } catch (error) {
+        return formatSyncSubAgentErrorResult(role.name, error);
+      }
+    }
+  }));
+}
+function createWaitAgentTool(runtime) {
+  return Tool.define("wait_agent", {
+    description: "Wait for one or more subagents to complete and return their results. When multiple IDs are provided, returns whichever finishes first. Use a timeout to avoid blocking indefinitely.",
+    parameters: z.object({
+      ids: z.array(z.string()).min(1).describe("Subagent IDs to wait on (from invoke_agent)"),
+      timeout_ms: z.number().optional().describe("Timeout in milliseconds (default: 60000, max: 600000)")
+    }),
+    execute: async (params) => {
+      const timeoutMs = Math.min(params.timeout_ms ?? 6e4, 6e5);
+      const existing = await Promise.all(
+        params.ids.map(async (id) => [id, await runtime.check(id)])
+      );
+      const missing = existing.filter(([, record]) => !record).map(([id]) => id);
+      if (missing.length > 0) {
+        return formatMissingAgentsResult(missing);
+      }
+      const checks = params.ids.map(async (id) => {
+        const record = await runtime.check(id, { waitMs: timeoutMs });
+        return [id, record];
+      });
+      try {
+        const [id, record] = await Promise.race(checks);
+        if (record.status === "running") {
+          const runningIds = existing.filter(([, current]) => current?.status === "running").map(([currentId]) => currentId);
+          return formatWaitTimeoutResult(timeoutMs, runningIds);
+        }
+        if (record.status === "completed") {
+          return formatWaitResult(
+            id,
+            record.targetType,
+            toCompletedResult(record)
+          );
+        }
+        return formatTerminalFailure(record);
+      } catch (error) {
+        return formatWaitErrorResult(error);
+      }
+    }
+  });
+}
+function createCloseAgentTool(runtime) {
+  return Tool.define("close_agent", {
+    description: "Cancel a running subagent. Use when the result is no longer needed or the subagent is taking too long.",
+    parameters: z.object({
+      id: z.string().describe("Subagent ID to cancel (from invoke_agent)")
+    }),
+    execute: async (params) => {
+      const record = await runtime.check(params.id);
+      if (!record) {
+        return formatCloseMissingAgentResult(params.id);
+      }
+      if (record.status !== "running") {
+        return formatCloseAlreadyResolvedResult(params.id, record.status);
+      }
+      const cancelled = await runtime.cancel(params.id);
+      return formatCancelledAgentResult(params.id, cancelled.targetType);
+    }
+  });
+}
+
+// src/subagents/tools.ts
+function createSubAgentTools(parent, options) {
+  if (options.roles.length === 0) {
+    return [];
+  }
+  const currentDepth = options.currentDepth ?? 0;
+  const maxDepth = options.maxDepth ?? DEFAULT_SUBAGENT_DEPTH;
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+  const runtime = createLocalDispatchRuntime({
+    ...options,
+    parent,
+    childToolIds: SUBAGENT_TOOL_IDS,
+    createChildTools: (childRuntime) => {
+      const tools2 = [
+        createInvokeAgentTool(childRuntime, options.roles, options)
+      ];
+      if (options.async) {
+        tools2.push(
+          createWaitAgentTool(childRuntime),
+          createCloseAgentTool(childRuntime)
+        );
+      }
+      return tools2;
+    }
+  });
+  const tools = [
+    createInvokeAgentTool(runtime, options.roles, options)
+  ];
+  if (options.async) {
+    tools.push(createWaitAgentTool(runtime), createCloseAgentTool(runtime));
+  }
+  return tools;
+}
+
+// src/subagents/installation.ts
+var LOCAL_SUBAGENT_BACKEND = "@cuylabs/agent-core/local";
+var installedSubAgents = /* @__PURE__ */ new WeakMap();
+function cloneConfig(config) {
+  return {
+    ...config,
+    roles: [...config.roles]
+  };
+}
+function configureSubAgents(agent, config) {
+  const next = cloneConfig(config);
+  const target = agent;
+  const current = installedSubAgents.get(target);
+  installedSubAgents.set(target, {
+    config: next,
+    backend: current?.backend ?? "uninstalled"
+  });
+  return next;
+}
+function getConfiguredSubAgents(agent) {
+  return installedSubAgents.get(agent)?.config;
+}
+function getInstalledSubAgentBackend(agent) {
+  const backend = installedSubAgents.get(agent)?.backend;
+  return backend && backend !== "uninstalled" ? backend : void 0;
+}
+function clearInstalledSubAgents(agent) {
+  installedSubAgents.delete(agent);
+  for (const toolId of SUBAGENT_TOOL_IDS) {
+    agent.removeTool(toolId);
+  }
+}
+function installSubAgentTools(options) {
+  const target = options.agent;
+  const config = configureSubAgents(target, options.config);
+  for (const toolId of SUBAGENT_TOOL_IDS) {
+    target.removeTool(toolId);
+  }
+  for (const tool of options.tools) {
+    target.addTool(tool);
+  }
+  installedSubAgents.set(target, {
+    config,
+    backend: options.backend
+  });
+  return options.tools;
+}
+function installLocalSubAgents(agent, config) {
+  const resolved = config ?? getConfiguredSubAgents(agent);
+  if (!resolved) {
+    return [];
+  }
+  const tools = createSubAgentTools(agent, resolved);
+  return installSubAgentTools({
+    agent,
+    config: resolved,
+    backend: LOCAL_SUBAGENT_BACKEND,
+    tools
+  });
+}
+
+// src/subagents/roles/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+
+// src/subagents/roles/markdown-profile.ts
+var FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+var VALID_REASONING_LEVELS = /* @__PURE__ */ new Set([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function parseSubAgentRoleFrontmatter(raw) {
+  const result = {};
+  const lines = raw.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "|") {
+      const blockLines = [];
+      i++;
+      while (i < lines.length) {
+        const blockLine = lines[i];
+        if (blockLine.length > 0 && !blockLine.startsWith(" ") && !blockLine.startsWith("	")) {
+          break;
+        }
+        blockLines.push(blockLine);
+        i++;
+      }
+      const minIndent = blockLines.filter((l) => l.trim().length > 0).reduce((min, l) => {
+        const indent = l.match(/^(\s*)/)?.[1].length ?? 0;
+        return Math.min(min, indent);
+      }, Infinity);
+      result[key] = blockLines.map((l) => l.trim().length === 0 ? "" : l.slice(minIndent)).join("\n").trim();
+      continue;
+    }
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key.length > 0) {
+      result[key] = value;
+    }
+    i++;
+  }
+  return result;
+}
+function parseMarkdownSubAgentRole(content, filePath) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    return null;
+  }
+  const [, rawFrontmatter, body] = match;
+  const fields = parseSubAgentRoleFrontmatter(rawFrontmatter);
+  if (!fields.name || !fields.description) {
+    return null;
+  }
+  const frontmatter = {
+    name: fields.name,
+    description: fields.description
+  };
+  if (fields.profile) frontmatter.profile = fields.profile;
+  if (fields.extends) frontmatter.extends = fields.extends;
+  if (fields.model) frontmatter.model = fields.model;
+  if (fields.maxSteps) frontmatter.maxSteps = fields.maxSteps;
+  if (fields.temperature) frontmatter.temperature = fields.temperature;
+  if (fields.reasoning) frontmatter.reasoning = fields.reasoning;
+  if (fields.tools) frontmatter.tools = fields.tools;
+  if (fields.skills) frontmatter.skills = fields.skills;
+  if (fields.allowFurtherDispatch) {
+    frontmatter.allowFurtherDispatch = fields.allowFurtherDispatch;
+  }
+  return {
+    frontmatter,
+    body: body.trim(),
+    filePath
+  };
+}
+function normalizeToolPattern(pattern) {
+  return pattern.trim();
+}
+function parseSubAgentToolSpec(raw) {
+  if (!raw || raw.trim().length === 0) {
+    return { mode: "inherit" };
+  }
+  const parts = raw.split(",").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    return { mode: "inherit" };
+  }
+  const hasModified = parts.some((part) => part.startsWith("+") || part.startsWith("-"));
+  if (hasModified) {
+    return {
+      mode: "modifiers",
+      modifiers: parts.map((part) => ({
+        kind: part.startsWith("-") ? "remove" : "add",
+        pattern: normalizeToolPattern(
+          part.startsWith("+") || part.startsWith("-") ? part.slice(1) : part
+        )
+      }))
+    };
+  }
+  return {
+    mode: "explicit",
+    patterns: parts.map(normalizeToolPattern)
+  };
+}
+function toSubAgentRole(parsed, resolvers = {}) {
+  const { frontmatter } = parsed;
+  const parent = frontmatter.extends ? resolvers.resolveParent?.(frontmatter.extends) : void 0;
+  const profile = frontmatter.profile ? resolvers.resolveProfile?.(frontmatter.profile) : parent?.profile;
+  const systemPrompt = parsed.body.length > 0 ? parent?.systemPrompt ? parsed.body.replaceAll("{basePrompt}", parent.systemPrompt) : parsed.body : parent?.systemPrompt;
+  const maxSteps = frontmatter.maxSteps ? parseInt(frontmatter.maxSteps, 10) : parent?.maxSteps;
+  let resolvedProfile = profile;
+  const temperature = frontmatter.temperature ? parseFloat(frontmatter.temperature) : void 0;
+  const reasoning = frontmatter.reasoning;
+  if (temperature !== void 0 || reasoning !== void 0) {
+    resolvedProfile = {
+      ...profile ?? { name: "custom", description: "Markdown-defined role" },
+      ...temperature !== void 0 ? { temperature } : {},
+      ...reasoning !== void 0 && VALID_REASONING_LEVELS.has(reasoning) ? { reasoningLevel: reasoning } : {}
+    };
+  }
+  const toolSpec = parseSubAgentToolSpec(frontmatter.tools);
+  if (toolSpec.mode === "explicit" || toolSpec.mode === "modifiers") {
+    resolvedProfile = {
+      ...resolvedProfile ?? { name: "custom", description: "Markdown-defined role" }
+    };
+    if (toolSpec.mode === "explicit") {
+      resolvedProfile.allowTools = toolSpec.patterns;
+      resolvedProfile.denyTools = void 0;
+    } else {
+      const baseAllow = [...resolvedProfile.allowTools ?? []];
+      const baseDeny = [...resolvedProfile.denyTools ?? []];
+      for (const mod of toolSpec.modifiers) {
+        if (mod.kind === "add") {
+          baseAllow.push(mod.pattern);
+          const denyIdx = baseDeny.indexOf(mod.pattern);
+          if (denyIdx !== -1) baseDeny.splice(denyIdx, 1);
+        } else {
+          baseDeny.push(mod.pattern);
+          const allowIdx = baseAllow.indexOf(mod.pattern);
+          if (allowIdx !== -1) baseAllow.splice(allowIdx, 1);
+        }
+      }
+      if (baseAllow.length > 0) resolvedProfile.allowTools = baseAllow;
+      if (baseDeny.length > 0) resolvedProfile.denyTools = baseDeny;
+    }
+  }
+  const allowFurtherDispatch = frontmatter.allowFurtherDispatch ? frontmatter.allowFurtherDispatch === "true" : parent?.allowFurtherDispatch;
+  const role = {
+    name: frontmatter.name,
+    description: frontmatter.description
+  };
+  if (resolvedProfile) role.profile = resolvedProfile;
+  if (systemPrompt) role.systemPrompt = systemPrompt;
+  if (maxSteps !== void 0 && !isNaN(maxSteps)) role.maxSteps = maxSteps;
+  if (allowFurtherDispatch !== void 0) {
+    role.allowFurtherDispatch = allowFurtherDispatch;
+  }
+  if (frontmatter.model) {
+    role._modelId = frontmatter.model;
+  }
+  if (frontmatter.skills) {
+    role._skillNames = frontmatter.skills.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  role._source = parsed.filePath;
+  return role;
+}
+function isMarkdownSubAgentRole(role) {
+  return "_source" in role;
+}
+
+// src/subagents/roles/discovery.ts
+var DEFAULT_USER_DIR = join(homedir(), ".cuylabs", "agents");
+var DEFAULT_PROJECT_DIR = ".cuylabs/agents";
+var PRESET_MAP = {
+  explore: Profiles.explore,
+  plan: Profiles.plan,
+  review: Profiles.review,
+  quick: Profiles.quick,
+  careful: Profiles.careful,
+  code: Profiles.code,
+  watch: Profiles.watch
+};
+function defaultResolveProfile(name) {
+  return PRESET_MAP[name.toLowerCase()];
+}
+function isLoadableMarkdown(filename) {
+  return filename.endsWith(".md") && !filename.startsWith("_") && !filename.startsWith(".");
+}
+function loadRoleDir(dir, source, resolvers, errors, onRole) {
+  if (!existsSync(dir)) return [];
+  let stat;
+  try {
+    stat = statSync(dir);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) return [];
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  entries.sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (!isLoadableMarkdown(entry.name)) continue;
+    const filePath = join(dir, entry.name);
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const parsed = parseMarkdownSubAgentRole(content, filePath);
+      if (!parsed) {
+        errors.push({ path: filePath, error: "Missing required frontmatter (name, description)" });
+        continue;
+      }
+      const role = toSubAgentRole(parsed, resolvers);
+      const discovered = { role, source, filePath };
+      results.push(discovered);
+      onRole?.(discovered);
+    } catch (err) {
+      errors.push({
+        path: filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+function loadRoleFile(filePath, source, resolvers, errors, onRole) {
+  if (!existsSync(filePath)) {
+    errors.push({ path: filePath, error: "File not found" });
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseMarkdownSubAgentRole(content, filePath);
+    if (!parsed) {
+      errors.push({ path: filePath, error: "Missing required frontmatter (name, description)" });
+      return null;
+    }
+    const role = toSubAgentRole(parsed, resolvers);
+    const discovered = { role, source, filePath };
+    onRole?.(discovered);
+    return discovered;
+  } catch (err) {
+    errors.push({
+      path: filePath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+function getUserSubAgentRolesDir(userDir = DEFAULT_USER_DIR) {
+  return userDir;
+}
+function getProjectSubAgentRolesDir(cwd, projectDir = DEFAULT_PROJECT_DIR) {
+  return resolve(cwd, projectDir);
+}
+function discoverSubAgentRoles(options) {
+  const errors = [];
+  const discovered = [];
+  const merged = /* @__PURE__ */ new Map();
+  const builtInRoles = options.builtInRoles ?? [];
+  for (const role of builtInRoles) {
+    discovered.push({ role, source: "builtin" });
+    merged.set(role.name, role);
+  }
+  const roleIndex = new Map(
+    builtInRoles.map((role) => [role.name, role])
+  );
+  const resolveProfile = options.resolveProfile ?? defaultResolveProfile;
+  const resolvers = {
+    resolveProfile,
+    resolveParent: (name) => roleIndex.get(name)
+  };
+  const register = (entry) => {
+    discovered.push(entry);
+    merged.set(entry.role.name, entry.role);
+    roleIndex.set(entry.role.name, entry.role);
+  };
+  loadRoleDir(
+    getUserSubAgentRolesDir(options.userDir),
+    "user",
+    resolvers,
+    errors,
+    register
+  );
+  loadRoleDir(
+    getProjectSubAgentRolesDir(options.cwd, options.projectDir),
+    "project",
+    resolvers,
+    errors,
+    register
+  );
+  for (const configPath of options.configPaths ?? []) {
+    const fullPath = isAbsolute(configPath) ? configPath : resolve(options.cwd, configPath);
+    const stat = existsSync(fullPath) ? statSync(fullPath) : void 0;
+    if (stat?.isDirectory()) {
+      loadRoleDir(fullPath, "config", resolvers, errors, register);
+    } else {
+      loadRoleFile(fullPath, "config", resolvers, errors, register);
+    }
+  }
+  return {
+    roles: [...merged.values()],
+    discovered,
+    errors
+  };
+}
+
+export {
+  DEFAULT_SUBAGENT_CONCURRENCY,
+  DEFAULT_SUBAGENT_DEPTH,
+  DEFAULT_SUBAGENT_SESSION_PREFIX,
+  formatInvalidAgentTypeResult,
+  formatSpawnBlockedResult,
+  formatSyncSubAgentResult,
+  formatSyncSubAgentErrorResult,
+  formatAsyncSpawnedResult,
+  formatWaitResult,
+  formatWaitTimeoutResult,
+  formatWaitErrorResult,
+  formatMissingAgentsResult,
+  formatCloseMissingAgentResult,
+  formatCloseAlreadyResolvedResult,
+  formatCancelledAgentResult,
+  SUBAGENT_TOOL_IDS,
+  createInvokeAgentTool,
+  createWaitAgentTool,
+  createCloseAgentTool,
+  createSubAgentTools,
+  LOCAL_SUBAGENT_BACKEND,
+  configureSubAgents,
+  getConfiguredSubAgents,
+  getInstalledSubAgentBackend,
+  clearInstalledSubAgents,
+  installSubAgentTools,
+  installLocalSubAgents,
+  parseSubAgentRoleFrontmatter,
+  parseMarkdownSubAgentRole,
+  parseSubAgentToolSpec,
+  toSubAgentRole,
+  isMarkdownSubAgentRole,
+  getUserSubAgentRolesDir,
+  getProjectSubAgentRolesDir,
+  discoverSubAgentRoles
+};