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

package/runtime/operations/manager.js

@@ -0,0 +1,210 @@
+/**
+ * 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 crypto from "node:crypto";
+import { logger } from "@elizaos/core";
+const DEFAULT_CLASSIFIER = () => "cold";
+function strategyErrorCode(err) {
+    const code = err?.code;
+    return code === "vault-resolve-failed" ? code : "strategy-failed";
+}
+export class DefaultRuntimeOperationManager {
+    repository;
+    runtime;
+    classifyContext;
+    classifier;
+    healthChecker;
+    strategies;
+    /**
+     * Serializes `executeOperation` invocations within a single process.
+     * The repo's active-op slot is the cross-process gate.
+     */
+    executionChain = Promise.resolve();
+    startChain = Promise.resolve();
+    constructor(opts) {
+        this.repository = opts.repository;
+        this.runtime = opts.runtime;
+        this.classifyContext = opts.classifyContext;
+        this.classifier = opts.classifier ?? DEFAULT_CLASSIFIER;
+        this.healthChecker = opts.healthChecker;
+        this.strategies = opts.strategies;
+    }
+    async start(req) {
+        let outcome;
+        const run = this.startChain.then(async () => {
+            outcome = await this.startLocked(req);
+        });
+        this.startChain = run.then(() => undefined, () => undefined);
+        await run;
+        if (!outcome) {
+            throw new Error("[runtime-ops] start did not produce an outcome");
+        }
+        return outcome;
+    }
+    async startLocked(req) {
+        if (req.idempotencyKey) {
+            const existing = await this.repository.findByIdempotencyKey(req.idempotencyKey);
+            if (existing) {
+                logger.info(`[runtime-ops] Idempotent hit for key=${req.idempotencyKey} → ${existing.id}`);
+                return { kind: "deduped", operation: existing };
+            }
+        }
+        const active = await this.repository.findActive();
+        if (active) {
+            logger.info(`[runtime-ops] Rejected new op: active operation in flight ${active.id}`);
+            return { kind: "rejected-busy", activeOperationId: active.id };
+        }
+        // Snapshot the classify context BEFORE prepare() runs: prepare() mutates
+        // the live config to the target provider, so reading currentProvider after
+        // it would always equal the target, so every provider-switch would
+        // classify as "hot" and an unloaded provider plugin (e.g. switching
+        // elizacloud -> cerebras, or onboarding a first provider) would miss the
+        // cold restart that loads it, leaving the runtime with no provider.
+        const ctxBeforePrepare = this.classifyContext();
+        const prepareResult = req.prepare ? await req.prepare() : undefined;
+        const preparedIntent = prepareResult === undefined ? req.intent : prepareResult;
+        const tier = this.classifier(preparedIntent, ctxBeforePrepare);
+        const now = Date.now();
+        const op = {
+            id: crypto.randomUUID(),
+            kind: preparedIntent.kind,
+            intent: preparedIntent,
+            tier,
+            idempotencyKey: req.idempotencyKey,
+            status: "pending",
+            phases: [],
+            startedAt: now,
+        };
+        await this.repository.create(op);
+        logger.info(`[runtime-ops] Accepted op ${op.id} kind=${op.kind} tier=${op.tier}`);
+        // Schedule async; do NOT await. The route caller returns 202
+        // immediately and the client polls /events for status.
+        this.scheduleExecution(op.id);
+        return { kind: "accepted", operation: op };
+    }
+    async get(id) {
+        return this.repository.get(id);
+    }
+    async list(opts) {
+        return this.repository.list(opts);
+    }
+    async findActive() {
+        return this.repository.findActive();
+    }
+    scheduleExecution(id) {
+        this.executionChain = this.executionChain.then(() => this.executeOperation(id).catch((err) => {
+            logger.error(`[runtime-ops] Unhandled error executing op ${id}: ${err instanceof Error ? err.stack : String(err)}`);
+        }));
+    }
+    async executeOperation(id) {
+        const op = await this.repository.get(id);
+        if (!op) {
+            logger.warn(`[runtime-ops] executeOperation: op ${id} not found`);
+            return;
+        }
+        await this.repository.update(id, { status: "running" });
+        // Validation gate (the route layer already validated; this records the
+        // gate boundary so the phase log is complete).
+        const validateAt = Date.now();
+        await this.repository.appendPhase(id, {
+            name: "validate",
+            status: "succeeded",
+            startedAt: validateAt,
+            finishedAt: validateAt,
+        });
+        const strategy = this.strategies[op.tier];
+        if (!strategy) {
+            await this.failOperation(id, {
+                message: `No strategy registered for tier=${op.tier}`,
+                code: "no-strategy-for-tier",
+            });
+            return;
+        }
+        const runtime = this.runtime();
+        if (!runtime) {
+            await this.failOperation(id, {
+                message: "No live runtime available to apply operation",
+                code: "no-runtime",
+            });
+            return;
+        }
+        const reportPhase = (phase) => this.repository.appendPhase(id, phase);
+        let newRuntime;
+        try {
+            newRuntime = await strategy.apply({
+                runtime,
+                intent: op.intent,
+                reportPhase,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[runtime-ops] Strategy failed for op ${id}: ${message}`);
+            await this.failOperation(id, { message, code: strategyErrorCode(err) });
+            return;
+        }
+        // Health-check gate.
+        const healthStart = Date.now();
+        await this.repository.appendPhase(id, {
+            name: "health-check",
+            status: "running",
+            startedAt: healthStart,
+        });
+        const report = await this.healthChecker.runForRuntime(newRuntime);
+        const healthEnd = Date.now();
+        if (!report.ok) {
+            await this.repository.updateLastPhase(id, {
+                status: "failed",
+                finishedAt: healthEnd,
+                detail: {
+                    passed: report.passed,
+                    failed: report.failed,
+                },
+            });
+            // The cold strategy has already swapped the runtime by the time we
+            // observe a failed health check. Surface the failure; restoring the
+            // previous runtime requires a two-phase restart contract with the API
+            // server restart closure.
+            logger.warn(`[runtime-ops] Health check failed for op ${id}`);
+            await this.failOperation(id, {
+                message: "Required health checks failed",
+                code: "health-check-failed",
+            });
+            return;
+        }
+        await this.repository.updateLastPhase(id, {
+            status: "succeeded",
+            finishedAt: healthEnd,
+            detail: {
+                passed: report.passed,
+                failed: report.failed,
+            },
+        });
+        await this.repository.update(id, {
+            status: "succeeded",
+            finishedAt: Date.now(),
+        });
+        logger.info(`[runtime-ops] Operation ${id} succeeded`);
+    }
+    async failOperation(id, error) {
+        await this.repository.update(id, {
+            status: "failed",
+            finishedAt: Date.now(),
+            error,
+        });
+        logger.warn(`[runtime-ops] Operation ${id} failed: ${error.code ?? "unknown"} — ${error.message}`);
+    }
+}

package/runtime/operations/reload-hot.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Hot reload strategy.
+ *
+ * The fast path. Used when the change can be applied by mutating env vars and
+ * (best-effort) notifying plugins via their `applyConfig` lifecycle hook —
+ * no plugin reload, no service teardown, no full runtime swap.
+ *
+ * Bounded ~100ms. Idempotent: calling twice with the same intent is safe;
+ * env vars settle to the same values, notifications are best-effort.
+ *
+ * The strategy delegates env mutation to a caller-supplied `applyProviderEnv`
+ * which wraps the existing first-run env-pump (`applyFirstRunConnectionConfig`
+ * + `createProviderSwitchConnection`). The plugin notify step iterates the
+ * runtime's plugins and invokes `plugin.applyConfig` when present; that hook
+ * is the one defined on the elizaOS Plugin contract for config-only updates.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { SecretsManager } from "@elizaos/vault";
+import type { ProviderSwitchIntent, ReloadStrategy } from "./types.ts";
+export interface HotStrategyDeps {
+    /**
+     * Apply env-var / config mutations for a provider switch. Defaults wrap the
+     * existing first-run env-pump. The wrapper must be idempotent: same intent
+     * in → same env state out.
+     */
+    applyProviderEnv: (intent: ProviderSwitchIntent) => Promise<void>;
+    /**
+     * Best-effort plugin notify. Called after env mutation. Implementations
+     * iterate `runtime.plugins` and call each plugin's `applyConfig` hook (the
+     * elizaOS Plugin contract's config-only update path). Failures here are
+     * logged and surfaced as a warning phase, but do NOT fail the operation —
+     * env was already applied and plugins will pick up the new values on
+     * their next request.
+     */
+    notifyConfigChanged: (runtime: AgentRuntime, change: {
+        kind: string;
+        detail?: Record<string, unknown>;
+    }) => Promise<void>;
+}
+export declare function createHotStrategy(opts?: Partial<HotStrategyDeps> & {
+    secrets?: SecretsManager;
+}): ReloadStrategy;
+//# sourceMappingURL=reload-hot.d.ts.map

package/runtime/operations/reload-hot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload-hot.d.ts","sourceRoot":"","sources":["../../../src/runtime/operations/reload-hot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AAG1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAGV,oBAAoB,EAEpB,cAAc,EACf,MAAM,YAAY,CAAC;AAMpB,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;;;;;OAOG;IACH,mBAAmB,EAAE,CACnB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,KACvD,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAiJD,wBAAgB,iBAAiB,CAC/B,IAAI,GAAE,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,cAAc,CAAA;CAAO,GACjE,cAAc,CAgEhB"}

package/runtime/operations/reload-hot.js

@@ -0,0 +1,181 @@
+/**
+ * Hot reload strategy.
+ *
+ * The fast path. Used when the change can be applied by mutating env vars and
+ * (best-effort) notifying plugins via their `applyConfig` lifecycle hook —
+ * no plugin reload, no service teardown, no full runtime swap.
+ *
+ * Bounded ~100ms. Idempotent: calling twice with the same intent is safe;
+ * env vars settle to the same values, notifications are best-effort.
+ *
+ * The strategy delegates env mutation to a caller-supplied `applyProviderEnv`
+ * which wraps the existing first-run env-pump (`applyFirstRunConnectionConfig`
+ * + `createProviderSwitchConnection`). The plugin notify step iterates the
+ * runtime's plugins and invokes `plugin.applyConfig` when present; that hook
+ * is the one defined on the elizaOS Plugin contract for config-only updates.
+ */
+import { logger } from "@elizaos/core";
+import { formatErrorWithStack } from "@elizaos/shared";
+import { defaultSecretsManager, resolveProviderApiKey, } from "./vault-bridge.js";
+function buildPhase(name, status, startedAt, finishedAt, extra = {}) {
+    return {
+        name,
+        status,
+        startedAt,
+        finishedAt,
+        ...(extra.error ? { error: extra.error } : {}),
+        ...(extra.detail ? { detail: extra.detail } : {}),
+    };
+}
+function describeIntent(intent) {
+    switch (intent.kind) {
+        case "provider-switch":
+            return {
+                kind: "provider-switch",
+                detail: {
+                    provider: intent.provider,
+                    ...(intent.primaryModel ? { primaryModel: intent.primaryModel } : {}),
+                    ...(intent.apiKeyRef ? { apiKeyChanged: true } : {}),
+                },
+            };
+        case "config-reload":
+            return {
+                kind: "config-reload",
+                detail: {
+                    ...(intent.changedPaths
+                        ? { changedPaths: [...intent.changedPaths] }
+                        : {}),
+                },
+            };
+        case "plugin-enable":
+        case "plugin-disable":
+            return {
+                kind: intent.kind,
+                detail: { pluginId: intent.pluginId },
+            };
+        case "restart":
+            return { kind: "restart", detail: { reason: intent.reason } };
+    }
+}
+/**
+ * Default env-pump wrapper. Lazy-imports the first-run env-pump to keep the
+ * dependency graph clean (the operations module sits below the api module
+ * in the layering, but the env-pump genuinely owns the canonical mutation).
+ *
+ * The intent carries `apiKeyRef` (a vault key), not the secret itself. The
+ * vault is consulted here on every hot reload and only the resolved
+ * plaintext is passed downstream to `createProviderSwitchConnection`.
+ */
+function makeDefaultApplyProviderEnv(secrets) {
+    return async (intent) => {
+        const { applyFirstRunConnectionConfig, createProviderSwitchConnection } = await import("../../api/provider-switch-config.js");
+        const { loadElizaConfig, saveElizaConfig } = await import("../../config/config.js");
+        const apiKey = await resolveProviderApiKey({
+            secrets,
+            apiKeyRef: intent.apiKeyRef,
+            caller: "runtime-ops:reload-hot",
+        });
+        const connection = createProviderSwitchConnection({
+            provider: intent.provider,
+            ...(apiKey ? { apiKey } : {}),
+            ...(intent.primaryModel ? { primaryModel: intent.primaryModel } : {}),
+        });
+        if (!connection) {
+            throw new Error(`[runtime-ops] hot reload: invalid provider "${intent.provider}"`);
+        }
+        const config = loadElizaConfig();
+        await applyFirstRunConnectionConfig(config, connection);
+        saveElizaConfig(config);
+    };
+}
+/**
+ * Default plugin notify. Iterates the runtime's plugins and calls
+ * `plugin.applyConfig` when defined. The hook receives the plugin's own
+ * config record (already attached to the plugin instance) and the runtime —
+ * matching the elizaOS Plugin contract.
+ *
+ * If no plugin defines `applyConfig`, this records that env has been set and
+ * plugins will resolve the new values on their next call into the provider
+ * client.
+ */
+async function defaultNotifyConfigChanged(runtime, change) {
+    const plugins = runtime.plugins;
+    let notified = 0;
+    let failures = 0;
+    for (const plugin of plugins) {
+        if (typeof plugin.applyConfig !== "function")
+            continue;
+        try {
+            const pluginConfig = {};
+            if (plugin.config) {
+                for (const [key, value] of Object.entries(plugin.config)) {
+                    if (value === null || value === undefined)
+                        continue;
+                    pluginConfig[key] = String(value);
+                }
+            }
+            await plugin.applyConfig(pluginConfig, runtime);
+            notified += 1;
+        }
+        catch (err) {
+            failures += 1;
+            logger.warn(`[runtime-ops] hot reload: plugin "${plugin.name}" applyConfig failed: ${formatErrorWithStack(err)}`);
+        }
+    }
+    if (notified === 0 && failures === 0) {
+        logger.info(`[runtime-ops] no plugin reload hook found — env applied, plugins will pick up on next request (change=${change.kind})`);
+        return;
+    }
+    logger.info(`[runtime-ops] hot reload: notified ${notified} plugin(s), ${failures} failure(s) (change=${change.kind})`);
+}
+export function createHotStrategy(opts = {}) {
+    const secrets = opts.secrets ?? defaultSecretsManager();
+    const applyProviderEnv = opts.applyProviderEnv ?? makeDefaultApplyProviderEnv(secrets);
+    const notifyConfigChanged = opts.notifyConfigChanged ?? defaultNotifyConfigChanged;
+    return {
+        tier: "hot",
+        async apply(ctx) {
+            const envStarted = Date.now();
+            if (ctx.intent.kind !== "provider-switch") {
+                // Other hot-eligible intents (config-reload over env./vars./models.)
+                // flow through the plugin notify step only — env was already mutated
+                // by whoever scheduled the operation (e.g. the config writer).
+                await ctx.reportPhase(buildPhase("apply-env", "skipped", envStarted, Date.now(), {
+                    detail: { reason: `intent=${ctx.intent.kind}` },
+                }));
+            }
+            else {
+                try {
+                    await applyProviderEnv(ctx.intent);
+                    await ctx.reportPhase(buildPhase("apply-env", "succeeded", envStarted, Date.now(), {
+                        detail: { provider: ctx.intent.provider },
+                    }));
+                }
+                catch (err) {
+                    await ctx.reportPhase(buildPhase("apply-env", "failed", envStarted, Date.now(), {
+                        error: { message: formatErrorWithStack(err) },
+                    }));
+                    throw err;
+                }
+            }
+            const notifyStarted = Date.now();
+            const change = describeIntent(ctx.intent);
+            try {
+                await notifyConfigChanged(ctx.runtime, change);
+                await ctx.reportPhase(buildPhase("notify-plugins", "succeeded", notifyStarted, Date.now(), {
+                    detail: change.detail,
+                }));
+            }
+            catch (err) {
+                // Best-effort: env is already applied, so we surface this as a failed
+                // phase with a warning but do NOT throw — the operation still
+                // succeeds at the manager level.
+                logger.warn(`[runtime-ops] hot reload: notify-plugins failed (env already applied): ${formatErrorWithStack(err)}`);
+                await ctx.reportPhase(buildPhase("notify-plugins", "failed", notifyStarted, Date.now(), {
+                    error: { message: formatErrorWithStack(err) },
+                }));
+            }
+            return ctx.runtime;
+        },
+    };
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../src/runtime/operations/repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAQH,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,2BAA2B,EAC3B,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAepB,MAAM,WAAW,2CAA2C;IAC1D,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA4CD,qBAAa,oCACX,YAAW,0BAA0B;IAErC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4C;IACjE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAGlC,QAAQ,GAAE,MAA0B,EACpC,IAAI,GAAE,2CAAgD;IAWxD,OAAO,CAAC,OAAO;YAMD,UAAU;IAiExB;;;;;;;OAOG;IACG,aAAa,CAAC,GAAG,GAAE,MAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAkC9D,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,cAAc;IAWhB,MAAM,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB3C,MAAM,CACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC,GAC1E,OAAO,CAAC,IAAI,CAAC;IAYV,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAc7D,eAAe,CACnB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC;IAmBV,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAKjD,IAAI,CAAC,IAAI,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAerE,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAYnE,UAAU,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;CAcrD;AAID;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,oCAAoC,CAK3E"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/operations/types.ts"],"names":[],"mappings":"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"}

package/runtime/operations/vault-bridge.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Vault bridge — the only place runtime-ops talks to `@elizaos/vault`.
+ *
+ * Enforces:
+ *   1. The naming convention for provider API key vault entries
+ *      (`providers.<normalizedProvider>.api-key`).
+ *   2. Sensitive flag on every write (so the secret is encrypted at rest).
+ *   3. Caller tagging for the audit log so a reader of
+ *      `<stateDir>/audit/vault.jsonl` can attribute every access to a
+ *      runtime-ops phase.
+ *
+ * The bridge owns NO mutable state. Either pass an explicit
+ * SecretsManager (tests), or call `defaultSecretsManager()` (production)
+ * which constructs a fresh manager backed by the OS-keychain vault.
+ */
+import { type SecretsManager, type Vault } from "@elizaos/vault";
+import type { OperationErrorCode } from "./types.ts";
+export declare class VaultResolveError extends Error {
+    readonly code: OperationErrorCode;
+    constructor(apiKeyRef: string, cause: unknown);
+}
+/** Format a stable vault key into the `vault://<key>` sentinel form. */
+export declare function formatVaultRef(key: string): string;
+/** Type guard: true when `value` is a `vault://<key>` sentinel string. */
+export declare function isVaultRef(value: unknown): value is string;
+/** Extract the underlying vault key from a sentinel; null if malformed. */
+export declare function parseVaultRef(value: string): string | null;
+/** Narrow surface of `Vault` used by the boot resolver and test fakes. */
+export type VaultLike = Pick<Vault, "get" | "has">;
+/**
+ * Walk an env-shaped record and replace `vault://<key>` sentinels with the
+ * resolved vault values. Non-sentinel strings are passed through unchanged;
+ * non-string values are dropped (process.env only accepts strings).
+ *
+ * Returns `missing` for sentinel keys the vault does not contain — callers
+ * should warn but continue (the legacy hydrate-from-config-env path will run
+ * next and may still backfill from non-sentinel sources).
+ */
+export declare function resolveConfigEnvForProcess(envBag: Record<string, unknown> | undefined, vault: VaultLike): Promise<{
+    resolved: Record<string, string>;
+    missing: string[];
+}>;
+/** Stable vault key for a provider API key. */
+export declare function vaultKeyForProviderApiKey(normalizedProvider: string): string;
+/**
+ * Persist a provider API key in the vault under the canonical key name and
+ * return the vault key (the `apiKeyRef`).
+ *
+ * This is the single write path used by `provider-switch-routes.ts`. The
+ * route MUST persist the secret here BEFORE constructing the
+ * `ProviderSwitchIntent` so the intent never carries plaintext.
+ */
+export declare function persistProviderApiKey(opts: {
+    secrets: SecretsManager;
+    normalizedProvider: string;
+    apiKey: string;
+    caller: string;
+}): Promise<string>;
+/**
+ * Resolve a stored API key for the in-memory `process.env` write path.
+ *
+ * Returns `undefined` only when `apiKeyRef` is absent. If a ref is present,
+ * the operation must fail loudly when the vault cannot resolve it; otherwise a
+ * provider switch can appear successful while running with no key or a stale
+ * key from process.env.
+ *
+ * The caller is recorded on each successful read.
+ */
+export declare function resolveProviderApiKey(opts: {
+    secrets: SecretsManager;
+    apiKeyRef: string | undefined;
+    caller: string;
+}): Promise<string | undefined>;
+/**
+ * Lazy default manager. Production code paths construct a fresh manager
+ * the first time runtime-ops needs the vault; tests inject their own.
+ */
+export declare function defaultSecretsManager(): SecretsManager;
+/** Test hook: drop the cached manager. */
+export declare function _resetDefaultSecretsManagerForTesting(): void;
+//# sourceMappingURL=vault-bridge.d.ts.map

package/runtime/operations/vault-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-bridge.d.ts","sourceRoot":"","sources":["../../../src/runtime/operations/vault-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAA0B;gBAE/C,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAQ9C;AAKD,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOlD;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAM1D;AAED,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG1D;AAED,0EAA0E;AAC1E,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AAEnD;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC3C,KAAK,EAAE,SAAS,GACf,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAqBlE;AAED,+CAA+C;AAC/C,wBAAgB,yBAAyB,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAO5E;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,cAAc,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAOlB;AAED;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,cAAc,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAO9B;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,cAAc,CAGtD;AAED,0CAA0C;AAC1C,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D"}

package/runtime/owner-entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner-entity.d.ts","sourceRoot":"","sources":["../../src/runtime/owner-entity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,eAAe,CAAC;AAMvB,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,WAAW,CAAC,GACpD,MAAM,CAGR;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoCxB"}

package/runtime/owner-entity.js

@@ -0,0 +1,34 @@
+import { logger, resolveCanonicalOwnerId, stringToUuid, } from "@elizaos/core";
+export function resolveFallbackOwnerEntityId(runtime) {
+    const agentName = runtime.character.name?.trim() || runtime.agentId;
+    return stringToUuid(`${agentName}-admin-entity`);
+}
+export async function resolveOwnerEntityId(runtime) {
+    const configuredOwnerId = resolveCanonicalOwnerId(runtime);
+    if (configuredOwnerId) {
+        return configuredOwnerId;
+    }
+    try {
+        const roomIds = await runtime.getRoomsForParticipant(runtime.agentId);
+        for (const roomId of roomIds.slice(0, 10)) {
+            try {
+                const room = await runtime.getRoom(roomId);
+                if (!room?.worldId) {
+                    continue;
+                }
+                const world = await runtime.getWorld(room.worldId);
+                const metadata = (world?.metadata ?? {});
+                if (metadata.ownership?.ownerId) {
+                    return metadata.ownership.ownerId;
+                }
+            }
+            catch (error) {
+                logger.debug(`[owner-entity] World ownership lookup failed for room ${roomId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    catch (error) {
+        logger.warn(`[owner-entity] Failed to resolve owner from world metadata; falling back to synthetic owner id: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return resolveFallbackOwnerEntityId(runtime);
+}

package/runtime/pglite-error-compat.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pglite error utilities.
+ *
+ * These are defined locally as an agent compatibility shim for plugin-sql
+ * releases that lack the pglite/errors.ts export. Remove this local copy when
+ * the package dependency guarantees that export.
+ */
+export declare const PGLITE_ERROR_CODES: {
+    readonly ACTIVE_LOCK: "ELIZA_PGLITE_DATA_DIR_IN_USE";
+    readonly CORRUPT_DATA: "ELIZA_PGLITE_CORRUPT_DATA";
+    readonly MANUAL_RESET_REQUIRED: "ELIZA_PGLITE_MANUAL_RESET_REQUIRED";
+};
+export type PgliteErrorCode = (typeof PGLITE_ERROR_CODES)[keyof typeof PGLITE_ERROR_CODES];
+export declare class PgliteInitError extends Error {
+    readonly code: PgliteErrorCode;
+    readonly dataDir?: string;
+    constructor(code: PgliteErrorCode, message: string, options?: {
+        cause?: unknown;
+        dataDir?: string;
+    });
+}
+export declare function createPgliteInitError(code: PgliteErrorCode, message: string, options?: {
+    cause?: unknown;
+    dataDir?: string;
+}): PgliteInitError;
+export declare function getPgliteErrorCode(err: unknown): PgliteErrorCode | null;
+//# sourceMappingURL=pglite-error-compat.d.ts.map

package/runtime/pglite-error-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pglite-error-compat.d.ts","sourceRoot":"","sources":["../../src/runtime/pglite-error-compat.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,kBAAkB;;;;CAIrB,CAAC;AAEX,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAgB,IAAI,EAAE,eAAe,CAAC;IACtC,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC;gBAG/B,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;CAOlD;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,eAAe,CAEjB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAoCvE"}

package/runtime/pglite-error-compat.js

@@ -0,0 +1,53 @@
+/**
+ * Pglite error utilities.
+ *
+ * These are defined locally as an agent compatibility shim for plugin-sql
+ * releases that lack the pglite/errors.ts export. Remove this local copy when
+ * the package dependency guarantees that export.
+ */
+export const PGLITE_ERROR_CODES = {
+    ACTIVE_LOCK: "ELIZA_PGLITE_DATA_DIR_IN_USE",
+    CORRUPT_DATA: "ELIZA_PGLITE_CORRUPT_DATA",
+    MANUAL_RESET_REQUIRED: "ELIZA_PGLITE_MANUAL_RESET_REQUIRED",
+};
+export class PgliteInitError extends Error {
+    code;
+    dataDir;
+    constructor(code, message, options) {
+        super(message, { cause: options?.cause });
+        this.name = "PgliteInitError";
+        this.code = code;
+        this.dataDir = options?.dataDir;
+    }
+}
+export function createPgliteInitError(code, message, options) {
+    return new PgliteInitError(code, message, options);
+}
+export function getPgliteErrorCode(err) {
+    const seen = new Set();
+    let current = err;
+    while (current && !seen.has(current)) {
+        seen.add(current);
+        if (typeof current === "object" &&
+            current !== null &&
+            "code" in current &&
+            typeof current.code === "string") {
+            const code = current.code;
+            if (code === PGLITE_ERROR_CODES.ACTIVE_LOCK ||
+                code === PGLITE_ERROR_CODES.CORRUPT_DATA ||
+                code === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED) {
+                return code;
+            }
+        }
+        if (current instanceof Error) {
+            current = current.cause;
+            continue;
+        }
+        if (typeof current === "object" && current !== null && "cause" in current) {
+            current = current.cause;
+            continue;
+        }
+        break;
+    }
+    return null;
+}