@cuylabs/agent-runtime-dapr 0.9.0 → 0.10.0

package/dist/workflow-host-D6W6fXoL.d.ts

@@ -0,0 +1,459 @@
+import { ApprovalRequest, ApprovalAction, ApprovalRememberScope, MiddlewareRunner, Tool, AgentEvent, FollowUpPolicy, FollowUpRequest, QueuedFollowUpRecord, FollowUpStatus, FollowUpDecisionAction, HumanInputRequest, HumanInputResponse, SteeringRequest, AgentWorkflowInterventionSnapshot, AgentWorkflowTurnState, SteeringResponse, FollowUpResponse, Agent, AgentTaskObserver } from '@cuylabs/agent-core';
+import { D as DaprWorkflowClient, p as DaprAgentTurnWorkflowActivityNames, r as DaprAgentTurnWorkflowDefinition, S as StartDaprWorkflowOptions, v as DaprStartWorkflowResponse, c as CreateDaprAgentTurnWorkflowKitOptions, a as DaprAgentTurnWorkflowToolHandler, b as DaprAgentTurnActivityRegistration } from './client-UsEIzDF6.js';
+import { e as DaprStateStoreClientOptions } from './workflow-bridge-BcicHH1Y.js';
+import { EventBus } from '@cuylabs/agent-core/events';
+
+interface DaprApprovalDecision {
+    action: ApprovalAction;
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+}
+type DaprApprovalResolution = ApprovalAction | DaprApprovalDecision;
+type DaprApprovalRequestStatus = "pending" | "approved" | "rejected" | "remembered";
+interface DaprApprovalRequestRecord {
+    id: string;
+    agentId: string;
+    sessionId: string;
+    workflowInstanceId: string;
+    toolCallId: string;
+    toolName: string;
+    step: number;
+    request: ApprovalRequest;
+    status: DaprApprovalRequestStatus;
+    createdAt: string;
+    updatedAt: string;
+    decidedAt?: string;
+    decision?: DaprApprovalDecision;
+}
+interface DaprApprovalRequestListOptions {
+    sessionId?: string;
+    workflowInstanceId?: string;
+    status?: DaprApprovalRequestStatus | DaprApprovalRequestStatus[];
+}
+interface DaprWorkflowApprovalCheckInput {
+    workflowInstanceId: string;
+    sessionId: string;
+    step: number;
+    toolCall: {
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    };
+}
+type DaprWorkflowApprovalCheckResult = {
+    action: "allow";
+} | {
+    action: "deny";
+    reason: string;
+} | {
+    action: "request";
+    request: DaprApprovalRequestRecord;
+};
+interface DaprWorkflowApprovalRuntimeOptions extends DaprStateStoreClientOptions {
+    agentId: string;
+    middleware: MiddlewareRunner;
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    keyPrefix?: string;
+    now?: () => string;
+    publishEvent?: (sessionId: string, event: AgentEvent) => Promise<void> | void;
+}
+interface DaprWorkflowApprovalRuntime {
+    readonly hasApprovalMiddleware: boolean;
+    evaluateToolApproval(input: DaprWorkflowApprovalCheckInput): Promise<DaprWorkflowApprovalCheckResult>;
+    getRequest(requestId: string): Promise<DaprApprovalRequestRecord | undefined>;
+    listRequests(options?: DaprApprovalRequestListOptions): Promise<DaprApprovalRequestRecord[]>;
+    respondToRequest(requestId: string, decision: DaprApprovalResolution, workflowClient: DaprWorkflowClient): Promise<DaprApprovalRequestRecord>;
+}
+declare function createDaprWorkflowApprovalRuntime(options: DaprWorkflowApprovalRuntimeOptions): DaprWorkflowApprovalRuntime;
+
+interface DaprFollowUpRecord extends QueuedFollowUpRecord {
+    agentId: string;
+}
+interface DaprFollowUpListOptions {
+    sessionId?: string;
+    workflowInstanceId?: string;
+    sourceTurnId?: string;
+    status?: FollowUpStatus | FollowUpStatus[];
+}
+interface DaprWorkflowFollowUpRuntimeOptions extends DaprStateStoreClientOptions {
+    agentId: string;
+    policy?: FollowUpPolicy;
+    keyPrefix?: string;
+    now?: () => string;
+    publishEvent?: (sessionId: string, event: AgentEvent) => Promise<void> | void;
+}
+interface DaprWorkflowFollowUpRuntime {
+    readonly policy: FollowUpPolicy;
+    createRequest(workflowInstanceId: string, request: FollowUpRequest, options?: {
+        sourceTurnId?: string;
+    }): Promise<DaprFollowUpRecord>;
+    listRequests(options?: DaprFollowUpListOptions): Promise<DaprFollowUpRecord[]>;
+    getRequest(requestId: string): Promise<DaprFollowUpRecord | undefined>;
+    respondToRequest(requestId: string, action: FollowUpDecisionAction): Promise<DaprFollowUpRecord>;
+    listSeedable(sessionId: string): Promise<DaprFollowUpRecord[]>;
+    markApplied(requestIds: readonly string[], seededTurnId: string): Promise<void>;
+}
+declare function createDaprWorkflowFollowUpRuntime(options: DaprWorkflowFollowUpRuntimeOptions): DaprWorkflowFollowUpRuntime;
+
+type DaprHumanInputRequestStatus = "pending" | "answered";
+interface DaprHumanInputRequestRecord {
+    id: string;
+    agentId: string;
+    sessionId: string;
+    workflowInstanceId: string;
+    toolCallId: string;
+    toolName: string;
+    step: number;
+    request: HumanInputRequest;
+    status: DaprHumanInputRequestStatus;
+    createdAt: string;
+    updatedAt: string;
+    respondedAt?: string;
+    response?: HumanInputResponse;
+}
+interface DaprHumanInputRequestListOptions {
+    sessionId?: string;
+    workflowInstanceId?: string;
+    status?: DaprHumanInputRequestStatus | DaprHumanInputRequestStatus[];
+}
+interface DaprWorkflowHumanInputCheckInput {
+    workflowInstanceId: string;
+    sessionId: string;
+    step: number;
+    toolCall: {
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    };
+}
+type DaprWorkflowHumanInputCheckResult = {
+    action: "allow";
+} | {
+    action: "deny";
+    reason: string;
+} | {
+    action: "request";
+    request: DaprHumanInputRequestRecord;
+};
+interface DaprWorkflowHumanInputRuntimeOptions extends DaprStateStoreClientOptions {
+    agentId: string;
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    keyPrefix?: string;
+    now?: () => string;
+    publishEvent?: (sessionId: string, event: AgentEvent) => Promise<void> | void;
+}
+interface DaprWorkflowHumanInputRuntime {
+    readonly hasHumanInputTools: boolean;
+    evaluateToolRequest(input: DaprWorkflowHumanInputCheckInput): Promise<DaprWorkflowHumanInputCheckResult>;
+    getRequest(requestId: string): Promise<DaprHumanInputRequestRecord | undefined>;
+    listRequests(options?: DaprHumanInputRequestListOptions): Promise<DaprHumanInputRequestRecord[]>;
+    respondToRequest(requestId: string, response: HumanInputResponse, workflowClient: DaprWorkflowClient): Promise<DaprHumanInputRequestRecord>;
+}
+declare function createDaprWorkflowHumanInputRuntime(options: DaprWorkflowHumanInputRuntimeOptions): DaprWorkflowHumanInputRuntime;
+
+type DaprSteerStatus = "pending" | "claimed";
+interface DaprSteerRecord {
+    id: string;
+    agentId: string;
+    sessionId: string;
+    workflowInstanceId: string;
+    message: string;
+    timestamp: number;
+    createdAt: string;
+    updatedAt: string;
+    status: DaprSteerStatus;
+    claimedBoundaryId?: string;
+    claimedStep?: number;
+    claimedAt?: string;
+}
+interface DaprWorkflowSteerRuntimeOptions extends DaprStateStoreClientOptions {
+    agentId: string;
+    keyPrefix?: string;
+    now?: () => string;
+}
+interface DaprWorkflowSteerRuntime {
+    createRequest(workflowInstanceId: string, request: SteeringRequest): Promise<DaprSteerRecord>;
+    drainPending(workflowInstanceId: string, step: number, maxItems?: number): Promise<AgentWorkflowInterventionSnapshot[]>;
+}
+declare function createDaprWorkflowSteerRuntime(options: DaprWorkflowSteerRuntimeOptions): DaprWorkflowSteerRuntime;
+
+/**
+ * Dapr Pub/Sub bridge for multi-instance event fan-out.
+ *
+ * Bridges the in-process `EventBus` to Dapr's pub/sub building block so
+ * agent events are delivered to *all* app instances — not just the one
+ * running the workflow activity.
+ *
+ * ## Architecture
+ *
+ * ```
+ * Instance A (runs the workflow)         Instance B (serves SSE clients)
+ * ┌─────────────────────────────┐       ┌──────────────────────────────┐
+ * │ Workflow Activity → onEvent │       │                              │
+ * │           ↓                 │       │                              │
+ * │     EventBus (local)        │       │     EventBus (local)         │
+ * │       ↓          ↓         │       │         ↑                    │
+ * │  SSE clients   publish()   │       │   ingest() from sub callback │
+ * │                   ↓         │       │         ↑                    │
+ * │            Dapr Sidecar     │       │    Dapr Sidecar              │
+ * │              (pub/sub)      │ ───→  │      (pub/sub)               │
+ * └─────────────────────────────┘       └──────────────────────────────┘
+ * ```
+ *
+ * ## Publishing
+ *
+ * Uses the Dapr HTTP pub/sub API:
+ * `POST /v1.0/publish/{pubsubName}/{topic}`
+ *
+ * All events go to a single topic (default: `agent-events`). The session
+ * ID is encoded in the CloudEvents `subject` field and inside the payload
+ * for filtering.
+ *
+ * ## Subscribing
+ *
+ * The bridge exposes an `ingest()` handler that should be wired to a Dapr
+ * subscription callback — either:
+ *
+ * 1. **Declarative** (YAML component + `GET /dapr/subscribe` at startup)
+ * 2. **Programmatic** (`DaprServer.pubsub.subscribe()` from `@dapr/dapr`)
+ * 3. **Streaming** (future: `SubscribeTopicEventsAlpha1` gRPC bidi stream)
+ *
+ * The bridge doesn't care *how* events arrive — it just needs `ingest()`
+ * called with the event data. This keeps the bridge transport-agnostic.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createEventBus, createDaprPubSubEventBridge } from "./index.js";
+ *
+ * const eventBus = createEventBus();
+ * const bridge = createDaprPubSubEventBridge({
+ *   eventBus,
+ *   daprHttpEndpoint: "http://localhost:3500",
+ *   pubsubName: "pubsub",
+ * });
+ *
+ * // In workflow host: events auto-publish to Dapr when enabled.
+ * // In HTTP handler: events arrive from Dapr and feed into local EventBus.
+ *
+ * // Wire the subscription callback (e.g., in an Express route):
+ * app.post("/dapr/agent-events", async (req, res) => {
+ *   bridge.ingest(req.body);
+ *   res.sendStatus(200);
+ * });
+ * ```
+ */
+
+interface DaprPubSubEventBridgeOptions {
+    /** The local EventBus to bridge. */
+    eventBus: EventBus;
+    /**
+     * Dapr sidecar HTTP endpoint (e.g. `http://localhost:3500`).
+     * Used for publishing events via `POST /v1.0/publish/{pubsubName}/{topic}`.
+     */
+    daprHttpEndpoint?: string;
+    /** Dapr pub/sub component name. Default: `"pubsub"`. */
+    pubsubName?: string;
+    /** Topic name for agent events. Default: `"agent-events"`. */
+    topic?: string;
+    /** Dapr API token for authentication. */
+    apiToken?: string;
+    /**
+     * Fetch implementation. Defaults to `globalThis.fetch`.
+     * Useful for testing or environments without native fetch.
+     */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Source identifier for CloudEvents envelope.
+     * Defaults to `"agent-runtime-dapr"`.
+     */
+    source?: string;
+    /**
+     * Whether to publish local events to Dapr pub/sub.
+     * Set to `false` on instances that only *receive* events (e.g., a
+     * read-only SSE gateway that doesn't run workflows).
+     * Default: `true`.
+     */
+    publishEnabled?: boolean;
+    /**
+     * Maximum queued publishes to the Dapr sidecar before low-value streaming
+     * events are dropped. This prevents unbounded memory growth under long,
+     * high-volume token streams.
+     */
+    maxPendingPublishes?: number;
+}
+interface DaprPubSubEventBridge {
+    /** The local EventBus bridged to Dapr pub/sub. */
+    readonly eventBus: EventBus;
+    /**
+     * Publish an agent event to Dapr pub/sub for cross-instance delivery.
+     *
+     * Typically called automatically by the workflow host's `onEvent`
+     * callback. Also publishes to the local EventBus.
+     */
+    publish(sessionId: string, type: string, data: unknown): Promise<void>;
+    /**
+     * Ingest an event received from a Dapr subscription callback.
+     *
+     * Extracts the session ID and event data from the CloudEvents envelope
+     * and pushes into the local EventBus. Should be wired to whatever
+     * subscription method you're using (declarative YAML, programmatic
+     * server.pubsub.subscribe, or streaming gRPC).
+     *
+     * Safe to call from any context — ignores malformed payloads.
+     */
+    ingest(cloudEvent: unknown): void;
+    /** The pub/sub component name. */
+    readonly pubsubName: string;
+    /** The topic name. */
+    readonly topic: string;
+    /**
+     * Express/Koa/Hono-compatible route handler for Dapr subscription
+     * callbacks. Returns the path and handler for easy wiring.
+     */
+    readonly subscriptionRoute: {
+        /** Path the Dapr sidecar should POST to (e.g. `/dapr/agent-events`). */
+        path: string;
+        /** Handle the incoming pub/sub event. Returns `{ status: "SUCCESS" }`. */
+        handler: (body: unknown) => {
+            status: "SUCCESS" | "DROP";
+        };
+    };
+    /**
+     * Dapr subscription declaration for `GET /dapr/subscribe`.
+     * Return this from your subscribe endpoint so the sidecar knows
+     * which topic to deliver to this app.
+     */
+    readonly subscriptionDeclaration: {
+        pubsubname: string;
+        topic: string;
+        route: string;
+    };
+}
+declare function createDaprPubSubEventBridge(options: DaprPubSubEventBridgeOptions): DaprPubSubEventBridge;
+
+interface DaprWorkflowRuntimeRegistrar {
+    registerWorkflowWithName(name: string, workflow: DaprAgentTurnWorkflowDefinition): this;
+    registerActivityWithName<TInput, TOutput>(name: string, handler: (context: unknown, input: TInput) => Promise<TOutput> | TOutput): this;
+}
+interface DaprWorkflowStarterLike {
+    startWorkflow<TInput = unknown>(workflowName: string, options?: StartDaprWorkflowOptions<TInput>): Promise<DaprStartWorkflowResponse>;
+}
+interface DaprWorkflowEventRaiserLike {
+    raiseWorkflowEvent(instanceId: string, eventName: string, options?: {
+        eventData?: unknown;
+    }): Promise<void>;
+}
+interface DaprAgentWorkflowRunRequest {
+    message: string;
+    sessionId?: string;
+    system?: string;
+    workflowInstanceId?: string;
+    maxSteps?: number;
+    title?: string;
+    parentSessionId?: string;
+}
+interface DaprAgentWorkflowRunResult {
+    sessionId: string;
+    workflowInstanceId: string;
+    initialState: AgentWorkflowTurnState;
+}
+interface DaprAgentWorkflowSteerRequest {
+    workflowInstanceId: string;
+    sessionId: string;
+    message: string;
+    id?: string;
+    timestamp?: number;
+}
+interface DaprAgentWorkflowFollowUpRequest {
+    workflowInstanceId: string;
+    sessionId: string;
+    message: string;
+    id?: string;
+    timestamp?: number;
+}
+interface DaprAgentWorkflowHostOptions {
+    agent: Agent;
+    workflowName?: string;
+    activityNames?: Partial<DaprAgentTurnWorkflowActivityNames>;
+    mcpTools?: CreateDaprAgentTurnWorkflowKitOptions["modelStepActivity"]["mcpTools"];
+    /**
+     * Timeout in milliseconds for durable human-input waits.
+     * When omitted, the workflow waits indefinitely for the user response.
+     */
+    humanInputTimeoutMs?: number;
+    /**
+     * Timeout in milliseconds for durable approval waits.
+     * When omitted, the workflow waits indefinitely for the user response.
+     */
+    approvalTimeoutMs?: number;
+    /**
+     * Enable mid-turn steering injection via the durable steer inbox.
+     * Default: `true` — opt out by setting to `false`.
+     */
+    steeringEnabled?: boolean;
+    /**
+     * Enable deferred follow-up queuing via the durable follow-up runtime.
+     * Default: `true` — opt out by setting to `false`.
+     */
+    followUpsEnabled?: boolean;
+    /**
+     * Optional observers that receive lifecycle notifications during
+     * workflow execution. The same observers used on the direct (`/agents/run`)
+     * path — `DaprExecutionObserver`, `createDaprLoggingObserver`, etc. —
+     * work here too via an internal bridge.
+     */
+    observers?: AgentTaskObserver[];
+    /**
+     * Optional event bus for streaming agent events (text deltas, tool calls,
+     * etc.) to connected SSE/WebSocket clients. When provided, every
+     * model-step event is published to a channel keyed by `sessionId`.
+     * The channel is automatically closed when the turn completes or errors.
+     */
+    eventBus?: EventBus;
+    /**
+     * Optional Dapr pub/sub bridge for multi-instance event fan-out.
+     * When provided, agent events are published to Dapr pub/sub in addition
+     * to the local EventBus, so SSE clients on other instances receive them.
+     * If set, `eventBus` is automatically derived from the bridge and you
+     * do not need to set it separately.
+     */
+    pubsubBridge?: DaprPubSubEventBridge;
+    approvalRuntime?: DaprWorkflowApprovalRuntime;
+    humanInputRuntime?: DaprWorkflowHumanInputRuntime;
+    steerRuntime?: DaprWorkflowSteerRuntime;
+    followUpRuntime?: DaprWorkflowFollowUpRuntime;
+    workflowToolHandlers?: readonly DaprAgentTurnWorkflowToolHandler[];
+    additionalActivities?: readonly DaprAgentTurnActivityRegistration<any, any>[];
+    createAbortSignal?: () => AbortSignal;
+    now?: () => string;
+}
+interface DaprAgentWorkflowHost {
+    workflowName: string;
+    activityNames: DaprAgentTurnWorkflowActivityNames;
+    /** Event bus for streaming agent events to clients. `undefined` if not configured. */
+    readonly eventBus: EventBus | undefined;
+    /** Dapr pub/sub bridge for multi-instance fan-out. `undefined` if not configured. */
+    readonly pubsubBridge: DaprPubSubEventBridge | undefined;
+    readonly approvalRuntime: DaprWorkflowApprovalRuntime | undefined;
+    readonly humanInputRuntime: DaprWorkflowHumanInputRuntime | undefined;
+    readonly followUpRuntime: DaprWorkflowFollowUpRuntime | undefined;
+    register<TRuntime extends DaprWorkflowRuntimeRegistrar>(runtime: TRuntime): TRuntime;
+    createInitialState(request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
+    startTurn(client: DaprWorkflowStarterLike, request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
+    steerTurn?(client: DaprWorkflowEventRaiserLike, request: DaprAgentWorkflowSteerRequest): Promise<SteeringResponse>;
+    followUpTurn?(client: DaprWorkflowEventRaiserLike, request: DaprAgentWorkflowFollowUpRequest): Promise<FollowUpResponse>;
+}
+/**
+ * Create the host-side Dapr workflow helper for an `Agent`.
+ *
+ * This wires the extracted workflow kit to a `WorkflowRuntime`-compatible
+ * object and provides a safe `startTurn()` helper that creates/loads the
+ * session, snapshots the durable turn state, and starts the workflow instance.
+ */
+declare function createDaprAgentWorkflowHost(options: DaprAgentWorkflowHostOptions): DaprAgentWorkflowHost;
+declare function startDaprAgentWorkflowTurn(client: DaprWorkflowClient, host: DaprAgentWorkflowHost, request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
+
+export { type DaprWorkflowHumanInputCheckInput as A, type DaprWorkflowHumanInputCheckResult as B, type DaprWorkflowHumanInputRuntime as C, type DaprWorkflowRuntimeRegistrar as D, type DaprWorkflowHumanInputRuntimeOptions as E, type DaprWorkflowStarterLike as F, type DaprWorkflowSteerRuntime as G, type DaprWorkflowSteerRuntimeOptions as H, createDaprAgentWorkflowHost as I, createDaprPubSubEventBridge as J, createDaprWorkflowApprovalRuntime as K, createDaprWorkflowFollowUpRuntime as L, createDaprWorkflowHumanInputRuntime as M, createDaprWorkflowSteerRuntime as N, startDaprAgentWorkflowTurn as O, type DaprAgentWorkflowHost as a, type DaprAgentWorkflowFollowUpRequest as b, type DaprAgentWorkflowHostOptions as c, type DaprAgentWorkflowRunRequest as d, type DaprAgentWorkflowRunResult as e, type DaprAgentWorkflowSteerRequest as f, type DaprApprovalDecision as g, type DaprApprovalRequestListOptions as h, type DaprApprovalRequestRecord as i, type DaprApprovalRequestStatus as j, type DaprApprovalResolution as k, type DaprFollowUpListOptions as l, type DaprFollowUpRecord as m, type DaprHumanInputRequestListOptions as n, type DaprHumanInputRequestRecord as o, type DaprHumanInputRequestStatus as p, type DaprPubSubEventBridge as q, type DaprPubSubEventBridgeOptions as r, type DaprSteerRecord as s, type DaprWorkflowApprovalCheckInput as t, type DaprWorkflowApprovalCheckResult as u, type DaprWorkflowApprovalRuntime as v, type DaprWorkflowApprovalRuntimeOptions as w, type DaprWorkflowEventRaiserLike as x, type DaprWorkflowFollowUpRuntime as y, type DaprWorkflowFollowUpRuntimeOptions as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/agent-runtime-dapr",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Dapr-backed workload runtime and host adapters for @cuylabs/agent-runtime",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,10 +21,20 @@
       "import": "./dist/host/index.js",
       "default": "./dist/host/index.js"
     },
+    "./dispatch": {
+      "types": "./dist/dispatch/index.d.ts",
+      "import": "./dist/dispatch/index.js",
+      "default": "./dist/dispatch/index.js"
+    },
     "./workflow": {
       "types": "./dist/workflow/index.d.ts",
       "import": "./dist/workflow/index.js",
       "default": "./dist/workflow/index.js"
+    },
+    "./team": {
+      "types": "./dist/team/index.d.ts",
+      "import": "./dist/team/index.js",
+      "default": "./dist/team/index.js"
     }
   },
   "files": [
@@ -32,8 +42,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@cuylabs/agent-core": "^0.9.0",
-    "@cuylabs/agent-runtime": "^0.9.0"
+    "@cuylabs/agent-core": "^0.10.0",
+    "@cuylabs/agent-runtime": "^0.10.0"
   },
   "peerDependencies": {
     "@dapr/dapr": "^3.6.1",
@@ -65,7 +75,7 @@
     "typescript": "^5.7.0",
     "vitest": "^4.0.18",
     "zod": "^3.24.0",
-    "@cuylabs/agent-code": "^0.9.0"
+    "@cuylabs/agent-code": "^0.10.0"
   },
   "keywords": [
     "agent",
@@ -88,8 +98,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/execution/index.ts src/host/index.ts src/workflow/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/execution/index.ts src/host/index.ts src/workflow/index.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/execution/index.ts src/host/index.ts src/dispatch/index.ts src/workflow/index.ts src/team/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/execution/index.ts src/host/index.ts src/dispatch/index.ts src/workflow/index.ts src/team/index.ts --format esm --dts --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",