@cuylabs/agent-runtime-dapr 0.9.0 → 0.10.0

package/dist/team/index.d.ts

@@ -0,0 +1,612 @@
+import { TaskBoardStore, TeamMember, TaskListFilter, TeamTask, MailboxStore, TeamMessage, MessageListFilter, TaskResult, WorkerReport, TeamCoordinator, TaskExecutor, CoordinatorLoopOptions, CoordinatorLoopResult, TeamEvent, TeamCoordinatorConfig } from '@cuylabs/agent-core/team';
+import { d as DaprSidecarClientOptions } from '../workflow-bridge-BcicHH1Y.js';
+import { TokenUsage, AgentWorkflowTurnState, Agent, DispatchRole } from '@cuylabs/agent-core';
+import { d as DaprWorkflowWorkerRuntime } from '../worker-CXq0IFGX.js';
+import { z as DaprWorkflowState, W as WaitForDaprWorkflowOptions } from '../client-UsEIzDF6.js';
+import { EventBus } from '@cuylabs/agent-core/events';
+import '../workflow-host-D6W6fXoL.js';
+
+type DaprStateQueryResponse<TValue> = {
+    results?: Array<{
+        key: string;
+        data?: TValue;
+        etag?: string;
+        error?: string;
+    }>;
+    token?: string;
+};
+type DaprStateValue<TValue> = {
+    value?: TValue;
+    etag?: string;
+};
+declare class DaprSidecarClient {
+    readonly stateStoreName?: string;
+    private readonly daprHttpEndpoint;
+    private readonly apiToken?;
+    private readonly fetchImpl;
+    private readonly requestTimeoutMs;
+    private readonly maxRequestRetries;
+    private readonly verifySidecarOnStart;
+    constructor(options: DaprSidecarClientOptions & {
+        stateStoreName?: string;
+    });
+    verifySidecar(): Promise<void>;
+    getStateEntry<TValue>(key: string): Promise<DaprStateValue<TValue>>;
+    getState<TValue>(key: string): Promise<TValue | undefined>;
+    saveState(key: string, value: unknown, options?: {
+        etag?: string;
+        concurrency?: "first-write" | "last-write";
+    }): Promise<void>;
+    deleteState(key: string, options?: {
+        etag?: string;
+        concurrency?: "first-write" | "last-write";
+    }): Promise<void>;
+    queryState<TValue>(query: unknown): Promise<DaprStateQueryResponse<TValue> | undefined>;
+    publish(pubsubName: string, topic: string, data: unknown, metadata?: Record<string, string>): Promise<void>;
+    requestJson<TValue = unknown>(path: string, init: RequestInit, allowedStatusCodes: number[]): Promise<TValue | undefined>;
+    request(path: string, init: RequestInit, allowedStatusCodes: number[], withJsonContentType?: boolean): Promise<Response>;
+    private requireStateStoreName;
+}
+
+/**
+ * Dapr State Store-backed TaskBoardStore
+ *
+ * Implements the `TaskBoardStore` interface from agent-core's team module
+ * using Dapr's state management API. Tasks and members are persisted as
+ * individual state entries, with lightweight indexes for list operations.
+ *
+ * Key layout:
+ *   team:{teamId}:members          — string[] index of member IDs
+ *   team:{teamId}:member:{id}      — serialized TeamMember
+ *   team:{teamId}:tasks            — string[] index of task IDs
+ *   team:{teamId}:task:{id}        — serialized TeamTask
+ *
+ * Index updates use optimistic concurrency (etag-based) with retries
+ * to handle concurrent access safely.
+ */
+
+interface DaprTaskBoardStoreOptions {
+    /** Dapr state store component name. Defaults to `"statestore"`. */
+    stateStoreName?: string;
+    /** Team identifier — scopes all keys. */
+    teamId: string;
+    /** Pre-existing client to reuse. If omitted, one is created from the other options. */
+    client?: DaprSidecarClient;
+    /** Dapr sidecar connection options (used only when `client` is not provided). */
+    clientOptions?: DaprSidecarClientOptions;
+}
+declare class DaprTaskBoardStore implements TaskBoardStore {
+    private readonly client;
+    private readonly teamId;
+    private readonly memberEtags;
+    private readonly taskEtags;
+    constructor(options: DaprTaskBoardStoreOptions);
+    private memberKey;
+    private memberIndexKey;
+    private taskKey;
+    private taskIndexKey;
+    listMembers(): Promise<TeamMember[]>;
+    getMember(memberId: string): Promise<TeamMember | undefined>;
+    putMember(member: TeamMember): Promise<TeamMember>;
+    listTasks(filter?: TaskListFilter): Promise<TeamTask[]>;
+    getTask(taskId: string): Promise<TeamTask | undefined>;
+    putTask(task: TeamTask): Promise<TeamTask>;
+    private resolveMemberEtag;
+    private resolveTaskEtag;
+    private readIndex;
+    private addToIndex;
+    private updateIndex;
+}
+
+/**
+ * Dapr State Store-backed MailboxStore
+ *
+ * Implements the `MailboxStore` interface from agent-core's team module
+ * using Dapr's state management API. Messages are individually stored
+ * with a lightweight index for list operations.
+ *
+ * Key layout:
+ *   team:{teamId}:messages          — string[] index of message IDs
+ *   team:{teamId}:msg:{id}          — serialized TeamMessage
+ *
+ * Index updates use optimistic concurrency (etag-based) with retries.
+ */
+
+interface DaprMailboxStoreOptions {
+    /** Dapr state store component name. Defaults to `"statestore"`. */
+    stateStoreName?: string;
+    /** Team identifier — scopes all keys. */
+    teamId: string;
+    /** Pre-existing client to reuse. If omitted, one is created from the other options. */
+    client?: DaprSidecarClient;
+    /** Dapr sidecar connection options (used only when `client` is not provided). */
+    clientOptions?: DaprSidecarClientOptions;
+}
+declare class DaprMailboxStore implements MailboxStore {
+    private readonly client;
+    private readonly teamId;
+    constructor(options: DaprMailboxStoreOptions);
+    private messageKey;
+    private messageIndexKey;
+    append(message: TeamMessage): Promise<TeamMessage>;
+    list(filter?: MessageListFilter): Promise<TeamMessage[]>;
+    private readIndex;
+    private addToIndex;
+    private updateIndex;
+}
+
+/**
+ * Durable Coordinator Workflow (Level 2)
+ *
+ * The coordinator loop runs as a Dapr workflow, but task and mailbox state
+ * still flow through `agent-core`'s team coordinator. The workflow records
+ * coordinator intent, applies those actions through the core coordinator,
+ * launches durable child turns for ready tasks, and feeds task/report
+ * notifications back into the next round.
+ */
+
+interface CoordinatorWorkflowInput {
+    prompt: string;
+    teamId: string;
+    maxRounds: number;
+    waitTimeoutMs: number;
+    coordinatorSessionId: string;
+    roleNames: string[];
+}
+interface CoordinatorAssignment {
+    /**
+     * Coordinator-local task alias used inside the LLM round.
+     * This is resolved to a real task-board task ID by `applyCoordinatorActions`.
+     */
+    taskId: string;
+    memberId: string;
+    title: string;
+    prompt: string;
+    dependsOn?: string[];
+}
+interface CoordinatorMessage {
+    memberId: string;
+    message: string;
+}
+interface CoordinatorAbort {
+    taskId: string;
+    reason?: string;
+}
+type CoordinatorRecordedAction = ({
+    kind: "assign";
+} & CoordinatorAssignment) | ({
+    kind: "message";
+} & CoordinatorMessage) | ({
+    kind: "abort";
+} & CoordinatorAbort);
+interface CoordinatorReasonResult {
+    response: string;
+    usage: TokenUsage;
+    actions: CoordinatorRecordedAction[];
+    assignments: CoordinatorAssignment[];
+    messages: CoordinatorMessage[];
+    aborts: CoordinatorAbort[];
+    allTasksDone: boolean;
+}
+interface CoordinatorTrackedTask {
+    id: string;
+    memberId?: string;
+    title: string;
+    status: string;
+    runId?: string;
+}
+interface CoordinatorTaskNotification {
+    taskId: string;
+    memberId: string;
+    title: string;
+    status: string;
+    result?: TaskResult;
+    error?: string;
+}
+interface AppliedCoordinatorActionsResult {
+    createdTasks: CoordinatorTrackedTask[];
+    notifications: CoordinatorTaskNotification[];
+}
+interface CoordinatorChildLaunch {
+    taskId: string;
+    memberId: string;
+    memberRole: string;
+    title: string;
+    prompt: string;
+    sessionId: string;
+    runId: string;
+}
+interface PreparedExternalTasksResult {
+    launches: CoordinatorChildLaunch[];
+}
+interface CommittedCoordinatorTaskResult {
+    notifications: CoordinatorTaskNotification[];
+}
+interface CollectedWorkerReportsResult {
+    reports: WorkerReport[];
+    consumedReportIds: string[];
+}
+interface CoordinatorWorkflowState {
+    input: CoordinatorWorkflowInput;
+    round: number;
+    nextMessage: string;
+    rounds: CoordinatorWorkflowRound[];
+    totalUsage: TokenUsage;
+    knownTerminalIds: string[];
+}
+interface CoordinatorWorkflowResult {
+    response: string;
+    rounds: CoordinatorWorkflowRound[];
+    usage: TokenUsage;
+}
+interface CoordinatorWorkflowRound {
+    number: number;
+    assigned: Array<{
+        taskId: string;
+        memberId: string;
+        title: string;
+    }>;
+    messaged: Array<{
+        memberId: string;
+    }>;
+    stopped: string[];
+    childResults: Array<{
+        taskId: string;
+        memberId: string;
+        title: string;
+        status: string;
+        result?: TaskResult;
+        error?: string;
+    }>;
+    response: string;
+    usage: TokenUsage;
+}
+interface CoordinatorWorkflowActivityNames {
+    coordinatorReason: string;
+    applyCoordinatorActions: string;
+    prepareExternalTasks: string;
+    commitExternalTask: string;
+    collectWorkerReports: string;
+    checkTrackedTasksTerminal: string;
+}
+interface CoordinatorWorkflowContextLike {
+    callActivity(name: string, input: unknown): unknown;
+    callChildWorkflow(name: string, input: unknown, instanceId?: string): unknown;
+    whenAny(tasks: unknown[]): unknown;
+    waitForExternalEvent(name: string): unknown;
+    createTimer(fireAt: Date | number): unknown;
+    setCustomStatus?(status: string): void;
+    isReplaying?(): boolean;
+    getWorkflowInstanceId?(): string;
+}
+interface CoordinatorWorkflowRegistration {
+    workflowName: string;
+    activityNames: CoordinatorWorkflowActivityNames;
+    workflow: (ctx: CoordinatorWorkflowContextLike, input: CoordinatorWorkflowInput) => AsyncGenerator<unknown, CoordinatorWorkflowResult, unknown>;
+}
+interface CreateCoordinatorWorkflowOptions {
+    workflowName?: string;
+    activityNames?: Partial<CoordinatorWorkflowActivityNames>;
+    resolveAgentTurnWorkflowName?: (roleName: string) => string;
+}
+declare function createCoordinatorWorkflowDefinition(options?: CreateCoordinatorWorkflowOptions): CoordinatorWorkflowRegistration;
+
+/**
+ * Coordinator Workflow Activities
+ *
+ * These activities bridge the durable workflow back into `agent-core` team
+ * semantics. The coordinator round still records intent deterministically,
+ * but task/message/abort side effects flow through the real coordinator,
+ * task board, and mailbox.
+ */
+
+interface CoordinatorReasonActivityInput {
+    coordinatorSessionId: string;
+    teamId: string;
+    message: string;
+    roundNum: number;
+    knownTerminalIds: string[];
+}
+interface CoordinatorReasonActivityOptions {
+    lead: Agent;
+    coordinator: TeamCoordinator;
+    onCoordinatorEvent?: (event: unknown) => void;
+}
+declare function createCoordinatorReasonActivity(options: CoordinatorReasonActivityOptions): (ctx: unknown, input: CoordinatorReasonActivityInput) => Promise<CoordinatorReasonResult>;
+interface ApplyCoordinatorActionsInput {
+    actions: CoordinatorRecordedAction[];
+}
+interface ApplyCoordinatorActionsActivityOptions {
+    coordinator: TeamCoordinator;
+}
+declare function createApplyCoordinatorActionsActivity(options: ApplyCoordinatorActionsActivityOptions): (ctx: unknown, input: ApplyCoordinatorActionsInput) => Promise<AppliedCoordinatorActionsResult>;
+interface PrepareExternalTasksInput {
+    tasks: Array<{
+        taskId: string;
+        runId: string;
+    }>;
+}
+interface PrepareExternalTasksActivityOptions {
+    coordinator: TeamCoordinator;
+}
+declare function createPrepareExternalTasksActivity(options: PrepareExternalTasksActivityOptions): (ctx: unknown, input: PrepareExternalTasksInput) => Promise<PreparedExternalTasksResult>;
+interface CommitExternalTaskInput {
+    taskId: string;
+    turnState?: AgentWorkflowTurnState;
+    error?: string;
+}
+interface CommitExternalTaskActivityOptions {
+    coordinator: TeamCoordinator;
+}
+declare function createCommitExternalTaskActivity(options: CommitExternalTaskActivityOptions): (ctx: unknown, input: CommitExternalTaskInput) => Promise<CommittedCoordinatorTaskResult>;
+interface CollectWorkerReportsInput {
+    consumedReportIds: string[];
+}
+interface CollectWorkerReportsActivityOptions {
+    coordinator: TeamCoordinator;
+}
+declare function createCollectWorkerReportsActivity(options: CollectWorkerReportsActivityOptions): (ctx: unknown, input: CollectWorkerReportsInput) => Promise<CollectedWorkerReportsResult>;
+interface CheckTrackedTasksTerminalInput {
+    taskIds: string[];
+}
+interface CheckTrackedTasksTerminalActivityOptions {
+    coordinator: TeamCoordinator;
+}
+declare function createCheckTrackedTasksTerminalActivity(options: CheckTrackedTasksTerminalActivityOptions): (ctx: unknown, input: CheckTrackedTasksTerminalInput) => Promise<boolean>;
+
+/**
+ * Type definitions for the Dapr Team Runner.
+ *
+ * Extracted from `team-runner.ts` for maintainability.
+ */
+
+interface DaprTeamDispatchOptions {
+    /**
+     * Explicit executor used for member task dispatch in non-durable runs.
+     *
+     * Build this with dispatch-layer helpers such as
+     * `createDaprCompositeDispatchExecutor(...)`,
+     * `createDaprAppDispatchExecutor(...)`, or any custom `TaskExecutor`.
+     *
+     * When `workflowRuntime` is enabled, durable child workflows own member
+     * execution and this executor is ignored.
+     */
+    executor?: TaskExecutor;
+}
+interface DaprTeamRunnerOptions {
+    /** The lead agent that members are forked from. */
+    lead: Agent;
+    /** Available roles for team members. */
+    roles: DispatchRole[];
+    /** Session ID for the lead agent (used for synthesis calls). */
+    leadSessionId: string;
+    /** Team identifier. Auto-generated if omitted. */
+    teamId?: string;
+    /** Dapr sidecar HTTP endpoint. Defaults to `http://127.0.0.1:3500`. */
+    daprHttpEndpoint?: string;
+    /** Dapr state store component name. Defaults to `"statestore"`. */
+    stateStoreName?: string;
+    /**
+     * Enable member work loops. When true, registered members enter
+     * a persistent idle loop that auto-claims tasks. When false (default),
+     * the coordinator dispatches tasks manually.
+     */
+    workLoopEnabled?: boolean;
+    /** How often (ms) the idle loop polls for new work. Default: 500. */
+    pollIntervalMs?: number;
+    /** Enable/disable built-in console logging. Defaults to `true`. */
+    logging?: boolean;
+    /** Prefix for log messages. Defaults to `"[team]"`. */
+    logPrefix?: string;
+    /** Coordinator loop options (used when calling run()). */
+    coordinatorLoopOptions?: Omit<CoordinatorLoopOptions, "onRound" | "onStatus">;
+    /** Optional event callback — invoked for every team lifecycle event. */
+    onEvent?: (event: TeamEvent) => void | Promise<void>;
+    /**
+     * Auto-register all roles on start.
+     * If true, all roles are registered as members when start() is called.
+     * If an array, only those role names are registered.
+     * Defaults to false (manual registration via coordinator or HTTP).
+     */
+    autoRegister?: boolean | string[];
+    /**
+     * Whether to attempt recovery of interrupted tasks on start.
+     * When true (default), tasks that were "running" when the process last
+     * died are marked as failed so the coordinator can re-queue them.
+     */
+    recoverOnStart?: boolean;
+    /**
+     * Dispatch-layer configuration for non-durable member execution.
+     *
+     * This keeps backend selection outside the runner itself. For example,
+     * pass `dispatch: { executor: createDaprCompositeDispatchExecutor(...) }`
+     * for mixed local/remote teams.
+     */
+    dispatch?: DaprTeamDispatchOptions;
+    /**
+     * Dapr workflow runtime for registering durable workflows.
+     * When provided, enables Level 2 durable coordination:
+     * - the root coordinator loop runs as a Dapr workflow
+     * - member task executions run as child workflows (durable, crash-safe)
+     * - use `runDurable()` to start the durable root workflow
+     *
+     * When omitted, the same core team semantics still run through
+     * `createDaprTeamRunner()`, but execution stays in-process and you
+     * use `run()` instead.
+     *
+     * Pass `new WorkflowRuntime(...)` from `@dapr/dapr`.
+     */
+    workflowRuntime?: DaprWorkflowWorkerRuntime;
+    /**
+     * Options for the coordinator workflow definition.
+     * Only used when `workflowRuntime` is provided.
+     */
+    coordinatorWorkflowOptions?: {
+        /** Custom workflow name. Defaults to `"team-coordinator"`. */
+        workflowName?: string;
+        /** Max rounds before forcing completion. Defaults to `20`. */
+        maxRounds?: number;
+        /** Wait timeout per round (ms). Defaults to `120_000`. */
+        waitTimeoutMs?: number;
+        /** Custom resolve function for agent turn workflow names. */
+        resolveAgentTurnWorkflowName?: (roleName: string) => string;
+    };
+    /**
+     * Additional coordinator config options to pass through.
+     */
+    coordinatorConfig?: Partial<Pick<TeamCoordinatorConfig, "onPermissionRequest" | "beforeIteration" | "sharedPermissions" | "signal" | "createId">>;
+}
+interface DaprTeamDurableRunOptions {
+    /** Max coordinator rounds before forcing completion. */
+    maxRounds?: number;
+    /** Wait timeout per round in milliseconds. */
+    waitTimeoutMs?: number;
+}
+interface DaprTeamDurableRunStartResult {
+    teamId: string;
+    workflowName: string;
+    coordinatorSessionId: string;
+    instanceId: string;
+}
+interface DaprTeamDurableRunState extends DaprWorkflowState {
+    teamId: string;
+    coordinatorSessionId: string;
+    result?: CoordinatorWorkflowResult;
+    customStatus?: unknown;
+}
+interface DaprTeamServeOptions {
+    /** HTTP port. Defaults to `3000`. */
+    port?: number;
+    /** HTTP host. Defaults to all interfaces. */
+    host?: string;
+}
+interface DaprTeamRunner {
+    /** The underlying team coordinator. */
+    readonly coordinator: TeamCoordinator;
+    /** The Dapr sidecar client. */
+    readonly client: DaprSidecarClient;
+    /** Start the team runner (stores + recovery + optional auto-register). */
+    start(): Promise<void>;
+    /** Start the HTTP server and block until SIGINT/SIGTERM. */
+    serve(options?: DaprTeamServeOptions): Promise<void>;
+    /**
+     * Run the coordinator loop directly (Level 1 — in-process).
+     * Convenience wrapper around coordinator.run().
+     *
+     * This keeps the core coordinator loop in-process while still using
+     * the Dapr-backed runner shell and stores.
+     */
+    run(prompt: string, options?: CoordinatorLoopOptions): Promise<CoordinatorLoopResult>;
+    /**
+     * Start a durable coordinator workflow (Level 2).
+     * Requires `workflowRuntime` in options.
+     *
+     * Vocabulary:
+     * - `run()` = direct, in-process coordinator execution
+     * - `runDurable()` = start the durable root coordinator workflow
+     * - child workflows = durable member task executions started by the root
+     *
+     * The coordinator loop itself is the root Dapr workflow. Each member task
+     * execution runs as a child workflow. On crash, Dapr replays from the last
+     * checkpoint — no work is lost.
+     *
+     * This is the durable transport for the same core team semantics
+     * exposed by `run()`. The call returns immediately with the workflow
+     * instance identifiers; use `getDurableRun()` or `waitForDurableRun()`
+     * to inspect or wait for completion explicitly from outside the workflow.
+     */
+    runDurable(prompt: string, options?: DaprTeamDurableRunOptions): Promise<DaprTeamDurableRunStartResult>;
+    /** Get the current state of a durable team run by workflow instance ID. */
+    getDurableRun(instanceId: string): Promise<DaprTeamDurableRunState | undefined>;
+    /**
+     * Wait for a durable team run to reach a terminal workflow state.
+     * This is an explicit edge-level polling helper over Dapr workflow APIs.
+     * It is for callers outside the workflow, not for parent/child coordination
+     * inside the durable team workflow itself.
+     */
+    waitForDurableRun(instanceId: string, options?: WaitForDaprWorkflowOptions): Promise<DaprTeamDurableRunState | undefined>;
+    /** Gracefully shut down. */
+    stop(): Promise<void>;
+}
+
+/**
+ * Team HTTP Handler
+ *
+ * Adds team-scoped HTTP routes to the Dapr host. These routes expose the
+ * TeamCoordinator's functionality over HTTP, enabling external callers
+ * (CLIs, dashboards, other services) to manage team coordination.
+ *
+ * Routes:
+ *   POST /team/run                    — Start coordinator.run(prompt) with optional SSE streaming
+ *   POST /team/run-durable            — Start a durable coordinator workflow and return its instance ID
+ *   POST /team/queue                  — Queue a new task
+ *   POST /team/register               — Register a member from a role
+ *   POST /team/guide                  — Send guidance to a member
+ *   POST /team/broadcast              — Broadcast message to all members
+ *   POST /team/abort/:taskId          — Abort a task
+ *   POST /team/cancel/:taskId         — Cancel a task
+ *   POST /team/shutdown               — Shutdown the team
+ *   GET  /team/status                 — Team snapshot (members, tasks, stats)
+ *   GET  /team/tasks                  — List tasks (optional ?status=... &memberId=...)
+ *   GET  /team/tasks/:taskId          — Get a specific task
+ *   GET  /team/members                — List members
+ *   GET  /team/messages               — List messages (optional ?from=... &to=... &kind=...)
+ *   GET  /team/roles                  — List available roles
+ *   GET  /team/workflows/:instanceId  — Inspect durable workflow status and extracted result/custom status
+ */
+
+interface DaprTeamHttpHandlerOptions {
+    /** The team coordinator instance. */
+    coordinator: TeamCoordinator;
+    /** Optional event bus for SSE streaming of coordinator rounds. */
+    eventBus?: EventBus;
+    /** Coordinator loop options passed to coordinator.run(). */
+    coordinatorLoopOptions?: Omit<CoordinatorLoopOptions, "onRound" | "onStatus">;
+    /** Optional durable team runner callback for /team/run-durable. */
+    runDurable?: (input: {
+        prompt: string;
+        maxRounds?: number;
+        waitTimeoutMs?: number;
+    }) => Promise<DaprTeamDurableRunStartResult>;
+    /** Optional durable team workflow lookup for /team/workflows/:instanceId. */
+    getDurableRun?: (instanceId: string) => Promise<DaprTeamDurableRunState | undefined>;
+    /** Optional guard for rejecting mutable routes such as late registration. */
+    rejectRegistration?: () => string | undefined;
+}
+/**
+ * Create an HTTP request handler for team coordination routes.
+ *
+ * Returns `undefined` for unmatched routes (not a team route), allowing
+ * the caller to chain with the standard agent HTTP handler.
+ */
+declare function createDaprTeamHttpHandler(options: DaprTeamHttpHandlerOptions): (request: Request) => Promise<Response | undefined>;
+
+/**
+ * Dapr Team Runner
+ *
+ * High-level composition helper that creates a durable team coordinator
+ * with Dapr-backed stores and an HTTP server.
+ *
+ * Organized into three files:
+ * - `team-runner-types.ts` — Options, interfaces
+ * - `team-runner-http.ts` — HTTP helpers (Request/Response bridge, health routes)
+ * - `team-runner.ts` (this file) — Factory function
+ */
+
+/**
+ * Create a Dapr-backed team runner.
+ *
+ * @example
+ * ```ts
+ * const runner = createDaprTeamRunner({
+ *   lead: agent,
+ *   leadSessionId: "main",
+ *   roles: [researcherRole, writerRole, reviewerRole],
+ * });
+ *
+ * await runner.serve({ port: 3000 });
+ * ```
+ */
+declare function createDaprTeamRunner(options: DaprTeamRunnerOptions): DaprTeamRunner;
+
+export { type AppliedCoordinatorActionsResult, type ApplyCoordinatorActionsActivityOptions, type ApplyCoordinatorActionsInput, type CheckTrackedTasksTerminalActivityOptions, type CheckTrackedTasksTerminalInput, type CollectWorkerReportsActivityOptions, type CollectWorkerReportsInput, type CollectedWorkerReportsResult, type CommitExternalTaskActivityOptions, type CommitExternalTaskInput, type CommittedCoordinatorTaskResult, type CoordinatorAbort, type CoordinatorAssignment, type CoordinatorChildLaunch, type CoordinatorMessage, type CoordinatorReasonActivityInput, type CoordinatorReasonActivityOptions, type CoordinatorReasonResult, type CoordinatorRecordedAction, type CoordinatorTaskNotification, type CoordinatorTrackedTask, type CoordinatorWorkflowActivityNames, type CoordinatorWorkflowContextLike, type CoordinatorWorkflowInput, type CoordinatorWorkflowRegistration, type CoordinatorWorkflowResult, type CoordinatorWorkflowRound, type CoordinatorWorkflowState, type CreateCoordinatorWorkflowOptions, DaprMailboxStore, type DaprMailboxStoreOptions, DaprTaskBoardStore, type DaprTaskBoardStoreOptions, type DaprTeamDispatchOptions, type DaprTeamDurableRunOptions, type DaprTeamDurableRunStartResult, type DaprTeamDurableRunState, type DaprTeamHttpHandlerOptions, type DaprTeamRunner, type DaprTeamRunnerOptions, type DaprTeamServeOptions, type PrepareExternalTasksActivityOptions, type PrepareExternalTasksInput, type PreparedExternalTasksResult, createApplyCoordinatorActionsActivity, createCheckTrackedTasksTerminalActivity, createCollectWorkerReportsActivity, createCommitExternalTaskActivity, createCoordinatorReasonActivity, createCoordinatorWorkflowDefinition, createDaprTeamHttpHandler, createDaprTeamRunner, createPrepareExternalTasksActivity };

package/dist/team/index.js

@@ -0,0 +1,30 @@
+import {
+  DaprMailboxStore,
+  DaprTaskBoardStore,
+  createApplyCoordinatorActionsActivity,
+  createCheckTrackedTasksTerminalActivity,
+  createCollectWorkerReportsActivity,
+  createCommitExternalTaskActivity,
+  createCoordinatorReasonActivity,
+  createCoordinatorWorkflowDefinition,
+  createDaprTeamHttpHandler,
+  createDaprTeamRunner,
+  createPrepareExternalTasksActivity
+} from "../chunk-MJKJT3ZO.js";
+import "../chunk-YQQTUE6B.js";
+import "../chunk-5CJIC4YB.js";
+import "../chunk-YS2CWYBQ.js";
+import "../chunk-MQJ4LZOX.js";
+export {
+  DaprMailboxStore,
+  DaprTaskBoardStore,
+  createApplyCoordinatorActionsActivity,
+  createCheckTrackedTasksTerminalActivity,
+  createCollectWorkerReportsActivity,
+  createCommitExternalTaskActivity,
+  createCoordinatorReasonActivity,
+  createCoordinatorWorkflowDefinition,
+  createDaprTeamHttpHandler,
+  createDaprTeamRunner,
+  createPrepareExternalTasksActivity
+};

package/dist/worker-CXq0IFGX.d.ts

@@ -0,0 +1,42 @@
+import { D as DaprWorkflowRuntimeRegistrar, a as DaprAgentWorkflowHost } from './workflow-host-D6W6fXoL.js';
+
+interface DaprWorkflowWorkerRuntime extends DaprWorkflowRuntimeRegistrar {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+interface DaprWorkflowWorkerLogger {
+    info?(message: string): void;
+    warn?(message: string): void;
+    error?(message: string): void;
+}
+interface DaprWorkflowWorkerAgentDefinition {
+    id: string;
+    host: DaprAgentWorkflowHost;
+    aliases?: string[];
+    description?: string;
+}
+interface DaprWorkflowWorkerOptions {
+    runtime: DaprWorkflowWorkerRuntime;
+    agents: readonly DaprWorkflowWorkerAgentDefinition[];
+    logger?: DaprWorkflowWorkerLogger;
+}
+interface DaprWorkflowWorker {
+    readonly runtime: DaprWorkflowWorkerRuntime;
+    readonly agents: readonly DaprWorkflowWorkerAgentDefinition[];
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    listAgents(): readonly DaprWorkflowWorkerAgentDefinition[];
+    getAgent(idOrAlias: string): DaprWorkflowWorkerAgentDefinition | undefined;
+}
+/**
+ * Create a Dapr workflow worker controller around one or more agent hosts.
+ *
+ * This is the host-process analogue of Diagrid's `runner.start()` path:
+ * the worker owns Dapr SDK lifecycle and workflow/activity registration,
+ * while each registered host owns the workflow definition for a concrete
+ * agent profile.
+ */
+declare function createDaprWorkflowWorker(options: DaprWorkflowWorkerOptions): DaprWorkflowWorker;
+
+export { type DaprWorkflowWorker as D, type DaprWorkflowWorkerAgentDefinition as a, type DaprWorkflowWorkerLogger as b, type DaprWorkflowWorkerOptions as c, type DaprWorkflowWorkerRuntime as d, createDaprWorkflowWorker as e };