@cuylabs/agent-runtime-dapr 0.5.0

package/dist/store-pRLGfYhN.d.ts

@@ -0,0 +1,97 @@
+import { AgentTaskPayload, AgentTaskCheckpointReason, AgentTaskExecutionSnapshot, AgentTurnState, AgentTaskResult, AgentTaskExecutionRun, AgentTaskExecutionCheckpoint } from '@cuylabs/agent-core';
+import { a as DaprExecutionStoreOptions } from './workflow-bridge-C8Z1yr0Y.js';
+
+interface DaprExecutionCleanupOptions {
+    maxAgeMs?: number;
+    maxExecutions?: number;
+    maxCheckpointsPerExecution?: number;
+    includeRunning?: boolean;
+    now?: () => number;
+}
+interface DaprExecutionCleanupResult {
+    deletedExecutions: number;
+    deletedExecutionIds: string[];
+    deletedCheckpoints: number;
+    trimmedSessions: number;
+}
+type DaprExecutionStatus = "running" | "completed" | "failed";
+interface DaprExecutionContextMetadata {
+    trigger?: string;
+    fallbackSessionKey?: string;
+}
+interface DaprExecutionSnapshot {
+    sessionId: string;
+    response: string;
+    usage: AgentTaskExecutionSnapshot["usage"];
+    toolCalls: Array<{
+        name: string;
+        result: unknown;
+    }>;
+    eventCount: number;
+    activeStep?: number;
+    lastEvent?: unknown;
+    error?: string;
+    startedAt: string;
+    updatedAt: string;
+    turnState: AgentTurnState;
+}
+interface DaprExecutionErrorRecord {
+    name: string;
+    message: string;
+    stack?: string;
+}
+interface DaprExecutionRunRecord<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    sessionId: string;
+    payload: TPayload;
+    context: DaprExecutionContextMetadata;
+    status: DaprExecutionStatus;
+    startedAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    checkpointCount: number;
+    lastCheckpointReason?: AgentTaskCheckpointReason;
+    snapshot: DaprExecutionSnapshot;
+    result?: AgentTaskResult;
+    error?: DaprExecutionErrorRecord;
+}
+interface DaprExecutionCheckpointRecord<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    id: string;
+    sessionId: string;
+    payload: TPayload;
+    context: DaprExecutionContextMetadata;
+    startedAt: string;
+    reason: AgentTaskCheckpointReason;
+    snapshot: DaprExecutionSnapshot;
+    event?: unknown;
+    createdAt: string;
+}
+declare class DaprExecutionStore<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    private readonly client;
+    private readonly keyPrefix;
+    constructor(options: DaprExecutionStoreOptions);
+    getExecution(sessionId: string): Promise<DaprExecutionRunRecord<TPayload> | undefined>;
+    listExecutions(): Promise<DaprExecutionRunRecord<TPayload>[]>;
+    listCheckpoints(sessionId: string): Promise<DaprExecutionCheckpointRecord<TPayload>[]>;
+    recordStart(run: AgentTaskExecutionRun<TPayload>, snapshot: AgentTaskExecutionSnapshot): Promise<void>;
+    recordCheckpoint(checkpoint: AgentTaskExecutionCheckpoint<TPayload>): Promise<void>;
+    recordCompletion(run: AgentTaskExecutionRun<TPayload>, result: AgentTaskResult, snapshot: AgentTaskExecutionSnapshot): Promise<void>;
+    recordError(run: AgentTaskExecutionRun<TPayload>, error: Error, snapshot: AgentTaskExecutionSnapshot): Promise<void>;
+    cleanup(options?: DaprExecutionCleanupOptions): Promise<DaprExecutionCleanupResult>;
+    private stateKeyForExecution;
+    private stateKeyForCheckpoint;
+    private stateKeyForCheckpointIndex;
+    private deleteExecutionRecord;
+    private deleteCheckpoint;
+    private readCheckpoint;
+    private readCheckpointIndex;
+    private writeCheckpointIndex;
+    private updateCheckpointIndex;
+    private addCheckpointToIndex;
+    private listCheckpointsFromIndex;
+    private writeExecution;
+    private writeCheckpoint;
+    private decodeExecution;
+    private decodeCheckpoint;
+}
+
+export { type DaprExecutionCheckpointRecord as D, type DaprExecutionCleanupOptions as a, type DaprExecutionCleanupResult as b, type DaprExecutionContextMetadata as c, type DaprExecutionErrorRecord as d, type DaprExecutionRunRecord as e, type DaprExecutionSnapshot as f, type DaprExecutionStatus as g, DaprExecutionStore as h };

package/dist/workflow/index.d.ts

@@ -0,0 +1,216 @@
+import { d as DaprSidecarClientOptions, f as DaprWorkflowObserverBridge } from '../workflow-bridge-C8Z1yr0Y.js';
+import { AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult, AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult, AgentWorkflowStepCommitPlan, AgentWorkflowCommitResult, AgentWorkflowOutputCommitPlan, AgentTurnStepRuntimeConfig, Tool, convertAgentMessagesToModelMessages, PrepareModelStepOptions, ToolHost, TurnTrackerContext, MiddlewareRunner, ReasoningLevel, AgentEvent, Message, AgentWorkflowTurnState } from '@cuylabs/agent-core';
+
+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;
+
+interface DaprAgentTurnWorkflowActivityNames {
+    modelStep: string;
+    toolCall: string;
+    stepCommit: string;
+    outputCommit: string;
+}
+interface DaprAgentTurnWorkflowContextLike {
+    callActivity(name: string, input: unknown): unknown;
+    setCustomStatus?(status: string): void;
+    isReplaying?(): boolean;
+}
+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 DaprAgentTurnWorkflowRegistration {
+    workflowName: string;
+    activityNames: DaprAgentTurnWorkflowActivityNames;
+    workflow: DaprAgentTurnWorkflowDefinition;
+}
+interface CreateDaprAgentTurnWorkflowOptions {
+    workflowName?: string;
+    activityNames?: Partial<DaprAgentTurnWorkflowActivityNames>;
+    now?: () => string;
+}
+type CreateDaprAgentTurnWorkflowRegistrationOptions = CreateDaprAgentTurnWorkflowOptions;
+interface DaprAgentTurnModelStepActivityOptions {
+    runtime: AgentTurnStepRuntimeConfig;
+    tools: Record<string, Tool.Info>;
+    toModelMessages?: typeof convertAgentMessagesToModelMessages;
+    mcpTools?: PrepareModelStepOptions["mcpTools"] | (() => Promise<PrepareModelStepOptions["mcpTools"]>);
+    host?: ToolHost;
+    turnTracker?: TurnTrackerContext;
+    middleware?: MiddlewareRunner;
+    reasoningLevel?: ReasoningLevel;
+    createAbortSignal?: () => AbortSignal;
+    onEvent?: (event: AgentEvent) => void | Promise<void>;
+    now?: () => string;
+    /** Observer bridge for OTel trace context propagation. */
+    observerBridge?: DaprWorkflowObserverBridge;
+}
+interface DaprAgentTurnToolCallActivityOptions {
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    host?: ToolHost;
+    turnTracker?: TurnTrackerContext;
+    middleware?: MiddlewareRunner;
+    createAbortSignal?: () => AbortSignal;
+    now?: () => string;
+    /** Observer bridge for OTel trace context propagation. */
+    observerBridge?: DaprWorkflowObserverBridge;
+}
+interface DaprAgentTurnCommitActivityOptions {
+    persistMessages: (sessionId: string, messages: Message[]) => Promise<void>;
+    now?: () => string;
+}
+interface CreateDaprAgentTurnWorkflowDefinitionOptions extends CreateDaprAgentTurnWorkflowRegistrationOptions {
+    modelStep: (input: AgentWorkflowModelStepPlan) => Promise<AgentWorkflowModelStepResult> | AgentWorkflowModelStepResult;
+    toolCall: (input: AgentWorkflowToolCallPlan) => Promise<AgentWorkflowToolCallResult> | AgentWorkflowToolCallResult;
+    stepCommit: (input: AgentWorkflowStepCommitPlan) => Promise<AgentWorkflowCommitResult> | AgentWorkflowCommitResult;
+    outputCommit: (input: AgentWorkflowOutputCommitPlan) => Promise<AgentWorkflowCommitResult> | AgentWorkflowCommitResult;
+    /**
+     * 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;
+}
+interface CreateDaprAgentTurnWorkflowKitOptions extends CreateDaprAgentTurnWorkflowRegistrationOptions {
+    modelStepActivity: DaprAgentTurnModelStepActivityOptions;
+    toolCallActivity: DaprAgentTurnToolCallActivityOptions;
+    commitActivity: DaprAgentTurnCommitActivityOptions;
+    /** Optional observer bridge passed through to the workflow definition. */
+    observerBridge?: DaprWorkflowObserverBridge;
+}
+interface DaprAgentTurnWorkflowKit extends DaprAgentTurnWorkflowRegistration {
+    activities: {
+        modelStep: DaprAgentTurnActivityRegistration<AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult>;
+        toolCall: DaprAgentTurnActivityRegistration<AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult>;
+        stepCommit: DaprAgentTurnActivityRegistration<AgentWorkflowStepCommitPlan, AgentWorkflowCommitResult>;
+        outputCommit: DaprAgentTurnActivityRegistration<AgentWorkflowOutputCommitPlan, AgentWorkflowCommitResult>;
+    };
+}
+/**
+ * Create the deterministic workflow definition that a host app can register
+ * with the Dapr JS SDK runtime.
+ *
+ * The returned workflow stays SDK-agnostic at the package boundary: it only
+ * assumes a context with `callActivity()` and optional `setCustomStatus()`.
+ */
+declare function createDaprAgentTurnWorkflowDefinition(options: CreateDaprAgentTurnWorkflowDefinitionOptions): DaprAgentTurnWorkflowRegistration;
+/**
+ * Build the default model-step activity over the extracted `agent-core`
+ * phase helpers.
+ */
+declare function createDaprAgentTurnModelStepActivity(options: DaprAgentTurnModelStepActivityOptions): DaprAgentTurnActivityRegistration<AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult>;
+/**
+ * Build the default single-tool-call activity.
+ *
+ * One tool call per activity is the durable boundary used by the workflow
+ * adapter. That is intentionally finer-grained than the in-process
+ * `runToolBatch(...)` helper.
+ */
+declare function createDaprAgentTurnToolCallActivity(options: DaprAgentTurnToolCallActivityOptions): DaprAgentTurnActivityRegistration<AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult>;
+/**
+ * Build the default step-commit activity that appends assistant/tool messages
+ * to the durable session store owned by the host app.
+ */
+declare function createDaprAgentTurnStepCommitActivity(options: DaprAgentTurnCommitActivityOptions): DaprAgentTurnActivityRegistration<AgentWorkflowStepCommitPlan, AgentWorkflowCommitResult>;
+/**
+ * Build the default output-commit activity that appends the final assistant
+ * message to the durable session store owned by the host app.
+ */
+declare function createDaprAgentTurnOutputCommitActivity(options: DaprAgentTurnCommitActivityOptions): DaprAgentTurnActivityRegistration<AgentWorkflowOutputCommitPlan, AgentWorkflowCommitResult>;
+/**
+ * Create a full workflow registration kit with default activity handlers.
+ *
+ * Host apps can register the returned workflow and activities directly with the
+ * Dapr JS SDK runtime while keeping execution semantics in `agent-core`.
+ */
+declare function createDaprAgentTurnWorkflowKit(options: CreateDaprAgentTurnWorkflowKitOptions): DaprAgentTurnWorkflowKit;
+
+/**
+ * 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 { type CreateDaprAgentTurnWorkflowDefinitionOptions, type CreateDaprAgentTurnWorkflowKitOptions, type CreateDaprAgentTurnWorkflowOptions, type DaprAgentTurnActivityRegistration, type DaprAgentTurnCommitActivityOptions, type DaprAgentTurnModelStepActivityOptions, type DaprAgentTurnToolCallActivityOptions, type DaprAgentTurnWorkflowActivityNames, type DaprAgentTurnWorkflowContextLike, type DaprAgentTurnWorkflowDefinition, type DaprAgentTurnWorkflowKit, type DaprAgentTurnWorkflowRegistration, type DaprStartWorkflowResponse, type DaprWorkflowApiVersion, DaprWorkflowClient, type DaprWorkflowClientOptions, type DaprWorkflowRuntimeStatus, type DaprWorkflowState, type RaiseDaprWorkflowEventOptions, type StartDaprWorkflowOptions, type WaitForDaprWorkflowOptions, createDaprAgentTurnModelStepActivity, createDaprAgentTurnOutputCommitActivity, createDaprAgentTurnStepCommitActivity, createDaprAgentTurnToolCallActivity, createDaprAgentTurnWorkflowDefinition, createDaprAgentTurnWorkflowKit, hasStartedDaprWorkflow, isTerminalDaprWorkflowStatus };

package/dist/workflow/index.js

@@ -0,0 +1,23 @@
+import {
+  DaprWorkflowClient,
+  createDaprAgentTurnModelStepActivity,
+  createDaprAgentTurnOutputCommitActivity,
+  createDaprAgentTurnStepCommitActivity,
+  createDaprAgentTurnToolCallActivity,
+  createDaprAgentTurnWorkflowDefinition,
+  createDaprAgentTurnWorkflowKit,
+  hasStartedDaprWorkflow,
+  isTerminalDaprWorkflowStatus
+} from "../chunk-DILON56B.js";
+import "../chunk-A34CHK2E.js";
+export {
+  DaprWorkflowClient,
+  createDaprAgentTurnModelStepActivity,
+  createDaprAgentTurnOutputCommitActivity,
+  createDaprAgentTurnStepCommitActivity,
+  createDaprAgentTurnToolCallActivity,
+  createDaprAgentTurnWorkflowDefinition,
+  createDaprAgentTurnWorkflowKit,
+  hasStartedDaprWorkflow,
+  isTerminalDaprWorkflowStatus
+};

package/dist/workflow-bridge-C8Z1yr0Y.d.ts

@@ -0,0 +1,83 @@
+import { AgentWorkflowTurnState, AgentTaskCheckpointReason, AgentTaskPayload, AgentTaskObserver } from '@cuylabs/agent-core';
+
+type DaprFetch = typeof fetch;
+interface DaprSidecarClientOptions {
+    /** Dapr sidecar HTTP endpoint. Defaults to http://127.0.0.1:3500 */
+    daprHttpEndpoint?: string;
+    /** Optional API token sent as the dapr-api-token header. */
+    apiToken?: string;
+    /** Request timeout (ms) for sidecar HTTP calls. Defaults to 15000. */
+    requestTimeoutMs?: number;
+    /** Max retries for transient sidecar/network failures. Defaults to 2. */
+    maxRequestRetries?: number;
+    /** Verify sidecar availability on start() via /v1.0/metadata. Defaults to true. */
+    verifySidecarOnStart?: boolean;
+    /** Override fetch implementation for tests and custom runtimes. */
+    fetch?: DaprFetch;
+}
+interface DaprStateStoreClientOptions extends DaprSidecarClientOptions {
+    /** Dapr state store component name used to persist runtime records. */
+    stateStoreName: string;
+}
+interface DaprRuntimeDriverOptions extends DaprStateStoreClientOptions {
+    /** Prefix for state keys in the configured store. */
+    keyPrefix?: string;
+    /** Prefix for Dapr scheduler job names. */
+    jobNamePrefix?: string;
+}
+interface DaprOrchestratorRunStoreOptions extends DaprStateStoreClientOptions {
+    /** Prefix for state keys used by durable orchestrator run records. */
+    keyPrefix?: string;
+}
+interface DaprExecutionStoreOptions extends DaprStateStoreClientOptions {
+    /** Prefix for state keys used by durable execution snapshots and checkpoints. */
+    keyPrefix?: string;
+}
+
+/**
+ * Options for the workflow observer adapter.
+ */
+interface DaprWorkflowObserverOptions<TPayload extends AgentTaskPayload = AgentTaskPayload> {
+    observers: AgentTaskObserver<TPayload>[];
+    /** Original payload that triggered the workflow. */
+    payload: Readonly<TPayload>;
+    /** Execution trigger label (e.g. "workflow", "http"). */
+    trigger?: string;
+}
+/**
+ * A bridge that lets existing `AgentTaskObserver`s (DaprExecutionObserver,
+ * DaprLoggingObserver, etc.) receive lifecycle notifications from the
+ * workflow execution path.
+ *
+ * The workflow path doesn't run through `createAgentTaskRunner`, so
+ * observers are never notified — unless the workflow host explicitly calls
+ * this adapter at each activity boundary.
+ *
+ * Usage in workflow-host.ts:
+ * ```ts
+ * const bridge = createWorkflowObserverBridge({ observers, payload });
+ * bridge.notifyTaskStart(initialState);
+ * // ... after each activity ...
+ * bridge.notifyCheckpoint("step-finish", state);
+ * // ... on completion ...
+ * bridge.notifyTaskComplete(state);
+ * ```
+ */
+interface DaprWorkflowObserverBridge {
+    notifyTaskStart(state: AgentWorkflowTurnState): Promise<void>;
+    notifyCheckpoint(reason: AgentTaskCheckpointReason, state: AgentWorkflowTurnState): Promise<void>;
+    notifyTaskComplete(state: AgentWorkflowTurnState): Promise<void>;
+    notifyTaskError(state: AgentWorkflowTurnState, error: Error): Promise<void>;
+    /** Update the payload for future observer notifications. */
+    updatePayload(payload: AgentTaskPayload): void;
+    /**
+     * Get the active OTel context for a session from the observers.
+     *
+     * Used by workflow activities to wrap their execution so child spans
+     * (AI SDK, tool calls) are correlated under the observer's root span.
+     */
+    getOtelContext(sessionId: string): unknown;
+}
+declare function createWorkflowObserverBridge<TPayload extends AgentTaskPayload = AgentTaskPayload>(options: DaprWorkflowObserverOptions<TPayload>): DaprWorkflowObserverBridge;
+
+export { type DaprOrchestratorRunStoreOptions as D, type DaprExecutionStoreOptions as a, type DaprFetch as b, type DaprRuntimeDriverOptions as c, type DaprSidecarClientOptions as d, type DaprStateStoreClientOptions as e, type DaprWorkflowObserverBridge as f, type DaprWorkflowObserverOptions as g, createWorkflowObserverBridge as h };

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@cuylabs/agent-runtime-dapr",
+  "version": "0.5.0",
+  "description": "Dapr-backed runtime driver for @cuylabs/agent-runtime",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./execution": {
+      "types": "./dist/execution/index.d.ts",
+      "import": "./dist/execution/index.js",
+      "default": "./dist/execution/index.js"
+    },
+    "./host": {
+      "types": "./dist/host/index.d.ts",
+      "import": "./dist/host/index.js",
+      "default": "./dist/host/index.js"
+    },
+    "./workflow": {
+      "types": "./dist/workflow/index.d.ts",
+      "import": "./dist/workflow/index.js",
+      "default": "./dist/workflow/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@cuylabs/agent-core": "^0.5.0",
+    "@cuylabs/agent-runtime": "^0.5.0"
+  },
+  "peerDependencies": {
+    "@dapr/dapr": "^3.6.1",
+    "@opentelemetry/api": "^1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@dapr/dapr": {
+      "optional": true
+    },
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ai-sdk/openai": "^3.0.0",
+    "@arizeai/openinference-vercel": "^2.7.1",
+    "@dapr/dapr": "^3.6.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.213.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
+    "@opentelemetry/exporter-zipkin": "^2.6.0",
+    "@opentelemetry/resources": "^2.6.0",
+    "@opentelemetry/sdk-node": "^0.213.0",
+    "@opentelemetry/sdk-trace-node": "^2.6.0",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@types/node": "^22.0.0",
+    "dotenv": "^17.2.3",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18",
+    "zod": "^3.24.0",
+    "@cuylabs/agent-code": "^0.5.0"
+  },
+  "keywords": [
+    "agent",
+    "runtime",
+    "dapr",
+    "scheduler",
+    "orchestration"
+  ],
+  "author": "cuylabs",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cuylabs-ai/agents-ts.git",
+    "directory": "packages/agent-runtime-dapr"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/execution/index.ts src/host/index.ts src/workflow/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/execution/index.ts src/host/index.ts src/workflow/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration:dapr": "RUN_DAPR_WORKFLOW_LIVE=1 vitest run tests/integration/",
+    "clean": "rm -rf dist"
+  }
+}