@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/safety/index.d.ts

@@ -1,10 +1,27 @@
-import { R as RiskLevel, a as ApprovalConfig, c as ApprovalRule } from '../types-CWm-7rvB.js';
-export { A as ApprovalAction, b as ApprovalRequest } from '../types-CWm-7rvB.js';
+import { c9 as RiskLevel, ap as ApprovalRule, an as ApprovalRequest, aq as ApprovalRuleContext, ca as RuleSource, ae as ApprovalCascadePolicy, am as ApprovalRememberScope, ah as ApprovalDecision, af as ApprovalConfig } from '../instance-BqV2D5pc.js';
+export { ab as ApprovalAction, ad as ApprovalCascadeMode, ag as ApprovalCorrection, ai as ApprovalEvaluation, ak as ApprovalHandler, ao as ApprovalResolution, dE as createApprovalHandler } from '../instance-BqV2D5pc.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
+import 'zod';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
 
 /**
  * Get the risk level for a tool.
+ *
+ * Resolution order (first match wins):
+ *  1. Caller-supplied `customRisks` map (e.g. from ApprovalMiddlewareConfig)
+ *  2. Tool-declared `riskLevel` from capabilities (set via Tool.define)
+ *  3. Built-in `DEFAULT_TOOL_RISKS` map
+ *  4. Fallback: `"moderate"`
  */
-declare function getToolRisk(tool: string, customRisks?: Record<string, RiskLevel>): RiskLevel;
+declare function getToolRisk(tool: string, customRisks?: Record<string, RiskLevel>, 
+/** Risk level declared by the tool's own capabilities. */
+declaredRisk?: RiskLevel): RiskLevel;
 
 /**
  * Thrown when a user or rule denies an operation.
@@ -12,7 +29,8 @@ declare function getToolRisk(tool: string, customRisks?: Record<string, RiskLeve
 declare class ApprovalDeniedError extends Error {
     readonly tool: string;
     readonly args: unknown;
-    constructor(tool: string, args: unknown, message?: string);
+    readonly feedback?: string;
+    constructor(tool: string, args: unknown, detail?: string);
 }
 /**
  * Thrown when an approval request times out.
@@ -23,16 +41,93 @@ declare class ApprovalTimeoutError extends Error {
     constructor(tool: string, timeoutMs: number);
 }
 
+type ApprovalRuleCondition = NonNullable<ApprovalRule["when"]>;
+declare function createConditionalApprovalRule(rule: Omit<ApprovalRule, "when">, when: ApprovalRuleCondition): ApprovalRule;
+declare function allApprovalConditions(...conditions: ApprovalRuleCondition[]): ApprovalRuleCondition;
+declare function anyApprovalConditions(...conditions: ApprovalRuleCondition[]): ApprovalRuleCondition;
+declare function matchApprovalSessions(...sessionIds: string[]): ApprovalRuleCondition;
+declare function matchApprovalRisks(...risks: RiskLevel[]): ApprovalRuleCondition;
+declare function matchApprovalArgValue(path: string, predicate: (value: unknown, context: ApprovalRuleContext) => boolean): ApprovalRuleCondition;
+interface ApprovalNumericThresholdOptions {
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+declare function matchApprovalNumericArg(path: string, thresholds: ApprovalNumericThresholdOptions): ApprovalRuleCondition;
+declare function matchApprovalStringPrefixes(path: string, ...prefixes: string[]): ApprovalRuleCondition;
+declare function normalizeApprovalCascadePolicy(input?: ApprovalCascadePolicy): Required<ApprovalCascadePolicy>;
+declare function normalizeRememberScopes(scopes?: readonly ApprovalRememberScope[]): ApprovalRememberScope[];
+declare function selectRememberScope(decision: ApprovalDecision, request: ApprovalRequest, fallback?: ApprovalRememberScope): ApprovalRememberScope;
+declare function createRememberedApprovalRules(request: ApprovalRequest, source?: RuleSource): ApprovalRule[];
+declare function approvalRequestsOverlap(left: ApprovalRequest, right: ApprovalRequest): boolean;
+declare function shouldCascadeApprovalDecision(resolved: ApprovalRequest, candidate: ApprovalRequest, decision: ApprovalDecision): boolean;
+declare function formatApprovalDeniedReason(tool: string, detail?: string): string;
+declare function createApprovalCorrection(tool: string, detail?: string): {
+    kind: "approval-denied";
+    tool: string;
+    reason: string;
+    feedback?: string;
+};
+declare function buildApprovalRuleContext(sessionId: string, tool: string, args: unknown, risk: RiskLevel, patternExtractor?: (input: unknown) => string[]): ApprovalRuleContext;
+
+type ApprovalPolicyPresetName = "interactive" | "headless-deny" | "dangerously-allow-all" | "risk-tier";
+interface ApprovalPolicyPresetOptions {
+    onRequest?: ApprovalConfig["onRequest"];
+    rules?: ApprovalRule[];
+    timeout?: number;
+    rememberScope?: ApprovalRememberScope;
+    allowedRememberScopes?: ApprovalConfig["allowedRememberScopes"];
+    cascade?: ApprovalConfig["cascade"];
+}
+interface RiskTierApprovalPolicyOptions extends ApprovalPolicyPresetOptions {
+    safe?: ApprovalConfig["defaultAction"];
+    moderate?: ApprovalConfig["defaultAction"];
+    dangerous?: ApprovalConfig["defaultAction"];
+    source?: RuleSource;
+}
+interface TrustedSessionApprovalPolicyOptions extends ApprovalPolicyPresetOptions {
+    sessionIds: string[];
+    tools?: string[];
+    patterns?: string[];
+    risks?: RiskLevel[];
+    source?: RuleSource;
+}
+interface ThresholdApprovalRuleOptions {
+    tool: string;
+    pattern?: string;
+    action: "allow" | "deny";
+    argPath: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+    source?: RuleSource;
+    reason?: string;
+}
+declare function createInteractiveApprovalPolicy(options?: ApprovalPolicyPresetOptions): ApprovalConfig;
+declare function createHeadlessDenyApprovalPolicy(options?: Omit<ApprovalPolicyPresetOptions, "onRequest">): ApprovalConfig;
+declare function createDangerouslyAllowAllApprovalPolicy(options?: Omit<ApprovalPolicyPresetOptions, "onRequest">): ApprovalConfig;
+declare function createRiskTierApprovalPolicy(options?: RiskTierApprovalPolicyOptions): ApprovalConfig;
+declare function createTrustedSessionApprovalPolicy(options: TrustedSessionApprovalPolicyOptions): ApprovalConfig;
+declare function createThresholdApprovalRule(options: ThresholdApprovalRuleOptions): ApprovalRule;
+declare function createApprovalPolicyPreset(name: ApprovalPolicyPresetName, options?: ApprovalPolicyPresetOptions | RiskTierApprovalPolicyOptions): ApprovalConfig;
+
 /**
- * Creates an approval handler for managing tool execution permissions.
+ * Simple glob-style pattern matching.
+ * Supports: `*` (any chars), `?` (single char)
+ *
+ * Uses an iterative two-pointer approach instead of regex
+ * to avoid ReDoS risk from user-provided patterns.
  */
-declare function createApprovalHandler(config?: ApprovalConfig): {
-    request: (sessionId: string, tool: string, args: unknown, customRisks?: Record<string, RiskLevel>) => Promise<void>;
-    cancelAll: (_reason?: string) => void;
-    addRule: (rule: ApprovalRule) => void;
-    getRules: () => readonly ApprovalRule[];
-    clearSessionRules: () => void;
-};
-type ApprovalHandler = ReturnType<typeof createApprovalHandler>;
+declare function matchApprovalPattern(pattern: string, value: string): boolean;
+/**
+ * Extract approval patterns from tool arguments for "remember" functionality.
+ */
+declare function extractApprovalPatterns(tool: string, args: unknown): string[];
+/**
+ * Generate a human-readable description of an operation.
+ */
+declare function describeApprovalOperation(tool: string, args: unknown): string;
 
-export { ApprovalConfig, ApprovalDeniedError, type ApprovalHandler, ApprovalRule, ApprovalTimeoutError, RiskLevel, createApprovalHandler, getToolRisk };
+export { ApprovalCascadePolicy, ApprovalConfig, ApprovalDecision, ApprovalDeniedError, type ApprovalPolicyPresetName, type ApprovalPolicyPresetOptions, ApprovalRememberScope, ApprovalRequest, ApprovalRule, type ApprovalRuleCondition, ApprovalRuleContext, ApprovalTimeoutError, RiskLevel, type RiskTierApprovalPolicyOptions, RuleSource, type ThresholdApprovalRuleOptions, type TrustedSessionApprovalPolicyOptions, allApprovalConditions, anyApprovalConditions, approvalRequestsOverlap, buildApprovalRuleContext, createApprovalCorrection, createApprovalPolicyPreset, createConditionalApprovalRule, createDangerouslyAllowAllApprovalPolicy, createHeadlessDenyApprovalPolicy, createInteractiveApprovalPolicy, createRememberedApprovalRules, createRiskTierApprovalPolicy, createThresholdApprovalRule, createTrustedSessionApprovalPolicy, describeApprovalOperation, extractApprovalPatterns, formatApprovalDeniedReason, getToolRisk, matchApprovalArgValue, matchApprovalNumericArg, matchApprovalPattern, matchApprovalRisks, matchApprovalSessions, matchApprovalStringPrefixes, normalizeApprovalCascadePolicy, normalizeRememberScopes, selectRememberScope, shouldCascadeApprovalDecision };

package/dist/safety/index.js

@@ -1,12 +1,68 @@
 import {
   ApprovalDeniedError,
   ApprovalTimeoutError,
+  allApprovalConditions,
+  anyApprovalConditions,
+  approvalRequestsOverlap,
+  buildApprovalRuleContext,
+  createApprovalCorrection,
   createApprovalHandler,
-  getToolRisk
-} from "../chunk-5ARZJWD2.js";
+  createApprovalPolicyPreset,
+  createConditionalApprovalRule,
+  createDangerouslyAllowAllApprovalPolicy,
+  createHeadlessDenyApprovalPolicy,
+  createInteractiveApprovalPolicy,
+  createRememberedApprovalRules,
+  createRiskTierApprovalPolicy,
+  createThresholdApprovalRule,
+  createTrustedSessionApprovalPolicy,
+  formatApprovalDeniedReason,
+  getToolRisk,
+  matchApprovalArgValue,
+  matchApprovalNumericArg,
+  matchApprovalRisks,
+  matchApprovalSessions,
+  matchApprovalStringPrefixes,
+  normalizeApprovalCascadePolicy,
+  normalizeRememberScopes,
+  selectRememberScope,
+  shouldCascadeApprovalDecision
+} from "../chunk-V4RFNEET.js";
+import {
+  describeApprovalOperation,
+  extractApprovalPatterns,
+  matchApprovalPattern
+} from "../chunk-FII65CN7.js";
 export {
   ApprovalDeniedError,
   ApprovalTimeoutError,
+  allApprovalConditions,
+  anyApprovalConditions,
+  approvalRequestsOverlap,
+  buildApprovalRuleContext,
+  createApprovalCorrection,
   createApprovalHandler,
-  getToolRisk
+  createApprovalPolicyPreset,
+  createConditionalApprovalRule,
+  createDangerouslyAllowAllApprovalPolicy,
+  createHeadlessDenyApprovalPolicy,
+  createInteractiveApprovalPolicy,
+  createRememberedApprovalRules,
+  createRiskTierApprovalPolicy,
+  createThresholdApprovalRule,
+  createTrustedSessionApprovalPolicy,
+  describeApprovalOperation,
+  extractApprovalPatterns,
+  formatApprovalDeniedReason,
+  getToolRisk,
+  matchApprovalArgValue,
+  matchApprovalNumericArg,
+  matchApprovalPattern,
+  matchApprovalRisks,
+  matchApprovalSessions,
+  matchApprovalStringPrefixes,
+  normalizeApprovalCascadePolicy,
+  normalizeRememberScopes,
+  selectRememberScope,
+  shouldCascadeApprovalDecision
 };

package/dist/sandbox/index.d.ts

@@ -0,0 +1,81 @@
+import { T as ToolHost } from '../types-C_LCeYNg.js';
+
+/**
+ * Preview endpoint exposed by a managed sandbox environment.
+ */
+interface SandboxPreview {
+    /** The internal port inside the environment. */
+    port: number;
+    /** Publicly reachable URL for the preview. */
+    url: string;
+    /** Optional user-facing label. */
+    label?: string;
+}
+/**
+ * Snapshot handle returned by a sandbox implementation.
+ */
+interface SandboxSnapshotResult {
+    /** Provider-specific snapshot identifier. */
+    id: string;
+    /** Optional display label or description. */
+    label?: string;
+    /** Provider-specific metadata for later restore flows. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Metadata describing a managed sandbox session.
+ */
+interface SandboxSessionMetadata {
+    /** Implementation kind such as "docker", "local", or "cloud". */
+    kind?: string;
+    /** Human-readable label for logs or dashboards. */
+    label?: string;
+    /** Working directory exposed through the embedded ToolHost. */
+    workingDirectory?: string;
+    /** Extra environment details suitable for prompts or UI surfaces. */
+    environmentDetails?: string;
+    /** Preview endpoints exposed by the environment. */
+    previews?: readonly SandboxPreview[];
+    /** Session expiration timestamp when managed by a lease/timeout system. */
+    expiresAt?: number;
+    /** Initial timeout/lease duration in milliseconds. */
+    timeoutMs?: number;
+    /** Provider-specific metadata. */
+    [key: string]: unknown;
+}
+/**
+ * Managed execution environment used by host-backed tools.
+ *
+ * A SandboxSession owns environment lifecycle concerns such as start/stop,
+ * snapshots, timeout extension, and preview URLs, while exposing a `ToolHost`
+ * for the actual file/shell operations tools perform.
+ */
+interface SandboxSession {
+    /** Stable identifier for the environment session. */
+    readonly id: string;
+    /** Tool execution surface exposed by the environment. */
+    readonly host: ToolHost;
+    /** Optional metadata about the environment. */
+    readonly metadata?: SandboxSessionMetadata;
+    /** Stop and clean up the environment. */
+    stop(): Promise<void>;
+    /** Create a restorable snapshot when supported by the provider. */
+    snapshot?(): Promise<SandboxSnapshotResult>;
+    /** Extend the environment lease/timeout when supported. */
+    extendTimeout?(additionalMs: number): Promise<{
+        expiresAt: number;
+    } | void>;
+    /** Return a preview URL for an exposed port when supported. */
+    getPreviewUrl?(port: number): string | undefined;
+}
+/**
+ * Factory/connector surface for sandbox implementations.
+ *
+ * Providers may support only `connect`, only `create`, or both.
+ */
+interface SandboxProvider<TConnectOptions = unknown, TCreateOptions = TConnectOptions> {
+    connect?(options: TConnectOptions): Promise<SandboxSession>;
+    create?(options: TCreateOptions): Promise<SandboxSession>;
+}
+
+export type { SandboxPreview, SandboxProvider, SandboxSession, SandboxSessionMetadata, SandboxSnapshotResult };

package/dist/sandbox/index.js

@@ -0,0 +1 @@
+import "../chunk-VOUEJSW6.js";

package/dist/skill/index.d.ts

@@ -1,12 +1,14 @@
-import { h as SkillScope, i as SkillSource, a as SkillMetadata, g as SkillResourceType, c as SkillResource, b as SkillContent, d as SkillConfig, S as SkillDiscoveryResult } from '../types-BfNpU8NS.js';
-export { R as RemoteSkillEntry, e as RemoteSkillIndex, f as SkillDiscoveryError, j as SkillSourceType } from '../types-BfNpU8NS.js';
-import { S as SkillRegistry } from '../registry-DwYqsQkX.js';
-export { c as createSkillRegistry, e as emptySkillRegistry } from '../registry-DwYqsQkX.js';
-import { T as Tool } from '../tool-CZWN3KbO.js';
+import { cy as SkillScope, cz as SkillSource, cu as SkillMetadata, cx as SkillResourceType, cw as SkillResource, cr as SkillContent, cq as SkillConfig, ct as SkillDiscoveryResult, cv as SkillRegistry, T as Tool } from '../instance-BqV2D5pc.js';
+export { c7 as RemoteSkillEntry, c8 as RemoteSkillIndex, cs as SkillDiscoveryError, cA as SkillSourceType, dH as createSkillRegistry, dJ as emptySkillRegistry } from '../instance-BqV2D5pc.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
 import 'zod';
-import '../tool-DkhSCV2Y.js';
-import '../types-CHiPh8U2.js';
-import '../types-CQL-SvTn.js';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
 
 declare const SKILL_FILENAME = "SKILL.md";
 declare const DEFAULT_SKILL_MAX_SIZE = 102400;

package/dist/skill/index.js

@@ -2,8 +2,7 @@ import {
   createSkillResourceTool,
   createSkillTool,
   createSkillTools
-} from "../chunk-RKEW5WXI.js";
-import "../chunk-MHKK374K.js";
+} from "../chunk-TOTDGK3P.js";
 import {
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_MAX_SCAN_DEPTH,
@@ -19,6 +18,7 @@ import {
   loadSkillMetadata,
   parseFrontmatter
 } from "../chunk-SPILYYDF.js";
+import "../chunk-Q742PSH3.js";
 export {
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_MAX_SCAN_DEPTH,

package/dist/storage/index.d.ts

@@ -1,6 +1,14 @@
-import { F as FileEntry, g as SessionEntry, M as MessageEntry, c as MetadataEntry, e as SerializedMessage, i as SessionInfo, j as SessionStorage, h as SessionHeader, S as SessionManager } from '../session-manager-KbYt2WUh.js';
-export { B as BranchEntry, C as CompactionEntry, a as ConfigChangeEntry, b as CreateSessionOptions, E as EntryBase, d as STORAGE_VERSION, f as SessionContext } from '../session-manager-KbYt2WUh.js';
-import { M as Message } from '../messages-BYWGn8TY.js';
+import { b8 as FileEntry, ci as SessionEntry, M as Message, bB as MessageEntry, bJ as MetadataEntry, cf as SerializedMessage, ck as SessionInfo, cl as SessionStorage, cj as SessionHeader, S as SessionManager } from '../instance-BqV2D5pc.js';
+export { at as BranchEntry, ay as CompactionEntry, aA as ConfigChangeEntry, aG as CreateSessionOptions, b5 as EntryBase, ce as STORAGE_VERSION, ch as SessionContext } from '../instance-BqV2D5pc.js';
+import { L as Logger } from '../types-RSCv7nQ4.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import 'zod';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
 
 /**
  * Storage Utilities
@@ -17,7 +25,7 @@ declare function generateEntryId(existingIds?: Set<string>): string;
  * Parse JSONL content into entries
  * Handles malformed lines gracefully
  */
-declare function parseJSONL<T>(content: string): T[];
+declare function parseJSONL<T>(content: string, logger?: Logger): T[];
 /**
  * Serialize entry to JSONL line
  */

package/dist/storage/index.js

@@ -22,7 +22,7 @@ import {
   serializeMessage,
   toJSONL,
   toJSONLBatch
-} from "../chunk-UHCJEM2E.js";
+} from "../chunk-ICZ66572.js";
 export {
   FileStorage,
   MemoryStorage,

package/dist/subagents/index.d.ts

@@ -0,0 +1,177 @@
+import { aT as DispatchRole, aS as DispatchResult, br as LocalDispatchRuntimeOptions, B as Agent, T as Tool, aU as DispatchRuntime, c2 as Profile } from '../instance-BqV2D5pc.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
+import 'zod';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
+
+/**
+ * Subagent types.
+ *
+ * Subagents are the model-facing tool surface built on top of the local
+ * dispatch runtime.
+ *
+ * @packageDocumentation
+ */
+
+type SubAgentRole = DispatchRole;
+interface SubAgentCompletedResult extends DispatchResult {
+    sessionId: string;
+}
+interface SubAgentConfig extends Omit<LocalDispatchRuntimeOptions, "parent" | "childToolIds" | "createChildTools"> {
+    async?: boolean;
+}
+type SubAgentToolsOptions = SubAgentConfig;
+declare const DEFAULT_SUBAGENT_CONCURRENCY = 6;
+declare const DEFAULT_SUBAGENT_DEPTH = 2;
+declare const DEFAULT_SUBAGENT_SESSION_PREFIX = "Subagent";
+
+/**
+ * Subagent tools.
+ *
+ * Provides `invoke_agent`, `wait_agent`, and `close_agent` backed by the
+ * local in-process dispatch runtime.
+ *
+ * @packageDocumentation
+ */
+
+declare function createSubAgentTools(parent: Agent, options: SubAgentToolsOptions): Tool.AnyInfo[];
+
+declare const SUBAGENT_TOOL_IDS: readonly ["invoke_agent", "wait_agent", "close_agent"];
+declare function createInvokeAgentTool(runtime: DispatchRuntime, roles: readonly SubAgentRole[], options?: {
+    async?: boolean;
+    sessionTitlePrefix?: string;
+}): Tool.AnyInfo;
+declare function createWaitAgentTool(runtime: DispatchRuntime): Tool.AnyInfo;
+declare function createCloseAgentTool(runtime: DispatchRuntime): Tool.AnyInfo;
+
+declare function formatInvalidAgentTypeResult(roleName: string, validNames: string[]): Tool.ExecuteResult;
+declare function formatSpawnBlockedResult(message: string): Tool.ExecuteResult;
+declare function formatSyncSubAgentResult(roleName: string, result: SubAgentCompletedResult): Tool.ExecuteResult;
+declare function formatSyncSubAgentErrorResult(roleName: string, error: unknown): Tool.ExecuteResult;
+declare function formatAsyncSpawnedResult(agentId: string, roleName: string, sessionId?: string): Tool.ExecuteResult;
+declare function formatWaitResult(agentId: string, roleName: string, result: SubAgentCompletedResult): Tool.ExecuteResult;
+declare function formatWaitTimeoutResult(timeoutMs: number, runningIds: string[]): Tool.ExecuteResult;
+declare function formatWaitErrorResult(error: unknown): Tool.ExecuteResult;
+declare function formatMissingAgentsResult(ids: string[]): Tool.ExecuteResult;
+declare function formatCloseMissingAgentResult(id: string): Tool.ExecuteResult;
+declare function formatCloseAlreadyResolvedResult(id: string, state: string): Tool.ExecuteResult;
+declare function formatCancelledAgentResult(id: string, roleName: string): Tool.ExecuteResult;
+
+declare const LOCAL_SUBAGENT_BACKEND = "@cuylabs/agent-core/local";
+interface SubAgentInstallTarget {
+    addTool(tool: Tool.Info): void;
+    removeTool(toolId: string): boolean;
+}
+declare function configureSubAgents(agent: object, config: SubAgentConfig): SubAgentConfig;
+declare function getConfiguredSubAgents(agent: object): SubAgentConfig | undefined;
+declare function getInstalledSubAgentBackend(agent: object): string | undefined;
+declare function clearInstalledSubAgents(agent: SubAgentInstallTarget & object): void;
+declare function installSubAgentTools(options: {
+    agent: SubAgentInstallTarget & object;
+    config: SubAgentConfig;
+    backend: string;
+    tools: readonly Tool.AnyInfo[];
+}): readonly Tool.AnyInfo[];
+declare function installLocalSubAgents(agent: SubAgentInstallTarget & object, config?: SubAgentConfig): readonly Tool.AnyInfo[];
+
+/**
+ * Markdown subagent role parser.
+ *
+ * Parses `.md` files into `SubAgentRole` objects using a hybrid approach:
+ * frontmatter maps to role config, and the body becomes the system prompt.
+ *
+ * @packageDocumentation
+ */
+
+interface MarkdownSubAgentRoleFrontmatter {
+    name: string;
+    description: string;
+    profile?: string;
+    extends?: string;
+    model?: string;
+    maxSteps?: string;
+    temperature?: string;
+    reasoning?: string;
+    tools?: string;
+    skills?: string;
+    allowFurtherDispatch?: string;
+}
+interface ParsedMarkdownSubAgentRole {
+    frontmatter: MarkdownSubAgentRoleFrontmatter;
+    body: string;
+    filePath: string;
+}
+type ToolModifier = {
+    kind: "add";
+    pattern: string;
+} | {
+    kind: "remove";
+    pattern: string;
+};
+type ParsedToolSpec = {
+    mode: "explicit";
+    patterns: string[];
+} | {
+    mode: "modifiers";
+    modifiers: ToolModifier[];
+} | {
+    mode: "inherit";
+};
+interface SubAgentRoleResolvers {
+    resolveProfile?: (name: string) => Profile | undefined;
+    resolveParent?: (name: string) => SubAgentRole | undefined;
+}
+declare function parseSubAgentRoleFrontmatter(raw: string): Record<string, string>;
+declare function parseMarkdownSubAgentRole(content: string, filePath: string): ParsedMarkdownSubAgentRole | null;
+declare function parseSubAgentToolSpec(raw?: string): ParsedToolSpec;
+declare function toSubAgentRole(parsed: ParsedMarkdownSubAgentRole, resolvers?: SubAgentRoleResolvers): SubAgentRole;
+interface MarkdownSubAgentRole extends SubAgentRole {
+    _modelId?: string;
+    _skillNames?: string[];
+    _source?: string;
+}
+declare function isMarkdownSubAgentRole(role: SubAgentRole): role is MarkdownSubAgentRole;
+type ParsedSubAgentToolSpec = ParsedToolSpec;
+type SubAgentToolModifier = ToolModifier;
+
+/**
+ * Subagent role discovery.
+ *
+ * Discovers subagent roles from markdown files across multiple locations
+ * and merges them with built-in TypeScript roles.
+ *
+ * @packageDocumentation
+ */
+
+type SubAgentRoleSource = "builtin" | "user" | "project" | "config";
+interface DiscoveredSubAgentRole {
+    role: SubAgentRole;
+    source: SubAgentRoleSource;
+    filePath?: string;
+}
+interface SubAgentRoleDiscoveryOptions {
+    cwd: string;
+    userDir?: string;
+    projectDir?: string;
+    configPaths?: string[];
+    builtInRoles?: SubAgentRole[];
+    resolveProfile?: (name: string) => Profile | undefined;
+}
+interface SubAgentRoleDiscoveryResult {
+    roles: SubAgentRole[];
+    discovered: DiscoveredSubAgentRole[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+declare function getUserSubAgentRolesDir(userDir?: string): string;
+declare function getProjectSubAgentRolesDir(cwd: string, projectDir?: string): string;
+declare function discoverSubAgentRoles(options: SubAgentRoleDiscoveryOptions): SubAgentRoleDiscoveryResult;
+
+export { DEFAULT_SUBAGENT_CONCURRENCY, DEFAULT_SUBAGENT_DEPTH, DEFAULT_SUBAGENT_SESSION_PREFIX, type DiscoveredSubAgentRole, LOCAL_SUBAGENT_BACKEND, type MarkdownSubAgentRole, type MarkdownSubAgentRoleFrontmatter, type ParsedMarkdownSubAgentRole, type ParsedSubAgentToolSpec, SUBAGENT_TOOL_IDS, type SubAgentCompletedResult, type SubAgentConfig, type SubAgentRole, type SubAgentRoleDiscoveryOptions, type SubAgentRoleDiscoveryResult, type SubAgentRoleResolvers, type SubAgentRoleSource, type SubAgentToolModifier, type SubAgentToolsOptions, clearInstalledSubAgents, configureSubAgents, createCloseAgentTool, createInvokeAgentTool, createSubAgentTools, createWaitAgentTool, discoverSubAgentRoles, formatAsyncSpawnedResult, formatCancelledAgentResult, formatCloseAlreadyResolvedResult, formatCloseMissingAgentResult, formatInvalidAgentTypeResult, formatMissingAgentsResult, formatSpawnBlockedResult, formatSyncSubAgentErrorResult, formatSyncSubAgentResult, formatWaitErrorResult, formatWaitResult, formatWaitTimeoutResult, getConfiguredSubAgents, getInstalledSubAgentBackend, getProjectSubAgentRolesDir, getUserSubAgentRolesDir, installLocalSubAgents, installSubAgentTools, isMarkdownSubAgentRole, parseMarkdownSubAgentRole, parseSubAgentRoleFrontmatter, parseSubAgentToolSpec, toSubAgentRole };

package/dist/subagents/index.js

@@ -0,0 +1,78 @@
+import {
+  DEFAULT_SUBAGENT_CONCURRENCY,
+  DEFAULT_SUBAGENT_DEPTH,
+  DEFAULT_SUBAGENT_SESSION_PREFIX,
+  LOCAL_SUBAGENT_BACKEND,
+  SUBAGENT_TOOL_IDS,
+  clearInstalledSubAgents,
+  configureSubAgents,
+  createCloseAgentTool,
+  createInvokeAgentTool,
+  createSubAgentTools,
+  createWaitAgentTool,
+  discoverSubAgentRoles,
+  formatAsyncSpawnedResult,
+  formatCancelledAgentResult,
+  formatCloseAlreadyResolvedResult,
+  formatCloseMissingAgentResult,
+  formatInvalidAgentTypeResult,
+  formatMissingAgentsResult,
+  formatSpawnBlockedResult,
+  formatSyncSubAgentErrorResult,
+  formatSyncSubAgentResult,
+  formatWaitErrorResult,
+  formatWaitResult,
+  formatWaitTimeoutResult,
+  getConfiguredSubAgents,
+  getInstalledSubAgentBackend,
+  getProjectSubAgentRolesDir,
+  getUserSubAgentRolesDir,
+  installLocalSubAgents,
+  installSubAgentTools,
+  isMarkdownSubAgentRole,
+  parseMarkdownSubAgentRole,
+  parseSubAgentRoleFrontmatter,
+  parseSubAgentToolSpec,
+  toSubAgentRole
+} from "../chunk-2O4MCSQS.js";
+import "../chunk-6HZBHFOL.js";
+import "../chunk-SSFBF3US.js";
+import "../chunk-Q742PSH3.js";
+import "../chunk-ICZ66572.js";
+export {
+  DEFAULT_SUBAGENT_CONCURRENCY,
+  DEFAULT_SUBAGENT_DEPTH,
+  DEFAULT_SUBAGENT_SESSION_PREFIX,
+  LOCAL_SUBAGENT_BACKEND,
+  SUBAGENT_TOOL_IDS,
+  clearInstalledSubAgents,
+  configureSubAgents,
+  createCloseAgentTool,
+  createInvokeAgentTool,
+  createSubAgentTools,
+  createWaitAgentTool,
+  discoverSubAgentRoles,
+  formatAsyncSpawnedResult,
+  formatCancelledAgentResult,
+  formatCloseAlreadyResolvedResult,
+  formatCloseMissingAgentResult,
+  formatInvalidAgentTypeResult,
+  formatMissingAgentsResult,
+  formatSpawnBlockedResult,
+  formatSyncSubAgentErrorResult,
+  formatSyncSubAgentResult,
+  formatWaitErrorResult,
+  formatWaitResult,
+  formatWaitTimeoutResult,
+  getConfiguredSubAgents,
+  getInstalledSubAgentBackend,
+  getProjectSubAgentRolesDir,
+  getUserSubAgentRolesDir,
+  installLocalSubAgents,
+  installSubAgentTools,
+  isMarkdownSubAgentRole,
+  parseMarkdownSubAgentRole,
+  parseSubAgentRoleFrontmatter,
+  parseSubAgentToolSpec,
+  toSubAgentRole
+};