@cuylabs/agent-runtime-dapr 0.5.0

package/dist/index-CKTP36vE.d.ts

@@ -0,0 +1,533 @@
+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 { RuntimeDriver, RuntimeDriverContext, RuntimeJobRecord, AgentRuntime, AgentRuntimeOptions, RuntimeExecutionContext } from '@cuylabs/agent-runtime';
+import { c as DaprRuntimeDriverOptions, a as DaprExecutionStoreOptions } from './workflow-bridge-C8Z1yr0Y.js';
+import { Server } from 'node:http';
+
+interface DaprJobTriggerHandler {
+    handleJobTriggerByName(jobName: string): Promise<boolean>;
+}
+interface DaprHttpJobHandlerOptions {
+    driver: DaprJobTriggerHandler;
+    handledStatus?: number;
+    unhandledStatus?: number;
+    errorStatus?: number;
+    onError?: (error: unknown, jobName: string) => void | Promise<void>;
+}
+interface DaprHttpJobHandlerResult {
+    status: number;
+    handled: boolean;
+    error?: unknown;
+}
+declare function createDaprHttpJobHandler(options: DaprHttpJobHandlerOptions): (jobName: string) => Promise<DaprHttpJobHandlerResult>;
+
+declare class DaprRuntimeDriver<TPayload = unknown> implements RuntimeDriver<TPayload> {
+    readonly name = "dapr";
+    private readonly client;
+    private readonly jobsApi;
+    private readonly keyPrefix;
+    private context;
+    private started;
+    constructor(options: DaprRuntimeDriverOptions);
+    start(context: RuntimeDriverContext<TPayload>): Promise<void>;
+    stop(): Promise<void>;
+    listJobs(): Promise<RuntimeJobRecord<TPayload>[]>;
+    getJob(jobId: string): Promise<RuntimeJobRecord<TPayload> | undefined>;
+    upsertJob(job: RuntimeJobRecord<TPayload>): Promise<RuntimeJobRecord<TPayload>>;
+    removeJob(jobId: string): Promise<boolean>;
+    /**
+     * Handle a Dapr scheduler callback routed to `/job/:name`.
+     * Returns false when the job name is not managed by this driver.
+     */
+    handleJobTriggerByName(jobName: string): Promise<boolean>;
+    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;
+        startTurn(client: DaprWorkflowStarterLike, request: DaprAgentWorkflowRunRequest): Promise<DaprAgentWorkflowRunResult>;
+    };
+    readonly runtimeBundle: {
+        readonly executionStore?: DaprExecutionStore<TPayload>;
+    };
+}
+interface DaprHostReadinessCheck {
+    readonly name: string;
+    readonly ok: boolean;
+    readonly detail?: string;
+}
+interface DaprHostReadinessStatus {
+    readonly ok: boolean;
+    readonly checks: readonly DaprHostReadinessCheck[];
+}
+interface DaprHostApp<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    isRunning(): boolean;
+    checkReadiness?(): DaprHostReadinessStatus | Promise<DaprHostReadinessStatus>;
+    listAgents(): readonly DaprHostedAgentInfo<TPayload>[];
+    getAgent(idOrAlias: string): DaprHostedAgentInfo<TPayload> | undefined;
+    runAgent(idOrAlias: string, payload: TPayload): Promise<unknown>;
+    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.
+ *
+ * Default route: `POST /agents/run`.
+ */
+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;
+}
+/**
+ * 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;
+
+interface DaprAgentTaskResultContext<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    jobId: string;
+    payload: TPayload;
+    runtimeContext: RuntimeExecutionContext;
+    result: AgentTaskResult;
+}
+interface DaprAgentTaskErrorContext<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    jobId: string;
+    payload: TPayload;
+    runtimeContext: RuntimeExecutionContext;
+    error: unknown;
+    message: string;
+}
+interface DaprAgentRuntimeOptions<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    /** Agent instance used for job execution. */
+    agent: Agent;
+    /** Dapr driver configuration (sidecar + state store + retries). */
+    driver: DaprRuntimeDriverOptions;
+    /**
+     * Optional runtime options excluding driver and execute.
+     * Use this to set concurrency/timeouts/logging behavior.
+     */
+    runtime?: Omit<AgentRuntimeOptions<TPayload>, "driver" | "execute">;
+    /**
+     * Optional explicit task runner. If omitted, one is created with
+     * createAgentTaskRunner(agent, taskRunnerOptions).
+     */
+    taskRunner?: AgentTaskRunner<TPayload>;
+    /** Options used when creating the default task runner. */
+    taskRunnerOptions?: AgentTaskRunnerOptions<TPayload>;
+    /**
+     * Persist neutral execution snapshots/checkpoints into Dapr state.
+     *
+     * Enabled by default when this helper creates the task runner. Disable it if
+     * you only want outer scheduling/orchestration durability.
+     */
+    persistExecutionState?: boolean;
+    /**
+     * Optional pre-created execution store. When omitted and
+     * `persistExecutionState !== false`, a store is created from the driver
+     * configuration.
+     */
+    executionStore?: DaprExecutionStore<TPayload>;
+    /**
+     * Optional execution store configuration override. This is only used when
+     * `executionStore` is not provided.
+     */
+    executionStoreOptions?: DaprExecutionStoreOptions;
+    /** Optional hook invoked after successful task execution. */
+    onTaskResult?: (context: DaprAgentTaskResultContext<TPayload>) => void | Promise<void>;
+    /** Optional hook invoked when task execution fails. */
+    onTaskError?: (context: DaprAgentTaskErrorContext<TPayload>) => void | Promise<void>;
+}
+interface DaprAgentRuntimeBundle<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    runtime: AgentRuntime<TPayload>;
+    driver: DaprRuntimeDriver<TPayload>;
+    runTask: AgentTaskRunner<TPayload>;
+    executionStore?: DaprExecutionStore<TPayload>;
+    handleDaprJob: (jobName: string) => Promise<DaprHttpJobHandlerResult>;
+}
+/**
+ * Create a Dapr-backed runtime bundle for executing agent tasks.
+ *
+ * The returned bundle includes:
+ * - runtime: scheduling + execution loop
+ * - driver: Dapr persistence/scheduler adapter
+ * - runTask: direct task runner (for manual invocation/tests)
+ * - handleDaprJob: reusable callback handler for `/job/:name` routes
+ */
+declare function createDaprAgentRuntime<TPayload extends AgentTaskPayload = AgentTaskPayload>(options: DaprAgentRuntimeOptions<TPayload>): DaprAgentRuntimeBundle<TPayload>;
+
+interface DaprHostRemoteRunRequest extends AgentTaskPayload {
+    agentId?: string;
+}
+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 /agents`
+ * - `POST /job/:name`
+ * - `POST /agents/run`
+ * - `POST /agents/workflow`
+ * - `POST /agents/:id/run`
+ * - `POST /agents/:id/workflow`
+ * - `GET /agents/:id/executions/:sessionId`
+ * - `GET /agents/:id/executions/:sessionId/checkpoints`
+ * - `GET /agents/:id/workflows/:instanceId`
+ */
+declare function createDaprHostHttpHandler<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest>(options: DaprHostHttpHandlerOptions<TPayload>): (request: Request) => Promise<Response>;
+declare function startDaprHostHttpServer<TPayload extends AgentTaskPayload = DaprHostRemoteRunRequest>(options: DaprHostHttpServerOptions<TPayload>): Promise<DaprHostHttpServer>;
+
+interface DaprAgentRunnerOptions {
+    /** The agent to run. */
+    agent: Agent;
+    /**
+     * Unique identifier for this agent in the Dapr ecosystem.
+     * Defaults to `agent.name` if omitted.
+     */
+    name?: string;
+    /**
+     * Dapr sidecar HTTP endpoint.
+     * Defaults to `http://${DAPR_HOST ?? "127.0.0.1"}:${DAPR_HTTP_PORT ?? "3500"}`.
+     */
+    daprHttpEndpoint?: string;
+    /**
+     * Dapr gRPC host for the workflow runtime.
+     * Configure this directly on the provided `workflowRuntime`.
+     */
+    /**
+     * Dapr state store component name.
+     * Defaults to `"statestore"`.
+     */
+    stateStoreName?: string;
+    /**
+     * Dapr workflow component name.
+     * Defaults to `"dapr"`.
+     */
+    workflowComponent?: string;
+    /**
+     * Advanced Dapr driver options shared by the runtime bundle and readiness
+     * checks. Use this for API tokens, retry/timeouts, or custom fetch impls.
+     */
+    driverOptions?: Omit<DaprRuntimeDriverOptions, "stateStoreName" | "daprHttpEndpoint">;
+    /**
+     * The Dapr workflow runtime for registering workflows and activities.
+     * Must implement `start()`, `stop()`, `registerWorkflowWithName()`,
+     * and `registerActivityWithName()`.
+     *
+     * Pass `new WorkflowRuntime(...)` from `@dapr/dapr`.
+     */
+    workflowRuntime: DaprWorkflowWorkerRuntime;
+    /**
+     * Optional aliases for multi-agent lookups.
+     */
+    aliases?: string[];
+    /**
+     * Optional description for this agent.
+     */
+    description?: string;
+    /**
+     * Additional observers for execution lifecycle events.
+     * A logging observer is always included by default — pass extras here
+     * for persistence (e.g. `createDaprExecutionObserver()`), telemetry, etc.
+     */
+    observers?: AgentTaskObserver[];
+    /**
+     * Enable/disable the built-in console logging observer.
+     * Defaults to `true`.
+     */
+    logging?: boolean;
+    /**
+     * Prefix for log lines from the built-in logging observer.
+     * Defaults to `[${name}]`.
+     */
+    logPrefix?: string;
+    /**
+     * Override for workflow host options (advanced).
+     * Properties set here override the defaults derived from the runner config.
+     */
+    workflowHost?: Omit<DaprAgentWorkflowHostOptions, "agent" | "observers">;
+    /**
+     * Override for runtime bundle options (advanced).
+     * The `agent` and `driver` fields are always derived from the runner config.
+     */
+    runtimeOptions?: Omit<DaprAgentRuntimeOptions, "agent" | "driver" | "taskRunnerOptions"> & {
+        taskRunnerOptions?: Omit<NonNullable<DaprAgentRuntimeOptions["taskRunnerOptions"]>, "observers">;
+    };
+}
+interface DaprAgentServeOptions {
+    /** HTTP port. Defaults to `3000`. */
+    port?: number;
+    /** HTTP host. Defaults to all interfaces. */
+    host?: string;
+}
+interface DaprAgentRunner {
+    /** Agent name / ID. */
+    readonly name: string;
+    /** The underlying workflow host. */
+    readonly workflowHost: DaprAgentWorkflowHost;
+    /** The underlying runtime bundle (scheduling, task runner, execution store). */
+    readonly runtimeBundle: DaprAgentRuntimeBundle;
+    /** The underlying workflow worker. */
+    readonly worker: DaprWorkflowWorker;
+    /** The workflow client for managing workflow instances. */
+    readonly workflowClient: DaprWorkflowClient;
+    /**
+     * Start the runtime and workflow worker.
+     * Must be called before `serve()` or manual invocation.
+     */
+    start(): Promise<void>;
+    /**
+     * Start the HTTP server and block until SIGINT/SIGTERM.
+     * Calls `start()` internally if not already started.
+     */
+    serve(options?: DaprAgentServeOptions): Promise<void>;
+    /**
+     * Run a task directly (synchronous execution, no workflow).
+     * The agent must be started first.
+     */
+    run(message: string, options?: {
+        sessionId?: string;
+    }): Promise<AgentTaskResult>;
+    /**
+     * 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 + task runner + 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;
+    /** Unique identifier for this agent in the Dapr ecosystem. */
+    name: string;
+    /** Optional aliases for multi-agent lookups. */
+    aliases?: string[];
+    /** Optional description for this agent. */
+    description?: string;
+}
+interface DaprMultiAgentRunnerOptions {
+    /** Agent configurations. */
+    agents: DaprMultiAgentRunnerAgentConfig[];
+    /** Shared Dapr workflow runtime. */
+    workflowRuntime: DaprWorkflowWorkerRuntime;
+    /** Dapr sidecar HTTP endpoint. */
+    daprHttpEndpoint?: string;
+    /** Dapr state store component name. Defaults to `"statestore"`. */
+    stateStoreName?: string;
+    /** Advanced Dapr driver options shared by all hosted runtimes. */
+    driverOptions?: Omit<DaprRuntimeDriverOptions, "stateStoreName" | "daprHttpEndpoint">;
+    /** Dapr workflow component name. Defaults to `"dapr"`. */
+    workflowComponent?: string;
+    /** Additional observers applied to all agents. */
+    observers?: AgentTaskObserver[];
+    /** Enable/disable built-in console logging. Defaults to `true`. */
+    logging?: boolean;
+}
+interface DaprMultiAgentRunner {
+    /** Start all runtimes and the shared workflow worker. */
+    start(): Promise<void>;
+    /** Start HTTP server and block until SIGINT/SIGTERM. Calls `start()` internally. */
+    serve(options?: DaprAgentServeOptions): Promise<void>;
+    /** Gracefully shut down. */
+    stop(): Promise<void>;
+}
+/**
+ * Create a multi-agent Dapr runner — multiple agents sharing a single
+ * workflow worker, HTTP server, and Dapr sidecar.
+ *
+ * @example
+ * ```ts
+ * const runner = createDaprMultiAgentRunner({
+ *   agents: [
+ *     { agent: greeter, name: "greeter" },
+ *     { agent: calculator, name: "calculator" },
+ *   ],
+ *   workflowRuntime: new WorkflowRuntime(),
+ * });
+ *
+ * await runner.serve({ port: 3000 });
+ * ```
+ */
+declare function createDaprMultiAgentRunner(options: DaprMultiAgentRunnerOptions): DaprMultiAgentRunner;
+
+export { 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 RemoteAgentRunResponse as L, createDaprAgentRunner as M, createDaprAgentRuntime as N, createDaprAgentWorkflowHost as O, createDaprHostHttpHandler as P, createDaprHttpJobHandler as Q, type RemoteAgentRunRequest as R, createDaprMultiAgentRunner as S, createDaprWorkflowWorker as T, invokeRemoteAgentRun as U, startDaprAgentWorkflowTurn as V, startDaprHostHttpServer as W, 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 };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { D as DaprOrchestratorRunStoreOptions } from './workflow-bridge-C8Z1yr0Y.js';
+export { a as DaprExecutionStoreOptions, b as DaprFetch, c as DaprRuntimeDriverOptions, d as DaprSidecarClientOptions, e as DaprStateStoreClientOptions, f as DaprWorkflowObserverBridge, g as DaprWorkflowObserverOptions, h as createWorkflowObserverBridge } from './workflow-bridge-C8Z1yr0Y.js';
+export { CreateDaprAgentTurnWorkflowDefinitionOptions, CreateDaprAgentTurnWorkflowKitOptions, CreateDaprAgentTurnWorkflowOptions, DaprAgentTurnActivityRegistration, DaprAgentTurnCommitActivityOptions, DaprAgentTurnModelStepActivityOptions, DaprAgentTurnToolCallActivityOptions, DaprAgentTurnWorkflowActivityNames, DaprAgentTurnWorkflowContextLike, DaprAgentTurnWorkflowDefinition, DaprAgentTurnWorkflowKit, DaprAgentTurnWorkflowRegistration, DaprStartWorkflowResponse, DaprWorkflowApiVersion, DaprWorkflowClient, DaprWorkflowClientOptions, DaprWorkflowRuntimeStatus, DaprWorkflowState, RaiseDaprWorkflowEventOptions, StartDaprWorkflowOptions, WaitForDaprWorkflowOptions, createDaprAgentTurnModelStepActivity, createDaprAgentTurnOutputCommitActivity, createDaprAgentTurnStepCommitActivity, createDaprAgentTurnToolCallActivity, createDaprAgentTurnWorkflowDefinition, createDaprAgentTurnWorkflowKit, hasStartedDaprWorkflow, isTerminalDaprWorkflowStatus } from './workflow/index.js';
+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, s as DaprHttpJobHandlerOptions, t as DaprHttpJobHandlerResult, u as DaprInvokeMethodOptions, v as DaprInvokeMethodResult, w as DaprJobTriggerHandler, x as DaprMultiAgentRunner, y as DaprMultiAgentRunnerAgentConfig, z as DaprMultiAgentRunnerOptions, A as DaprRuntimeDriver, 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, R as RemoteAgentRunRequest, L as RemoteAgentRunResponse, M as createDaprAgentRunner, N as createDaprAgentRuntime, O as createDaprAgentWorkflowHost, P as createDaprHostHttpHandler, Q as createDaprHttpJobHandler, S as createDaprMultiAgentRunner, T as createDaprWorkflowWorker, U as invokeRemoteAgentRun, V as startDaprAgentWorkflowTurn, W as startDaprHostHttpServer } from './index-CKTP36vE.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, h as DaprExecutionStore } from './store-pRLGfYhN.js';
+export { DaprExecutionObserver, DaprExecutionObserverOptions, DaprHostLoggerLike, DaprLoggingObserverOptions, OtelObserverConfig, createDaprExecutionObserver, createDaprLoggingObserver, createOtelObserver } from './execution/index.js';
+import { OrchestratorRunStatus, OrchestratorRunStore, OrchestratorRunRecord } from '@cuylabs/agent-runtime';
+import '@cuylabs/agent-core';
+import 'node:http';
+
+interface DaprOrchestratorRunCleanupOptions {
+    maxAgeMs?: number;
+    maxRuns?: number;
+    statuses?: OrchestratorRunStatus[];
+    includeActive?: boolean;
+    now?: () => number;
+}
+interface DaprOrchestratorRunCleanupResult {
+    deletedRuns: number;
+    deletedRunIds: string[];
+}
+declare class DaprOrchestratorRunStore<TInput = unknown, TResult = unknown> implements OrchestratorRunStore<TInput, TResult> {
+    private readonly client;
+    private readonly keyPrefix;
+    constructor(options: DaprOrchestratorRunStoreOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    get(runId: string): Promise<OrchestratorRunRecord<TInput, TResult> | undefined>;
+    list(): Promise<OrchestratorRunRecord<TInput, TResult>[]>;
+    upsert(run: OrchestratorRunRecord<TInput, TResult>): Promise<OrchestratorRunRecord<TInput, TResult>>;
+    remove(runId: string): Promise<boolean>;
+    cleanup(options?: DaprOrchestratorRunCleanupOptions): Promise<DaprOrchestratorRunCleanupResult>;
+    private stateKeyForRun;
+    private stateKeyForIndex;
+    private readRun;
+    private writeRun;
+    private readIndex;
+    private writeIndex;
+    private addToIndex;
+    private removeFromIndex;
+    private listRunsViaStateQuery;
+    private listRunsFromIndex;
+    private decodeStoredRun;
+    private updateIndex;
+}
+
+export { type DaprOrchestratorRunCleanupOptions, type DaprOrchestratorRunCleanupResult, DaprOrchestratorRunStore, DaprOrchestratorRunStoreOptions };

package/dist/index.js

@@ -0,0 +1,65 @@
+import {
+  DaprOrchestratorRunStore,
+  DaprRuntimeDriver,
+  DaprServiceInvoker,
+  createDaprAgentRunner,
+  createDaprAgentRuntime,
+  createDaprAgentWorkflowHost,
+  createDaprHostHttpHandler,
+  createDaprHttpJobHandler,
+  createDaprMultiAgentRunner,
+  createDaprWorkflowWorker,
+  invokeRemoteAgentRun,
+  startDaprAgentWorkflowTurn,
+  startDaprHostHttpServer
+} from "./chunk-2FMHOZLU.js";
+import {
+  DaprExecutionObserver,
+  DaprExecutionStore,
+  createDaprExecutionObserver,
+  createDaprLoggingObserver,
+  createOtelObserver,
+  createWorkflowObserverBridge
+} from "./chunk-2CEICSJH.js";
+import {
+  DaprWorkflowClient,
+  createDaprAgentTurnModelStepActivity,
+  createDaprAgentTurnOutputCommitActivity,
+  createDaprAgentTurnStepCommitActivity,
+  createDaprAgentTurnToolCallActivity,
+  createDaprAgentTurnWorkflowDefinition,
+  createDaprAgentTurnWorkflowKit,
+  hasStartedDaprWorkflow,
+  isTerminalDaprWorkflowStatus
+} from "./chunk-DILON56B.js";
+import "./chunk-A34CHK2E.js";
+export {
+  DaprExecutionObserver,
+  DaprExecutionStore,
+  DaprOrchestratorRunStore,
+  DaprRuntimeDriver,
+  DaprServiceInvoker,
+  DaprWorkflowClient,
+  createDaprAgentRunner,
+  createDaprAgentRuntime,
+  createDaprAgentTurnModelStepActivity,
+  createDaprAgentTurnOutputCommitActivity,
+  createDaprAgentTurnStepCommitActivity,
+  createDaprAgentTurnToolCallActivity,
+  createDaprAgentTurnWorkflowDefinition,
+  createDaprAgentTurnWorkflowKit,
+  createDaprAgentWorkflowHost,
+  createDaprExecutionObserver,
+  createDaprHostHttpHandler,
+  createDaprHttpJobHandler,
+  createDaprLoggingObserver,
+  createDaprMultiAgentRunner,
+  createDaprWorkflowWorker,
+  createOtelObserver,
+  createWorkflowObserverBridge,
+  hasStartedDaprWorkflow,
+  invokeRemoteAgentRun,
+  isTerminalDaprWorkflowStatus,
+  startDaprAgentWorkflowTurn,
+  startDaprHostHttpServer
+};