@cuylabs/agent-runtime-dapr 0.8.0 → 0.10.0

package/dist/client-UsEIzDF6.d.ts

@@ -0,0 +1,322 @@
+import { AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult, AgentWorkflowInterventionSnapshot, AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult, HumanInputRequest, ApprovalRequest, AgentWorkflowInputCommitPlan, AgentWorkflowStepCommitPlan, AgentWorkflowCommitResult, AgentWorkflowOutputCommitPlan, AgentEvent, AgentTurnStepRuntimeConfig, Tool, convertAgentMessagesToModelMessages, PrepareModelStepOptions, ToolHost, TurnTrackerContext, MiddlewareRunner, ReasoningLevel, Message, AgentWorkflowTurnState } from '@cuylabs/agent-core';
+import { d as DaprSidecarClientOptions, f as DaprWorkflowObserverBridge } from './workflow-bridge-BcicHH1Y.js';
+
+type DaprWorkflowApiVersion = "v1.0" | "v1.0-beta1" | "v1.0-alpha1";
+type DaprWorkflowRuntimeStatus = "RUNNING" | "COMPLETED" | "FAILED" | "TERMINATED" | "CONTINUED_AS_NEW" | "PENDING" | "SUSPENDED" | (string & {});
+interface DaprWorkflowClientOptions extends DaprSidecarClientOptions {
+    /**
+     * Dapr workflow component name configured in the sidecar resources.
+     *
+     * Dapr requires the component name as part of the workflow HTTP route, so the
+     * client keeps it explicit rather than guessing a default.
+     */
+    workflowComponent: string;
+    /**
+     * HTTP API version for workflow endpoints. Defaults to `v1.0`.
+     */
+    workflowApiVersion?: DaprWorkflowApiVersion;
+    /**
+     * Default polling interval for wait helpers. Defaults to 1000ms.
+     */
+    workflowPollIntervalMs?: number;
+}
+interface StartDaprWorkflowOptions<TInput = unknown> {
+    /**
+     * Optional workflow instance identifier. When omitted, Dapr generates one.
+     */
+    instanceId?: string;
+    /**
+     * Optional workflow input payload. Objects are JSON serialized; strings are
+     * sent as-is to preserve exact text payloads.
+     */
+    input?: TInput;
+}
+interface RaiseDaprWorkflowEventOptions<TEventData = unknown> {
+    eventData?: TEventData;
+}
+interface WaitForDaprWorkflowOptions {
+    /**
+     * Max time to wait before returning `undefined`. Defaults to 60000ms.
+     */
+    timeoutMs?: number;
+    /**
+     * Polling interval for repeated `getWorkflow` checks. Defaults to the client
+     * default and never below 50ms.
+     */
+    pollIntervalMs?: number;
+}
+interface DaprWorkflowState {
+    instanceId: string;
+    workflowName: string;
+    createdAt?: string;
+    lastUpdatedAt?: string;
+    runtimeStatus: DaprWorkflowRuntimeStatus;
+    /**
+     * Raw string properties returned by Dapr for the orchestration instance.
+     */
+    properties: Record<string, string>;
+}
+interface DaprStartWorkflowResponse {
+    instanceId: string;
+}
+declare function isTerminalDaprWorkflowStatus(status: DaprWorkflowRuntimeStatus): boolean;
+declare function hasStartedDaprWorkflow(status: DaprWorkflowRuntimeStatus): boolean;
+
+/**
+ * Type definitions for the durable agent-turn workflow runtime.
+ *
+ * Extracted from `runtime.ts` for maintainability.
+ */
+
+interface DaprAgentTurnWorkflowActivityNames {
+    steerDrain?: string;
+    modelStep: string;
+    humanInputCheck?: string;
+    approvalCheck?: string;
+    toolCall: string;
+    stepCommit: string;
+    outputCommit: string;
+}
+interface DaprAgentTurnWorkflowContextLike {
+    callActivity(name: string, input: unknown): unknown;
+    callChildWorkflow?(name: string, input: unknown, instanceId?: string): unknown;
+    waitForExternalEvent?(name: string): unknown;
+    createTimer?(fireAt: Date | number): unknown;
+    whenAll?(tasks: unknown[]): unknown;
+    whenAny?(tasks: unknown[]): unknown;
+    continueAsNew?(input: unknown, preserveUnprocessedEvents?: boolean): never;
+    setCustomStatus?(status: string): void;
+    isReplaying?(): boolean;
+    getWorkflowInstanceId?(): string;
+}
+type DaprAgentTurnWorkflowDefinition = (context: DaprAgentTurnWorkflowContextLike, input: AgentWorkflowTurnState) => AsyncGenerator<unknown, AgentWorkflowTurnState, unknown>;
+interface DaprAgentTurnActivityRegistration<TInput, TOutput> {
+    name: string;
+    handler: (context: unknown, input: TInput) => Promise<TOutput> | TOutput;
+}
+interface DaprAgentTurnApprovalCheckInput {
+    workflowInstanceId: string;
+    sessionId: string;
+    step: number;
+    toolCall: AgentWorkflowToolCallPlan["toolCall"];
+}
+type DaprAgentTurnApprovalCheckResult = {
+    action: "allow";
+} | {
+    action: "deny";
+    reason: string;
+} | {
+    action: "request";
+    requestId: string;
+    eventName: string;
+    request: ApprovalRequest;
+};
+interface DaprAgentTurnHumanInputCheckInput {
+    workflowInstanceId: string;
+    sessionId: string;
+    step: number;
+    toolCall: AgentWorkflowToolCallPlan["toolCall"];
+}
+type DaprAgentTurnHumanInputCheckResult = {
+    action: "allow";
+} | {
+    action: "deny";
+    reason: string;
+} | {
+    action: "request";
+    requestId: string;
+    eventName: string;
+    request: HumanInputRequest;
+};
+interface DaprAgentTurnSteerDrainInput {
+    workflowInstanceId: string;
+    sessionId: string;
+    step: number;
+    maxItems: number;
+}
+interface DaprAgentTurnWorkflowRegistration {
+    workflowName: string;
+    activityNames: DaprAgentTurnWorkflowActivityNames;
+    workflow: DaprAgentTurnWorkflowDefinition;
+}
+interface CreateDaprAgentTurnWorkflowOptions {
+    workflowName?: string;
+    activityNames?: Partial<DaprAgentTurnWorkflowActivityNames>;
+    now?: () => string;
+    /**
+     * Timeout in milliseconds for durable human-input waits.
+     * When set, the workflow races `waitForExternalEvent` against a Dapr timer.
+     * If the timer fires first, the tool call is denied with a timeout message.
+     * Requires the workflow context to support `createTimer` and `whenAny`.
+     * Default: no timeout (wait indefinitely).
+     */
+    humanInputTimeoutMs?: number;
+    /**
+     * Timeout in milliseconds for durable approval waits.
+     * Same semantics as `humanInputTimeoutMs`.
+     * Default: no timeout (wait indefinitely).
+     */
+    approvalTimeoutMs?: number;
+    /**
+     * Enable mid-turn steering injection.
+     * When `true`, the workflow drains pending steer messages before each
+     * model-step and injects them as user messages.
+     * Requires a configured steer-drain activity.
+     * Default: `true`.
+     */
+    steeringEnabled?: boolean;
+    /**
+     * Maximum number of workflow steps before issuing `continueAsNew`.
+     * Resets the Dapr workflow history to prevent unbounded growth in
+     * long-running agents. The turn state is preserved across the reset.
+     * Default: no limit (history grows until the turn completes).
+     */
+    continueAsNewThreshold?: number;
+    /**
+     * Enable deferred follow-up queuing.
+     * When `true`, the durable host accepts follow-up requests and stores
+     * them in the follow-up runtime for next-turn seeding.
+     * Default: `true`.
+     */
+    followUpsEnabled?: boolean;
+}
+type CreateDaprAgentTurnWorkflowRegistrationOptions = CreateDaprAgentTurnWorkflowOptions;
+interface DaprAgentTurnModelStepActivityOptions {
+    runtime: AgentTurnStepRuntimeConfig | (() => AgentTurnStepRuntimeConfig);
+    tools: Record<string, Tool.Info> | (() => Record<string, Tool.Info>);
+    toModelMessages?: typeof convertAgentMessagesToModelMessages;
+    mcpTools?: PrepareModelStepOptions["mcpTools"] | (() => Promise<PrepareModelStepOptions["mcpTools"]>);
+    host?: ToolHost | (() => ToolHost | undefined);
+    turnTracker?: TurnTrackerContext;
+    middleware?: MiddlewareRunner | (() => MiddlewareRunner | undefined);
+    reasoningLevel?: ReasoningLevel | (() => ReasoningLevel | undefined);
+    /**
+     * Resolve system prompts dynamically at model-step execution time.
+     *
+     * When provided, called at the start of every model-step activity with
+     * the session ID and the prompts carried in the workflow state. The
+     * returned prompts replace `plan.systemPrompts` for that step.
+     *
+     * This keeps the workflow future-proof for dynamic prompt injection
+     * (MCP prompt resources, middleware-injected instructions, etc.)
+     * without freezing prompts at workflow start.
+     *
+     * During Dapr replay the activity result is cached, so the resolver
+     * only runs on the first execution of each activity — not on replay.
+     */
+    resolveSystemPrompts?: (sessionId: string, current: string[]) => Promise<string[]> | string[];
+    createAbortSignal?: () => AbortSignal;
+    onEvent?: (sessionId: string, event: AgentEvent) => void | Promise<void>;
+    now?: () => string;
+    /** Observer bridge for OTel trace context propagation. */
+    observerBridge?: DaprWorkflowObserverBridge;
+}
+interface DaprAgentTurnToolCallActivityOptions {
+    tools: Record<string, Tool.Info> | (() => Record<string, Tool.Info>);
+    cwd: string;
+    host?: ToolHost | (() => ToolHost | undefined);
+    turnTracker?: TurnTrackerContext;
+    middleware?: MiddlewareRunner | (() => MiddlewareRunner | undefined);
+    createAbortSignal?: () => AbortSignal;
+    now?: () => string;
+    /** Observer bridge for OTel trace context propagation. */
+    observerBridge?: DaprWorkflowObserverBridge;
+}
+interface DaprAgentTurnApprovalCheckActivityOptions {
+    check: (input: DaprAgentTurnApprovalCheckInput) => Promise<DaprAgentTurnApprovalCheckResult> | DaprAgentTurnApprovalCheckResult;
+}
+interface DaprAgentTurnHumanInputCheckActivityOptions {
+    check: (input: DaprAgentTurnHumanInputCheckInput) => Promise<DaprAgentTurnHumanInputCheckResult> | DaprAgentTurnHumanInputCheckResult;
+}
+interface DaprAgentTurnSteerDrainActivityOptions {
+    drain: (input: DaprAgentTurnSteerDrainInput) => Promise<AgentWorkflowInterventionSnapshot[]> | AgentWorkflowInterventionSnapshot[];
+}
+interface DaprAgentTurnCommitActivityOptions {
+    persistMessages: (sessionId: string, messages: Message[]) => Promise<void>;
+    now?: () => string;
+}
+interface CreateDaprAgentTurnWorkflowDefinitionOptions extends CreateDaprAgentTurnWorkflowRegistrationOptions {
+    modelStep: (input: AgentWorkflowModelStepPlan) => Promise<AgentWorkflowModelStepResult> | AgentWorkflowModelStepResult;
+    steerDrain?: (input: DaprAgentTurnSteerDrainInput) => Promise<AgentWorkflowInterventionSnapshot[]> | AgentWorkflowInterventionSnapshot[];
+    toolCall: (input: AgentWorkflowToolCallPlan) => Promise<AgentWorkflowToolCallResult> | AgentWorkflowToolCallResult;
+    humanInputCheck?: (input: DaprAgentTurnHumanInputCheckInput) => Promise<DaprAgentTurnHumanInputCheckResult> | DaprAgentTurnHumanInputCheckResult;
+    approvalCheck?: (input: DaprAgentTurnApprovalCheckInput) => Promise<DaprAgentTurnApprovalCheckResult> | DaprAgentTurnApprovalCheckResult;
+    stepCommit: (input: AgentWorkflowInputCommitPlan | AgentWorkflowStepCommitPlan) => Promise<AgentWorkflowCommitResult> | AgentWorkflowCommitResult;
+    outputCommit: (input: AgentWorkflowOutputCommitPlan) => Promise<AgentWorkflowCommitResult> | AgentWorkflowCommitResult;
+    workflowToolHandlers?: readonly DaprAgentTurnWorkflowToolHandler[];
+    /**
+     * Optional observer bridge. When provided, the workflow generator emits
+     * lifecycle notifications (task-start, checkpoint, complete, error) so
+     * that `AgentTaskObserver`s work on the workflow path too.
+     */
+    observerBridge?: DaprWorkflowObserverBridge;
+    /**
+     * Optional event sink for workflow-level events that are produced inside
+     * the orchestrator rather than model-step activities.
+     *
+     * Used for durable steering/intervention events that should reach the
+     * same real-time channels as direct execution.
+     */
+    onEvent?: (sessionId: string, event: AgentEvent) => void | Promise<void>;
+}
+interface CreateDaprAgentTurnWorkflowKitOptions extends CreateDaprAgentTurnWorkflowRegistrationOptions {
+    modelStepActivity: DaprAgentTurnModelStepActivityOptions;
+    steerDrainActivity?: DaprAgentTurnSteerDrainActivityOptions;
+    humanInputCheckActivity?: DaprAgentTurnHumanInputCheckActivityOptions;
+    approvalCheckActivity?: DaprAgentTurnApprovalCheckActivityOptions;
+    toolCallActivity: DaprAgentTurnToolCallActivityOptions;
+    commitActivity: DaprAgentTurnCommitActivityOptions;
+    workflowToolHandlers?: readonly DaprAgentTurnWorkflowToolHandler[];
+    /** Optional observer bridge passed through to the workflow definition. */
+    observerBridge?: DaprWorkflowObserverBridge;
+    /** Optional workflow-level event sink passed through to the definition. */
+    onEvent?: (sessionId: string, event: AgentEvent) => void | Promise<void>;
+}
+interface DaprAgentTurnWorkflowToolHandlerInput {
+    context: DaprAgentTurnWorkflowContextLike;
+    plan: AgentWorkflowToolCallPlan;
+    now: string;
+    isReplaying: boolean;
+}
+type DaprAgentTurnWorkflowToolHandler = (input: DaprAgentTurnWorkflowToolHandlerInput) => AsyncGenerator<unknown, AgentWorkflowToolCallResult | undefined, unknown>;
+interface DaprAgentTurnWorkflowKit extends DaprAgentTurnWorkflowRegistration {
+    activities: {
+        steerDrain?: DaprAgentTurnActivityRegistration<DaprAgentTurnSteerDrainInput, AgentWorkflowInterventionSnapshot[]>;
+        modelStep: DaprAgentTurnActivityRegistration<AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult>;
+        humanInputCheck?: DaprAgentTurnActivityRegistration<DaprAgentTurnHumanInputCheckInput, DaprAgentTurnHumanInputCheckResult>;
+        approvalCheck?: DaprAgentTurnActivityRegistration<DaprAgentTurnApprovalCheckInput, DaprAgentTurnApprovalCheckResult>;
+        toolCall: DaprAgentTurnActivityRegistration<AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult>;
+        stepCommit: DaprAgentTurnActivityRegistration<AgentWorkflowInputCommitPlan | AgentWorkflowStepCommitPlan, AgentWorkflowCommitResult>;
+        outputCommit: DaprAgentTurnActivityRegistration<AgentWorkflowOutputCommitPlan, AgentWorkflowCommitResult>;
+    };
+}
+
+/**
+ * Thin HTTP client for Dapr workflow management APIs.
+ *
+ * This intentionally mirrors the rest of `agent-runtime-dapr`: direct sidecar
+ * HTTP calls with retry/timeout behavior owned by `DaprSidecarClient`. The
+ * higher-level runtime/workflow adapter can build on this without pulling gRPC
+ * or DurableTask types into the package boundary.
+ */
+declare class DaprWorkflowClient {
+    private readonly client;
+    private readonly workflowComponent;
+    private readonly workflowApiVersion;
+    private readonly workflowPollIntervalMs;
+    constructor(options: DaprWorkflowClientOptions);
+    verifySidecar(): Promise<void>;
+    startWorkflow<TInput = unknown>(workflowName: string, options?: StartDaprWorkflowOptions<TInput>): Promise<DaprStartWorkflowResponse>;
+    getWorkflow(instanceId: string): Promise<DaprWorkflowState | undefined>;
+    waitForWorkflowStart(instanceId: string, options?: WaitForDaprWorkflowOptions): Promise<DaprWorkflowState | undefined>;
+    waitForWorkflowCompletion(instanceId: string, options?: WaitForDaprWorkflowOptions): Promise<DaprWorkflowState | undefined>;
+    pauseWorkflow(instanceId: string): Promise<void>;
+    resumeWorkflow(instanceId: string): Promise<void>;
+    terminateWorkflow(instanceId: string): Promise<void>;
+    purgeWorkflow(instanceId: string): Promise<void>;
+    raiseWorkflowEvent<TEventData = unknown>(instanceId: string, eventName: string, options?: RaiseDaprWorkflowEventOptions<TEventData>): Promise<void>;
+    private controlWorkflow;
+    private waitForWorkflowState;
+}
+
+export { hasStartedDaprWorkflow as A, isTerminalDaprWorkflowStatus as B, type CreateDaprAgentTurnWorkflowDefinitionOptions as C, DaprWorkflowClient as D, type RaiseDaprWorkflowEventOptions as R, type StartDaprWorkflowOptions as S, type WaitForDaprWorkflowOptions as W, type DaprAgentTurnWorkflowToolHandler as a, type DaprAgentTurnActivityRegistration as b, type CreateDaprAgentTurnWorkflowKitOptions as c, type CreateDaprAgentTurnWorkflowOptions as d, type DaprAgentTurnApprovalCheckActivityOptions as e, type DaprAgentTurnApprovalCheckInput as f, type DaprAgentTurnApprovalCheckResult as g, type DaprAgentTurnCommitActivityOptions as h, type DaprAgentTurnHumanInputCheckActivityOptions as i, type DaprAgentTurnHumanInputCheckInput as j, type DaprAgentTurnHumanInputCheckResult as k, type DaprAgentTurnModelStepActivityOptions as l, type DaprAgentTurnSteerDrainActivityOptions as m, type DaprAgentTurnSteerDrainInput as n, type DaprAgentTurnToolCallActivityOptions as o, type DaprAgentTurnWorkflowActivityNames as p, type DaprAgentTurnWorkflowContextLike as q, type DaprAgentTurnWorkflowDefinition as r, type DaprAgentTurnWorkflowKit as s, type DaprAgentTurnWorkflowRegistration as t, type DaprAgentTurnWorkflowToolHandlerInput as u, type DaprStartWorkflowResponse as v, type DaprWorkflowApiVersion as w, type DaprWorkflowClientOptions as x, type DaprWorkflowRuntimeStatus as y, type DaprWorkflowState as z };

package/dist/dispatch/index.d.ts

@@ -0,0 +1,9 @@
+export { b as DaprAppDispatchExecutorOptions, c as DaprDispatchRecord, D as DaprDispatchRuntimeOptions, d as DaprDispatchTarget, e as DaprDispatchTargetInspection, f as DaprWorkflowDispatchExecutorOptions, R as RemoteAgentDispatchTargetOptions, W as WorkflowDispatchTargetOptions, g as createDaprAppDispatchExecutor, h as createDaprCompositeDispatchExecutor, i as createDaprDispatchRuntime, j as createDaprWorkflowDispatchExecutor, k as createRemoteAgentDispatchTarget, l as createWorkflowDispatchTarget } from '../index-BEOwKSPI.js';
+import '@cuylabs/agent-core';
+import '../workflow-bridge-BcicHH1Y.js';
+import '../client-UsEIzDF6.js';
+import '../workflow-host-D6W6fXoL.js';
+import '@cuylabs/agent-core/events';
+import '../invoker-B1jvz9DG.js';
+import '../store-BXBIDz40.js';
+import '@cuylabs/agent-runtime';

package/dist/dispatch/index.js

@@ -0,0 +1,17 @@
+import {
+  createDaprAppDispatchExecutor,
+  createDaprCompositeDispatchExecutor,
+  createDaprDispatchRuntime,
+  createDaprWorkflowDispatchExecutor,
+  createRemoteAgentDispatchTarget,
+  createWorkflowDispatchTarget
+} from "../chunk-YQQTUE6B.js";
+import "../chunk-MQJ4LZOX.js";
+export {
+  createDaprAppDispatchExecutor,
+  createDaprCompositeDispatchExecutor,
+  createDaprDispatchRuntime,
+  createDaprWorkflowDispatchExecutor,
+  createRemoteAgentDispatchTarget,
+  createWorkflowDispatchTarget
+};

package/dist/execution/index.d.ts

@@ -1,7 +1,8 @@
-import { h as DaprExecutionStore } from '../store-pRLGfYhN.js';
-export { D as DaprExecutionCheckpointRecord, a as DaprExecutionCleanupOptions, b as DaprExecutionCleanupResult, c as DaprExecutionContextMetadata, d as DaprExecutionErrorRecord, e as DaprExecutionRunRecord, f as DaprExecutionSnapshot, g as DaprExecutionStatus } from '../store-pRLGfYhN.js';
+import { h as DaprExecutionStore } from '../store-BXBIDz40.js';
+export { D as DaprExecutionCheckpointRecord, a as DaprExecutionCleanupOptions, b as DaprExecutionCleanupResult, c as DaprExecutionContextMetadata, d as DaprExecutionErrorRecord, e as DaprExecutionRunRecord, f as DaprExecutionSnapshot, g as DaprExecutionStatus } from '../store-BXBIDz40.js';
 import { AgentTaskPayload, AgentTaskObserver, AgentTaskExecutionRun, AgentTaskExecutionSnapshot, AgentTaskExecutionCheckpoint, AgentTaskResult } from '@cuylabs/agent-core';
-export { f as DaprWorkflowObserverBridge, g as DaprWorkflowObserverOptions, h as createWorkflowObserverBridge } from '../workflow-bridge-C8Z1yr0Y.js';
+export { f as DaprWorkflowObserverBridge, g as DaprWorkflowObserverOptions, h as createWorkflowObserverBridge } from '../workflow-bridge-BcicHH1Y.js';
+import '@cuylabs/agent-runtime';
 
 interface DaprExecutionObserverOptions<TPayload extends AgentTaskPayload = AgentTaskPayload> {
     /**
@@ -72,7 +73,7 @@ declare function createDaprLoggingObserver<TPayload extends AgentTaskPayload = A
  *        └─ execute_tool greet      ← otelMiddleware
  * ```
  *
- * Span hierarchy (workflow execution — /agents/workflow):
+ * Span hierarchy (workflow execution — /agents/run-durable):
  * ```
  * agent.turn                        ← this observer
  *   └─ invoke_agent my-agent        ← otelMiddleware (via runChatStart/End)

package/dist/execution/index.js

@@ -5,8 +5,8 @@ import {
   createDaprLoggingObserver,
   createOtelObserver,
   createWorkflowObserverBridge
-} from "../chunk-2CEICSJH.js";
-import "../chunk-A34CHK2E.js";
+} from "../chunk-5CJIC4YB.js";
+import "../chunk-MQJ4LZOX.js";
 export {
   DaprExecutionObserver,
   DaprExecutionStore,

package/dist/host/index.d.ts

@@ -1,7 +1,11 @@
-export { D as DaprAgentRunner, a as DaprAgentRunnerOptions, b as DaprAgentRuntimeBundle, c as DaprAgentRuntimeOptions, d as DaprAgentServeOptions, e as DaprAgentTaskErrorContext, f as DaprAgentTaskResultContext, g as DaprAgentWorkflowHost, h as DaprAgentWorkflowHostOptions, i as DaprAgentWorkflowRunRequest, j as DaprAgentWorkflowRunResult, k as DaprHostApp, l as DaprHostHttpHandlerOptions, m as DaprHostHttpServer, n as DaprHostHttpServerOptions, o as DaprHostReadinessCheck, p as DaprHostReadinessStatus, q as DaprHostRemoteRunRequest, r as DaprHostedAgentInfo, u as DaprInvokeMethodOptions, v as DaprInvokeMethodResult, x as DaprMultiAgentRunner, y as DaprMultiAgentRunnerAgentConfig, z as DaprMultiAgentRunnerOptions, B as DaprServiceInvoker, C as DaprServiceInvokerOptions, E as DaprWorkflowRuntimeRegistrar, F as DaprWorkflowStarterLike, G as DaprWorkflowWorker, H as DaprWorkflowWorkerAgentDefinition, I as DaprWorkflowWorkerLogger, J as DaprWorkflowWorkerOptions, K as DaprWorkflowWorkerRuntime, L as DaprWorkloadErrorContext, M as DaprWorkloadResultContext, N as DaprWorkloadRuntimeBundle, O as DaprWorkloadRuntimeOptions, R as RemoteAgentRunRequest, P as RemoteAgentRunResponse, Q as createDaprAgentRunner, S as createDaprAgentRuntime, T as createDaprAgentWorkflowHost, U as createDaprHostHttpHandler, W as createDaprMultiAgentRunner, X as createDaprWorkflowWorker, Y as createDaprWorkloadRuntime, Z as invokeRemoteAgentRun, _ as startDaprAgentWorkflowTurn, $ as startDaprHostHttpServer } from '../index-nZvCz3bO.js';
+export { C as CreateDaprAgentServerAdapterOptions, a as CreateRemoteAgentToolOptions, D as DaprAgentDurableRunOptions, b as DaprAgentDurableRunResult, N as DaprAgentHttpHandlerOptions, O as DaprAgentHttpRoute, c as DaprAgentRunner, d as DaprAgentRunnerOptions, e as DaprAgentRuntimeBundle, f as DaprAgentRuntimeOptions, g as DaprAgentServeOptions, h as DaprAgentTaskErrorContext, i as DaprAgentTaskResultContext, j as DaprHostApp, P as DaprHostHttpHandler, k as DaprHostHttpHandlerOptions, l as DaprHostHttpServer, m as DaprHostHttpServerOptions, n as DaprHostReadinessCheck, o as DaprHostReadinessStatus, p as DaprHostRemoteRunRequest, q as DaprHostedAgentInfo, Q as DaprHttpServerOptions, u as DaprMultiAgentRunner, v as DaprMultiAgentRunnerAgentConfig, w as DaprMultiAgentRunnerOptions, y as DaprWorkloadErrorContext, z as DaprWorkloadResultContext, A as DaprWorkloadRuntimeBundle, B as DaprWorkloadRuntimeOptions, E as createDaprAgentRunner, F as createDaprAgentRuntime, G as createDaprAgentServerAdapter, H as createDaprHostHttpHandler, J as createDaprMultiAgentRunner, K as createDaprWorkloadRuntime, L as createRemoteAgentTool, M as startDaprHostHttpServer, R as startDaprHttpServer } from '../index-BmM58WZa.js';
+export { D as DaprInvokeMethodOptions, a as DaprInvokeMethodResult, b as DaprServiceInvoker, c as DaprServiceInvokerOptions, R as RemoteAgentRunRequest, d as RemoteAgentRunResponse, i as invokeRemoteAgentRun } from '../invoker-B1jvz9DG.js';
+export { b as DaprAgentWorkflowFollowUpRequest, a as DaprAgentWorkflowHost, c as DaprAgentWorkflowHostOptions, d as DaprAgentWorkflowRunRequest, e as DaprAgentWorkflowRunResult, f as DaprAgentWorkflowSteerRequest, g as DaprApprovalDecision, h as DaprApprovalRequestListOptions, i as DaprApprovalRequestRecord, j as DaprApprovalRequestStatus, k as DaprApprovalResolution, l as DaprFollowUpListOptions, m as DaprFollowUpRecord, n as DaprHumanInputRequestListOptions, o as DaprHumanInputRequestRecord, p as DaprHumanInputRequestStatus, q as DaprPubSubEventBridge, r as DaprPubSubEventBridgeOptions, s as DaprSteerRecord, t as DaprWorkflowApprovalCheckInput, u as DaprWorkflowApprovalCheckResult, v as DaprWorkflowApprovalRuntime, w as DaprWorkflowApprovalRuntimeOptions, x as DaprWorkflowEventRaiserLike, y as DaprWorkflowFollowUpRuntime, z as DaprWorkflowFollowUpRuntimeOptions, A as DaprWorkflowHumanInputCheckInput, B as DaprWorkflowHumanInputCheckResult, C as DaprWorkflowHumanInputRuntime, E as DaprWorkflowHumanInputRuntimeOptions, D as DaprWorkflowRuntimeRegistrar, F as DaprWorkflowStarterLike, G as DaprWorkflowSteerRuntime, H as DaprWorkflowSteerRuntimeOptions, I as createDaprAgentWorkflowHost, J as createDaprPubSubEventBridge, K as createDaprWorkflowApprovalRuntime, L as createDaprWorkflowFollowUpRuntime, M as createDaprWorkflowHumanInputRuntime, N as createDaprWorkflowSteerRuntime, O as startDaprAgentWorkflowTurn } from '../workflow-host-D6W6fXoL.js';
+export { D as DaprWorkflowWorker, a as DaprWorkflowWorkerAgentDefinition, b as DaprWorkflowWorkerLogger, c as DaprWorkflowWorkerOptions, d as DaprWorkflowWorkerRuntime, e as createDaprWorkflowWorker } from '../worker-CXq0IFGX.js';
+export { EventBus, EventBusMessage, EventBusOptions, EventBusSubscribeOptions, EventBusSubscription, createEventBus } from '@cuylabs/agent-core/events';
 import '@cuylabs/agent-core';
-import '../store-pRLGfYhN.js';
-import '../workflow-bridge-C8Z1yr0Y.js';
-import '../workflow/index.js';
+import '../store-BXBIDz40.js';
 import '@cuylabs/agent-runtime';
+import '../workflow-bridge-BcicHH1Y.js';
+import '../client-UsEIzDF6.js';
 import 'node:http';

package/dist/host/index.js

@@ -1,29 +1,49 @@
 import {
-  DaprServiceInvoker,
   createDaprAgentRunner,
   createDaprAgentRuntime,
+  createDaprAgentServerAdapter,
   createDaprAgentWorkflowHost,
   createDaprHostHttpHandler,
   createDaprMultiAgentRunner,
+  createDaprPubSubEventBridge,
+  createDaprWorkflowApprovalRuntime,
+  createDaprWorkflowFollowUpRuntime,
+  createDaprWorkflowHumanInputRuntime,
+  createDaprWorkflowSteerRuntime,
   createDaprWorkflowWorker,
   createDaprWorkloadRuntime,
-  invokeRemoteAgentRun,
+  createEventBus,
+  createRemoteAgentTool,
   startDaprAgentWorkflowTurn,
-  startDaprHostHttpServer
-} from "../chunk-R47X4FG2.js";
-import "../chunk-2CEICSJH.js";
-import "../chunk-DILON56B.js";
-import "../chunk-A34CHK2E.js";
+  startDaprHostHttpServer,
+  startDaprHttpServer
+} from "../chunk-MJKJT3ZO.js";
+import {
+  DaprServiceInvoker,
+  invokeRemoteAgentRun
+} from "../chunk-YQQTUE6B.js";
+import "../chunk-5CJIC4YB.js";
+import "../chunk-YS2CWYBQ.js";
+import "../chunk-MQJ4LZOX.js";
 export {
   DaprServiceInvoker,
   createDaprAgentRunner,
   createDaprAgentRuntime,
+  createDaprAgentServerAdapter,
   createDaprAgentWorkflowHost,
   createDaprHostHttpHandler,
   createDaprMultiAgentRunner,
+  createDaprPubSubEventBridge,
+  createDaprWorkflowApprovalRuntime,
+  createDaprWorkflowFollowUpRuntime,
+  createDaprWorkflowHumanInputRuntime,
+  createDaprWorkflowSteerRuntime,
   createDaprWorkflowWorker,
   createDaprWorkloadRuntime,
+  createEventBus,
+  createRemoteAgentTool,
   invokeRemoteAgentRun,
   startDaprAgentWorkflowTurn,
-  startDaprHostHttpServer
+  startDaprHostHttpServer,
+  startDaprHttpServer
 };

package/dist/index-BEOwKSPI.d.ts

@@ -0,0 +1,101 @@
+import { DispatchRecord, DispatchTarget, DispatchTargetInspection, DispatchRuntime, TaskExecutor } from '@cuylabs/agent-core';
+import { e as DaprStateStoreClientOptions } from './workflow-bridge-BcicHH1Y.js';
+import { D as DaprWorkflowClient, z as DaprWorkflowState } from './client-UsEIzDF6.js';
+import { a as DaprAgentWorkflowHost, d as DaprAgentWorkflowRunRequest } from './workflow-host-D6W6fXoL.js';
+import { b as DaprServiceInvoker, c as DaprServiceInvokerOptions } from './invoker-B1jvz9DG.js';
+import { h as DaprExecutionStore } from './store-BXBIDz40.js';
+
+interface DaprDispatchRecord extends DispatchRecord {
+    agentId: string;
+}
+type DaprDispatchTargetInspection = DispatchTargetInspection;
+type DaprDispatchTarget = DispatchTarget<DaprDispatchRecord>;
+interface DaprDispatchRuntimeOptions extends DaprStateStoreClientOptions {
+    agentId: string;
+    targets: readonly DaprDispatchTarget[];
+    keyPrefix?: string;
+    now?: () => string;
+    pollIntervalMs?: number;
+    createId?: () => string;
+}
+interface DaprDispatchRecordWriterOptions extends DaprStateStoreClientOptions {
+    agentId: string;
+    keyPrefix?: string;
+}
+interface WorkflowDispatchTargetOptions {
+    name: string;
+    description: string;
+    host: DaprAgentWorkflowHost;
+    client: DaprWorkflowClient;
+    /**
+     * Optional hook for customizing the child workflow input.
+     * `message`, `sessionId`, and `workflowInstanceId` defaults are provided.
+     */
+    buildRequest?: (input: {
+        id: string;
+        brief: string;
+        title: string;
+        parentSessionId?: string;
+        sessionId?: string;
+    }) => DaprAgentWorkflowRunRequest;
+    /**
+     * Optional terminal-state reader that can attach a final result or
+     * richer error details when the child workflow completes.
+     */
+    readCompletion?: (input: {
+        record: DaprDispatchRecord;
+        workflow: DaprWorkflowState;
+    }) => Promise<Pick<DispatchTargetInspection, "result" | "error"> | undefined>;
+    /**
+     * When `true`, waits for the child workflow to reach a running state
+     * before returning the dispatch record. This confirms the sidecar has
+     * actually scheduled the workflow before the caller proceeds.
+     * Default: `false`.
+     */
+    waitForStart?: boolean;
+}
+interface RemoteAgentDispatchTargetOptions {
+    name: string;
+    description: string;
+    appId: string;
+    agentId?: string;
+    invoker?: DaprServiceInvoker;
+    invokerOptions?: DaprServiceInvokerOptions;
+    buildRunRequest?: (input: {
+        id: string;
+        brief: string;
+        title: string;
+        parentSessionId?: string;
+        sessionId?: string;
+    }) => {
+        message: string;
+        sessionId?: string;
+    };
+}
+declare function createWorkflowDispatchTarget(options: WorkflowDispatchTargetOptions): DaprDispatchTarget;
+declare function createRemoteAgentDispatchTarget(options: RemoteAgentDispatchTargetOptions): DaprDispatchTarget;
+declare function createDaprDispatchRuntime(options: DaprDispatchRuntimeOptions): DispatchRuntime;
+
+interface DaprWorkflowDispatchExecutorOptions {
+    workflowHosts: Map<string, DaprAgentWorkflowHost>;
+    workflowClient: DaprWorkflowClient;
+    executionStore?: DaprExecutionStore;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+declare function createDaprWorkflowDispatchExecutor(options: DaprWorkflowDispatchExecutorOptions): TaskExecutor;
+interface DaprAppDispatchExecutorOptions {
+    appsByRole: Map<string, string>;
+    invoker?: DaprServiceInvoker;
+    invokerOptions?: DaprServiceInvokerOptions;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+declare function createDaprAppDispatchExecutor(options: DaprAppDispatchExecutorOptions): TaskExecutor;
+declare function createDaprCompositeDispatchExecutor(options: {
+    workflow?: DaprWorkflowDispatchExecutorOptions;
+    app?: DaprAppDispatchExecutorOptions;
+    fallback?: TaskExecutor;
+}): TaskExecutor;
+
+export { type DaprDispatchRuntimeOptions as D, type RemoteAgentDispatchTargetOptions as R, type WorkflowDispatchTargetOptions as W, type DaprDispatchRecordWriterOptions as a, type DaprAppDispatchExecutorOptions as b, type DaprDispatchRecord as c, type DaprDispatchTarget as d, type DaprDispatchTargetInspection as e, type DaprWorkflowDispatchExecutorOptions as f, createDaprAppDispatchExecutor as g, createDaprCompositeDispatchExecutor as h, createDaprDispatchRuntime as i, createDaprWorkflowDispatchExecutor as j, createRemoteAgentDispatchTarget as k, createWorkflowDispatchTarget as l };