@cuylabs/agent-runtime-dapr 0.9.0 → 0.10.0

package/dist/{index-BCMkUMAf.d.ts → index-BmM58WZa.d.ts}

@@ -1,8 +1,12 @@
-import { AgentWorkflowTurnState, Agent, AgentTaskObserver, AgentTaskPayload, AgentTaskResult, AgentTaskRunner, AgentTaskRunnerOptions } from '@cuylabs/agent-core';
-import { h as DaprExecutionStore } from './store-pRLGfYhN.js';
-import { DaprAgentTurnWorkflowActivityNames, DaprAgentTurnWorkflowDefinition, StartDaprWorkflowOptions, DaprStartWorkflowResponse, CreateDaprAgentTurnWorkflowKitOptions, DaprWorkflowClient } from './workflow/index.js';
+import { AgentTaskPayload, SteeringResponse, FollowUpResponse, Tool, AgentTaskResult, AgentTaskRunner, Agent, AgentTaskRunnerOptions, AgentTaskObserver, FollowUpPolicy, AgentEvent, ApprovalRememberScope, HumanInputResponse, FollowUpStatus, QueuedFollowUpRecord, FollowUpDecisionAction } from '@cuylabs/agent-core';
+import { h as DaprExecutionStore } from './store-BXBIDz40.js';
+import { q as DaprPubSubEventBridge, v as DaprWorkflowApprovalRuntime, C as DaprWorkflowHumanInputRuntime, y as DaprWorkflowFollowUpRuntime, F as DaprWorkflowStarterLike, d as DaprAgentWorkflowRunRequest, e as DaprAgentWorkflowRunResult, x as DaprWorkflowEventRaiserLike, f as DaprAgentWorkflowSteerRequest, b as DaprAgentWorkflowFollowUpRequest, a as DaprAgentWorkflowHost, c as DaprAgentWorkflowHostOptions } from './workflow-host-D6W6fXoL.js';
+import { EventBus } from '@cuylabs/agent-core/events';
+import { b as DaprServiceInvoker, c as DaprServiceInvokerOptions } from './invoker-B1jvz9DG.js';
+import { D as DaprWorkflowWorker, d as DaprWorkflowWorkerRuntime } from './worker-CXq0IFGX.js';
 import { RuntimeDriver, RuntimeDriverContext, RuntimeJobRecord, WorkloadRuntime, RuntimeWorkloadRunner, WorkloadRuntimeOptions, RuntimeWorkloadContext } from '@cuylabs/agent-runtime';
-import { c as DaprRuntimeDriverOptions, a as DaprExecutionStoreOptions } from './workflow-bridge-C8Z1yr0Y.js';
+import { c as DaprRuntimeDriverOptions, D as DaprExecutionStoreOptions } from './workflow-bridge-BcicHH1Y.js';
+import { D as DaprWorkflowClient } from './client-UsEIzDF6.js';
 import { Server } from 'node:http';
 
 interface DaprJobTriggerHandler {
@@ -32,6 +36,7 @@ declare class DaprRuntimeDriver<TPayload = unknown> implements RuntimeDriver<TPa
     constructor(options: DaprRuntimeDriverOptions);
     start(context: RuntimeDriverContext): Promise<void>;
     stop(): Promise<void>;
+    private ensureStarted;
     listJobs(): Promise<RuntimeJobRecord<TPayload>[]>;
     getJob(jobId: string): Promise<RuntimeJobRecord<TPayload> | undefined>;
     upsertJob(job: RuntimeJobRecord<TPayload>): Promise<RuntimeJobRecord<TPayload>>;
@@ -44,79 +49,32 @@ declare class DaprRuntimeDriver<TPayload = unknown> implements RuntimeDriver<TPa
     private syncScheduledJob;
     private fromDaprJobName;
     private stateKeyForJob;
-    private stateKeyForIndex;
     private readJob;
     private writeJob;
-    private readIndex;
-    private writeIndex;
-    private addToIndex;
-    private removeFromIndex;
     private listJobsViaStateQuery;
-    private listJobsFromIndex;
     private decodeStoredJob;
-    private updateIndex;
     private deleteScheduledJob;
 }
 
-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 DaprAgentWorkflowRunRequest {
-    message: string;
-    sessionId?: string;
-    system?: string;
-    workflowInstanceId?: string;
-    maxSteps?: number;
-}
-interface DaprAgentWorkflowRunResult {
-    sessionId: string;
-    workflowInstanceId: string;
-    initialState: AgentWorkflowTurnState;
-}
-interface DaprAgentWorkflowHostOptions {
-    agent: Agent;
-    workflowName?: string;
-    activityNames?: Partial<DaprAgentTurnWorkflowActivityNames>;
-    mcpTools?: CreateDaprAgentTurnWorkflowKitOptions["modelStepActivity"]["mcpTools"];
-    /**
-     * 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[];
-    createAbortSignal?: () => AbortSignal;
-    now?: () => string;
-}
-interface DaprAgentWorkflowHost {
-    workflowName: string;
-    activityNames: DaprAgentTurnWorkflowActivityNames;
-    register<TRuntime extends DaprWorkflowRuntimeRegistrar>(runtime: TRuntime): TRuntime;
-    createInitialState(request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
-    startTurn(client: DaprWorkflowStarterLike, request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
-}
-/**
- * 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, appends the initial user message, 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>;
-
 interface DaprHostedAgentInfo<TPayload extends AgentTaskPayload = AgentTaskPayload> {
     readonly id: string;
     readonly aliases: string[];
     readonly description?: string;
     readonly workflowHost: {
         readonly workflowName: string;
+        /** Event bus for real-time streaming. `undefined` if not configured. */
+        readonly eventBus?: EventBus;
+        /** Dapr pub/sub bridge for multi-instance fan-out. `undefined` if not configured. */
+        readonly pubsubBridge?: DaprPubSubEventBridge;
+        /** Durable approval runtime for workflow-backed approvals, when configured. */
+        readonly approvalRuntime?: DaprWorkflowApprovalRuntime;
+        /** Durable human-input runtime for workflow-backed question tools, when configured. */
+        readonly humanInputRuntime?: DaprWorkflowHumanInputRuntime;
+        /** Durable follow-up runtime for workflow-backed next-turn control, when configured. */
+        readonly followUpRuntime?: DaprWorkflowFollowUpRuntime;
         startTurn(client: DaprWorkflowStarterLike, request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
+        steerTurn?(client: DaprWorkflowEventRaiserLike, request: DaprAgentWorkflowSteerRequest): Promise<SteeringResponse>;
+        followUpTurn?(client: DaprWorkflowEventRaiserLike, request: DaprAgentWorkflowFollowUpRequest): Promise<FollowUpResponse>;
     };
     readonly runtimeBundle: {
         readonly executionStore?: DaprExecutionStore<TPayload>;
@@ -140,93 +98,127 @@ interface DaprHostApp<TPayload extends AgentTaskPayload = AgentTaskPayload> {
     handleScheduledJob(jobName: string): Promise<DaprHttpJobHandlerResult>;
 }
 
-interface DaprServiceInvokerOptions {
-    /** Dapr sidecar HTTP endpoint. Defaults to http://127.0.0.1:3500. */
-    daprHttpEndpoint?: string;
-    /** Optional Dapr API token sent as the dapr-api-token header. */
-    apiToken?: string;
-    /** Default request timeout in milliseconds. Defaults to 15000. */
-    requestTimeoutMs?: number;
-    /** Override fetch implementation for tests/custom runtimes. */
-    fetch?: typeof fetch;
-}
-interface DaprInvokeMethodOptions<TBody = unknown> {
-    /** HTTP method for invocation. Defaults to POST when body exists, otherwise GET. */
-    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-    /** Request body. Objects are serialized as JSON. */
-    body?: TBody;
-    /** Additional HTTP headers. */
-    headers?: Record<string, string>;
-    /** Query-string parameters appended to method URL. */
-    query?: Record<string, string | number | boolean | undefined>;
-    /** Per-request timeout override in milliseconds. */
-    timeoutMs?: number;
-}
-interface DaprInvokeMethodResult<TResponse = unknown> {
-    status: number;
-    data: TResponse | undefined;
-    headers: Headers;
-}
-/** Default request contract for invoking a remote agent over service invocation. */
-interface RemoteAgentRunRequest extends AgentTaskPayload {
-}
-/** Default response contract for remote agent execution. */
-interface RemoteAgentRunResponse extends AgentTaskResult {
-}
-
-declare class DaprServiceInvoker {
-    private readonly daprHttpEndpoint;
-    private readonly apiToken?;
-    private readonly requestTimeoutMs;
-    private readonly fetchImpl;
-    constructor(options?: DaprServiceInvokerOptions);
-    invokeMethod<TResponse = unknown, TBody = unknown>(appId: string, methodPath: string, options?: DaprInvokeMethodOptions<TBody>): Promise<DaprInvokeMethodResult<TResponse>>;
-}
 /**
- * Invoke a remote agent endpoint using the default run contract.
+ * Remote agent tool — wraps Dapr service invocation into an agent Tool.
+ *
+ * Creates a tool that a coordinator agent can use to invoke a remote
+ * agent running as its own Dapr app. Each remote agent has its own
+ * sidecar, workflow runtime, and state — making them independently
+ * durable and scalable.
+ *
+ * ## Modes
+ *
+ * ### Durable (default, `mode: "durable"`)
+ *
+ * 1. `POST /agents/run-durable` on the remote app → 202 `{ instanceId, sessionId }`
+ * 2. Poll `GET /agents/{id}/workflows/{instanceId}` until terminal status
+ * 3. Fetch result from `GET /agents/{id}/executions/{sessionId}`
+ *
+ * Both sides are fully durable workflows. If the remote agent crashes
+ * mid-turn, its Dapr workflow resumes from the last checkpoint — the
+ * coordinator just keeps polling.
  *
- * Default route: `POST /agents/run`.
+ * ### Direct (`mode: "direct"`)
+ *
+ * `POST /agents/run` — synchronous. Simple but not durable on the
+ * remote side. If the remote crashes, the call fails and the
+ * coordinator's workflow retries the whole tool call.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * const researcherTool = createRemoteAgentTool({
+ *   appId: "researcher",
+ *   name: "researcher",
+ *   description: "Research topics and gather information.",
+ *   // mode: "durable" is the default — fully durable
+ * });
+ * ```
  */
-declare function invokeRemoteAgentRun(invoker: DaprServiceInvoker, appId: string, request: RemoteAgentRunRequest, methodPath?: string): Promise<RemoteAgentRunResponse>;
 
-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;
+interface CreateRemoteAgentToolOptions {
+    /**
+     * The Dapr service invoker to use for HTTP requests.
+     * If omitted, a new invoker is created with default settings
+     * (or you can pass `invokerOptions` instead).
+     */
+    invoker?: DaprServiceInvoker;
+    /**
+     * Options for creating a `DaprServiceInvoker` when `invoker` is not
+     * provided. Ignored if `invoker` is set.
+     */
+    invokerOptions?: DaprServiceInvokerOptions;
+    /**
+     * The Dapr app ID of the remote agent.
+     * This must match the `--app-id` used when launching the remote agent
+     * with `dapr run`.
+     */
+    appId: string;
+    /**
+     * Tool name exposed to the LLM. The tool will be registered as
+     * `ask_{name}` (e.g., `ask_researcher`).
+     */
+    name: string;
+    /**
+     * Tool description exposed to the LLM. Explain what the remote agent
+     * is good at so the coordinator knows when to delegate.
+     */
+    description: string;
+    /**
+     * Execution mode for the remote agent.
+     *
+     * - `"durable"` (default) — Starts a durable workflow on the remote
+     *   agent and polls for completion. Both coordinator and remote agent
+     *   are independently durable. If the remote crashes, its workflow
+     *   resumes from the last activity checkpoint.
+     *
+     * - `"direct"` — Synchronous `POST /agents/run`. Simpler but if the
+     *   remote crashes, the whole call fails and the coordinator retries
+     *   from scratch.
+     */
+    mode?: "durable" | "direct";
+    /**
+     * Polling interval for checking workflow completion (workflow mode only).
+     * Defaults to 2000ms.
+     */
+    pollIntervalMs?: number;
+    /**
+     * Maximum time to wait for the remote workflow to complete.
+     * Defaults to 5 minutes (300_000ms).
+     */
+    timeoutMs?: number;
 }
 /**
- * Create a Dapr workflow worker controller around one or more agent hosts.
+ * Create a tool that invokes a remote Dapr agent via service invocation.
+ *
+ * In the default `"durable"` mode, both the coordinator and the remote
+ * agent run as independent durable workflows:
+ *
+ * ```
+ * Coordinator Workflow
+ *   │
+ *   ├─ activity: start remote workflow
+ *   │    POST /agents/run-durable → 202 { instanceId, sessionId }
+ *   │    checkpoint instanceId ✓
+ *   │
+ *   ├─ activity: poll remote workflow
+ *   │    GET /agents/{id}/workflows/{instanceId}
+ *   │    ...RUNNING → RUNNING → COMPLETED
+ *   │    checkpoint completion ✓
+ *   │
+ *   ├─ activity: fetch remote result
+ *   │    GET /agents/{id}/executions/{sessionId}
+ *   │    checkpoint result ✓
+ * ```
+ *
+ * If the coordinator crashes after starting the remote workflow, it
+ * resumes polling (doesn't re-start the remote). If the remote crashes
+ * mid-turn, its own Dapr workflow resumes from the last activity
+ * checkpoint.
  *
- * 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.
+ * @returns A `Tool.AnyInfo` that can be passed to `createAgent({ tools: [...] })`.
  */
-declare function createDaprWorkflowWorker(options: DaprWorkflowWorkerOptions): DaprWorkflowWorker;
+declare function createRemoteAgentTool(options: CreateRemoteAgentToolOptions): Tool.AnyInfo;
 
 interface DaprWorkloadResultContext<TPayload = unknown, TResult = unknown> {
     jobId: string;
@@ -333,38 +325,66 @@ declare function createDaprAgentRuntime<TPayload extends AgentTaskPayload = Agen
 interface DaprHostRemoteRunRequest extends AgentTaskPayload {
     agentId?: string;
 }
+
+/**
+ * Main HTTP router for a Dapr host app.
+ *
+ * This is a thin dispatcher that delegates to domain-specific routers
+ * under `routers/`. Each router returns `Response | undefined` — `undefined`
+ * means "not my route", so the chain continues.
+ */
+
+type DaprHostHttpHandler = (request: Request) => Promise<Response>;
 interface DaprHostHttpHandlerOptions<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest> {
     app: DaprHostApp<TPayload>;
     workflowClient?: DaprWorkflowClient;
 }
-interface DaprHostHttpServerOptions<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest> extends DaprHostHttpHandlerOptions<TPayload> {
-    port: number;
-    host?: string;
-}
-interface DaprHostHttpServer {
-    server: Server;
-    origin: string;
-    close(): Promise<void>;
-}
 /**
  * Create a lightweight HTTP handler for a Dapr host app.
  *
  * Routes:
- * - `GET /health`
- * - `GET /healthz`
- * - `GET /ready`
- * - `GET /readyz`
+ * - `GET /health` / `GET /healthz`
+ * - `GET /ready` / `GET /readyz`
  * - `GET /agents`
  * - `POST /job/:name`
+ * - `GET /dapr/subscribe`
+ * - `POST /dapr/:topic`
  * - `POST /agents/run`
- * - `POST /agents/workflow`
+ * - `POST /agents/run-durable`
  * - `POST /agents/:id/run`
- * - `POST /agents/:id/workflow`
+ * - `POST /agents/:id/run-durable`
+ * - `GET /agents/:id/events/:sessionId` — SSE stream
  * - `GET /agents/:id/executions/:sessionId`
  * - `GET /agents/:id/executions/:sessionId/checkpoints`
  * - `GET /agents/:id/workflows/:instanceId`
+ * - `POST /agents/:id/workflows/:instanceId/terminate`
+ * - `POST /agents/:id/workflows/:instanceId/pause`
+ * - `POST /agents/:id/workflows/:instanceId/resume`
+ * - `POST /agents/:id/workflows/:instanceId/purge`
+ * - `GET /agents/:id/inputs` / `:requestId` / `:requestId/respond`
+ * - `GET /agents/:id/approvals` / `:requestId` / `:requestId/respond`
+ * - `GET /agents/:id/follow-ups` / `:requestId` / `:requestId/respond`
+ * - `POST /agents/:id/steer`
+ * - `POST /agents/:id/follow-up`
+ * - Shorthand variants (`/agents/inputs`, `/agents/approvals`, etc.) for single-agent hosts
  */
-declare function createDaprHostHttpHandler<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest>(options: DaprHostHttpHandlerOptions<TPayload>): (request: Request) => Promise<Response>;
+declare function createDaprHostHttpHandler<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest>(options: DaprHostHttpHandlerOptions<TPayload>): DaprHostHttpHandler;
+
+interface DaprHttpServerOptions {
+    handler: DaprHostHttpHandler;
+    port: number;
+    host?: string;
+}
+interface DaprHostHttpServerOptions<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest> extends DaprHostHttpHandlerOptions<TPayload> {
+    port: number;
+    host?: string;
+}
+interface DaprHostHttpServer {
+    server: Server;
+    origin: string;
+    close(): Promise<void>;
+}
+declare function startDaprHttpServer(options: DaprHttpServerOptions): Promise<DaprHostHttpServer>;
 declare function startDaprHostHttpServer<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest>(options: DaprHostHttpServerOptions<TPayload>): Promise<DaprHostHttpServer>;
 
 interface DaprAgentRunnerOptions {
@@ -436,6 +456,10 @@ interface DaprAgentRunnerOptions {
      * Properties set here override the defaults derived from the runner config.
      */
     workflowHost?: Omit<DaprAgentWorkflowHostOptions, "agent" | "observers">;
+    /**
+     * Policy for deferred follow-up requests in durable mode.
+     */
+    followUpPolicy?: FollowUpPolicy;
     /**
      * Override for runtime bundle options (advanced).
      * The `agent` and `driver` fields are always derived from the runner config.
@@ -449,10 +473,42 @@ interface DaprAgentServeOptions {
     port?: number;
     /** HTTP host. Defaults to all interfaces. */
     host?: string;
+    /** Serve static assets from this directory before the built-in agent routes. */
+    staticDir?: string;
+    /** File served for `/` when `staticDir` is configured. Defaults to `index.html`. */
+    indexFile?: string;
+    /** Additional exact-match routes evaluated before static assets and built-in routes. */
+    extraRoutes?: readonly DaprAgentHttpRoute[];
+}
+interface DaprAgentHttpRoute {
+    /** Exact URL pathname match, e.g. `/` or `/ui/config.json`. */
+    path: string;
+    /** Allowed HTTP methods. Defaults to all methods. */
+    method?: string | readonly string[];
+    handler(request: Request): Response | Promise<Response>;
+}
+interface DaprAgentHttpHandlerOptions {
+    staticDir?: string;
+    indexFile?: string;
+    extraRoutes?: readonly DaprAgentHttpRoute[];
+}
+interface DaprAgentDurableRunOptions {
+    sessionId?: string;
+    system?: string;
+    workflowInstanceId?: string;
+    maxSteps?: number;
+}
+interface DaprAgentDurableRunResult {
+    agentId: string;
+    workflowName: string;
+    sessionId: string;
+    instanceId: string;
 }
 interface DaprAgentRunner {
     /** Agent name / ID. */
     readonly name: string;
+    /** The underlying agent instance. */
+    readonly agent: Agent;
     /** The underlying workflow host. */
     readonly workflowHost: DaprAgentWorkflowHost;
     /** The underlying runtime bundle (scheduling, workload adapter, execution store). */
@@ -461,6 +517,32 @@ interface DaprAgentRunner {
     readonly worker: DaprWorkflowWorker;
     /** The workflow client for managing workflow instances. */
     readonly workflowClient: DaprWorkflowClient;
+    /**
+     * Return a capabilities patch describing the Dapr runtime backing.
+     *
+     * Structurally compatible with `AgentServerCapabilitiesPatch` from
+     * `@cuylabs/agent-server`. Used internally by
+     * `createDaprAgentServerAdapter(...)` and available for custom
+     * composition if you need to layer additional transport metadata.
+     *
+     * @example
+     * ```ts
+     * import { createDaprAgentServerAdapter } from "@cuylabs/agent-runtime-dapr";
+     * const adapter = createDaprAgentServerAdapter(runner);
+     * ```
+     */
+    agentServerCapabilities(): {
+        runtime: {
+            execution: "local";
+            orchestration: "agent-runtime-dapr";
+            durability: "workflow";
+            dapr: {
+                available: true;
+                delegatedTurns: false;
+                workflowBacked: true;
+            };
+        };
+    };
     /**
      * Start the runtime and workflow worker.
      * Must be called before `serve()` or manual invocation.
@@ -471,6 +553,11 @@ interface DaprAgentRunner {
      * Calls `start()` internally if not already started.
      */
     serve(options?: DaprAgentServeOptions): Promise<void>;
+    /**
+     * Build the HTTP handler for this runner.
+     * Useful when embedding the Dapr host routes inside a custom server.
+     */
+    createHttpHandler(options?: DaprAgentHttpHandlerOptions): DaprHostHttpHandler;
     /**
      * Run a task directly (synchronous execution, no workflow).
      * The agent must be started first.
@@ -478,34 +565,16 @@ interface DaprAgentRunner {
     run(message: string, options?: {
         sessionId?: string;
     }): Promise<AgentTaskResult>;
+    /**
+     * Start a durable workflow-backed task and return its identifiers.
+     * The agent must be started first.
+     */
+    runDurable(message: string, options?: DaprAgentDurableRunOptions): Promise<DaprAgentDurableRunResult>;
     /**
      * Gracefully shut down the runner.
      */
     stop(): Promise<void>;
 }
-/**
- * Create a Dapr agent runner — the single-call composition of all pieces
- * needed to run an agent with Dapr durability.
- *
- * Equivalent to Diagrid's `DaprWorkflowAgentRunner`. Internally creates:
- * - Workflow host (Dapr workflow registration + turn state management)
- * - Runtime bundle (scheduling + workload adapter + execution store)
- * - Workflow worker (gRPC worker for Dapr workflow engine)
- * - Workflow client (HTTP client for managing workflow instances)
- * - HTTP server (on `serve()`)
- *
- * @example
- * ```ts
- * const runner = createDaprAgentRunner({
- *   agent,
- *   name: "my-agent",
- *   workflowRuntime: new WorkflowRuntime({ daprHost: "127.0.0.1", daprPort: "50001" }),
- * });
- *
- * await runner.serve({ port: 3000 });
- * ```
- */
-declare function createDaprAgentRunner(options: DaprAgentRunnerOptions): DaprAgentRunner;
 interface DaprMultiAgentRunnerAgentConfig {
     /** The agent instance. */
     agent: Agent;
@@ -515,6 +584,8 @@ interface DaprMultiAgentRunnerAgentConfig {
     aliases?: string[];
     /** Optional description for this agent. */
     description?: string;
+    /** Policy for deferred follow-up requests for this hosted agent. */
+    followUpPolicy?: FollowUpPolicy;
 }
 interface DaprMultiAgentRunnerOptions {
     /** Agent configurations. */
@@ -539,9 +610,146 @@ interface DaprMultiAgentRunner {
     start(): Promise<void>;
     /** Start HTTP server and block until SIGINT/SIGTERM. Calls `start()` internally. */
     serve(options?: DaprAgentServeOptions): Promise<void>;
+    /** Build the HTTP handler for this multi-agent runner. */
+    createHttpHandler(options?: DaprAgentHttpHandlerOptions): DaprHostHttpHandler;
     /** Gracefully shut down. */
     stop(): Promise<void>;
 }
+
+type AgentServerCapabilitiesPatch = Record<string, unknown>;
+interface AppToolInfo {
+    id: string;
+}
+interface AppSkillInfo {
+    name: string;
+    description?: string;
+    path?: string;
+}
+interface AppSubAgentProfileInfo {
+    name: string;
+    description?: string;
+}
+interface AppPluginCommandInfo {
+    pluginId?: string;
+    name: string;
+    alias: string[];
+    summary: string;
+    metadata?: unknown;
+}
+interface AppModelState {
+    label: string;
+    switchable: boolean;
+}
+type AppModelSwitchResult = {
+    ok: true;
+    label: string;
+} | {
+    ok: false;
+    error: string;
+};
+type AppRuntimeStatusSnapshot = {
+    session: Record<string, unknown>;
+    model: Record<string, unknown>;
+    context: unknown;
+};
+type AppContextCompactionResult = unknown;
+type AppUndoResult = unknown;
+interface AppFollowUpListOptions {
+    sessionId?: string;
+    sourceTurnId?: string;
+    status?: FollowUpStatus | FollowUpStatus[];
+}
+type ResolveInputRequestPayload = {
+    kind: "approval";
+    action: "allow" | "deny" | "remember";
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+} | {
+    kind: "human";
+    response: HumanInputResponse;
+};
+interface AgentServerPluginCommand {
+    pluginId?: string;
+    name: string;
+    alias: string[];
+    summary: string;
+    metadata?: unknown;
+    execute(args: string): Promise<string | null> | string | null;
+}
+interface AgentServerAdapter {
+    readonly cwd: string;
+    getCapabilities?(): AgentServerCapabilitiesPatch;
+    getModelState?(): Promise<AppModelState> | AppModelState;
+    switchModel?(spec: string): Promise<AppModelSwitchResult> | AppModelSwitchResult;
+    getSessionRuntimeStatus?(sessionId: string): Promise<AppRuntimeStatusSnapshot> | AppRuntimeStatusSnapshot;
+    listTools?(): Promise<AppToolInfo[]> | AppToolInfo[];
+    listSkills?(): Promise<AppSkillInfo[]> | AppSkillInfo[];
+    listSubAgents?(): Promise<AppSubAgentProfileInfo[]> | AppSubAgentProfileInfo[];
+    compactSessionContext?(sessionId: string): Promise<AppContextCompactionResult> | AppContextCompactionResult;
+    undoSessionTurn?(sessionId: string): Promise<AppUndoResult> | AppUndoResult;
+    getSessionTurnDiff?(sessionId: string): Promise<string | null> | string | null;
+    chat(sessionId: string, message: string, options?: {
+        system?: string;
+        abort?: AbortSignal;
+    }): AsyncGenerator<AgentEvent>;
+    steer?(request: {
+        sessionId: string;
+        turnId: string;
+        message: string;
+    }): SteeringResponse;
+    followUp?(request: {
+        sessionId: string;
+        turnId: string;
+        message: string;
+    }): FollowUpResponse;
+    interruptTurn?(request: {
+        sessionId: string;
+        turnId: string;
+    }): void | Promise<void>;
+    respondToInputRequest?(requestId: string, payload: ResolveInputRequestPayload): void | Promise<void>;
+    listFollowUps?(options?: AppFollowUpListOptions): Promise<QueuedFollowUpRecord[]> | QueuedFollowUpRecord[];
+    getFollowUp?(followUpId: string): Promise<QueuedFollowUpRecord | null> | QueuedFollowUpRecord | null;
+    resolveFollowUp?(followUpId: string, action: FollowUpDecisionAction): Promise<QueuedFollowUpRecord | null> | QueuedFollowUpRecord | null;
+    listSessions(): ReturnType<Agent["listSessions"]>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    getSessionStorage(): ReturnType<ReturnType<Agent["getSessionManager"]>["getStorage"]>;
+    listPluginCommands?(): Promise<AppPluginCommandInfo[]> | AppPluginCommandInfo[];
+    executePluginCommand?(name: string, args: string): Promise<string | null> | string | null;
+}
+interface CreateDaprAgentServerAdapterOptions {
+    pluginCommands?: AgentServerPluginCommand[];
+    currentModelLabel?: string;
+    switchModel?: (spec: string) => Promise<AppModelSwitchResult> | AppModelSwitchResult;
+    listSkills?: () => Promise<AppSkillInfo[]> | AppSkillInfo[];
+    listSubAgents?: () => Promise<AppSubAgentProfileInfo[]> | AppSubAgentProfileInfo[];
+    capabilities?: AgentServerCapabilitiesPatch;
+}
+declare function createDaprAgentServerAdapter(runner: DaprAgentRunner, options?: CreateDaprAgentServerAdapterOptions): AgentServerAdapter;
+
+/**
+ * Create a Dapr agent runner — the single-call composition of all pieces
+ * needed to run an agent with Dapr durability.
+ *
+ * Equivalent to Diagrid's `DaprWorkflowAgentRunner`. Internally creates:
+ * - Workflow host (Dapr workflow registration + turn state management)
+ * - Runtime bundle (scheduling + workload adapter + execution store)
+ * - Workflow worker (gRPC worker for Dapr workflow engine)
+ * - Workflow client (HTTP client for managing workflow instances)
+ * - HTTP server (on `serve()`)
+ *
+ * @example
+ * ```ts
+ * const runner = createDaprAgentRunner({
+ *   agent,
+ *   name: "my-agent",
+ *   workflowRuntime: new WorkflowRuntime({ daprHost: "127.0.0.1", daprPort: "50001" }),
+ * });
+ *
+ * await runner.serve({ port: 3000 });
+ * ```
+ */
+declare function createDaprAgentRunner(options: DaprAgentRunnerOptions): DaprAgentRunner;
+
 /**
  * Create a multi-agent Dapr runner — multiple agents sharing a single
  * workflow worker, HTTP server, and Dapr sidecar.
@@ -561,4 +769,4 @@ interface DaprMultiAgentRunner {
  */
 declare function createDaprMultiAgentRunner(options: DaprMultiAgentRunnerOptions): DaprMultiAgentRunner;
 
-export { startDaprHostHttpServer as $, DaprRuntimeDriver as A, DaprServiceInvoker as B, type DaprServiceInvokerOptions as C, type DaprAgentRunner as D, type DaprWorkflowRuntimeRegistrar as E, type DaprWorkflowStarterLike as F, type DaprWorkflowWorker as G, type DaprWorkflowWorkerAgentDefinition as H, type DaprWorkflowWorkerLogger as I, type DaprWorkflowWorkerOptions as J, type DaprWorkflowWorkerRuntime as K, type DaprWorkloadErrorContext as L, type DaprWorkloadResultContext as M, type DaprWorkloadRuntimeBundle as N, type DaprWorkloadRuntimeOptions as O, type RemoteAgentRunResponse as P, createDaprAgentRunner as Q, type RemoteAgentRunRequest as R, createDaprAgentRuntime as S, createDaprAgentWorkflowHost as T, createDaprHostHttpHandler as U, createDaprHttpJobHandler as V, createDaprMultiAgentRunner as W, createDaprWorkflowWorker as X, createDaprWorkloadRuntime as Y, invokeRemoteAgentRun as Z, startDaprAgentWorkflowTurn as _, type DaprAgentRunnerOptions as a, type DaprAgentRuntimeBundle as b, type DaprAgentRuntimeOptions as c, type DaprAgentServeOptions as d, type DaprAgentTaskErrorContext as e, type DaprAgentTaskResultContext as f, type DaprAgentWorkflowHost as g, type DaprAgentWorkflowHostOptions as h, type DaprAgentWorkflowRunRequest as i, type DaprAgentWorkflowRunResult as j, type DaprHostApp as k, type DaprHostHttpHandlerOptions as l, type DaprHostHttpServer as m, type DaprHostHttpServerOptions as n, type DaprHostReadinessCheck as o, type DaprHostReadinessStatus as p, type DaprHostRemoteRunRequest as q, type DaprHostedAgentInfo as r, type DaprHttpJobHandlerOptions as s, type DaprHttpJobHandlerResult as t, type DaprInvokeMethodOptions as u, type DaprInvokeMethodResult as v, type DaprJobTriggerHandler as w, type DaprMultiAgentRunner as x, type DaprMultiAgentRunnerAgentConfig as y, type DaprMultiAgentRunnerOptions as z };
+export { type DaprWorkloadRuntimeBundle as A, type DaprWorkloadRuntimeOptions as B, type CreateDaprAgentServerAdapterOptions as C, type DaprAgentDurableRunOptions as D, createDaprAgentRunner as E, createDaprAgentRuntime as F, createDaprAgentServerAdapter as G, createDaprHostHttpHandler as H, createDaprHttpJobHandler as I, createDaprMultiAgentRunner as J, createDaprWorkloadRuntime as K, createRemoteAgentTool as L, startDaprHostHttpServer as M, type DaprAgentHttpHandlerOptions as N, type DaprAgentHttpRoute as O, type DaprHostHttpHandler as P, type DaprHttpServerOptions as Q, startDaprHttpServer as R, type CreateRemoteAgentToolOptions as a, type DaprAgentDurableRunResult as b, type DaprAgentRunner as c, type DaprAgentRunnerOptions as d, type DaprAgentRuntimeBundle as e, type DaprAgentRuntimeOptions as f, type DaprAgentServeOptions as g, type DaprAgentTaskErrorContext as h, type DaprAgentTaskResultContext as i, type DaprHostApp as j, type DaprHostHttpHandlerOptions as k, type DaprHostHttpServer as l, type DaprHostHttpServerOptions as m, type DaprHostReadinessCheck as n, type DaprHostReadinessStatus as o, type DaprHostRemoteRunRequest as p, type DaprHostedAgentInfo as q, type DaprHttpJobHandlerOptions as r, type DaprHttpJobHandlerResult as s, type DaprJobTriggerHandler as t, type DaprMultiAgentRunner as u, type DaprMultiAgentRunnerAgentConfig as v, type DaprMultiAgentRunnerOptions as w, DaprRuntimeDriver as x, type DaprWorkloadErrorContext as y, type DaprWorkloadResultContext as z };