@cuylabs/agent-runtime 0.11.0 → 0.12.0

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

@@ -1,7 +1,7 @@
 import {
   computeNextRunAtMs,
   normalizeSchedule
-} from "./chunk-ZVISWF7S.js";
+} from "./chunk-PXXGA4YJ.js";
 
 // src/orchestration/types.ts
 var TERMINAL_STATUSES = {
@@ -85,7 +85,9 @@ function normalizeExecutionTimeoutMs(value) {
     return DEFAULT_EXECUTION_TIMEOUT_MS;
   }
   if (!Number.isFinite(value)) {
-    throw new Error(`executionTimeoutMs must be a finite number. Received: ${String(value)}`);
+    throw new Error(
+      `executionTimeoutMs must be a finite number. Received: ${String(value)}`
+    );
   }
   const normalized = Math.floor(value);
   if (normalized <= 0) {
@@ -98,7 +100,9 @@ function normalizeMaxQueuedDispatches(value) {
     return void 0;
   }
   if (!Number.isFinite(value)) {
-    throw new Error(`maxQueuedDispatches must be a finite number. Received: ${String(value)}`);
+    throw new Error(
+      `maxQueuedDispatches must be a finite number. Received: ${String(value)}`
+    );
   }
   return Math.max(0, Math.floor(value));
 }
@@ -158,17 +162,23 @@ function normalizeRetryPolicy(policy) {
     return void 0;
   }
   if (!Number.isFinite(policy.maxAttempts)) {
-    throw new Error(`retryPolicy.maxAttempts must be a finite number. Received: ${String(policy.maxAttempts)}`);
+    throw new Error(
+      `retryPolicy.maxAttempts must be a finite number. Received: ${String(policy.maxAttempts)}`
+    );
   }
   const maxAttempts = Math.max(1, Math.floor(policy.maxAttempts));
   const strategy = policy.strategy ?? "fixed";
   if (strategy !== "fixed" && strategy !== "exponential") {
-    throw new Error(`retryPolicy.strategy must be "fixed" or "exponential". Received: ${String(policy.strategy)}`);
+    throw new Error(
+      `retryPolicy.strategy must be "fixed" or "exponential". Received: ${String(policy.strategy)}`
+    );
   }
   let backoffMs;
   if (policy.backoffMs !== void 0) {
     if (!Number.isFinite(policy.backoffMs) || policy.backoffMs < 0) {
-      throw new Error(`retryPolicy.backoffMs must be a non-negative finite number. Received: ${String(policy.backoffMs)}`);
+      throw new Error(
+        `retryPolicy.backoffMs must be a non-negative finite number. Received: ${String(policy.backoffMs)}`
+      );
     }
     backoffMs = Math.floor(policy.backoffMs);
   }
@@ -241,9 +251,13 @@ var WorkloadRuntime = class {
       1,
       Math.floor(options.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS)
     );
-    this.maxQueuedDispatches = normalizeMaxQueuedDispatches(options.maxQueuedDispatches);
+    this.maxQueuedDispatches = normalizeMaxQueuedDispatches(
+      options.maxQueuedDispatches
+    );
     this.createId = options.createId ?? (() => randomUUID());
-    this.executionTimeoutMs = normalizeExecutionTimeoutMs(options.executionTimeoutMs);
+    this.executionTimeoutMs = normalizeExecutionTimeoutMs(
+      options.executionTimeoutMs
+    );
     this.abortInFlightOnStop = options.abortInFlightOnStop ?? DEFAULT_ABORT_IN_FLIGHT_ON_STOP;
     this.onDeadLetter = options.onDeadLetter;
     this.observers = options.observers ?? [];
@@ -273,12 +287,16 @@ var WorkloadRuntime = class {
           return await this.dispatchDue(jobId);
         }
       });
-      await this.forEachObserver("runtime start", { driver: this.driver.name }, async (observer) => {
-        await observer.notifyRuntimeStart?.({
-          driver: this.driver.name,
-          at: Date.now()
-        });
-      });
+      await this.forEachObserver(
+        "runtime start",
+        { driver: this.driver.name },
+        async (observer) => {
+          await observer.notifyRuntimeStart?.({
+            driver: this.driver.name,
+            at: Date.now()
+          });
+        }
+      );
       this.logger.info("Runtime started", { driver: this.driver.name });
     } catch (error) {
       this.started = false;
@@ -315,18 +333,25 @@ var WorkloadRuntime = class {
         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
-        });
+        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?.({
-        driver: this.driver.name,
-        at: Date.now()
-      });
-    });
+    await this.forEachObserver(
+      "runtime stop",
+      { driver: this.driver.name },
+      async (observer) => {
+        await observer.notifyRuntimeStop?.({
+          driver: this.driver.name,
+          at: Date.now()
+        });
+      }
+    );
     this.logger.info("Runtime stopped", { driver: this.driver.name });
   }
   status() {
@@ -356,7 +381,9 @@ var WorkloadRuntime = class {
     const jobId = normalizeJobId(input.id ?? this.createId());
     const name = normalizeJobName(input.name);
     const metadata = input.metadata ?? existing?.metadata;
-    const retryPolicy = normalizeRetryPolicy(input.retryPolicy ?? existing?.retryPolicy);
+    const retryPolicy = normalizeRetryPolicy(
+      input.retryPolicy ?? existing?.retryPolicy
+    );
     validateMetadata(metadata);
     let enabled = input.enabled ?? existing?.enabled ?? true;
     let nextRunAtMs = enabled ? computeNextRunAtMs(schedule, now) : void 0;
@@ -386,7 +413,9 @@ var WorkloadRuntime = class {
     const now = Date.now();
     const name = normalizeJobName(patch.name ?? current.name);
     const nextSchedule = patch.schedule ? normalizeSchedule(patch.schedule) : current.schedule;
-    const retryPolicy = normalizeRetryPolicy(patch.retryPolicy ?? current.retryPolicy);
+    const retryPolicy = normalizeRetryPolicy(
+      patch.retryPolicy ?? current.retryPolicy
+    );
     let enabled = patch.enabled ?? current.enabled;
     const metadata = patch.metadata ?? current.metadata;
     validateMetadata(metadata);
@@ -593,9 +622,13 @@ var WorkloadRuntime = class {
   }
   async emitDeadLetter(event) {
     if (!this.onDeadLetter) {
-      await this.forEachObserver("dead letter", { jobId: event.job.id }, async (observer) => {
-        await observer.notifyDeadLetter?.(event);
-      });
+      await this.forEachObserver(
+        "dead letter",
+        { jobId: event.job.id },
+        async (observer) => {
+          await observer.notifyDeadLetter?.(event);
+        }
+      );
       return;
     }
     try {
@@ -606,9 +639,13 @@ var WorkloadRuntime = class {
         error: String(error)
       });
     }
-    await this.forEachObserver("dead letter", { jobId: event.job.id }, async (observer) => {
-      await observer.notifyDeadLetter?.(event);
-    });
+    await this.forEachObserver(
+      "dead letter",
+      { jobId: event.job.id },
+      async (observer) => {
+        await observer.notifyDeadLetter?.(event);
+      }
+    );
   }
   async executeReservedJob(jobId, trigger) {
     const startedAt = Date.now();
@@ -646,13 +683,17 @@ var WorkloadRuntime = class {
           error: String(error)
         });
       });
-      await this.forEachObserver("run start", { jobId, trigger }, async (observer) => {
-        await observer.notifyRunStart?.({
-          job,
-          trigger,
-          startedAt
-        });
-      });
+      await this.forEachObserver(
+        "run start",
+        { jobId, trigger },
+        async (observer) => {
+          await observer.notifyRunStart?.({
+            job,
+            trigger,
+            startedAt
+          });
+        }
+      );
       const retryPolicy = normalizeRetryPolicy(job.retryPolicy);
       const maxAttempts = retryPolicy?.maxAttempts ?? 1;
       const abortController = new AbortController();
@@ -686,7 +727,12 @@ var WorkloadRuntime = class {
           });
           await this.forEachObserver(
             "run retry",
-            { jobId, trigger, attempt: attemptCount, nextAttempt: attemptCount + 1 },
+            {
+              jobId,
+              trigger,
+              attempt: attemptCount,
+              nextAttempt: attemptCount + 1
+            },
             async (observer) => {
               await observer.notifyRunRetry?.({
                 job,
@@ -862,7 +908,9 @@ function normalizeLimit(value) {
     return void 0;
   }
   if (!Number.isFinite(value)) {
-    throw new Error(`limit must be a finite number. Received: ${String(value)}`);
+    throw new Error(
+      `limit must be a finite number. Received: ${String(value)}`
+    );
   }
   return Math.max(0, Math.floor(value));
 }
@@ -871,7 +919,9 @@ function normalizeScheduleAheadMs(value) {
     return DEFAULT_SCHEDULE_AHEAD_MS;
   }
   if (!Number.isFinite(value)) {
-    throw new Error(`scheduleAheadMs must be a finite number. Received: ${String(value)}`);
+    throw new Error(
+      `scheduleAheadMs must be a finite number. Received: ${String(value)}`
+    );
   }
   return Math.max(1, Math.floor(value));
 }
@@ -920,7 +970,10 @@ var AgentOrchestrator = class {
     this.store = options.store ?? new InMemoryOrchestratorRunStore();
     this.logger = options.logger ?? options.runtime?.logger ?? silentRuntimeLogger;
     this.createId = options.createId ?? (() => randomUUID2());
-    this.jobIdPrefix = normalizeNonEmpty(options.jobIdPrefix ?? DEFAULT_JOB_ID_PREFIX, "jobIdPrefix");
+    this.jobIdPrefix = normalizeNonEmpty(
+      options.jobIdPrefix ?? DEFAULT_JOB_ID_PREFIX,
+      "jobIdPrefix"
+    );
     this.runLabelPrefix = normalizeNonEmpty(
       options.runLabelPrefix ?? DEFAULT_RUN_LABEL_PREFIX,
       "runLabelPrefix"
@@ -972,9 +1025,12 @@ var AgentOrchestrator = class {
       if (!runtimeError) {
         throw error;
       }
-      this.logger.error("Failed to stop orchestrator run store after runtime stop failure", {
-        error: toErrorMessage(error)
-      });
+      this.logger.error(
+        "Failed to stop orchestrator run store after runtime stop failure",
+        {
+          error: toErrorMessage(error)
+        }
+      );
     }
     if (runtimeError) {
       throw runtimeError;
@@ -1008,7 +1064,10 @@ var AgentOrchestrator = class {
     const now = Date.now();
     const run = {
       id: runId,
-      label: normalizeNonEmpty(input.label ?? `${this.runLabelPrefix}:${runId}`, "label"),
+      label: normalizeNonEmpty(
+        input.label ?? `${this.runLabelPrefix}:${runId}`,
+        "label"
+      ),
       input: input.input,
       parentRunId: input.parentRunId?.trim() || void 0,
       metadata: input.metadata,
@@ -1031,7 +1090,9 @@ var AgentOrchestrator = class {
       });
     } catch (error) {
       await this.failRunLaunch(run, error, "Failed to schedule run");
-      throw new Error(`Failed to schedule run "${runId}": ${toErrorMessage(error)}`);
+      throw new Error(
+        `Failed to schedule run "${runId}": ${toErrorMessage(error)}`
+      );
     }
     return {
       run: await this.requireRun(runId),
@@ -1067,60 +1128,72 @@ var AgentOrchestrator = class {
     if (isTerminalRunStatus(current.state.status)) {
       return current;
     }
-    return await new Promise((resolve, reject) => {
-      const timeoutRef = {};
-      let abortHandler;
-      const cleanup = () => {
-        if (timeoutRef.current) {
-          clearTimeout(timeoutRef.current);
-        }
-        if (abortHandler && options.signal) {
-          options.signal.removeEventListener("abort", abortHandler);
-        }
-        const currentGroup = this.waiters.get(normalizedRunId);
-        currentGroup?.delete(waiter);
-        if (currentGroup && currentGroup.size === 0) {
-          this.waiters.delete(normalizedRunId);
+    return await new Promise(
+      (resolve, reject) => {
+        const timeoutRef = {};
+        let abortHandler;
+        const cleanup = () => {
+          if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+          }
+          if (abortHandler && options.signal) {
+            options.signal.removeEventListener("abort", abortHandler);
+          }
+          const currentGroup = this.waiters.get(normalizedRunId);
+          currentGroup?.delete(waiter);
+          if (currentGroup && currentGroup.size === 0) {
+            this.waiters.delete(normalizedRunId);
+          }
+        };
+        const waiter = {
+          resolve: (record) => {
+            cleanup();
+            resolve(record);
+          },
+          reject: (error) => {
+            cleanup();
+            reject(error);
+          }
+        };
+        const group = this.waiters.get(normalizedRunId) ?? /* @__PURE__ */ new Set();
+        group.add(waiter);
+        this.waiters.set(normalizedRunId, group);
+        if (options.signal) {
+          abortHandler = () => {
+            waiter.reject(
+              new Error(`Waiting for run "${normalizedRunId}" aborted`)
+            );
+          };
+          if (options.signal.aborted) {
+            abortHandler();
+            return;
+          }
+          options.signal.addEventListener("abort", abortHandler, {
+            once: true
+          });
         }
-      };
-      const waiter = {
-        resolve: (record) => {
-          cleanup();
-          resolve(record);
-        },
-        reject: (error) => {
-          cleanup();
-          reject(error);
+        if (options.timeoutMs === void 0) {
+          return;
         }
-      };
-      const group = this.waiters.get(normalizedRunId) ?? /* @__PURE__ */ new Set();
-      group.add(waiter);
-      this.waiters.set(normalizedRunId, group);
-      if (options.signal) {
-        abortHandler = () => {
-          waiter.reject(new Error(`Waiting for run "${normalizedRunId}" aborted`));
-        };
-        if (options.signal.aborted) {
-          abortHandler();
+        if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+          waiter.reject(
+            new Error(
+              `timeoutMs must be greater than zero. Received: ${String(options.timeoutMs)}`
+            )
+          );
           return;
         }
-        options.signal.addEventListener("abort", abortHandler, { once: true });
-      }
-      if (options.timeoutMs === void 0) {
-        return;
-      }
-      if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
-        waiter.reject(
-          new Error(`timeoutMs must be greater than zero. Received: ${String(options.timeoutMs)}`)
-        );
-        return;
+        const timeoutMs = Math.floor(options.timeoutMs);
+        timeoutRef.current = setTimeout(() => {
+          waiter.reject(
+            new Error(
+              `Timed out waiting for run "${normalizedRunId}" after ${timeoutMs}ms`
+            )
+          );
+        }, timeoutMs);
+        timeoutRef.current.unref?.();
       }
-      const timeoutMs = Math.floor(options.timeoutMs);
-      timeoutRef.current = setTimeout(() => {
-        waiter.reject(new Error(`Timed out waiting for run "${normalizedRunId}" after ${timeoutMs}ms`));
-      }, timeoutMs);
-      timeoutRef.current.unref?.();
-    });
+    );
   }
   async close(runId, options = {}) {
     const normalizedRunId = normalizeId(runId, "runId");
@@ -1165,7 +1238,9 @@ var AgentOrchestrator = class {
     const guideMessage = normalizeNonEmpty(input.message, "message");
     const run = await this.requireRun(runId);
     if (isTerminalRunStatus(run.state.status)) {
-      throw new Error(`Cannot guide terminal run "${runId}" (${run.state.status})`);
+      throw new Error(
+        `Cannot guide terminal run "${runId}" (${run.state.status})`
+      );
     }
     const nextInput = input.input ?? this.resolveGuidedInput({
       run,
@@ -1206,13 +1281,17 @@ var AgentOrchestrator = class {
       });
     } catch (error) {
       await this.failRunLaunch(next, error, "Failed to relaunch guided run");
-      throw new Error(`Failed to relaunch guided run "${runId}": ${toErrorMessage(error)}`);
+      throw new Error(
+        `Failed to relaunch guided run "${runId}": ${toErrorMessage(error)}`
+      );
     }
     return await this.requireRun(runId);
   }
   ensureStarted() {
     if (!this.runtime.status().started) {
-      throw new Error("Orchestrator runtime is not started. Call start() before this operation.");
+      throw new Error(
+        "Orchestrator runtime is not started. Call start() before this operation."
+      );
     }
   }
   toJobId(runId) {
@@ -1311,7 +1390,11 @@ var AgentOrchestrator = class {
         jobId,
         error: toErrorMessage(error)
       });
-      void this.failPendingRunLaunch(run.id, error, "Run dispatch failed").catch((persistError) => {
+      void this.failPendingRunLaunch(
+        run.id,
+        error,
+        "Run dispatch failed"
+      ).catch((persistError) => {
         this.logger.error("Failed to persist run dispatch failure", {
           runId: run.id,
           jobId,
@@ -1367,7 +1450,9 @@ var AgentOrchestrator = class {
     await this.store.upsert(running);
     const runController = new AbortController();
     const onRuntimeAbort = () => runController.abort();
-    runtimeContext.signal.addEventListener("abort", onRuntimeAbort, { once: true });
+    runtimeContext.signal.addEventListener("abort", onRuntimeAbort, {
+      once: true
+    });
     this.runControllers.set(run.id, runController);
     try {
       const result = await this.executeRun(running, {
@@ -1431,14 +1516,16 @@ var AgentOrchestrator = class {
                 runId: queued.id,
                 error: toErrorMessage(retryError)
               });
-              void this.failRunLaunch(queued, retryError, "Failed to relaunch guided run").catch(
-                (persistError) => {
-                  this.logger.error("Failed to persist guided relaunch failure", {
-                    runId: queued.id,
-                    error: toErrorMessage(persistError)
-                  });
-                }
-              );
+              void this.failRunLaunch(
+                queued,
+                retryError,
+                "Failed to relaunch guided run"
+              ).catch((persistError) => {
+                this.logger.error("Failed to persist guided relaunch failure", {
+                  runId: queued.id,
+                  error: toErrorMessage(persistError)
+                });
+              });
             });
           }, 0);
           retryTimer.unref?.();

package/dist/{chunk-ZVISWF7S.js → chunk-PXXGA4YJ.js}

@@ -44,17 +44,25 @@ function normalizeSchedule(input) {
   if (input.kind === "every") {
     const everyMs = Math.floor(input.everyMs);
     if (!Number.isFinite(everyMs) || everyMs <= 0) {
-      throw new Error(`Invalid every-schedule interval: ${String(input.everyMs)}`);
+      throw new Error(
+        `Invalid every-schedule interval: ${String(input.everyMs)}`
+      );
     }
     let anchorMs;
     if (input.anchorMs !== void 0) {
       const nextAnchor = Math.floor(input.anchorMs);
       if (!Number.isFinite(nextAnchor) || nextAnchor < 0) {
-        throw new Error(`Invalid every-schedule anchor: ${String(input.anchorMs)}`);
+        throw new Error(
+          `Invalid every-schedule anchor: ${String(input.anchorMs)}`
+        );
       }
       anchorMs = nextAnchor;
     }
-    return { kind: "every", everyMs, ...anchorMs !== void 0 ? { anchorMs } : {} };
+    return {
+      kind: "every",
+      everyMs,
+      ...anchorMs !== void 0 ? { anchorMs } : {}
+    };
   }
   const expr = input.expr.trim();
   if (!expr) {
@@ -76,7 +84,10 @@ function computeNextRunAtMs(schedule, nowMs) {
       return anchor;
     }
     const elapsed = nowMs - anchor;
-    const steps = Math.max(1, Math.floor((elapsed + schedule.everyMs - 1) / schedule.everyMs));
+    const steps = Math.max(
+      1,
+      Math.floor((elapsed + schedule.everyMs - 1) / schedule.everyMs)
+    );
     return anchor + steps * schedule.everyMs;
   }
   const cron = resolveCachedCron(schedule);

package/dist/{chunk-DBQSJ476.js → chunk-RCSNDSHJ.js}

@@ -1,6 +1,6 @@
 import {
   computeNextRunAtMs
-} from "./chunk-ZVISWF7S.js";
+} from "./chunk-PXXGA4YJ.js";
 
 // src/drivers/in-memory.ts
 import { Cron } from "croner";
@@ -15,7 +15,10 @@ var InMemoryRuntimeDriver = class {
   context;
   started = false;
   constructor(options = {}) {
-    this.maxTimerDelayMs = Math.max(1e3, Math.floor(options.maxTimerDelayMs ?? 6e4));
+    this.maxTimerDelayMs = Math.max(
+      1e3,
+      Math.floor(options.maxTimerDelayMs ?? 6e4)
+    );
   }
   async start(context) {
     if (this.started) {

package/dist/drivers/in-memory.js

@@ -1,7 +1,7 @@
 import {
   InMemoryRuntimeDriver
-} from "../chunk-DBQSJ476.js";
-import "../chunk-ZVISWF7S.js";
+} from "../chunk-RCSNDSHJ.js";
+import "../chunk-PXXGA4YJ.js";
 export {
   InMemoryRuntimeDriver
 };

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   InMemoryRuntimeDriver
-} from "./chunk-DBQSJ476.js";
+} from "./chunk-RCSNDSHJ.js";
 import {
   AgentOrchestrator,
   InMemoryOrchestratorRunStore,
@@ -10,11 +10,11 @@ import {
   createWorkloadRuntime,
   isTerminalRunStatus,
   silentRuntimeLogger
-} from "./chunk-U7M333GT.js";
+} from "./chunk-DRMXPKPK.js";
 import {
   computeNextRunAtMs,
   normalizeSchedule
-} from "./chunk-ZVISWF7S.js";
+} from "./chunk-PXXGA4YJ.js";
 import {
   createRuntimeWorkloadContext,
   createRuntimeWorkloadExecutor
@@ -39,14 +39,18 @@ var PROMETHEUS_TEXT_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
 function normalizeMetricPrefix(value) {
   const normalized = (value ?? DEFAULT_METRIC_PREFIX).trim().replace(/[^a-zA-Z0-9_:]/g, "_").replace(/^[^a-zA-Z_:]+/, "");
   if (!normalized) {
-    throw new Error("metricPrefix must contain at least one valid Prometheus metric character");
+    throw new Error(
+      "metricPrefix must contain at least one valid Prometheus metric character"
+    );
   }
   return normalized;
 }
 function normalizeDurationBuckets(value) {
   const buckets = [...value ?? DEFAULT_DURATION_BUCKETS_MS].map((bucket) => Math.floor(bucket)).filter((bucket) => Number.isFinite(bucket) && bucket > 0).sort((left, right) => left - right);
   if (buckets.length === 0) {
-    throw new Error("durationBucketsMs must include at least one positive bucket");
+    throw new Error(
+      "durationBucketsMs must include at least one positive bucket"
+    );
   }
   return [...new Set(buckets)];
 }
@@ -62,7 +66,9 @@ function cloneLabels(labels) {
   );
 }
 function serializeLabels(labels) {
-  const entries = Object.entries(labels).sort(([left], [right]) => left.localeCompare(right));
+  const entries = Object.entries(labels).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
   return entries.map(([key, value]) => `${key}="${escapeLabelValue(value)}"`).join(",");
 }
 function labelsKey(labels) {
@@ -259,7 +265,10 @@ function createPrometheusRuntimeMetrics(options = {}) {
         mergeLabels(defaultLabels, { trigger: event.trigger })
       );
       adjustGauge(inFlightGauge, baseGaugeLabels, 1);
-      const queueDepth = getOrCreateMetricEntry(queueDepthGauge, baseGaugeLabels);
+      const queueDepth = getOrCreateMetricEntry(
+        queueDepthGauge,
+        baseGaugeLabels
+      );
       if (queueDepth.value > 0) {
         queueDepth.value -= 1;
       }
@@ -333,7 +342,9 @@ function createPrometheusRuntimeMetrics(options = {}) {
   };
   const render = () => {
     const lines = [];
-    for (const [name, store] of [...counters.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    for (const [name, store] of [...counters.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )) {
       lines.push(`# HELP ${name} ${escapeMetricHelp(store.help)}`);
       lines.push(`# TYPE ${name} ${store.type}`);
       for (const entry of sortMetricEntries(store.entries.values())) {
@@ -341,7 +352,9 @@ function createPrometheusRuntimeMetrics(options = {}) {
         lines.push(`${name}${labels ? `{${labels}}` : ""} ${entry.value}`);
       }
     }
-    for (const [name, store] of [...gauges.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    for (const [name, store] of [...gauges.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )) {
       lines.push(`# HELP ${name} ${escapeMetricHelp(store.help)}`);
       lines.push(`# TYPE ${name} ${store.type}`);
       for (const entry of sortMetricEntries(store.entries.values())) {
@@ -349,7 +362,9 @@ function createPrometheusRuntimeMetrics(options = {}) {
         lines.push(`${name}${labels ? `{${labels}}` : ""} ${entry.value}`);
       }
     }
-    for (const [name, store] of [...histograms.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    for (const [name, store] of [...histograms.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )) {
       lines.push(`# HELP ${name} ${escapeMetricHelp(store.help)}`);
       lines.push(`# TYPE ${name} ${store.type}`);
       for (const entry of sortMetricEntries(store.entries.values())) {
@@ -367,8 +382,12 @@ function createPrometheusRuntimeMetrics(options = {}) {
         });
         const seriesLabels = serializeLabels(baseLabels);
         lines.push(`${name}_bucket{${infiniteLabels}} ${entry.count}`);
-        lines.push(`${name}_sum${seriesLabels ? `{${seriesLabels}}` : ""} ${entry.sum}`);
-        lines.push(`${name}_count${seriesLabels ? `{${seriesLabels}}` : ""} ${entry.count}`);
+        lines.push(
+          `${name}_sum${seriesLabels ? `{${seriesLabels}}` : ""} ${entry.sum}`
+        );
+        lines.push(
+          `${name}_count${seriesLabels ? `{${seriesLabels}}` : ""} ${entry.count}`
+        );
       }
     }
     return `${lines.join("\n")}

package/dist/orchestration/index.js

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

package/package.json

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