@cuylabs/agent-runtime 0.9.0 → 0.11.0

package/README.md

@@ -11,6 +11,12 @@ The package now makes one architectural seam explicit:
 - `agent-runtime` consumes a generic workload contract
 - infrastructure packages such as `agent-runtime-dapr` implement that contract
 
+Another way to say it:
+
+- `agent-runtime` is the API your application targets for orchestration
+- backend packages are allowed to provide stronger guarantees and extra helpers
+- those backend-specific helpers should not leak back into the base runtime contract
+
 ## Package Boundary
 
 Use `@cuylabs/agent-runtime` when you need outer orchestration:
@@ -28,14 +34,31 @@ This package does not own in-process model or tool interception.
 
 So most users start with `agent-core`, then add `agent-runtime` when they need workers, jobs, or orchestrated execution.
 
+## What Stays In The Shared Contract
+
+`agent-runtime` should only own concepts that remain meaningful without naming a
+specific backend:
+
+- jobs and schedules
+- dispatch and retry semantics
+- queueing and concurrency limits
+- invocation lifecycle and control-plane grammar
+- runtime drivers and run stores as abstract contracts
+
+If a feature only makes sense when you say "Dapr", "workflow instance",
+"sidecar callback", or "HTTP runner", it should live outside this package.
+
 ## What This Package Owns
 
-- Job definitions and lifecycle (`schedule`, `update`, `pause`, `resume`, `runNow`, `dispatch`)
+- Job definitions and lifecycle (`schedule`, `update`, `pause`, `resume`, `remove`, `runNow`, `dispatch`, `dispatchDue`)
+- Runtime introspection (`status`, `listJobs`, `getJob`)
 - Schedule evaluation (`at`, `every`, `cron`)
 - Execution loop with concurrency limits
 - Pluggable runtime drivers (in-memory now, Dapr/others later)
 - Neutral workload adapter for plugging application work into the runtime
-- Optional app-level orchestration API (`invoke`, `listInvocations`, `waitForInvocation`, `close`, `guide`)
+- Optional app-level orchestration API (`invoke`, `get`, `status`, `listInvocations`, `waitForInvocation`, `close`, `guide`)
+- Execution-store contracts (`ExecutionStore`, `ExecutionRunRecord`, `ExecutionStatus`) for provider-agnostic persistence
+- Prometheus-compatible metrics (`createPrometheusRuntimeMetrics`)
 
 ## Layered Architecture
 
@@ -94,13 +117,18 @@ src/
     index.ts               # Generic workload contract + adapter helper
   observer.ts              # Runtime lifecycle/queue/run observer contracts
   logger.ts                # Logger interface + defaults
+  metrics.ts               # Prometheus counters/gauges/histograms
   schedule.ts              # Schedule normalization + next-run calculation
   driver.ts                # Driver interface
   runtime.ts               # WorkloadRuntime orchestration class
   drivers/
     in-memory.ts           # Default local runtime driver
+  execution/
+    types.ts               # ExecutionStatus, ExecutionRunRecord
+    store.ts               # ExecutionStore contract
+    index.ts               # barrel
   orchestration/
-    service.ts             # invoke/listInvocations/waitForInvocation/close/guide API
+    service.ts             # invoke/get/status/listInvocations/waitForInvocation/close/guide
     store.ts               # run-record persistence contract
     stores/
       in-memory.ts         # default orchestration run store

package/dist/{chunk-MAVHVV2U.js → chunk-U7M333GT.js}

@@ -305,6 +305,21 @@ var WorkloadRuntime = class {
         pending.reject(error);
       }
     }
+    if (this.inFlight.size > 0) {
+      this.logger.info("Waiting for in-flight jobs to drain before stopping", {
+        count: this.inFlight.size
+      });
+      const drainStart = Date.now();
+      const drainTimeoutMs = 1e4;
+      while (this.inFlight.size > 0 && Date.now() - drainStart < drainTimeoutMs) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+      if (this.inFlight.size > 0) {
+        this.logger.warn("Drain timeout reached, stopping with in-flight jobs", {
+          remaining: this.inFlight.size
+        });
+      }
+    }
     await this.driver.stop();
     await this.forEachObserver("runtime stop", { driver: this.driver.name }, async (observer) => {
       await observer.notifyRuntimeStop?.({
@@ -456,9 +471,6 @@ var WorkloadRuntime = class {
   async enqueuePendingDispatch(jobId, trigger) {
     const existing = this.pendingDispatchByJobId.get(jobId);
     if (existing) {
-      if (existing.trigger === "due" && trigger === "manual") {
-        existing.trigger = "manual";
-      }
       return await existing.promise;
     }
     if (this.maxQueuedDispatches !== void 0 && this.pendingDispatches.length >= this.maxQueuedDispatches) {
@@ -730,7 +742,14 @@ var WorkloadRuntime = class {
           nextRunAtMs
         }
       };
-      await this.driver.upsertJob(persisted);
+      await this.driver.upsertJob(persisted).catch((error) => {
+        this.logger.error("Failed to persist final job state after execution", {
+          jobId,
+          trigger,
+          status,
+          error: String(error)
+        });
+      });
       await this.forEachObserver(
         "run complete",
         { jobId, trigger, status },
@@ -934,6 +953,13 @@ var AgentOrchestrator = class {
     }
   }
   async stop() {
+    const stopError = new Error("Orchestrator stopped");
+    for (const [, waiterSet] of this.waiters) {
+      for (const waiter of waiterSet) {
+        waiter.reject(stopError);
+      }
+    }
+    this.waiters.clear();
     let runtimeError;
     try {
       await this.runtime.stop();
@@ -1042,11 +1068,11 @@ var AgentOrchestrator = class {
       return current;
     }
     return await new Promise((resolve, reject) => {
-      let timeout;
+      const timeoutRef = {};
       let abortHandler;
       const cleanup = () => {
-        if (timeout) {
-          clearTimeout(timeout);
+        if (timeoutRef.current) {
+          clearTimeout(timeoutRef.current);
         }
         if (abortHandler && options.signal) {
           options.signal.removeEventListener("abort", abortHandler);
@@ -1090,10 +1116,10 @@ var AgentOrchestrator = class {
         return;
       }
       const timeoutMs = Math.floor(options.timeoutMs);
-      timeout = setTimeout(() => {
+      timeoutRef.current = setTimeout(() => {
         waiter.reject(new Error(`Timed out waiting for run "${normalizedRunId}" after ${timeoutMs}ms`));
       }, timeoutMs);
-      timeout.unref?.();
+      timeoutRef.current.unref?.();
     });
   }
   async close(runId, options = {}) {

package/dist/{driver-BaLji34_.d.ts → driver-CQg5G_ey.d.ts}

@@ -1,4 +1,4 @@
-import { o as RuntimeRunResult, R as RuntimeJobRecord } from './types-DllX9NP8.js';
+import { c as RuntimeRunResult, R as RuntimeJobRecord } from './types-AoJlEcyK.js';
 
 type RuntimeLogMeta = Record<string, unknown>;
 interface RuntimeLogger {

package/dist/drivers/in-memory.d.ts

@@ -1,5 +1,5 @@
-import { R as RuntimeDriver, a as RuntimeDriverContext } from '../driver-BaLji34_.js';
-import { R as RuntimeJobRecord } from '../types-DllX9NP8.js';
+import { R as RuntimeDriver, a as RuntimeDriverContext } from '../driver-CQg5G_ey.js';
+import { R as RuntimeJobRecord } from '../types-AoJlEcyK.js';
 
 interface InMemoryRuntimeDriverOptions {
     maxTimerDelayMs?: number;

package/dist/{index-DkdkAAoL.d.ts → index-acbJQol3.d.ts}

@@ -1,5 +1,5 @@
-import { s as RuntimeTrigger, R as RuntimeJobRecord, p as RuntimeRunStatus, h as RuntimeDeadLetterEvent, b as RuntimeExecutor, q as RuntimeScheduleInput, r as RuntimeSchedulePatch, o as RuntimeRunResult, i as RuntimeDispatchInput } from './types-DllX9NP8.js';
-import { R as RuntimeDriver, c as RuntimeLogger } from './driver-BaLji34_.js';
+import { s as RuntimeTrigger, R as RuntimeJobRecord, p as RuntimeRunStatus, i as RuntimeDeadLetterEvent, b as RuntimeExecutor, q as RuntimeScheduleInput, r as RuntimeSchedulePatch, c as RuntimeRunResult, j as RuntimeDispatchInput } from './types-AoJlEcyK.js';
+import { R as RuntimeDriver, c as RuntimeLogger } from './driver-CQg5G_ey.js';
 
 interface RuntimeLifecycleEvent {
     driver: string;

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { c as RuntimeJobSchedule, d as RuntimeJobScheduleInput } from './types-DllX9NP8.js';
-export { e as RuntimeAtSchedule, f as RuntimeAtScheduleInput, g as RuntimeCronSchedule, h as RuntimeDeadLetterEvent, i as RuntimeDispatchInput, j as RuntimeEverySchedule, a as RuntimeExecutionContext, k as RuntimeExecutionResult, b as RuntimeExecutor, R as RuntimeJobRecord, l as RuntimeJobState, m as RuntimeRetryPolicy, n as RuntimeRetryStrategy, o as RuntimeRunResult, p as RuntimeRunStatus, q as RuntimeScheduleInput, r as RuntimeSchedulePatch, s as RuntimeTrigger } from './types-DllX9NP8.js';
+import { d as RuntimeJobSchedule, e as RuntimeJobScheduleInput } from './types-AoJlEcyK.js';
+export { f as RuntimeAtSchedule, g as RuntimeAtScheduleInput, h as RuntimeCronSchedule, i as RuntimeDeadLetterEvent, j as RuntimeDispatchInput, k as RuntimeEverySchedule, a as RuntimeExecutionContext, l as RuntimeExecutionResult, b as RuntimeExecutor, R as RuntimeJobRecord, m as RuntimeJobState, n as RuntimeRetryPolicy, o as RuntimeRetryStrategy, c as RuntimeRunResult, p as RuntimeRunStatus, q as RuntimeScheduleInput, r as RuntimeSchedulePatch, s as RuntimeTrigger } from './types-AoJlEcyK.js';
 export { RuntimeWorkloadContext, RuntimeWorkloadErrorContext, RuntimeWorkloadExecutorOptions, RuntimeWorkloadResultContext, RuntimeWorkloadRunner, createRuntimeWorkloadContext, createRuntimeWorkloadExecutor } from './workload/index.js';
-export { R as RuntimeDriver, a as RuntimeDriverContext, b as RuntimeLogMeta, c as RuntimeLogger, d as createConsoleRuntimeLogger, s as silentRuntimeLogger } from './driver-BaLji34_.js';
-import { R as RuntimeObserver } from './index-DkdkAAoL.js';
-export { A as AgentOrchestrator, a as AgentOrchestratorOptions, I as InMemoryOrchestratorRunStore, O as OrchestratorCloseOptions, b as OrchestratorExecutionContext, c as OrchestratorExecutor, d as OrchestratorGuideInput, e as OrchestratorGuidedInputResolver, f as OrchestratorInvokeInput, g as OrchestratorInvokeResult, h as OrchestratorJobPayload, i as OrchestratorListOptions, j as OrchestratorRunMode, k as OrchestratorRunRecord, l as OrchestratorRunState, m as OrchestratorRunStatus, n as OrchestratorRunStore, o as OrchestratorWaitOptions, p as RuntimeDispatchDroppedEvent, q as RuntimeDispatchQueuedEvent, r as RuntimeLifecycleEvent, s as RuntimeRunCompleteEvent, t as RuntimeRunRetryEvent, u as RuntimeRunStartEvent, W as WorkloadRuntime, v as WorkloadRuntimeOptions, w as createAgentOrchestrator, x as createWorkloadRuntime, y as isTerminalRunStatus } from './index-DkdkAAoL.js';
+export { R as RuntimeDriver, a as RuntimeDriverContext, b as RuntimeLogMeta, c as RuntimeLogger, d as createConsoleRuntimeLogger, s as silentRuntimeLogger } from './driver-CQg5G_ey.js';
+import { R as RuntimeObserver } from './index-acbJQol3.js';
+export { A as AgentOrchestrator, a as AgentOrchestratorOptions, I as InMemoryOrchestratorRunStore, O as OrchestratorCloseOptions, b as OrchestratorExecutionContext, c as OrchestratorExecutor, d as OrchestratorGuideInput, e as OrchestratorGuidedInputResolver, f as OrchestratorInvokeInput, g as OrchestratorInvokeResult, h as OrchestratorJobPayload, i as OrchestratorListOptions, j as OrchestratorRunMode, k as OrchestratorRunRecord, l as OrchestratorRunState, m as OrchestratorRunStatus, n as OrchestratorRunStore, o as OrchestratorWaitOptions, p as RuntimeDispatchDroppedEvent, q as RuntimeDispatchQueuedEvent, r as RuntimeLifecycleEvent, s as RuntimeRunCompleteEvent, t as RuntimeRunRetryEvent, u as RuntimeRunStartEvent, W as WorkloadRuntime, v as WorkloadRuntimeOptions, w as createAgentOrchestrator, x as createWorkloadRuntime, y as isTerminalRunStatus } from './index-acbJQol3.js';
 export { InMemoryRuntimeDriver } from './drivers/in-memory.js';
 
 declare const PROMETHEUS_TEXT_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
@@ -40,7 +40,172 @@ interface PrometheusRuntimeMetrics<TPayload = unknown> {
 }
 declare function createPrometheusRuntimeMetrics<TPayload = unknown>(options?: PrometheusRuntimeMetricsOptions): PrometheusRuntimeMetrics<TPayload>;
 
+/**
+ * Generic execution record and checkpoint types.
+ *
+ * These types define the provider-agnostic contract for persisting and
+ * querying agent task execution state. Runtime providers (Dapr, Temporal,
+ * etc.) implement `ExecutionStore` against their own durable backend.
+ *
+ * There is no built-in/in-memory implementation — durability requires a
+ * real runtime provider.
+ */
+type ExecutionStatus = "running" | "completed" | "failed";
+/**
+ * Lightweight execution run metadata. Provider-specific stores may persist
+ * richer records (e.g. Dapr envelopes), but this is the portable shape
+ * that runtime-agnostic code can rely on.
+ */
+interface ExecutionRunRecord {
+    /** Session ID that scopes this execution. */
+    sessionId: string;
+    /** Current lifecycle status. */
+    status: ExecutionStatus;
+    /** ISO timestamp when the execution started. */
+    startedAt: string;
+    /** ISO timestamp of the last update. */
+    updatedAt: string;
+    /** ISO timestamp when the execution completed (if terminal). */
+    completedAt?: string;
+    /** Number of checkpoints persisted so far. */
+    checkpointCount: number;
+    /** Reason tag of the most recent checkpoint. */
+    lastCheckpointReason?: string;
+    /** The latest execution snapshot (serializable turn state). */
+    snapshot: ExecutionSnapshot;
+    /** Final result when `status === "completed"`. */
+    result?: ExecutionResult;
+    /** Error details when `status === "failed"`. */
+    error?: ExecutionErrorRecord;
+}
+/**
+ * Serializable snapshot of an in-flight or completed execution.
+ * This is the portable subset of the agent-core `AgentTaskExecutionSnapshot`
+ * — enough to resume or inspect, without leaking runtime-specific fields.
+ */
+interface ExecutionSnapshot {
+    sessionId: string;
+    response: string;
+    usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    toolCalls: Array<{
+        name: string;
+        result: unknown;
+    }>;
+    eventCount: number;
+    activeStep?: number;
+    error?: string;
+    startedAt: string;
+    updatedAt: string;
+}
+/**
+ * Final result of a completed execution.
+ */
+interface ExecutionResult {
+    response: string;
+    sessionId: string;
+    usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    toolCalls: Array<{
+        name: string;
+        result: unknown;
+    }>;
+}
+interface ExecutionErrorRecord {
+    name: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * A persisted checkpoint captured at a specific phase boundary during
+ * execution. Checkpoints enable resume-from-last-safe-point on crash.
+ */
+interface ExecutionCheckpointRecord {
+    /** Unique checkpoint identifier (provider-generated). */
+    id: string;
+    /** Session that owns this checkpoint. */
+    sessionId: string;
+    /** Phase boundary that triggered this checkpoint. */
+    reason: string;
+    /** Snapshot of execution state at checkpoint time. */
+    snapshot: ExecutionSnapshot;
+    /** ISO timestamp when this checkpoint was recorded. */
+    createdAt: string;
+}
+
+/**
+ * Provider-agnostic execution store contract.
+ *
+ * Runtime providers (Dapr, Temporal, etc.) implement this interface to
+ * persist and query agent task execution state. This enables:
+ *
+ * - Execution lookup and inspection after completion
+ * - Crash detection (find `status === "running"` after restart)
+ * - Resume from the last checkpoint on the direct (non-workflow) path
+ *
+ * There is no built-in/in-memory implementation. Durability requires a
+ * real runtime provider — if no provider is configured, execution
+ * persistence is simply not available.
+ */
+interface ExecutionStore {
+    /** Optional lifecycle hook called on runtime start. */
+    start?(): Promise<void>;
+    /** Optional lifecycle hook called on runtime stop. */
+    stop?(): Promise<void>;
+    /**
+     * Get the execution record for a session.
+     * Returns `undefined` if no execution exists for the given session.
+     */
+    get(sessionId: string): Promise<ExecutionRunRecord | undefined>;
+    /**
+     * List all known execution records.
+     * Providers may support optional filtering (e.g. by status) through
+     * their own extended options.
+     */
+    list(options?: ExecutionListOptions): Promise<ExecutionRunRecord[]>;
+    /**
+     * List checkpoints for a specific execution, ordered by creation time.
+     * Returns an empty array if the session has no checkpoints.
+     */
+    listGenericCheckpoints(sessionId: string): Promise<ExecutionCheckpointRecord[]>;
+    /**
+     * Remove an execution record and all its checkpoints.
+     * Returns `true` if the record existed and was removed.
+     */
+    remove?(sessionId: string): Promise<boolean>;
+    /**
+     * Clean up old execution records according to provider-specific
+     * retention policies. This is an optional maintenance operation.
+     */
+    cleanup?(options?: Record<string, unknown>): Promise<ExecutionCleanupResult>;
+}
+/**
+ * Options for listing executions. Providers may extend this with their
+ * own filter capabilities.
+ */
+interface ExecutionListOptions {
+    /** Filter by execution status. */
+    status?: ExecutionStatus | ExecutionStatus[];
+    /** Maximum number of records to return. */
+    limit?: number;
+}
+/**
+ * Result of an execution store cleanup operation.
+ */
+interface ExecutionCleanupResult {
+    /** Number of execution records deleted. */
+    deletedExecutions: number;
+    /** Number of checkpoint records deleted. */
+    deletedCheckpoints: number;
+}
+
 declare function normalizeSchedule(input: RuntimeJobScheduleInput): RuntimeJobSchedule;
 declare function computeNextRunAtMs(schedule: RuntimeJobSchedule, nowMs: number): number | undefined;
 
-export { PROMETHEUS_TEXT_CONTENT_TYPE, type PrometheusHistogramBucketSample, type PrometheusHistogramSample, type PrometheusMetricSample, type PrometheusRuntimeMetrics, type PrometheusRuntimeMetricsOptions, type PrometheusRuntimeMetricsSnapshot, RuntimeJobSchedule, RuntimeJobScheduleInput, RuntimeObserver, computeNextRunAtMs, createPrometheusRuntimeMetrics, normalizeSchedule };
+export { type ExecutionCheckpointRecord, type ExecutionCleanupResult, type ExecutionErrorRecord, type ExecutionListOptions, type ExecutionResult, type ExecutionRunRecord, type ExecutionSnapshot, type ExecutionStatus, type ExecutionStore, PROMETHEUS_TEXT_CONTENT_TYPE, type PrometheusHistogramBucketSample, type PrometheusHistogramSample, type PrometheusMetricSample, type PrometheusRuntimeMetrics, type PrometheusRuntimeMetricsOptions, type PrometheusRuntimeMetricsSnapshot, RuntimeJobSchedule, RuntimeJobScheduleInput, RuntimeObserver, computeNextRunAtMs, createPrometheusRuntimeMetrics, normalizeSchedule };

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   createWorkloadRuntime,
   isTerminalRunStatus,
   silentRuntimeLogger
-} from "./chunk-MAVHVV2U.js";
+} from "./chunk-U7M333GT.js";
 import {
   computeNextRunAtMs,
   normalizeSchedule

package/dist/orchestration/index.d.ts

@@ -1,3 +1,3 @@
-export { A as AgentOrchestrator, a as AgentOrchestratorOptions, I as InMemoryOrchestratorRunStore, O as OrchestratorCloseOptions, b as OrchestratorExecutionContext, c as OrchestratorExecutor, d as OrchestratorGuideInput, e as OrchestratorGuidedInputResolver, f as OrchestratorInvokeInput, g as OrchestratorInvokeResult, h as OrchestratorJobPayload, i as OrchestratorListOptions, j as OrchestratorRunMode, k as OrchestratorRunRecord, l as OrchestratorRunState, m as OrchestratorRunStatus, n as OrchestratorRunStore, o as OrchestratorWaitOptions, w as createAgentOrchestrator, y as isTerminalRunStatus } from '../index-DkdkAAoL.js';
-import '../types-DllX9NP8.js';
-import '../driver-BaLji34_.js';
+export { A as AgentOrchestrator, a as AgentOrchestratorOptions, I as InMemoryOrchestratorRunStore, O as OrchestratorCloseOptions, b as OrchestratorExecutionContext, c as OrchestratorExecutor, d as OrchestratorGuideInput, e as OrchestratorGuidedInputResolver, f as OrchestratorInvokeInput, g as OrchestratorInvokeResult, h as OrchestratorJobPayload, i as OrchestratorListOptions, j as OrchestratorRunMode, k as OrchestratorRunRecord, l as OrchestratorRunState, m as OrchestratorRunStatus, n as OrchestratorRunStore, o as OrchestratorWaitOptions, w as createAgentOrchestrator, y as isTerminalRunStatus } from '../index-acbJQol3.js';
+import '../types-AoJlEcyK.js';
+import '../driver-CQg5G_ey.js';

package/dist/orchestration/index.js

@@ -3,7 +3,7 @@ import {
   InMemoryOrchestratorRunStore,
   createAgentOrchestrator,
   isTerminalRunStatus
-} from "../chunk-MAVHVV2U.js";
+} from "../chunk-U7M333GT.js";
 import "../chunk-ZVISWF7S.js";
 export {
   AgentOrchestrator,

package/dist/{types-DllX9NP8.d.ts → types-AoJlEcyK.d.ts}

@@ -99,4 +99,4 @@ interface RuntimeDeadLetterEvent<TPayload = unknown> {
     error: string;
 }
 
-export type { RuntimeJobRecord as R, RuntimeExecutionContext as a, RuntimeExecutor as b, RuntimeJobSchedule as c, RuntimeJobScheduleInput as d, RuntimeAtSchedule as e, RuntimeAtScheduleInput as f, RuntimeCronSchedule as g, RuntimeDeadLetterEvent as h, RuntimeDispatchInput as i, RuntimeEverySchedule as j, RuntimeExecutionResult as k, RuntimeJobState as l, RuntimeRetryPolicy as m, RuntimeRetryStrategy as n, RuntimeRunResult as o, RuntimeRunStatus as p, RuntimeScheduleInput as q, RuntimeSchedulePatch as r, RuntimeTrigger as s };
+export type { RuntimeJobRecord as R, RuntimeExecutionContext as a, RuntimeExecutor as b, RuntimeRunResult as c, RuntimeJobSchedule as d, RuntimeJobScheduleInput as e, RuntimeAtSchedule as f, RuntimeAtScheduleInput as g, RuntimeCronSchedule as h, RuntimeDeadLetterEvent as i, RuntimeDispatchInput as j, RuntimeEverySchedule as k, RuntimeExecutionResult as l, RuntimeJobState as m, RuntimeRetryPolicy as n, RuntimeRetryStrategy as o, RuntimeRunStatus as p, RuntimeScheduleInput as q, RuntimeSchedulePatch as r, RuntimeTrigger as s };

package/dist/workload/index.d.ts

@@ -1,4 +1,4 @@
-import { a as RuntimeExecutionContext, R as RuntimeJobRecord, b as RuntimeExecutor } from '../types-DllX9NP8.js';
+import { a as RuntimeExecutionContext, R as RuntimeJobRecord, b as RuntimeExecutor } from '../types-AoJlEcyK.js';
 
 /**
  * Context exposed to domain workloads that run inside `WorkloadRuntime`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/agent-runtime",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Workload runtime orchestration layer - scheduling, execution, and pluggable runtime drivers",
   "type": "module",
   "main": "./dist/index.js",