@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/packages/agent/src/runtime/operations/classifier.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Reload-tier classifier.
+ *
+ * Pure function. Given an OperationIntent and a small ClassifyContext snapshot
+ * of the current runtime config, returns the cheapest reload tier that can
+ * apply the change correctly.
+ *
+ * Decision rules (FIRST match wins; conservative upgrade when uncertain):
+ *
+ *   1. restart                                 → cold (explicit user intent)
+ *   2. plugin-enable / plugin-disable          → cold (loaded plugin set changes)
+ *   3. provider-switch:
+ *        a. same provider, key only            → hot
+ *        b. same provider, primaryModel only   → hot
+ *        c. same provider, both                → hot (still same plugin family)
+ *        d. different provider, same family    → warm
+ *        e. otherwise (cross-family / first-time provider with no current)
+ *                                              → cold
+ *   4. config-reload:
+ *        - all changedPaths under env./vars./models. → hot
+ *        - otherwise                            → cold
+ */
+import type { OperationIntent, ReloadTier } from "./types.js";
+export interface ClassifyContext {
+    currentProvider?: string;
+    currentApiKey?: string;
+    currentPrimaryModel?: string;
+}
+export declare function classifyOperation(intent: OperationIntent, ctx: ClassifyContext): ReloadTier;
+/**
+ * Default classifier reference suitable for injection into the operations
+ * manager. Identical to calling `classifyOperation` directly; provided so
+ * the manager's wiring stays symmetric with the strategies.
+ */
+export declare const defaultClassifier: (intent: OperationIntent, ctx: ClassifyContext) => ReloadTier;
+//# sourceMappingURL=classifier.d.ts.map

package/packages/agent/src/runtime/operations/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAsCD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,eAAe,GACnB,UAAU,CAiBZ;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAC9B,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,eAAe,KACjB,UAA4D,CAAC"}

package/packages/agent/src/runtime/operations/classifier.js

@@ -0,0 +1,72 @@
+/**
+ * Reload-tier classifier.
+ *
+ * Pure function. Given an OperationIntent and a small ClassifyContext snapshot
+ * of the current runtime config, returns the cheapest reload tier that can
+ * apply the change correctly.
+ *
+ * Decision rules (FIRST match wins; conservative upgrade when uncertain):
+ *
+ *   1. restart                                 → cold (explicit user intent)
+ *   2. plugin-enable / plugin-disable          → cold (loaded plugin set changes)
+ *   3. provider-switch:
+ *        a. same provider, key only            → hot
+ *        b. same provider, primaryModel only   → hot
+ *        c. same provider, both                → hot (still same plugin family)
+ *        d. different provider, same family    → warm
+ *        e. otherwise (cross-family / first-time provider with no current)
+ *                                              → cold
+ *   4. config-reload:
+ *        - all changedPaths under env./vars./models. → hot
+ *        - otherwise                            → cold
+ */
+import { getOnboardingProviderFamily } from "../../contracts/onboarding.js";
+const HOT_CONFIG_PATH_PREFIXES = ["env.", "vars.", "models."];
+function allPathsAreHotEligible(paths) {
+    if (paths.length === 0)
+        return false;
+    return paths.every((path) => HOT_CONFIG_PATH_PREFIXES.some((prefix) => path.startsWith(prefix)));
+}
+function classifyProviderSwitch(intent, ctx) {
+    const target = intent.provider;
+    const current = ctx.currentProvider;
+    if (!current) {
+        // First-time provider setup with no current provider — cold.
+        return "cold";
+    }
+    if (current === target) {
+        // Same provider; key/model swaps stay in the same plugin family.
+        return "hot";
+    }
+    const targetFamily = getOnboardingProviderFamily(target);
+    const currentFamily = getOnboardingProviderFamily(current);
+    if (targetFamily && currentFamily && targetFamily === currentFamily) {
+        // Same plugin family (e.g. openai ↔ openai-subscription) — warm.
+        return "warm";
+    }
+    return "cold";
+}
+export function classifyOperation(intent, ctx) {
+    switch (intent.kind) {
+        case "restart":
+            return "cold";
+        case "plugin-enable":
+        case "plugin-disable":
+            return "cold";
+        case "provider-switch":
+            return classifyProviderSwitch(intent, ctx);
+        case "config-reload": {
+            const paths = intent.changedPaths;
+            if (paths && allPathsAreHotEligible(paths)) {
+                return "hot";
+            }
+            return "cold";
+        }
+    }
+}
+/**
+ * Default classifier reference suitable for injection into the operations
+ * manager. Identical to calling `classifyOperation` directly; provided so
+ * the manager's wiring stays symmetric with the strategies.
+ */
+export const defaultClassifier = (intent, ctx) => classifyOperation(intent, ctx);

package/packages/agent/src/runtime/operations/cold-strategy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Cold reload strategy — full runtime swap.
+ *
+ * Phase 1: delegates to the existing `restartRuntime` closure injected by
+ * the API server. Reports phase boundaries (`shutdown-old`, `start-new`,
+ * `swap`) from the manager's perspective; `restartRuntime` itself is
+ * opaque, so the inner phases are recorded as a single bracketed step.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { ReloadStrategy } from "./types.js";
+export interface ColdStrategyOptions {
+    /**
+     * Restart closure injected from the API server boot path. Returns the
+     * new runtime on success or null on failure.
+     */
+    restartRuntime: (reason: string) => Promise<AgentRuntime | null>;
+}
+export declare function createColdStrategy(opts: ColdStrategyOptions): ReloadStrategy;
+//# sourceMappingURL=cold-strategy.d.ts.map

package/packages/agent/src/runtime/operations/cold-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cold-strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/cold-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CAClE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,cAAc,CAqE5E"}

package/packages/agent/src/runtime/operations/cold-strategy.js

@@ -0,0 +1,83 @@
+/**
+ * Cold reload strategy — full runtime swap.
+ *
+ * Phase 1: delegates to the existing `restartRuntime` closure injected by
+ * the API server. Reports phase boundaries (`shutdown-old`, `start-new`,
+ * `swap`) from the manager's perspective; `restartRuntime` itself is
+ * opaque, so the inner phases are recorded as a single bracketed step.
+ */
+export function createColdStrategy(opts) {
+    const { restartRuntime } = opts;
+    return {
+        tier: "cold",
+        async apply(ctx) {
+            const reason = describeIntent(ctx.intent);
+            const shutdownStart = Date.now();
+            await ctx.reportPhase({
+                name: "shutdown-old",
+                status: "running",
+                startedAt: shutdownStart,
+            });
+            const startNewStart = Date.now();
+            await ctx.reportPhase({
+                name: "shutdown-old",
+                status: "succeeded",
+                startedAt: shutdownStart,
+                finishedAt: startNewStart,
+            });
+            await ctx.reportPhase({
+                name: "start-new",
+                status: "running",
+                startedAt: startNewStart,
+            });
+            const newRuntime = await restartRuntime(reason);
+            const startNewEnd = Date.now();
+            if (!newRuntime) {
+                await ctx.reportPhase({
+                    name: "start-new",
+                    status: "failed",
+                    startedAt: startNewStart,
+                    finishedAt: startNewEnd,
+                    error: { message: "Cold restart returned null runtime" },
+                });
+                throw new Error("Cold restart returned null runtime");
+            }
+            await ctx.reportPhase({
+                name: "start-new",
+                status: "succeeded",
+                startedAt: startNewStart,
+                finishedAt: startNewEnd,
+            });
+            const swapStart = startNewEnd;
+            await ctx.reportPhase({
+                name: "swap",
+                status: "running",
+                startedAt: swapStart,
+            });
+            // The actual swap into server.ts state is owned by `restartRuntime`'s
+            // closure; from the strategy's perspective, the moment we've received
+            // a non-null runtime back the swap has happened.
+            await ctx.reportPhase({
+                name: "swap",
+                status: "succeeded",
+                startedAt: swapStart,
+                finishedAt: Date.now(),
+            });
+            return newRuntime;
+        },
+    };
+}
+function describeIntent(intent) {
+    switch (intent.kind) {
+        case "provider-switch":
+            return `provider switch to ${intent.provider}`;
+        case "config-reload":
+            return "config reload";
+        case "plugin-enable":
+            return `plugin enable: ${intent.pluginId}`;
+        case "plugin-disable":
+            return `plugin disable: ${intent.pluginId}`;
+        case "restart":
+            return intent.reason;
+    }
+}

package/packages/agent/src/runtime/operations/health-checks.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Built-in health checks used by the runtime-operations health gate.
+ *
+ * Each check is a small, self-contained `HealthCheck`. The `HealthChecker`
+ * (in `health.ts`) runs them in parallel with per-check timeouts; required
+ * checks block promotion of a new/re-initialised runtime.
+ *
+ * Conventions:
+ *   - No shared mutable state across checks.
+ *   - Logger only (`[runtime-ops:health-checks]`).
+ *   - Treat optional/missing runtime surface as "not applicable, ok".
+ *   - Treat real failures (DB ping false, provider unreachable) as failures.
+ */
+import type { HealthCheck } from "./types.js";
+export declare const runtimeReadyCheck: HealthCheck;
+export declare const essentialServicesCheck: HealthCheck;
+export declare const dbConnectionCheck: HealthCheck;
+export declare const providerSmokeCheck: HealthCheck;
+/**
+ * The full set of built-in checks pre-registered by the default checker.
+ * Order is not significant — checks run in parallel.
+ */
+export declare const builtInHealthChecks: readonly HealthCheck[];
+//# sourceMappingURL=health-checks.d.ts.map

package/packages/agent/src/runtime/operations/health-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-checks.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/health-checks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,YAAY,CAAC;AA2CjE,eAAO,MAAM,iBAAiB,EAAE,WAuB/B,CAAC;AAMF,eAAO,MAAM,sBAAsB,EAAE,WAmCpC,CAAC;AAMF,eAAO,MAAM,iBAAiB,EAAE,WA2B/B,CAAC;AAOF,eAAO,MAAM,kBAAkB,EAAE,WAwChC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,WAAW,EAKrD,CAAC"}

package/packages/agent/src/runtime/operations/health-checks.js

@@ -0,0 +1,186 @@
+/**
+ * Built-in health checks used by the runtime-operations health gate.
+ *
+ * Each check is a small, self-contained `HealthCheck`. The `HealthChecker`
+ * (in `health.ts`) runs them in parallel with per-check timeouts; required
+ * checks block promotion of a new/re-initialised runtime.
+ *
+ * Conventions:
+ *   - No shared mutable state across checks.
+ *   - Logger only (`[runtime-ops:health-checks]`).
+ *   - Treat optional/missing runtime surface as "not applicable, ok".
+ *   - Treat real failures (DB ping false, provider unreachable) as failures.
+ */
+import { logger, ModelType } from "@elizaos/core";
+import { isInsufficientCreditsError } from "../../api/credit-detection.js";
+const LOG_PREFIX = "[runtime-ops:health-checks]";
+function getDbAdapter(runtime) {
+    const adapter = runtime.adapter;
+    if (adapter == null || typeof adapter !== "object")
+        return null;
+    return adapter;
+}
+function asServiceRegistry(runtime) {
+    return runtime;
+}
+function describeError(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === "string")
+        return err;
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+// ---------------------------------------------------------------------------
+// runtimeReadyCheck — character + agentId populated.
+// ---------------------------------------------------------------------------
+export const runtimeReadyCheck = {
+    name: "runtime-ready",
+    required: true,
+    timeoutMs: 1000,
+    async run(runtime) {
+        if (!runtime || typeof runtime !== "object") {
+            return { ok: false, reason: "runtime is not an object" };
+        }
+        const agentId = runtime.agentId;
+        if (typeof agentId !== "string" || agentId.length === 0) {
+            return { ok: false, reason: "runtime.agentId is empty" };
+        }
+        const character = runtime.character;
+        if (!character || typeof character !== "object") {
+            return { ok: false, reason: "runtime.character is missing" };
+        }
+        const name = typeof character.name === "string" ? character.name.trim() : "";
+        if (name.length === 0) {
+            return { ok: false, reason: "runtime.character.name is empty" };
+        }
+        return { ok: true };
+    },
+};
+// ---------------------------------------------------------------------------
+// essentialServicesCheck — no registered service is in a failed state.
+// ---------------------------------------------------------------------------
+export const essentialServicesCheck = {
+    name: "essential-services",
+    required: true,
+    timeoutMs: 2000,
+    async run(runtime) {
+        const reg = asServiceRegistry(runtime);
+        if (typeof reg.getRegisteredServiceTypes !== "function") {
+            // Older runtime build without the enumeration API. Cannot enforce
+            // anything reliably — silent pass beats a wrong fail.
+            logger.debug(`${LOG_PREFIX} runtime.getRegisteredServiceTypes unavailable; skipping`);
+            return { ok: true };
+        }
+        const types = reg.getRegisteredServiceTypes();
+        if (!Array.isArray(types) || types.length === 0) {
+            return { ok: true };
+        }
+        if (typeof reg.getServiceRegistrationStatus !== "function") {
+            return { ok: true };
+        }
+        for (const type of types) {
+            const status = reg.getServiceRegistrationStatus(type);
+            if (status === "failed") {
+                return {
+                    ok: false,
+                    reason: `service ${type} is in failed state`,
+                };
+            }
+        }
+        return { ok: true };
+    },
+};
+// ---------------------------------------------------------------------------
+// dbConnectionCheck — adapter.isReady() returns true (when adapter exists).
+// ---------------------------------------------------------------------------
+export const dbConnectionCheck = {
+    name: "db-connection",
+    required: true,
+    timeoutMs: 1500,
+    async run(runtime) {
+        const adapter = getDbAdapter(runtime);
+        if (!adapter) {
+            // Runtime without a database adapter (rare but supported) — pass.
+            return { ok: true };
+        }
+        if (typeof adapter.isReady !== "function") {
+            // Older adapter without isReady — best-effort pass; don't block on
+            // a missing API surface we cannot probe.
+            return { ok: true };
+        }
+        try {
+            const ready = await adapter.isReady();
+            if (ready === true)
+                return { ok: true };
+            return { ok: false, reason: "adapter.isReady() returned false" };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                reason: `adapter.isReady() threw: ${describeError(err)}`,
+                cause: err,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// providerSmokeCheck — minimal useModel call to confirm the provider
+// pipeline is wired and reachable.
+// ---------------------------------------------------------------------------
+export const providerSmokeCheck = {
+    name: "provider-smoke",
+    required: true,
+    timeoutMs: 5000,
+    async run(runtime) {
+        if (typeof runtime.useModel !== "function") {
+            // Older / stripped runtime — no model surface to probe.
+            return { ok: true };
+        }
+        try {
+            // Tiny, deterministic prompt with a hard 1-token cap. Empty completions
+            // still count as "model responded" — we only need transport health.
+            await runtime.useModel(ModelType.TEXT_SMALL, {
+                prompt: "ping",
+                maxTokens: 1,
+                temperature: 0,
+            });
+            return { ok: true };
+        }
+        catch (err) {
+            if (isInsufficientCreditsError(err)) {
+                return {
+                    ok: false,
+                    reason: "provider quota exhausted",
+                    cause: err,
+                };
+            }
+            const name = err instanceof Error ? err.name : "";
+            // The AI SDK throws AI_NoOutputGeneratedError when the model returned
+            // zero tokens. That's still a healthy transport: the request reached
+            // the provider, the provider replied, just with no text. Treat as ok.
+            if (name === "AI_NoOutputGeneratedError") {
+                return { ok: true };
+            }
+            return {
+                ok: false,
+                reason: `provider unreachable: ${describeError(err)}`,
+                cause: err,
+            };
+        }
+    },
+};
+/**
+ * The full set of built-in checks pre-registered by the default checker.
+ * Order is not significant — checks run in parallel.
+ */
+export const builtInHealthChecks = [
+    runtimeReadyCheck,
+    essentialServicesCheck,
+    dbConnectionCheck,
+    providerSmokeCheck,
+];

package/packages/agent/src/runtime/operations/health.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HealthChecker — the runtime-operations health gate.
+ *
+ * Reload strategies (hot/warm/cold) call `runForRuntime(newRuntime)` after
+ * applying their change. Promotion to primary is allowed only when every
+ * REQUIRED check passes. Optional checks surface in the report's `failed[]`
+ * but never flip `ok` to false.
+ *
+ * Execution model:
+ *   - All registered checks run in parallel (Promise.allSettled).
+ *   - Each check's `run(runtime)` is wrapped in a Promise.race against a
+ *     per-check timeout sentinel (`check.timeoutMs`).
+ *   - One slow optional check cannot block required checks from finishing.
+ *
+ * Logging prefix: `[runtime-ops:health]`.
+ */
+import { type AgentRuntime } from "@elizaos/core";
+import type { HealthCheck, HealthCheckReport } from "./types.js";
+export declare class HealthChecker {
+    private readonly checks;
+    register(check: HealthCheck): void;
+    unregister(name: string): void;
+    /** Internal — exposed for tests so they can assert deterministic state. */
+    list(): readonly HealthCheck[];
+    runForRuntime(runtime: AgentRuntime): Promise<HealthCheckReport>;
+}
+/**
+ * Lazy per-process singleton, pre-registered with the four built-in checks.
+ * Tests can construct their own `HealthChecker` directly.
+ */
+export declare function getDefaultHealthChecker(): HealthChecker;
+//# sourceMappingURL=health.d.ts.map

package/packages/agent/src/runtime/operations/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/health.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAU,MAAM,eAAe,CAAC;AAE1D,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EAElB,MAAM,YAAY,CAAC;AAWpB,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IAEzD,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAiBlC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI9B,2EAA2E;IAC3E,IAAI,IAAI,SAAS,WAAW,EAAE;IAIxB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC;CA8DvE;AA2DD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,aAAa,CASvD"}

package/packages/agent/src/runtime/operations/health.js

@@ -0,0 +1,151 @@
+/**
+ * HealthChecker — the runtime-operations health gate.
+ *
+ * Reload strategies (hot/warm/cold) call `runForRuntime(newRuntime)` after
+ * applying their change. Promotion to primary is allowed only when every
+ * REQUIRED check passes. Optional checks surface in the report's `failed[]`
+ * but never flip `ok` to false.
+ *
+ * Execution model:
+ *   - All registered checks run in parallel (Promise.allSettled).
+ *   - Each check's `run(runtime)` is wrapped in a Promise.race against a
+ *     per-check timeout sentinel (`check.timeoutMs`).
+ *   - One slow optional check cannot block required checks from finishing.
+ *
+ * Logging prefix: `[runtime-ops:health]`.
+ */
+import { logger } from "@elizaos/core";
+import { builtInHealthChecks } from "./health-checks.js";
+const LOG_PREFIX = "[runtime-ops:health]";
+export class HealthChecker {
+    checks = new Map();
+    register(check) {
+        if (!check || typeof check.name !== "string" || check.name.length === 0) {
+            throw new Error(`${LOG_PREFIX} register: check.name is required`);
+        }
+        if (typeof check.run !== "function") {
+            throw new Error(`${LOG_PREFIX} register: check.run must be a function (${check.name})`);
+        }
+        if (typeof check.timeoutMs !== "number" || check.timeoutMs <= 0) {
+            throw new Error(`${LOG_PREFIX} register: check.timeoutMs must be > 0 (${check.name})`);
+        }
+        this.checks.set(check.name, check);
+    }
+    unregister(name) {
+        this.checks.delete(name);
+    }
+    /** Internal — exposed for tests so they can assert deterministic state. */
+    list() {
+        return Array.from(this.checks.values());
+    }
+    async runForRuntime(runtime) {
+        const registered = Array.from(this.checks.values());
+        if (registered.length === 0) {
+            return { passed: [], failed: [], ok: true };
+        }
+        const settled = await Promise.allSettled(registered.map((check) => runOne(check, runtime)));
+        const passed = [];
+        const failed = [];
+        settled.forEach((res, idx) => {
+            const check = registered[idx];
+            if (res.status === "fulfilled") {
+                const { name, required, durationMs, result } = res.value;
+                if (result.ok === true) {
+                    passed.push({ name, durationMs });
+                }
+                else {
+                    failed.push({
+                        name,
+                        required,
+                        reason: result.reason,
+                        durationMs,
+                    });
+                }
+            }
+            else {
+                // Should never hit — runOne catches everything — but fail safe.
+                failed.push({
+                    name: check.name,
+                    required: check.required,
+                    reason: `internal: ${describeError(res.reason)}`,
+                    durationMs: 0,
+                });
+            }
+        });
+        const ok = failed.every((f) => f.required === false);
+        if (failed.length > 0) {
+            logger.warn(`${LOG_PREFIX} report ok=${ok} passed=${passed.length} failed=${failed.length}`);
+            for (const f of failed) {
+                logger.warn(`${LOG_PREFIX} failed name=${f.name} required=${f.required} reason=${f.reason} durationMs=${f.durationMs}`);
+            }
+        }
+        else {
+            logger.debug(`${LOG_PREFIX} report ok=true passed=${passed.length} failed=0`);
+        }
+        return { passed, failed, ok };
+    }
+}
+async function runOne(check, runtime) {
+    const startedAt = Date.now();
+    let timeoutHandle;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => {
+            resolve({
+                ok: false,
+                reason: `timeout after ${check.timeoutMs}ms`,
+            });
+        }, check.timeoutMs);
+    });
+    try {
+        const result = await Promise.race([
+            Promise.resolve()
+                .then(() => check.run(runtime))
+                .catch((err) => ({
+                ok: false,
+                reason: `threw: ${describeError(err)}`,
+                cause: err,
+            })),
+            timeoutPromise,
+        ]);
+        return {
+            name: check.name,
+            required: check.required,
+            durationMs: Date.now() - startedAt,
+            result,
+        };
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
+}
+function describeError(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === "string")
+        return err;
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+// ---------------------------------------------------------------------------
+// Default singleton. Lazy, swappable in tests.
+// ---------------------------------------------------------------------------
+let cachedDefault = null;
+/**
+ * Lazy per-process singleton, pre-registered with the four built-in checks.
+ * Tests can construct their own `HealthChecker` directly.
+ */
+export function getDefaultHealthChecker() {
+    if (!cachedDefault) {
+        const checker = new HealthChecker();
+        for (const check of builtInHealthChecks) {
+            checker.register(check);
+        }
+        cachedDefault = checker;
+    }
+    return cachedDefault;
+}

package/packages/agent/src/runtime/operations/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * RuntimeOperation public surface.
+ *
+ * Implementations are sibling files; this barrel keeps consumers off the
+ * individual paths.
+ */
+export { type ClassifyContext, classifyOperation, defaultClassifier, } from "./classifier.js";
+export type { ColdStrategyOptions } from "./cold-strategy.js";
+export { createColdStrategy } from "./cold-strategy.js";
+export { getDefaultHealthChecker, HealthChecker } from "./health.js";
+export { builtInHealthChecks, dbConnectionCheck, essentialServicesCheck, providerSmokeCheck, runtimeReadyCheck, } from "./health-checks.js";
+export { DefaultRuntimeOperationManager, type DefaultRuntimeOperationManagerOptions, type IntentClassifier, } from "./manager.js";
+export { createHotStrategy, type HotStrategyDeps } from "./reload-hot.js";
+export { FilesystemRuntimeOperationRepository, getDefaultRepository, } from "./repository.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/runtime/operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,eAAe,EACpB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,8BAA8B,EAC9B,KAAK,qCAAqC,EAC1C,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EACL,oCAAoC,EACpC,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/packages/agent/src/runtime/operations/index.js

@@ -0,0 +1,14 @@
+/**
+ * RuntimeOperation public surface.
+ *
+ * Implementations are sibling files; this barrel keeps consumers off the
+ * individual paths.
+ */
+export { classifyOperation, defaultClassifier, } from "./classifier.js";
+export { createColdStrategy } from "./cold-strategy.js";
+export { getDefaultHealthChecker, HealthChecker } from "./health.js";
+export { builtInHealthChecks, dbConnectionCheck, essentialServicesCheck, providerSmokeCheck, runtimeReadyCheck, } from "./health-checks.js";
+export { DefaultRuntimeOperationManager, } from "./manager.js";
+export { createHotStrategy } from "./reload-hot.js";
+export { FilesystemRuntimeOperationRepository, getDefaultRepository, } from "./repository.js";
+export * from "./types.js";