@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/runtime/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./advanced-capabilities-config.ts";
+export * from "./agent-event-service.ts";
+export * from "./conversation-compactor.ts";
+export * from "./conversation-compactor.types.ts";
+export * from "./eliza.ts";
+export * from "./eliza-plugin.ts";
+export * from "./first-run-names.ts";
+export * from "./owner-entity.ts";
+export * from "./plugin-collector.ts";
+export * from "./plugin-lifecycle.ts";
+export { getLastFailedPluginDetails, 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/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,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,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/runtime/index.js

@@ -0,0 +1,18 @@
+export * from "./advanced-capabilities-config.js";
+export * from "./agent-event-service.js";
+export * from "./conversation-compactor.js";
+export * from "./conversation-compactor.types.js";
+export * from "./eliza.js";
+export * from "./eliza-plugin.js";
+export * from "./first-run-names.js";
+export * from "./owner-entity.js";
+export * from "./plugin-collector.js";
+export * from "./plugin-lifecycle.js";
+export { getLastFailedPluginDetails, 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/runtime/load-plugin-from-directory.d.ts

@@ -0,0 +1,59 @@
+import type { AgentRuntime } from "@elizaos/core";
+/**
+ * Live-load a plugin from an on-disk directory into the running runtime.
+ *
+ * This is the disk-directory counterpart to {@link loadPluginFromVfs}: it
+ * resolves the directory's built entry point, dynamically imports it, and
+ * registers the plugin via `runtime.registerPlugin` — which (through the
+ * runtime plugin-lifecycle wrapper) also registers any `Plugin.views` so a
+ * freshly scaffolded/edited view plugin actually shows up in the catalog
+ * without an agent restart.
+ *
+ * It is intentionally NOT a build step: the caller (e.g. the VIEWS/APP create
+ * verification pipeline) is expected to have compiled the plugin already, so
+ * the entry must point at built JS, not TS source.
+ */
+export interface LoadPluginFromDirectoryOptions {
+    runtime: AgentRuntime;
+    /** Absolute path to the plugin's package directory. */
+    directory: string;
+    /**
+     * Explicit entry file relative to `directory`. When omitted the loader reads
+     * package.json (`module` → `main` → `exports["."]`) and falls back to
+     * `dist/index.js`.
+     */
+    entry?: string;
+}
+export interface LoadedDirectoryPlugin {
+    pluginName: string;
+    directory: string;
+    diskPath: string;
+    loadedAt: number;
+}
+/**
+ * Import a built plugin directory and register it with the runtime. Returns the
+ * registered plugin name. Re-loading the same directory re-imports a fresh
+ * module (cache-busted) so an edited+rebuilt plugin hot-reloads.
+ */
+export declare function loadPluginFromDirectory(options: LoadPluginFromDirectoryOptions): Promise<{
+    pluginName: string;
+    loaded: true;
+}>;
+export interface UnloadPluginFromDirectoryOptions {
+    runtime: AgentRuntime;
+    pluginName: string;
+}
+/**
+ * Unload a plugin previously registered via {@link loadPluginFromDirectory}.
+ * Delegates to the runtime's `unloadPlugin` (installed by the lifecycle
+ * wrapper), which also deregisters the plugin's views.
+ */
+export declare function unloadPluginFromDirectory(options: UnloadPluginFromDirectoryOptions): Promise<{
+    pluginName: string;
+    unloaded: boolean;
+}>;
+/** Read-only view of plugins currently tracked as loaded from a directory. */
+export declare function getLoadedDirectoryPlugins(): readonly LoadedDirectoryPlugin[];
+/** Test helper — clears the in-memory tracking map. */
+export declare function _resetLoadedDirectoryPluginsForTests(): void;
+//# sourceMappingURL=load-plugin-from-directory.d.ts.map

package/runtime/load-plugin-from-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-plugin-from-directory.d.ts","sourceRoot":"","sources":["../../src/runtime/load-plugin-from-directory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AAG1D;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,YAAY,CAAC;IACtB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAmGD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CA8B/C;AAED,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAepD;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,IAAI,SAAS,qBAAqB,EAAE,CAE5E;AAED,uDAAuD;AACvD,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D"}

package/runtime/load-plugin-from-directory.js

@@ -0,0 +1,143 @@
+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 { readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { extractPlugin } from "./load-plugin-from-vfs.js";
+const loadedPlugins = new Map();
+function asRelativeEntry(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return null;
+    if (path.isAbsolute(value) || value.split(/[\\/]/).includes("..")) {
+        return null;
+    }
+    // Only built JS is loadable here; ignore a TS `main` left over from source.
+    if (value.endsWith(".ts") || value.endsWith(".tsx"))
+        return null;
+    return value;
+}
+function assertPathInsideDirectory(directory, file) {
+    const relative = path.relative(directory, file);
+    if (relative === "" ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative)) {
+        throw new Error(`loadPluginFromDirectory: entry must stay inside plugin directory (${path.relative(process.cwd(), file)})`);
+    }
+}
+async function resolveEntryFile(directory, explicitEntry) {
+    const realDirectory = await realpath(directory);
+    if (explicitEntry) {
+        const relativeEntry = asRelativeEntry(explicitEntry);
+        if (!relativeEntry) {
+            throw new Error("loadPluginFromDirectory: explicit entry must be a relative built JavaScript path inside the plugin directory");
+        }
+        const entry = await realpath(path.resolve(realDirectory, relativeEntry));
+        assertPathInsideDirectory(realDirectory, entry);
+        return entry;
+    }
+    const candidates = [];
+    const pkgRaw = await readFile(path.join(realDirectory, "package.json"), "utf8").catch(() => null);
+    if (pkgRaw) {
+        let pkg = null;
+        try {
+            pkg = JSON.parse(pkgRaw);
+        }
+        catch {
+            pkg = null;
+        }
+        if (pkg) {
+            const fromModule = asRelativeEntry(pkg.module);
+            const fromMain = asRelativeEntry(pkg.main);
+            const exportsField = pkg.exports;
+            let fromExports = null;
+            if (exportsField && typeof exportsField === "object") {
+                const dot = exportsField["."];
+                if (typeof dot === "string")
+                    fromExports = asRelativeEntry(dot);
+                else if (dot && typeof dot === "object") {
+                    const rec = dot;
+                    fromExports =
+                        asRelativeEntry(rec.import) ??
+                            asRelativeEntry(rec.default) ??
+                            asRelativeEntry(rec.require);
+                }
+            }
+            for (const c of [fromModule, fromMain, fromExports]) {
+                if (c)
+                    candidates.push(path.resolve(realDirectory, c));
+            }
+        }
+    }
+    candidates.push(path.resolve(realDirectory, "dist/index.js"));
+    for (const candidate of candidates) {
+        const entry = await realpath(candidate).catch(() => null);
+        if (!entry)
+            continue;
+        assertPathInsideDirectory(realDirectory, entry);
+        const exists = await readFile(entry)
+            .then(() => true)
+            .catch(() => false);
+        if (exists)
+            return entry;
+    }
+    throw new Error(`loadPluginFromDirectory: no built entry found in ${realDirectory} (looked for ${candidates
+        .map((c) => path.relative(realDirectory, c))
+        .join(", ")}). Build the plugin first.`);
+}
+/**
+ * Import a built plugin directory and register it with the runtime. Returns the
+ * registered plugin name. Re-loading the same directory re-imports a fresh
+ * module (cache-busted) so an edited+rebuilt plugin hot-reloads.
+ */
+export async function loadPluginFromDirectory(options) {
+    const { runtime, directory } = options;
+    if (typeof runtime.registerPlugin !== "function") {
+        throw new Error("loadPluginFromDirectory: runtime.registerPlugin is not available — ensure installRuntimePluginLifecycle has run");
+    }
+    const diskPath = await resolveEntryFile(directory, options.entry);
+    // `?t=` cache-busts Node's ESM loader so a rebuild 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(`loadPluginFromDirectory: no valid plugin export in ${diskPath} (expected a default export, a named \`plugin\` export, or a module with a string \`name\`)`);
+    }
+    await runtime.registerPlugin(plugin);
+    loadedPlugins.set(plugin.name, {
+        pluginName: plugin.name,
+        directory: await realpath(directory),
+        diskPath,
+        loadedAt: Date.now(),
+    });
+    return { pluginName: plugin.name, loaded: true };
+}
+/**
+ * Unload a plugin previously registered via {@link loadPluginFromDirectory}.
+ * Delegates to the runtime's `unloadPlugin` (installed by the lifecycle
+ * wrapper), which also deregisters the plugin's views.
+ */
+export async function unloadPluginFromDirectory(options) {
+    const { runtime, pluginName } = options;
+    const runtimeWithLifecycle = runtime;
+    if (typeof runtimeWithLifecycle.unloadPlugin !== "function") {
+        throw new Error("unloadPluginFromDirectory: 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 a directory. */
+export function getLoadedDirectoryPlugins() {
+    return [...loadedPlugins.values()];
+}
+/** Test helper — clears the in-memory tracking map. */
+export function _resetLoadedDirectoryPluginsForTests() {
+    loadedPlugins.clear();
+}

package/runtime/load-plugin-from-vfs.d.ts

@@ -0,0 +1,68 @@
+import type { AgentRuntime, Plugin } 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;
+}
+export interface LoadedVfsPluginView {
+    pluginName: string;
+    vfsPath: 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[];
+/** Public API view that does not expose host filesystem paths. */
+export declare function getLoadedVfsPluginViews(): readonly LoadedVfsPluginView[];
+/** Test helper — clears the in-memory tracking map. */
+export declare function _resetLoadedVfsPluginsForTests(): void;
+/**
+ * Pull a `Plugin` out of an imported module. Accepts a default export, a named
+ * `plugin` export, or the module namespace itself, requiring a non-empty string
+ * `name`. Shared with the disk-directory loader.
+ */
+export declare function extractPlugin(mod: Record<string, unknown>): Plugin | null;
+//# sourceMappingURL=load-plugin-from-vfs.d.ts.map

package/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,EAAE,MAAM,EAAE,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;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,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,kEAAkE;AAClE,wBAAgB,uBAAuB,IAAI,SAAS,mBAAmB,EAAE,CASxE;AAED,uDAAuD;AACvD,wBAAgB,8BAA8B,IAAI,IAAI,CAErD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAczE"}

package/runtime/load-plugin-from-vfs.js

@@ -0,0 +1,100 @@
+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()];
+}
+/** Public API view that does not expose host filesystem paths. */
+export function getLoadedVfsPluginViews() {
+    return [...loadedPlugins.values()].map(({ pluginName, vfsPath, projectId, loadedAt }) => ({
+        pluginName,
+        vfsPath,
+        projectId,
+        loadedAt,
+    }));
+}
+/** Test helper — clears the in-memory tracking map. */
+export function _resetLoadedVfsPluginsForTests() {
+    loadedPlugins.clear();
+}
+/**
+ * Pull a `Plugin` out of an imported module. Accepts a default export, a named
+ * `plugin` export, or the module namespace itself, requiring a non-empty string
+ * `name`. Shared with the disk-directory loader.
+ */
+export 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/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, type RuntimeExecutionMode, type RuntimeExecutionModeSource, resolveLocalExecutionMode, resolveRuntimeExecutionMode, shouldUseSandboxExecution, } from "@elizaos/shared";
+//# sourceMappingURL=local-execution-mode.d.ts.map

package/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,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,yBAAyB,EACzB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC"}

package/runtime/mobile-dns.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 declare function configureMobileDnsIfNeeded(): void;
+//# sourceMappingURL=mobile-dns.d.ts.map

package/runtime/mobile-dns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-dns.d.ts","sourceRoot":"","sources":["../../src/runtime/mobile-dns.ts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAmFjD"}