@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/team/index.d.ts

@@ -0,0 +1,544 @@
+import { aB as CoordinatorNotification, cS as TaskCompletion, dg as TokenUsage, A as AgentEvent, dT as CoordinatorCtx, B as Agent, bw as MemberRuntime, cP as TaskBoard, bs as Mailbox, cW as TaskDispatchMode, bV as PermissionHandler, d4 as TeamCoordinatorConfig, cX as TaskExecutor, d5 as TeamEvent, d6 as TeamMember, c6 as QueueTaskInput, dd as TeamTask, d7 as TeamMessage, d9 as TeamPlan, cL as SynthesisResult, da as TeamSnapshot, c_ as TaskListFilter, bF as MessageListFilter, c1 as PreparedExternalTask, c$ as TaskResult, d1 as TaskTransition, bx as MemberStats, by as MemberStatus, L as AgentMiddleware, dh as ToolCallDecision } from '../instance-BqV2D5pc.js';
+export { aC as CoordinatorNotificationKind, aD as CoordinatorRoundEvent, b7 as ExternalTaskControl, b9 as GuidancePayload, bl as IdleNotificationPayload, bm as InMemoryMailboxStore, bn as InMemoryTaskBoardStore, bt as MailboxStore, bu as MailboxSubscriber, bv as MemberRegisteredEvent, bz as MemberStatusChangedEvent, bD as MessageInput, bE as MessageKind, bG as MessagePayload, bI as MessageSentEvent, bO as NotificationPriority, bU as PermissionForwardedEvent, bW as PermissionRequestPayload, bX as PermissionResolvedEvent, bY as PermissionResponsePayload, bZ as PlanCreatedEvent, b_ as PlannedTask, cm as ShutdownRequestPayload, cn as ShutdownRequestedEvent, co as ShutdownResolvedEvent, cp as ShutdownResponsePayload, cK as SynthesisCompleteEvent, cN as TERMINAL_STATUSES, cO as TaskAbortedEvent, cQ as TaskBoardStore, cR as TaskCompletedEvent, cT as TaskConflictError, cU as TaskCreateInput, cV as TaskCreatedEvent, cY as TaskExecutorInput, cZ as TaskFailedEvent, d0 as TaskStatus, d2 as TaskTransitionEvent, d3 as TaskTransitionReason, d8 as TeamNotificationEvent, db as TeamStartedEvent, dc as TeamStoppedEvent, dw as WorkerReportPayload, dA as buildCoordinatorNotificationEvent } from '../instance-BqV2D5pc.js';
+import { R as ReasoningLevel } from '../types-CQaXbRsS.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
+import 'zod';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
+
+interface CoordinatorInboxItem {
+    id: string;
+    kind: "user-message" | "notification";
+    createdAt: string;
+    body: string;
+    notification?: CoordinatorNotification;
+}
+interface CoordinatorRuntimeStatus {
+    phase: "ready" | "running" | "waiting" | "error";
+    message: string;
+    pendingInboxCount: number;
+    activeTaskCount: number;
+}
+interface CoordinatorStatus {
+    phase: "thinking" | "waiting" | "done";
+    round: number;
+    message: string;
+}
+interface WorkerReport {
+    messageId: string;
+    memberId: string;
+    taskId?: string;
+    createdAt?: string;
+    message: string;
+}
+interface CoordinatorRound {
+    number: number;
+    assigned: Array<{
+        taskId: string;
+        memberId: string;
+        title: string;
+    }>;
+    messaged: Array<{
+        memberId: string;
+    }>;
+    stopped: string[];
+    completions: TaskCompletion[];
+    reports: WorkerReport[];
+    response: string;
+    usage: TokenUsage;
+}
+interface CoordinatorLoopOptions {
+    maxRounds?: number;
+    waitTimeoutMs?: number;
+    onRound?: (round: CoordinatorRound) => void | Promise<void>;
+    onStatus?: (status: CoordinatorStatus) => void;
+    onCoordinatorEvent?: (event: AgentEvent) => void;
+    onLog?: (message: string) => void;
+    coordinatorReasoningLevel?: ReasoningLevel;
+}
+interface CoordinatorLoopResult {
+    response: string;
+    rounds: CoordinatorRound[];
+    usage: TokenUsage;
+}
+
+/**
+ * Team Coordinator
+ *
+ * Orchestrates a team of forked agents working toward a shared goal.
+ *
+ * Responsibilities:
+ * - Register members by forking agents from roles
+ * - Queue and dispatch tasks with dependency-aware scheduling
+ * - Route messages between coordinator and members
+ * - Track task execution and cascade status transitions
+ * - Synthesize results from completed tasks
+ * - Emit team events for observability
+ *
+ * The coordinator is deliberately host-agnostic. It uses:
+ * - `TaskBoard` + `TaskBoardStore` for task/member persistence
+ * - `Mailbox` + `MailboxStore` for messaging persistence
+ * - `Agent.fork()` + `Agent.run()` for member execution
+ *
+ * Hosts (CLI, HTTP server, chatbot) provide concrete stores
+ * and wire the coordinator to their UI/transport layer.
+ *
+ * Design choices vs CLI CliTeamController:
+ * - No dependency on agent-runtime's orchestrator — uses Agent.run() directly
+ * - Explicit "claimed" state between pending and running
+ * - Event-driven via TeamEvent emitter instead of mailbox system messages
+ * - Members tracked as `{ agent, member, role }` tuples
+ * - `guide()` method for mid-task interventions via InterventionController
+ * - Configurable `onEvent` callback instead of coupling to a specific event bus
+ *
+ * Execution, work-loop, and shutdown logic are extracted into
+ * focused modules to keep this file manageable:
+ * - `execution.ts` — task dispatch and Agent.run() lifecycle
+ * - `work-loop.ts` — persistent idle loop and auto-claim
+ * - `shutdown.ts` — two-phase graceful shutdown protocol
+ */
+
+/**
+ * Team coordinator — manages a team of agents working in parallel.
+ *
+ * ```typescript
+ * const team = createTeamCoordinator({
+ *   lead: agent,
+ *   leadSessionId: "main",
+ *   roles: [explorerRole, coderRole, reviewerRole],
+ * });
+ *
+ * await team.start();
+ * await team.registerAll();
+ * await team.queue({ title: "Explore codebase", prompt: "...", memberId: "explorer" });
+ * await team.queue({ title: "Implement feature", prompt: "...", dependsOn: [task1.id] });
+ * await team.waitForAll();
+ * const result = await team.synthesize("Build a REST API");
+ * await team.stop();
+ * ```
+ */
+declare class TeamCoordinator implements CoordinatorCtx {
+    readonly teamId: string;
+    /** @internal */ readonly lead: Agent;
+    /** @internal */ readonly leadSessionId: string;
+    /** @internal */ readonly createId: () => string;
+    private readonly roles;
+    /** @internal */ readonly members: Map<string, MemberRuntime>;
+    /** @internal */ readonly taskBoard: TaskBoard;
+    /** @internal */ readonly mailbox: Mailbox;
+    private readonly onEvent?;
+    private readonly eventListeners;
+    private readonly signal?;
+    /** @internal */ readonly workLoopEnabled: boolean;
+    /** @internal */ readonly taskDispatchMode: TaskDispatchMode;
+    /** @internal */ readonly pollIntervalMs: number;
+    /** @internal */ readonly onPermissionRequest?: PermissionHandler;
+    /** @internal */ readonly beforeIteration?: TeamCoordinatorConfig["beforeIteration"];
+    /** @internal */ readonly sharedPermissions?: TeamCoordinatorConfig["sharedPermissions"];
+    /** @internal */ readonly taskExecutor?: TaskExecutor;
+    private readonly externalTaskControl?;
+    /** @internal */ started: boolean;
+    private readonly onLog?;
+    private readonly logger?;
+    private activeCoordinatorTurn?;
+    private mailboxUnsubscribe?;
+    private coordinatorAgent?;
+    private coordinatorSessionId?;
+    /** @internal */ coordinatorInbox: CoordinatorInboxItem[];
+    /** @internal */ coordinatorProcessing: boolean;
+    /** @internal */ coordinatorReschedule: boolean;
+    private coordinatorStatus;
+    private readonly coordinatorEventListeners;
+    private readonly coordinatorStatusListeners;
+    private coordinatorIdleResolvers;
+    /** @internal */ coordinatorRoundNumber: number;
+    private coordinatorRunSequence;
+    private coordinatorTurnState;
+    /** @internal Structured log output — writes to both logger and onLog when provided. */
+    log(msg: string): void;
+    private dispatchEvent;
+    subscribeTeamEvents(listener: (event: TeamEvent) => void | Promise<void>): () => void;
+    /** @internal */
+    publishCoordinatorEvent(event: AgentEvent): void;
+    /** @internal */
+    publishCoordinatorStatus(status: Partial<CoordinatorRuntimeStatus>): void;
+    /** @internal */
+    resolveCoordinatorIdleWaiters(): void;
+    constructor(config: TeamCoordinatorConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Register a team member from a role.
+     * Forks the lead agent with the role's specialization.
+     */
+    register(roleName: string, memberId?: string): Promise<TeamMember>;
+    /**
+     * Register all roles (or a subset) as team members.
+     */
+    registerAll(roleNames?: string[]): Promise<TeamMember[]>;
+    /**
+     * List available role names.
+     */
+    listRoles(): string[];
+    /**
+     * Queue a task. If dependencies are met and a member is idle,
+     * the task is dispatched immediately.
+     */
+    queue(input: QueueTaskInput): Promise<TeamTask>;
+    /**
+     * Dispatch all pending tasks to idle members.
+     * Called automatically after queue/complete/fail/cancel.
+     */
+    dispatchReady(): Promise<TeamTask[]>;
+    /**
+     * Wait for a specific task to reach a terminal state.
+     */
+    waitForTask(taskId: string, timeoutMs?: number): Promise<TaskCompletion>;
+    /**
+     * Wait for all tasks to reach terminal states.
+     */
+    waitForAll(timeoutMs?: number): Promise<TaskCompletion[]>;
+    /**
+     * Cancel a task. If it's running, the task's AbortController fires.
+     * Cascades to dependent tasks.
+     */
+    cancel(taskId: string, reason?: string): Promise<TeamTask>;
+    /**
+     * Abort a running task. The member returns to idle and can pick up
+     * new work. Unlike `cancel()`, abort preserves downstream tasks by
+     * leaving them blocked on the aborted prerequisite.
+     */
+    abort(taskId: string, reason?: string): Promise<void>;
+    /**
+     * Send a guidance message to a running member via intervention.
+     * If the member is idle, queues a direct-message task instead.
+     */
+    guide(memberId: string, message: string): Promise<void>;
+    /**
+     * Broadcast a message to all members. Active members receive it
+     * as an intervention; idle members see it on their next task.
+     */
+    broadcast(message: string): Promise<TeamMessage>;
+    /**
+     * Request graceful shutdown of a specific member.
+     *
+     * - If member is idle, auto-accepts and goes offline immediately
+     * - If member is busy, marks as shutting-down and waits for current
+     *   task to finish before going offline
+     * - Returns true if shutdown succeeded within the timeout
+     */
+    requestShutdown(memberId: string, reason?: string, timeoutMs?: number): Promise<boolean>;
+    /**
+     * Gracefully shut down all members.
+     */
+    shutdown(reason?: string, timeoutMs?: number): Promise<void>;
+    /**
+     * Handle a permission request forwarded from a team member.
+     * Called by the `teamPermissionPolicy` middleware when it has
+     * a `forwardApproval` callback pointing at the coordinator.
+     */
+    handlePermissionRequest(memberId: string, tool: string, args: unknown): Promise<{
+        decision: "allow" | "deny";
+        reason?: string;
+    }>;
+    /**
+     * Create a `forwardApproval` callback for `teamPermissionPolicy`
+     * that routes through this coordinator's permission handler.
+     */
+    createPermissionForwarder(memberId: string): (_memberId: string, tool: string, args: unknown, _ctx?: unknown) => Promise<{
+        action: "allow" | "deny";
+        reason?: string;
+    }>;
+    /** @internal */
+    beginCoordinatorTurnState(): {
+        actions: {
+            assigned: Array<{
+                taskId: string;
+                memberId: string;
+                title: string;
+            }>;
+            sentMessages: Array<{
+                memberId: string;
+            }>;
+            abortedTaskIds: string[];
+        };
+    };
+    /** @internal */
+    getActiveCoordinatorTurnState(): {
+        actions: {
+            assigned: Array<{
+                taskId: string;
+                memberId: string;
+                title: string;
+            }>;
+            sentMessages: Array<{
+                memberId: string;
+            }>;
+            abortedTaskIds: string[];
+        };
+    };
+    /** @internal */
+    endCoordinatorTurnState(): void;
+    /** @internal */
+    getCoordinatorInboxSize(): number;
+    /** @internal */
+    getActiveTaskCount(): Promise<number>;
+    /** @internal */
+    ensureCoordinatorAgent(): Agent;
+    /** @internal */
+    getCoordinatorSessionId(): string;
+    private resetCoordinatorRunSession;
+    private enqueueCoordinatorInboxItem;
+    private enqueueCoordinatorNotification;
+    /** @internal */
+    scheduleCoordinatorProcessing(): void;
+    /** @internal */ autonomousTurnCount: number;
+    waitForCoordinatorIdle(): Promise<void>;
+    submitToCoordinator(message: string): string;
+    subscribeCoordinatorEvents(listener: (event: AgentEvent) => void): () => void;
+    subscribeCoordinatorStatus(listener: (status: CoordinatorRuntimeStatus) => void): () => void;
+    getCoordinatorStatus(): CoordinatorRuntimeStatus;
+    /** @internal */
+    attachCoordinatorTurn(agent: Agent, sessionId: string): void;
+    /** @internal */
+    setCoordinatorTurnOpen(open: boolean): void;
+    /** @internal */
+    detachCoordinatorTurn(agent?: Agent): void;
+    /**
+     * Run the coordinator in an iterative loop.
+     *
+     * The lead agent is forked with delegation tools and a coordinator
+     * system prompt. It reasons about the request, assigns tasks to
+     * teammates, receives results, and continues until all work is done.
+     *
+     * This replaces the plan → fan-out → synthesize pipeline with a
+     * dynamic multi-round conversation where the coordinator decides
+     * what to delegate, how to react to results, and when it's done.
+     *
+     * Members must be registered before calling this method.
+     *
+     * @param prompt  - The user's request
+     * @param options - Loop configuration (max rounds, timeouts, progress callback)
+     */
+    run(prompt: string, options?: CoordinatorLoopOptions): Promise<CoordinatorLoopResult>;
+    plan(prompt: string, memberIds?: string[]): Promise<TeamPlan>;
+    planAndExecute(prompt: string, memberIds?: string[]): Promise<{
+        plan: TeamPlan;
+        tasks: TeamTask[];
+    }>;
+    /**
+     * Use the lead agent to synthesize all completed task results
+     * into a single coherent response.
+     *
+     * @param originalPrompt - The original task/prompt
+     * @param taskIds - Optional subset of task IDs to synthesize (defaults to all terminal tasks)
+     */
+    synthesize(originalPrompt: string, taskIds?: string[]): Promise<SynthesisResult>;
+    snapshot(): Promise<TeamSnapshot>;
+    listMembers(): Promise<TeamMember[]>;
+    listTasks(filter?: TaskListFilter): Promise<TeamTask[]>;
+    listMessages(filter?: Omit<MessageListFilter, "teamId">): Promise<TeamMessage[]>;
+    getMemberSessionId(memberId: string): string;
+    getMemberRole(memberId: string): string;
+    prepareTaskForExternalExecution(taskId: string, runId: string): Promise<PreparedExternalTask | undefined>;
+    completeExternalTask(taskId: string, result: TaskResult): Promise<{
+        task: TeamTask;
+        transitions: TaskTransition[];
+    } | undefined>;
+    failExternalTask(taskId: string, error: string): Promise<{
+        task: TeamTask;
+        transitions: TaskTransition[];
+    } | undefined>;
+    abortExternalTask(taskId: string, reason: string): Promise<{
+        task: TeamTask;
+        transitions: TaskTransition[];
+    } | undefined>;
+    getTask(taskId: string): Promise<TeamTask | undefined>;
+    /**
+     * Get aggregate stats for a member.
+     * Returns undefined if the member is not registered.
+     */
+    getMemberStats(memberId: string): MemberStats | undefined;
+    /**
+     * Subscribe to a member's agent events (text-delta, tool-start, etc.).
+     * Returns an unsubscribe function. Throws if the member is not registered.
+     */
+    onMemberEvent(memberId: string, handler: (event: AgentEvent) => void): () => void;
+    /**
+     * Serialize the coordinator state for persistence / resume.
+     * Returns snapshot + member stats, enough to reconstruct state.
+     */
+    toJSON(): Promise<{
+        teamId: string;
+        snapshot: TeamSnapshot;
+        memberStats: Record<string, MemberStats>;
+    }>;
+    /** @internal */
+    updateMemberStatus(memberId: string, status: MemberStatus, activeTaskId: string | undefined): Promise<void>;
+    private requireMember;
+    /** @internal */
+    emit(event: TeamEvent): Promise<void>;
+    /** @internal */
+    emitTransitions(transitions: TaskTransition[]): Promise<void>;
+    private finalizeExternallyTerminatedTask;
+}
+/**
+ * Create a team coordinator.
+ *
+ * ```typescript
+ * const team = createTeamCoordinator({
+ *   lead: agent,
+ *   leadSessionId: "main",
+ *   roles: [explorerRole, reviewerRole],
+ *   onEvent: (event) => console.log(event.type),
+ * });
+ * ```
+ */
+declare function createTeamCoordinator(config: TeamCoordinatorConfig): TeamCoordinator;
+
+/**
+ * Team Permission Policy
+ *
+ * Extends the existing approval middleware to support team-wide
+ * permission delegation. When a coordinator creates team members,
+ * it can install a `teamPermissionPolicy` middleware that:
+ *
+ * 1. Applies team-wide allow/deny rules to all member tool calls
+ * 2. Forwards unresolved approvals to the coordinator (lead agent)
+ * 3. Propagates "remember" decisions to all team members
+ *
+ * This is layered ON TOP of the existing `approvalMiddleware` —
+ * it doesn't replace it. Members inherit the lead's approval rules
+ * via fork(), and the team policy adds team-specific delegation.
+ *
+ * Design choices vs ccsource:
+ * - No filesystem polling for permission responses — uses callbacks
+ * - No separate sandbox permission path — uses standard approval pipeline
+ * - Team rules are typed objects, not mailbox message payloads
+ * - Integrates with existing `beforeToolCall` middleware contract
+ */
+
+/**
+ * A team-wide permission rule.
+ *
+ * Rules are evaluated in order — first match wins.
+ */
+interface TeamPermissionRule {
+    /** Tool name to match (exact or glob-style with `*`) */
+    tool: string;
+    /** Optional approval pattern to match against the tool input */
+    pattern?: string;
+    /** Member IDs this rule applies to (undefined = all members) */
+    members?: string[];
+    /** Whether to allow or deny */
+    action: "allow" | "deny";
+    /** Optional reason (shown to model on deny) */
+    reason?: string;
+}
+/**
+ * Callback for forwarding approval requests to the coordinator.
+ * Returns the coordinator's decision.
+ */
+type ApprovalForwarder = (memberId: string, tool: string, args: unknown, ctx: Parameters<NonNullable<AgentMiddleware["beforeToolCall"]>>[2]) => Promise<ToolCallDecision>;
+/**
+ * Configuration for the team permission policy middleware.
+ */
+interface TeamPermissionPolicyConfig {
+    /** The member ID this middleware is installed on */
+    memberId: string;
+    /** Team-wide rules (evaluated first, before forwarding) */
+    rules?: TeamPermissionRule[];
+    /**
+     * Forward unresolved approvals to this callback.
+     * If not provided, unresolved tools are allowed (fall through
+     * to the member's own approval middleware).
+     */
+    forwardApproval?: ApprovalForwarder;
+    /**
+     * Callback when a "remember" decision is made — the coordinator
+     * can propagate it to all members by updating their rule sets.
+     */
+    onRemember?: (rule: TeamPermissionRule) => void | Promise<void>;
+}
+/**
+ * Create a team permission policy middleware.
+ *
+ * Install this on forked member agents to enforce team-wide
+ * permission rules and optionally forward approvals to the
+ * coordinator.
+ *
+ * ```typescript
+ * const memberAgent = lead.fork({
+ *   name: "explorer",
+ *   additionalMiddleware: [
+ *     teamPermissionPolicy({
+ *       memberId: "explorer",
+ *       rules: [
+ *         { tool: "read_*", action: "allow" },
+ *         { tool: "write_*", action: "deny", reason: "Explorer is read-only" },
+ *       ],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function teamPermissionPolicy(config: TeamPermissionPolicyConfig): AgentMiddleware;
+
+interface CoordinatorRosterMember {
+    id: string;
+    role: string;
+    description?: string;
+}
+interface CoordinatorTaskNotificationLike {
+    taskId: string;
+    memberId: string;
+    title: string;
+    status: string;
+    result?: TaskResult;
+    error?: string;
+}
+interface CoordinatorWorkerReportLike {
+    messageId?: string;
+    memberId: string;
+    taskId?: string;
+    createdAt?: string;
+    message: string;
+}
+declare const coordinatorToolDescriptions: {
+    readonly assignTask: (memberList: string) => string;
+    readonly sendMessage: string;
+    readonly abortTask: string;
+};
+declare function buildCoordinatorSystemPrompt(members: CoordinatorRosterMember[]): string;
+declare function formatCoordinatorTaskNotifications(notifications: CoordinatorTaskNotificationLike[]): string;
+declare function formatCoordinatorWorkerReports(reports: CoordinatorWorkerReportLike[]): string;
+declare function formatCoordinatorRoundMessage(notifications: CoordinatorTaskNotificationLike[], reports: CoordinatorWorkerReportLike[]): string;
+
+interface CoordinatorRoundTransitionInput {
+    reasonAssignmentsCount: number;
+    activeTaskCount: number;
+    terminalAfterEvent: boolean;
+    notifications: CoordinatorTaskNotificationLike[];
+    reports: CoordinatorWorkerReportLike[];
+    reasonResponse: string;
+    roundResponse: string;
+    blockedMessage: string;
+}
+type CoordinatorRoundTransition = {
+    kind: "done";
+    finalResponse: string;
+} | {
+    kind: "wait";
+    nextMessage: string;
+} | {
+    kind: "continue";
+    nextMessage: string;
+};
+declare function addTokenUsage(total: TokenUsage, usage?: TokenUsage): TokenUsage;
+declare function evaluateCoordinatorRoundTransition(input: CoordinatorRoundTransitionInput): CoordinatorRoundTransition;
+
+export { type ApprovalForwarder, type CoordinatorInboxItem, type CoordinatorLoopOptions, type CoordinatorLoopResult, CoordinatorNotification, type CoordinatorRosterMember, type CoordinatorRound, type CoordinatorRoundTransition, type CoordinatorRoundTransitionInput, type CoordinatorRuntimeStatus, type CoordinatorStatus, type CoordinatorTaskNotificationLike, type CoordinatorWorkerReportLike, Mailbox, MemberRuntime, MemberStats, MemberStatus, MessageListFilter, PermissionHandler, PreparedExternalTask, QueueTaskInput, SynthesisResult, TaskBoard, TaskCompletion, TaskDispatchMode, TaskExecutor, TaskListFilter, TaskResult, TaskTransition, TeamCoordinator, TeamCoordinatorConfig, TeamEvent, TeamMember, TeamMessage, type TeamPermissionPolicyConfig, type TeamPermissionRule, TeamPlan, TeamSnapshot, TeamTask, type WorkerReport, addTokenUsage, buildCoordinatorSystemPrompt, coordinatorToolDescriptions, createTeamCoordinator, evaluateCoordinatorRoundTransition, formatCoordinatorRoundMessage, formatCoordinatorTaskNotifications, formatCoordinatorWorkerReports, teamPermissionPolicy };

package/dist/team/index.js

@@ -0,0 +1,41 @@
+import {
+  InMemoryMailboxStore,
+  InMemoryTaskBoardStore,
+  Mailbox,
+  TERMINAL_STATUSES,
+  TaskBoard,
+  TaskConflictError,
+  TeamCoordinator,
+  addTokenUsage,
+  buildCoordinatorNotificationEvent,
+  buildCoordinatorSystemPrompt,
+  coordinatorToolDescriptions,
+  createTeamCoordinator,
+  evaluateCoordinatorRoundTransition,
+  formatCoordinatorRoundMessage,
+  formatCoordinatorTaskNotifications,
+  formatCoordinatorWorkerReports,
+  teamPermissionPolicy
+} from "../chunk-MXAP4UG6.js";
+import "../chunk-SZ2XBPTW.js";
+import "../chunk-Q742PSH3.js";
+import "../chunk-FII65CN7.js";
+export {
+  InMemoryMailboxStore,
+  InMemoryTaskBoardStore,
+  Mailbox,
+  TERMINAL_STATUSES,
+  TaskBoard,
+  TaskConflictError,
+  TeamCoordinator,
+  addTokenUsage,
+  buildCoordinatorNotificationEvent,
+  buildCoordinatorSystemPrompt,
+  coordinatorToolDescriptions,
+  createTeamCoordinator,
+  evaluateCoordinatorRoundTransition,
+  formatCoordinatorRoundMessage,
+  formatCoordinatorTaskNotifications,
+  formatCoordinatorWorkerReports,
+  teamPermissionPolicy
+};

package/dist/tool/host/index.d.ts

@@ -0,0 +1,41 @@
+import { T as ToolHost } from '../../types-C_LCeYNg.js';
+export { D as DirEntry, E as ExecOptions, a as ExecResult, F as FileStat } from '../../types-C_LCeYNg.js';
+
+interface ToolHostProviderSummary {
+    name: string;
+    description?: string;
+}
+interface ToolHostProvider<Options = unknown> extends ToolHostProviderSummary {
+    create(options?: Options): ToolHost | Promise<ToolHost>;
+}
+declare class ToolHostRegistry {
+    private readonly providers;
+    register<Options>(provider: ToolHostProvider<Options>): this;
+    unregister(name: string): boolean;
+    get(name: string): ToolHostProvider<unknown> | undefined;
+    list(): ToolHostProviderSummary[];
+    create(name: string, options?: unknown): Promise<ToolHost>;
+}
+
+/**
+ * LocalHost — executes tools on the local machine.
+ *
+ * Default ToolHost implementation. Uses Node's `child_process.spawn`
+ * for commands and `node:fs/promises` for file operations.
+ */
+
+/**
+ * Create a ToolHost that runs everything on the local machine.
+ *
+ * @param defaultCwd  Working directory for commands when none is specified.
+ *                    Defaults to `process.cwd()`.
+ */
+declare function localHost(defaultCwd?: string): ToolHost;
+
+/**
+ * Tool host module — execution environment abstraction for tools.
+ */
+
+declare const defaultToolHostRegistry: ToolHostRegistry;
+
+export { ToolHost, type ToolHostProvider, type ToolHostProviderSummary, ToolHostRegistry, defaultToolHostRegistry, localHost };

package/dist/tool/host/index.js

@@ -0,0 +1,10 @@
+import {
+  ToolHostRegistry,
+  defaultToolHostRegistry,
+  localHost
+} from "../../chunk-X4VN4GIJ.js";
+export {
+  ToolHostRegistry,
+  defaultToolHostRegistry,
+  localHost
+};