@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

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

@@ -0,0 +1,20 @@
+export * from "./advanced-capabilities-config.ts";
+export * from "./conversation-compactor.ts";
+export * from "./conversation-compactor.types.ts";
+export * from "./agent-event-service.ts";
+export * from "./eliza.ts";
+export * from "./eliza-plugin.ts";
+export * from "./embedding-presets.ts";
+export * from "./onboarding-names.ts";
+export * from "./owner-entity.ts";
+export * from "./plugin-collector.ts";
+export * from "./plugin-lifecycle.ts";
+export { getLastFailedPluginNames, resolvePlugins } from "./plugin-resolver.ts";
+export * from "./plugin-types.ts";
+export * from "./release-plugin-policy.ts";
+export * from "./roles.ts";
+export * from "./trajectory-internals.ts";
+export * from "./trajectory-persistence.ts";
+export * from "./trajectory-query.ts";
+export * from "./version.ts";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAChF,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC"}

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

@@ -0,0 +1,19 @@
+export * from "./advanced-capabilities-config.js";
+export * from "./conversation-compactor.js";
+export * from "./conversation-compactor.types.js";
+export * from "./agent-event-service.js";
+export * from "./eliza.js";
+export * from "./eliza-plugin.js";
+export * from "./embedding-presets.js";
+export * from "./onboarding-names.js";
+export * from "./owner-entity.js";
+export * from "./plugin-collector.js";
+export * from "./plugin-lifecycle.js";
+export { getLastFailedPluginNames, resolvePlugins } from "./plugin-resolver.js";
+export * from "./plugin-types.js";
+export * from "./release-plugin-policy.js";
+export * from "./roles.js";
+export * from "./trajectory-internals.js";
+export * from "./trajectory-persistence.js";
+export * from "./trajectory-query.js";
+export * from "./version.js";

package/dist/packages/agent/src/runtime/load-plugin-from-vfs.d.ts

@@ -0,0 +1,54 @@
+import type { AgentRuntime } from "@elizaos/core";
+import { PluginCompiler } from "../services/plugin-compiler.ts";
+import type { VirtualFilesystemService } from "../services/virtual-filesystem.ts";
+export interface LoadPluginFromVfsOptions {
+    runtime: AgentRuntime;
+    vfs: VirtualFilesystemService;
+    /** Project id is informational; the VFS already binds to a project. */
+    projectId?: string;
+    /**
+     * Virtual entry path. When `compileFirst` is true, this points at TS/TSX
+     * source. When false, it points at already-built JS.
+     */
+    entry: string;
+    /** Override the compiler output path. Defaults to PluginCompiler's default. */
+    outFile?: string;
+    /** Compile `entry` with `PluginCompiler` first. Default true. */
+    compileFirst?: boolean;
+    /** Optional pre-built compiler instance (useful for tests/DI). */
+    compiler?: PluginCompiler;
+}
+export interface LoadedVfsPlugin {
+    pluginName: string;
+    vfsPath: string;
+    diskPath: string;
+    projectId: string | null;
+    loadedAt: number;
+}
+/**
+ * Compile (optional) → import → register a plugin sourced from a VFS.
+ *
+ * The compiled JS is dynamically imported via `pathToFileURL` with a cache-bust
+ * query so callers can hot-reload by recompiling the same VFS path.
+ */
+export declare function loadPluginFromVfs(options: LoadPluginFromVfsOptions): Promise<{
+    pluginName: string;
+    unloaded: false;
+}>;
+export interface UnloadPluginFromVfsOptions {
+    runtime: AgentRuntime;
+    pluginName: string;
+}
+/**
+ * Unload a plugin previously registered via `loadPluginFromVfs`. Delegates to
+ * the runtime's `unloadPlugin` (installed by `installRuntimePluginLifecycle`).
+ */
+export declare function unloadPluginFromVfs(options: UnloadPluginFromVfsOptions): Promise<{
+    pluginName: string;
+    unloaded: boolean;
+}>;
+/** Read-only view of plugins currently tracked as loaded from VFS. */
+export declare function getLoadedVfsPlugins(): readonly LoadedVfsPlugin[];
+/** Test helper — clears the in-memory tracking map. */
+export declare function _resetLoadedVfsPluginsForTests(): void;
+//# sourceMappingURL=load-plugin-from-vfs.d.ts.map

package/dist/packages/agent/src/runtime/load-plugin-from-vfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-plugin-from-vfs.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/load-plugin-from-vfs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAElF,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,wBAAwB,CAAC;IAC9B,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,CAAC,CAmDlD;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAiBpD;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,IAAI,SAAS,eAAe,EAAE,CAEhE;AAED,uDAAuD;AACvD,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/packages/agent/src/runtime/load-plugin-from-vfs.js

@@ -0,0 +1,86 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { pathToFileURL } from "node:url";
+import { PluginCompiler } from "../services/plugin-compiler.js";
+const loadedPlugins = new Map();
+/**
+ * Compile (optional) → import → register a plugin sourced from a VFS.
+ *
+ * The compiled JS is dynamically imported via `pathToFileURL` with a cache-bust
+ * query so callers can hot-reload by recompiling the same VFS path.
+ */
+export async function loadPluginFromVfs(options) {
+    const { runtime, vfs, entry, outFile, compileFirst = true, compiler, } = options;
+    if (typeof runtime.registerPlugin !== "function") {
+        throw new Error("loadPluginFromVfs: runtime.registerPlugin is not available");
+    }
+    let importPath = entry;
+    if (compileFirst) {
+        const compilerInstance = compiler ?? new PluginCompiler();
+        const compileResult = await compilerInstance.compile({
+            vfs,
+            entry,
+            ...(outFile !== undefined ? { outFile } : {}),
+        });
+        importPath = compileResult.outFile;
+    }
+    const diskPath = vfs.resolveDiskPath(importPath);
+    // `?t=` cache-busts Node's ESM loader so a recompile reloads the module.
+    const moduleUrl = `${pathToFileURL(diskPath).href}?t=${Date.now()}`;
+    const mod = (await import(__rewriteRelativeImportExtension(moduleUrl)));
+    const plugin = extractPlugin(mod);
+    if (!plugin) {
+        throw new Error(`loadPluginFromVfs: no valid plugin export in ${importPath} (expected default export with a string \`name\`, or a named \`plugin\` export)`);
+    }
+    await runtime.registerPlugin(plugin);
+    const record = {
+        pluginName: plugin.name,
+        vfsPath: importPath,
+        diskPath,
+        projectId: options.projectId ?? null,
+        loadedAt: Date.now(),
+    };
+    loadedPlugins.set(plugin.name, record);
+    return { pluginName: plugin.name, unloaded: false };
+}
+/**
+ * Unload a plugin previously registered via `loadPluginFromVfs`. Delegates to
+ * the runtime's `unloadPlugin` (installed by `installRuntimePluginLifecycle`).
+ */
+export async function unloadPluginFromVfs(options) {
+    const { runtime, pluginName } = options;
+    const runtimeWithLifecycle = runtime;
+    if (typeof runtimeWithLifecycle.unloadPlugin !== "function") {
+        throw new Error("unloadPluginFromVfs: runtime.unloadPlugin is not available — ensure installRuntimePluginLifecycle has run");
+    }
+    const result = await runtimeWithLifecycle.unloadPlugin(pluginName);
+    loadedPlugins.delete(pluginName);
+    return { pluginName, unloaded: result != null };
+}
+/** Read-only view of plugins currently tracked as loaded from VFS. */
+export function getLoadedVfsPlugins() {
+    return [...loadedPlugins.values()];
+}
+/** Test helper — clears the in-memory tracking map. */
+export function _resetLoadedVfsPluginsForTests() {
+    loadedPlugins.clear();
+}
+function extractPlugin(mod) {
+    const candidates = [mod.default, mod.plugin, mod];
+    for (const candidate of candidates) {
+        if (candidate &&
+            typeof candidate === "object" &&
+            "name" in candidate &&
+            typeof candidate.name === "string" &&
+            candidate.name.length > 0) {
+            return candidate;
+        }
+    }
+    return null;
+}

package/dist/packages/agent/src/runtime/local-execution-mode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Re-export shim for the canonical runtime execution-mode resolvers.
+ *
+ * The shared package owns the source of truth (`@elizaos/shared`'s
+ * `config/runtime-mode.ts`) because it is the inward-most layer that both
+ * `@elizaos/agent` and the plugins (`plugin-shell`, `plugin-coding-tools`)
+ * can depend on without creating a cycle. This file keeps the historical
+ * import path stable for callers inside the agent package.
+ */
+export { isCloudExecutionMode, type LocalExecutionMode, resolveLocalExecutionMode, resolveRuntimeExecutionMode, type RuntimeExecutionMode, type RuntimeExecutionModeSource, shouldUseSandboxExecution, } from "@elizaos/shared";
+//# sourceMappingURL=local-execution-mode.d.ts.map

package/dist/packages/agent/src/runtime/local-execution-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-execution-mode.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/local-execution-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,yBAAyB,EACzB,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC"}

package/dist/packages/agent/src/runtime/local-execution-mode.js

@@ -0,0 +1,10 @@
+/**
+ * Re-export shim for the canonical runtime execution-mode resolvers.
+ *
+ * The shared package owns the source of truth (`@elizaos/shared`'s
+ * `config/runtime-mode.ts`) because it is the inward-most layer that both
+ * `@elizaos/agent` and the plugins (`plugin-shell`, `plugin-coding-tools`)
+ * can depend on without creating a cycle. This file keeps the historical
+ * import path stable for callers inside the agent package.
+ */
+export { isCloudExecutionMode, resolveLocalExecutionMode, resolveRuntimeExecutionMode, shouldUseSandboxExecution, } from "@elizaos/shared";

package/dist/packages/agent/src/runtime/model-resolution.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-resolution.d.ts.map

package/dist/packages/agent/src/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/dist/packages/agent/src/runtime/model-resolution.js

@@ -0,0 +1,55 @@
+import { getOnboardingProviderOption, normalizeOnboardingProviderId, 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 (normalizeOnboardingProviderId(trimmed) ??
+        normalizeOnboardingProviderId(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 = normalizeOnboardingProviderId(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
+        ? getOnboardingProviderOption(providerId)?.pluginName
+        : undefined;
+}

package/dist/packages/agent/src/runtime/native-runtime-features.d.ts

@@ -0,0 +1,4 @@
+import type { AgentRuntime } from "@elizaos/core";
+export declare function runtimeTrajectoriesEnabled(runtime: AgentRuntime): boolean;
+export declare function runtimeDocumentsEnabled(runtime: AgentRuntime): boolean;
+//# sourceMappingURL=native-runtime-features.d.ts.map

package/dist/packages/agent/src/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/dist/packages/agent/src/runtime/native-runtime-features.js

@@ -0,0 +1,10 @@
+export function runtimeTrajectoriesEnabled(runtime) {
+    const runtimeWithFlags = runtime;
+    return (typeof runtimeWithFlags.isTrajectoriesEnabled === "function" &&
+        runtimeWithFlags.isTrajectoriesEnabled());
+}
+export function runtimeDocumentsEnabled(runtime) {
+    const runtimeWithFlags = runtime;
+    return (typeof runtimeWithFlags.isDocumentsEnabled === "function" &&
+        runtimeWithFlags.isDocumentsEnabled());
+}

package/dist/packages/agent/src/runtime/onboarding-names.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared pool of agent names for onboarding.
+ *
+ * Used by both the CLI first-run flow (eliza.ts) and the
+ * web UI API server (api/server.ts).
+ */
+export declare const DEFAULT_AGENT_NAME = "Eliza";
+export declare const AGENT_NAME_POOL: readonly string[];
+/** Pick `count` unique names, keeping the default agent name first. */
+export declare function pickRandomNames(count: number): string[];
+//# sourceMappingURL=onboarding-names.d.ts.map

package/dist/packages/agent/src/runtime/onboarding-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-names.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/onboarding-names.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,kBAAkB,UAAU,CAAC;AA4D1C,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAG5C,CAAC;AAEF,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAYvD"}

package/dist/packages/agent/src/runtime/onboarding-names.js

@@ -0,0 +1,81 @@
+/**
+ * Shared pool of agent names for onboarding.
+ *
+ * Used by both the CLI first-run flow (eliza.ts) and the
+ * web UI API server (api/server.ts).
+ */
+export const DEFAULT_AGENT_NAME = "Eliza";
+/** Pool of names to sample from during onboarding after the default option. */
+const RANDOM_AGENT_NAME_POOL = [
+    "Reimu",
+    "Sakuya",
+    "Yukari",
+    "Marisa",
+    "Youmu",
+    "Koakuma",
+    "Reisen",
+    "Yuyuko",
+    "Aya",
+    "Ran",
+    "Sanae",
+    "Suika",
+    "Koishi",
+    "Nue",
+    "Mokou",
+    "Satori",
+    "Remilia",
+    "Suwako",
+    "Momiji",
+    "Tenshi",
+    "Kaguya",
+    "Komachi",
+    "Nitori",
+    "Charlotte",
+    "Kasen",
+    "Mima",
+    "Yuuka",
+    "Kogasa",
+    "Rin",
+    "Tewi",
+    "Eirin",
+    "Hina",
+    "Kagerou",
+    "Sumireko",
+    "Kokoro",
+    "Mamizou",
+    "Rinnosuke",
+    "Yumemi",
+    "Akyuu",
+    "Kanako",
+    "Hatsune",
+    "Shinki",
+    "Shion",
+    "Daiyousei",
+    "Iku",
+    "Miya",
+    "Mai",
+    "Meira",
+    "Murasa",
+    "Usagi",
+    "Rei",
+    "Yumi",
+    "Miku",
+    "Kira",
+];
+export const AGENT_NAME_POOL = [
+    DEFAULT_AGENT_NAME,
+    ...RANDOM_AGENT_NAME_POOL,
+];
+/** Pick `count` unique names, keeping the default agent name first. */
+export function pickRandomNames(count) {
+    const clamped = Math.max(0, Math.min(count, AGENT_NAME_POOL.length));
+    if (clamped === 0) {
+        return [];
+    }
+    const pool = [...RANDOM_AGENT_NAME_POOL];
+    for (let i = pool.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [pool[i], pool[j]] = [pool[j], pool[i]];
+    }
+    return [DEFAULT_AGENT_NAME, ...pool.slice(0, clamped - 1)];
+}

package/dist/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.ts";
+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/dist/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/dist/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 "@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 = 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/dist/packages/agent/src/runtime/operations/cold-strategy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Cold reload strategy — full runtime swap.
+ *
+ * Delegates to the `restartRuntime` closure injected by the API server.
+ * The closure is opaque (it owns shutdown + boot + state swap), so the
+ * strategy reports a single terminal `cold-restart` phase rather than
+ * synthetic timestamp-only sub-phases.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { ReloadStrategy } from "./types.ts";
+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/dist/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,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/dist/packages/agent/src/runtime/operations/cold-strategy.js

@@ -0,0 +1,50 @@
+/**
+ * Cold reload strategy — full runtime swap.
+ *
+ * Delegates to the `restartRuntime` closure injected by the API server.
+ * The closure is opaque (it owns shutdown + boot + state swap), so the
+ * strategy reports a single terminal `cold-restart` phase rather than
+ * synthetic timestamp-only sub-phases.
+ */
+export function createColdStrategy(opts) {
+    const { restartRuntime } = opts;
+    return {
+        tier: "cold",
+        async apply(ctx) {
+            const startedAt = Date.now();
+            const newRuntime = await restartRuntime(describeIntent(ctx.intent));
+            const finishedAt = Date.now();
+            if (!newRuntime) {
+                await ctx.reportPhase({
+                    name: "cold-restart",
+                    status: "failed",
+                    startedAt,
+                    finishedAt,
+                    error: { message: "Cold restart returned null runtime" },
+                });
+                throw new Error("Cold restart returned null runtime");
+            }
+            await ctx.reportPhase({
+                name: "cold-restart",
+                status: "succeeded",
+                startedAt,
+                finishedAt,
+            });
+            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/dist/packages/agent/src/runtime/operations/health-checks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.ts";
+export declare function describeError(err: unknown): string;
+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/dist/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;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"}