@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/runtime/mobile-dns.js

@@ -0,0 +1,258 @@
+import dns from "node:dns";
+import http from "node:http";
+import https from "node:https";
+import net from "node:net";
+import zlib from "node:zlib";
+/**
+ * Public resolvers the on-device agent dials directly. Android/iOS expose no
+ * `/etc/resolv.conf` (DNS is brokered by the OS resolver — netd on Android),
+ * which the musl-linked bun agent process can't use, so without explicit
+ * nameservers every outbound request (cloud auth/inference, model catalog,
+ * connector APIs) fails with "Unable to connect. Is the computer able to access
+ * the url?". Cloudflare + Google, so a single provider outage doesn't strand the
+ * agent.
+ */
+const MOBILE_DNS_SERVERS = ["1.1.1.1", "8.8.8.8"];
+let configured = false;
+function isMobilePlatform() {
+    const platform = process.env.ELIZA_PLATFORM?.toLowerCase();
+    return platform === "android" || platform === "ios";
+}
+/** A real external hostname needing resolution (not an IP literal or loopback). */
+function needsResolution(hostname) {
+    if (!hostname)
+        return false;
+    if (net.isIP(hostname) !== 0)
+        return false;
+    return hostname !== "localhost";
+}
+/**
+ * Point the agent's DNS at public resolvers when running on a mobile device that
+ * has no system resolv.conf. Idempotent; a no-op on every non-mobile platform.
+ *
+ * Three layers, because Bun resolves over multiple paths:
+ *  1. `dns.setServers` on the default resolver — `dns.resolve*` consumers.
+ *  2. a `dns.lookup` / `dns.promises.lookup` patch backed by an explicit-server
+ *     resolver — undici/`http(s).Agent` consumers that resolve via `lookup`.
+ *     IP literals and `localhost` pass straight through so loopback (the agent's
+ *     own API + the device bridge) is untouched.
+ *  3. a `globalThis.fetch` wrapper that routes EXTERNAL https/http hostnames
+ *     through `node:https`/`node:http` with the explicit-server `lookup`. Bun's
+ *     native `fetch` ignores layers 1+2 (it reads only `/etc/resolv.conf`), but
+ *     `node:https` honors a custom `lookup` — the same mechanism the model
+ *     downloader already relies on. Loopback/IP requests keep using native fetch.
+ */
+export function configureMobileDnsIfNeeded() {
+    if (configured || !isMobilePlatform())
+        return;
+    configured = true;
+    try {
+        dns.setServers([...MOBILE_DNS_SERVERS]);
+    }
+    catch {
+        // older/locked-down resolvers may reject setServers; layers 2+3 cover us.
+    }
+    const resolver = new dns.Resolver();
+    try {
+        resolver.setServers([...MOBILE_DNS_SERVERS]);
+    }
+    catch {
+        return;
+    }
+    const lookup = ((hostname, options, callback) => {
+        const cb = (typeof options === "function" ? options : callback);
+        const opts = (typeof options === "function" ? {} : (options ?? {}));
+        const literal = net.isIP(hostname);
+        const direct = literal !== 0
+            ? { address: hostname, family: literal }
+            : hostname === "localhost"
+                ? { address: "127.0.0.1", family: 4 }
+                : null;
+        if (direct) {
+            cb(null, opts.all
+                ? [{ address: direct.address, family: direct.family }]
+                : direct.address, direct.family);
+            return;
+        }
+        resolver.resolve4(hostname, (error, addresses) => {
+            if (error || addresses.length === 0) {
+                cb(error ??
+                    Object.assign(new Error(`No A record for ${hostname}`), {
+                        code: "ENOTFOUND",
+                    }), undefined, undefined);
+                return;
+            }
+            cb(null, opts.all
+                ? addresses.map((address) => ({ address, family: 4 }))
+                : addresses[0], 4);
+        });
+    });
+    dns.lookup = lookup;
+    dns.promises.lookup = ((hostname, options) => new Promise((resolve, reject) => {
+        lookup(hostname, options ?? {}, (err, address, family) => {
+            if (err)
+                reject(err);
+            else
+                resolve(options?.all ? address : { address, family });
+        });
+    }));
+    installFetchOverNodeHttp(lookup);
+}
+/**
+ * Replace `globalThis.fetch` for external hostnames with a `node:http(s)`-backed
+ * implementation that honors the custom DNS `lookup`. Loopback/IP requests fall
+ * through to the original native fetch.
+ */
+function installFetchOverNodeHttp(lookup) {
+    const nativeFetch = globalThis.fetch;
+    if (typeof nativeFetch !== "function")
+        return;
+    const wrapped = async (input, init) => {
+        let url;
+        try {
+            url =
+                input instanceof URL
+                    ? input
+                    : new URL(typeof input === "string" ? input : input.url);
+        }
+        catch {
+            return nativeFetch(input, init);
+        }
+        const isHttp = url.protocol === "https:" || url.protocol === "http:";
+        if (!isHttp || !needsResolution(url.hostname)) {
+            return nativeFetch(input, init);
+        }
+        return fetchViaNode(url, input, init, lookup, 0);
+    };
+    // Carry over `fetch.preconnect` so the wrapper still satisfies `typeof fetch`.
+    globalThis.fetch = Object.assign(wrapped, {
+        preconnect: nativeFetch.preconnect.bind(nativeFetch),
+    });
+}
+async function fetchViaNode(url, input, init, lookup, redirectCount) {
+    if (redirectCount > 8)
+        throw new TypeError("Too many redirects");
+    // Merge init with a Request input (init wins), so callers passing a Request work.
+    const req = input instanceof Request && !(input instanceof URL) ? input : undefined;
+    const method = (init?.method ?? req?.method ?? "GET").toUpperCase();
+    const headers = new Headers(init?.headers ?? req?.headers ?? undefined);
+    const signal = init?.signal ?? req?.signal ?? undefined;
+    // Buffer the request body (agent payloads are small JSON/text).
+    let body;
+    const rawBody = init?.body ?? (req ? await req.clone().arrayBuffer() : undefined);
+    if (rawBody != null && method !== "GET" && method !== "HEAD") {
+        if (typeof rawBody === "string")
+            body = Buffer.from(rawBody);
+        else if (rawBody instanceof ArrayBuffer)
+            body = Buffer.from(rawBody);
+        else if (ArrayBuffer.isView(rawBody))
+            body = Buffer.from(rawBody.buffer, rawBody.byteOffset, rawBody.byteLength);
+        else
+            body = Buffer.from(await new Response(rawBody).arrayBuffer());
+        if (!headers.has("content-length"))
+            headers.set("content-length", String(body.length));
+    }
+    const transport = url.protocol === "https:" ? https : http;
+    const headerObj = {};
+    headers.forEach((v, k) => {
+        headerObj[k] = v;
+    });
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            request.destroy(new DOMException("The operation was aborted.", "AbortError"));
+        };
+        const request = transport.request(url, { method, headers: headerObj, lookup }, (res) => {
+            const status = res.statusCode ?? 0;
+            const location = res.headers.location;
+            if (location && [301, 302, 303, 307, 308].includes(status)) {
+                res.resume();
+                const nextUrl = new URL(location, url);
+                const nextInit = { ...init, headers: headerObj };
+                // Carry the abort signal across the redirect (the original may have
+                // arrived as a Request, so init.signal can be absent).
+                if (signal)
+                    nextInit.signal = signal;
+                if (status === 303 ||
+                    ((status === 301 || status === 302) && method === "POST")) {
+                    // Redirect-to-GET: drop the body AND its now-wrong framing headers,
+                    // otherwise the next GET advertises a Content-Length with no body
+                    // and mis-frames the connection.
+                    nextInit.method = "GET";
+                    delete nextInit.body;
+                    delete headerObj["content-length"];
+                    delete headerObj["content-type"];
+                }
+                else {
+                    // Body-preserving redirect (307/308, or a non-POST 301/302): carry
+                    // the resolved method and the already-buffered body forward — they
+                    // may have come from a Request object, so init.method/body are unset
+                    // and would otherwise silently degrade to an empty GET.
+                    nextInit.method = method;
+                    // Copy into a fresh-ArrayBuffer Uint8Array so it satisfies BodyInit
+                    // (a Buffer is ArrayBufferLike-backed); payloads here are small.
+                    if (body)
+                        nextInit.body = new Uint8Array(body);
+                }
+                resolve(fetchViaNode(nextUrl, nextUrl, nextInit, lookup, redirectCount + 1));
+                return;
+            }
+            const enc = String(res.headers["content-encoding"] ?? "").toLowerCase();
+            const decoded = enc === "gzip"
+                ? res.pipe(zlib.createGunzip())
+                : enc === "deflate"
+                    ? res.pipe(zlib.createInflate())
+                    : enc === "br"
+                        ? res.pipe(zlib.createBrotliDecompress())
+                        : res;
+            const respHeaders = new Headers();
+            for (const [k, v] of Object.entries(res.headers)) {
+                if (v == null)
+                    continue;
+                // strip hop-by-hop / now-invalid framing headers after decode
+                if ([
+                    "content-encoding",
+                    "content-length",
+                    "transfer-encoding",
+                ].includes(k))
+                    continue;
+                for (const item of Array.isArray(v) ? v : [v])
+                    respHeaders.append(k, item);
+            }
+            const stream = new ReadableStream({
+                start(controller) {
+                    decoded.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+                    decoded.on("end", () => controller.close());
+                    decoded.on("error", (err) => controller.error(err));
+                },
+                cancel() {
+                    res.destroy();
+                },
+            });
+            const response = new Response(status === 204 || status === 304 ? null : stream, {
+                status,
+                statusText: res.statusMessage ?? "",
+                headers: respHeaders,
+            });
+            Object.defineProperty(response, "url", { value: url.toString() });
+            resolve(response);
+        });
+        request.on("error", reject);
+        if (signal) {
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener("abort", onAbort, { once: true });
+                // `{ once: true }` only detaches after firing; for a request that
+                // completes normally the listener would leak on the (long-lived)
+                // caller signal, so remove it when the request settles.
+                request.on("close", () => {
+                    signal.removeEventListener("abort", onAbort);
+                });
+            }
+        }
+        if (body)
+            request.write(body);
+        request.end();
+    });
+}

package/runtime/model-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-resolution.d.ts","sourceRoot":"","sources":["../../src/runtime/model-resolution.ts"],"names":[],"mappings":""}

package/runtime/model-resolution.js

@@ -0,0 +1,55 @@
+import { getFirstRunProviderOption, normalizeFirstRunProviderId, resolveServiceRoutingInConfig, } from "@elizaos/shared";
+function trimEnvString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveProviderIdFromSelectionHint(value) {
+    const trimmed = trimEnvString(value);
+    if (!trimmed)
+        return undefined;
+    return (normalizeFirstRunProviderId(trimmed) ??
+        normalizeFirstRunProviderId(trimmed.split("/", 1)[0]) ??
+        undefined);
+}
+/**
+ * Resolve the primary model identifier from Eliza config.
+ *
+ * Eliza stores the model under `agents.defaults.model.primary` as an
+ * AgentModelListConfig object. Returns undefined when no model is
+ * explicitly configured (elizaOS falls back to whichever model
+ * plugin is loaded).
+ */
+/** @internal Exported for testing. */
+export function resolvePrimaryModel(config) {
+    const modelConfig = config.agents?.defaults?.model;
+    if (!modelConfig)
+        return undefined;
+    // AgentDefaultsConfig.model is AgentModelListConfig: { primary?, fallbacks? }
+    return modelConfig.primary;
+}
+/** @internal Exported for testing. */
+export function resolvePreferredProviderId(config) {
+    const llmText = resolveServiceRoutingInConfig(config)?.llmText;
+    const backend = normalizeFirstRunProviderId(llmText?.backend);
+    if (llmText?.transport === "cloud-proxy" && backend === "elizacloud") {
+        return "elizacloud";
+    }
+    if (llmText?.transport === "direct") {
+        const directProvider = backend && backend !== "elizacloud" ? backend : undefined;
+        return (directProvider ?? resolveProviderIdFromSelectionHint(llmText.primaryModel));
+    }
+    if (llmText?.transport === "remote") {
+        const remoteProvider = backend && backend !== "elizacloud" ? backend : undefined;
+        return (remoteProvider ?? resolveProviderIdFromSelectionHint(llmText.primaryModel));
+    }
+    return resolveProviderIdFromSelectionHint(resolvePrimaryModel(config));
+}
+/** @internal Exported for testing. */
+export function resolvePreferredProviderPluginName(config) {
+    const providerId = resolvePreferredProviderId(config);
+    return providerId
+        ? getFirstRunProviderOption(providerId)?.pluginName
+        : undefined;
+}

package/runtime/native-runtime-features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-runtime-features.d.ts","sourceRoot":"","sources":["../../src/runtime/native-runtime-features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAQlD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAMzE;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAMtE"}

package/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/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 { getFirstRunProviderFamily } from "@elizaos/shared";
+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 = getFirstRunProviderFamily(target);
+    const currentFamily = getFirstRunProviderFamily(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/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,EAGV,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,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,CA+B5E"}

package/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;AA6BjE,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQlD;AAMD,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/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;AAiDD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,aAAa,CASvD"}

package/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;AAC3B,OAAO,EACL,qCAAqC,EACrC,qBAAqB,EACrB,cAAc,EACd,UAAU,EACV,aAAa,EACb,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACrB,KAAK,SAAS,EACd,yBAAyB,GAC1B,MAAM,mBAAmB,CAAC"}

package/runtime/operations/manager.d.ts

@@ -0,0 +1,70 @@
+/**
+ * DefaultRuntimeOperationManager — the single use case for state-changing
+ * lifecycle actions against the live runtime.
+ *
+ * Lifecycle:
+ *   1. Caller (route layer) hands us an OperationIntent (already validated).
+ *   2. We classify the intent into a ReloadTier.
+ *   3. If an op is already active we reject with `rejected-busy`. If an
+ *      idempotency key matches a record within retention we return
+ *      `deduped`. Otherwise we accept synchronously and run the op
+ *      asynchronously on the next microtask.
+ *   4. Each phase mutation is appended to the repo. The repo's active-op
+ *      slot is the single-flight gate; no extra in-memory mutex is used
+ *      across operations, but the manager serializes its own
+ *      `executeOperation` calls via a Promise chain.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { ClassifyContext } from "./classifier.ts";
+import type { HealthChecker } from "./health.ts";
+import type { OperationIntent, ReloadStrategy, ReloadTier, RuntimeOperation, RuntimeOperationListOptions, RuntimeOperationManager, RuntimeOperationRepository, StartOperationOutcome, StartOperationRequest } from "./types.ts";
+export type IntentClassifier = (intent: OperationIntent, ctx: ClassifyContext) => ReloadTier;
+export interface DefaultRuntimeOperationManagerOptions {
+    repository: RuntimeOperationRepository;
+    /**
+     * Resolves the *current* live runtime. Called per-operation so the
+     * manager always sees the latest reference (cold ops swap it).
+     */
+    runtime: () => AgentRuntime | null;
+    /**
+     * Snapshots the live config slice the classifier needs. Called once per
+     * `start()` so the classifier sees the state at submission time, not at
+     * execution time (which may be after another op completes).
+     */
+    classifyContext: () => ClassifyContext;
+    /**
+     * Defaults to `() => "cold"` (conservative). Wire `defaultClassifier`
+     * from `./classifier.js` to enable hot/warm tiering.
+     */
+    classifier?: IntentClassifier;
+    healthChecker: HealthChecker;
+    /**
+     * Tier → strategy. Cold is the conservative baseline; warm/hot strategies
+     * are registered by hosts that support lighter-weight reload paths.
+     */
+    strategies: Partial<Record<ReloadTier, ReloadStrategy>>;
+}
+export declare class DefaultRuntimeOperationManager implements RuntimeOperationManager {
+    private readonly repository;
+    private readonly runtime;
+    private readonly classifyContext;
+    private readonly classifier;
+    private readonly healthChecker;
+    private readonly strategies;
+    /**
+     * Serializes `executeOperation` invocations within a single process.
+     * The repo's active-op slot is the cross-process gate.
+     */
+    private executionChain;
+    private startChain;
+    constructor(opts: DefaultRuntimeOperationManagerOptions);
+    start(req: StartOperationRequest): Promise<StartOperationOutcome>;
+    private startLocked;
+    get(id: string): Promise<RuntimeOperation | null>;
+    list(opts?: RuntimeOperationListOptions): Promise<RuntimeOperation[]>;
+    findActive(): Promise<RuntimeOperation | null>;
+    private scheduleExecution;
+    private executeOperation;
+    private failOperation;
+}
+//# sourceMappingURL=manager.d.ts.map

package/runtime/operations/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../src/runtime/operations/manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAGV,eAAe,EAEf,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,gBAAgB,GAAG,CAC7B,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,eAAe,KACjB,UAAU,CAAC;AAEhB,MAAM,WAAW,qCAAqC;IACpD,UAAU,EAAE,0BAA0B,CAAC;IACvC;;;OAGG;IACH,OAAO,EAAE,MAAM,YAAY,GAAG,IAAI,CAAC;IACnC;;;;OAIG;IACH,eAAe,EAAE,MAAM,eAAe,CAAC;IACvC;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,aAAa,EAAE,aAAa,CAAC;IAC7B;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;CACzD;AASD,qBAAa,8BAA+B,YAAW,uBAAuB;IAC5E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IACpD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAwB;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8C;IACzE;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,UAAU,CAAoC;gBAE1C,IAAI,EAAE,qCAAqC;IASjD,KAAK,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC;YAgBzD,WAAW;IA0DnB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAIjD,IAAI,CAAC,IAAI,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAIrE,UAAU,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAIpD,OAAO,CAAC,iBAAiB;YAUX,gBAAgB;YAsGhB,aAAa;CAa5B"}