@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/runtime/plugin-lifecycle.js

@@ -0,0 +1,602 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { resolveActionContexts, resolveProviderContexts } from "@elizaos/core";
+import { createToolCallCacheFromConfig, wrapActionWithCache, } from "./tool-call-cache-wrapper.js";
+const pluginRegistrationContext = new AsyncLocalStorage();
+const pluginServiceStartContext = new AsyncLocalStorage();
+const serviceClassOwners = new WeakMap();
+function getRuntimePrivateState(runtime) {
+    return runtime;
+}
+function getPluginOwnershipStore(runtime) {
+    if (!runtime.__elizaPluginOwnership) {
+        runtime.__elizaPluginOwnership = new Map();
+    }
+    return runtime.__elizaPluginOwnership;
+}
+function getOwnershipTarget(runtime, pluginName) {
+    const activeCapture = pluginRegistrationContext.getStore();
+    if (activeCapture && activeCapture.ownership.pluginName === pluginName) {
+        return activeCapture.ownership;
+    }
+    return getPluginOwnershipStore(runtime).get(pluginName) ?? null;
+}
+function pushUniqueRef(items, item) {
+    if (!items.includes(item)) {
+        items.push(item);
+    }
+}
+function pushUniqueString(items, value) {
+    if (!items.includes(value)) {
+        items.push(value);
+    }
+}
+function getPluginContexts(plugin) {
+    const contexts = plugin?.contexts;
+    return Array.isArray(contexts) ? contexts : undefined;
+}
+function inheritPluginContexts(component, pluginContexts) {
+    if (!pluginContexts?.length || (component.contexts?.length ?? 0) > 0) {
+        return component;
+    }
+    return {
+        ...component,
+        contexts: [...pluginContexts],
+    };
+}
+function applyEffectiveActionContexts(action, pluginContexts) {
+    const inherited = inheritPluginContexts(action, pluginContexts);
+    if ((inherited.contexts?.length ?? 0) > 0) {
+        return inherited;
+    }
+    return {
+        ...inherited,
+        contexts: [...resolveActionContexts(inherited)],
+    };
+}
+function applyEffectiveProviderContexts(provider, pluginContexts) {
+    const inherited = inheritPluginContexts(provider, pluginContexts);
+    if ((inherited.contexts?.length ?? 0) > 0) {
+        return inherited;
+    }
+    return {
+        ...inherited,
+        contexts: [...resolveProviderContexts(inherited)],
+    };
+}
+function pushUniqueEvent(items, next) {
+    if (items.some((existing) => existing.eventName === next.eventName &&
+        existing.handler === next.handler)) {
+        return;
+    }
+    items.push(next);
+}
+function pushUniqueModel(items, next) {
+    if (items.some((existing) => existing.modelType === next.modelType &&
+        existing.handler === next.handler &&
+        existing.provider === next.provider)) {
+        return;
+    }
+    items.push(next);
+}
+function pushUniqueService(items, next) {
+    if (items.some((existing) => existing.serviceType === next.serviceType &&
+        existing.serviceClass === next.serviceClass)) {
+        return;
+    }
+    items.push(next);
+}
+function createEmptyOwnership(plugin) {
+    return {
+        pluginName: plugin.name,
+        plugin,
+        registeredPlugin: null,
+        actions: [],
+        providers: [],
+        evaluators: [],
+        routes: [],
+        events: [],
+        models: [],
+        services: [],
+        sendHandlerSources: [],
+        hasAdapter: false,
+        registeredAt: Date.now(),
+    };
+}
+function removeArrayItemsByReference(items, owned) {
+    if (owned.length === 0 || items.length === 0)
+        return;
+    const ownedSet = new Set(owned);
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const current = items[index];
+        if (ownedSet.has(current)) {
+            items.splice(index, 1);
+        }
+    }
+}
+async function stopOwnedServices(privateState, runtime, ownership) {
+    if (ownership.services.length === 0)
+        return;
+    const serviceGroups = new Map();
+    for (const ownedService of ownership.services) {
+        const nextGroup = serviceGroups.get(ownedService.serviceType) ?? [];
+        nextGroup.push(ownedService.serviceClass);
+        serviceGroups.set(ownedService.serviceType, nextGroup);
+    }
+    for (const [serviceType, ownedClasses] of serviceGroups) {
+        const key = serviceType;
+        const inFlightStart = privateState.startingServices.get(key);
+        if (inFlightStart) {
+            await inFlightStart.catch(() => null);
+        }
+        const currentClasses = privateState.serviceTypes.get(key) ?? [];
+        if (currentClasses.length === 0) {
+            continue;
+        }
+        const ownedClassSet = new Set(ownedClasses);
+        const removalIndices = [];
+        currentClasses.forEach((serviceClass, index) => {
+            if (ownedClassSet.has(serviceClass)) {
+                removalIndices.push(index);
+            }
+        });
+        const instances = runtime.services.get(key) ?? [];
+        for (const removalIndex of [...removalIndices].sort((a, b) => b - a)) {
+            const instance = instances[removalIndex];
+            if (instance && typeof instance.stop === "function") {
+                await instance.stop();
+            }
+            instances.splice(removalIndex, 1);
+        }
+        for (const ownedClass of ownedClasses) {
+            if (typeof ownedClass.stopRuntime === "function") {
+                await ownedClass.stopRuntime(runtime);
+            }
+            serviceClassOwners.delete(ownedClass);
+        }
+        const remainingClasses = currentClasses.filter((serviceClass) => !ownedClassSet.has(serviceClass));
+        if (remainingClasses.length > 0) {
+            privateState.serviceTypes.set(key, remainingClasses);
+        }
+        else {
+            privateState.serviceTypes.delete(key);
+        }
+        if (instances.length > 0) {
+            runtime.services.set(key, instances);
+            privateState.serviceRegistrationStatus.set(key, "registered");
+        }
+        else {
+            runtime.services.delete(key);
+            if (remainingClasses.length > 0) {
+                privateState.serviceRegistrationStatus.set(key, "pending");
+            }
+            else {
+                privateState.serviceRegistrationStatus.delete(key);
+                privateState.servicePromises.delete(key);
+                privateState.servicePromiseHandlers.delete(key);
+            }
+        }
+    }
+}
+function removeOwnedModels(privateState, ownership) {
+    if (ownership.models.length === 0)
+        return;
+    const modelGroups = new Map();
+    for (const model of ownership.models) {
+        const nextGroup = modelGroups.get(model.modelType) ?? [];
+        nextGroup.push(model);
+        modelGroups.set(model.modelType, nextGroup);
+    }
+    for (const [modelType, ownedModels] of modelGroups) {
+        const currentModels = privateState.models.get(modelType);
+        if (!currentModels || currentModels.length === 0)
+            continue;
+        const remainingModels = currentModels.filter((candidate) => !ownedModels.some((owned) => owned.handler === candidate.handler &&
+            owned.provider === candidate.provider));
+        if (remainingModels.length > 0) {
+            privateState.models.set(modelType, remainingModels);
+        }
+        else {
+            privateState.models.delete(modelType);
+        }
+    }
+}
+function removeOwnedEvents(runtime, ownership) {
+    if (ownership.events.length === 0)
+        return;
+    const eventGroups = new Map();
+    for (const ownedEvent of ownership.events) {
+        const nextGroup = eventGroups.get(ownedEvent.eventName) ?? [];
+        nextGroup.push(ownedEvent.handler);
+        eventGroups.set(ownedEvent.eventName, nextGroup);
+    }
+    for (const [eventName, ownedHandlers] of eventGroups) {
+        const currentHandlers = runtime.events[eventName];
+        if (!currentHandlers || currentHandlers.length === 0)
+            continue;
+        const ownedSet = new Set(ownedHandlers);
+        const remainingHandlers = currentHandlers.filter((handler) => !ownedSet.has(handler));
+        if (remainingHandlers.length > 0) {
+            runtime.events[eventName] = remainingHandlers;
+        }
+        else {
+            delete runtime.events[eventName];
+        }
+    }
+}
+function removeOwnedRoutes(runtime, ownership) {
+    if (ownership.routes.length === 0 || runtime.routes.length === 0)
+        return;
+    removeArrayItemsByReference(runtime.routes, ownership.routes);
+}
+function removeOwnedPlugins(runtime, ownership) {
+    if (runtime.plugins.length === 0)
+        return;
+    const pluginRefs = ownership.registeredPlugin
+        ? [ownership.registeredPlugin]
+        : [];
+    if (pluginRefs.length > 0) {
+        removeArrayItemsByReference(runtime.plugins, pluginRefs);
+    }
+    for (let index = runtime.plugins.length - 1; index >= 0; index -= 1) {
+        if (runtime.plugins[index]?.name === ownership.pluginName) {
+            runtime.plugins.splice(index, 1);
+        }
+    }
+}
+function removeOwnedSendHandlers(privateState, ownership) {
+    for (const source of ownership.sendHandlerSources) {
+        privateState.sendHandlers.delete(source);
+    }
+}
+function removeOwnedComponents(runtime, ownership) {
+    removeArrayItemsByReference(runtime.actions, ownership.actions);
+    removeArrayItemsByReference(runtime.providers, ownership.providers);
+    removeArrayItemsByReference(runtime.evaluators, ownership.evaluators);
+}
+async function restoreAdapterIfNeeded(runtime, ownership, adapterBefore) {
+    if (!ownership.hasAdapter)
+        return;
+    if (runtime.adapter && runtime.adapter !== adapterBefore) {
+        const currentAdapter = runtime.adapter;
+        if (typeof currentAdapter.close === "function") {
+            await currentAdapter.close();
+        }
+        else if (typeof currentAdapter.stop === "function") {
+            await currentAdapter.stop();
+        }
+    }
+    runtime.adapter = (adapterBefore ?? null);
+}
+async function teardownPluginOwnership(runtime, ownership, options) {
+    const privateState = getRuntimePrivateState(runtime);
+    if (ownership.hasAdapter && !options?.allowAdapterUnload) {
+        throw new Error(`Plugin "${ownership.pluginName}" provides a database adapter and requires a runtime reload`);
+    }
+    const errors = [];
+    const lifecyclePlugin = ownership.registeredPlugin ?? ownership.plugin;
+    const disposeHook = lifecyclePlugin
+        .dispose;
+    if (typeof disposeHook === "function") {
+        try {
+            await disposeHook(runtime);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    try {
+        removeOwnedSendHandlers(privateState, ownership);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+    }
+    try {
+        await stopOwnedServices(privateState, runtime, ownership);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+    }
+    try {
+        removeOwnedEvents(runtime, ownership);
+        removeOwnedRoutes(runtime, ownership);
+        removeOwnedModels(privateState, ownership);
+        removeOwnedComponents(runtime, ownership);
+        removeOwnedPlugins(runtime, ownership);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+    }
+    if (ownership.hasAdapter && options?.allowAdapterUnload) {
+        try {
+            await restoreAdapterIfNeeded(runtime, ownership, options.adapterBefore);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    if (options?.removeOwnership !== false) {
+        getPluginOwnershipStore(runtime).delete(ownership.pluginName);
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors, `Failed to fully tear down plugin "${ownership.pluginName}"`);
+    }
+}
+function trackRoutesAndPluginRef(runtime, ownership, pluginsBefore, routesBefore) {
+    for (const plugin of runtime.plugins) {
+        if (!pluginsBefore.has(plugin) && plugin.name === ownership.pluginName) {
+            ownership.registeredPlugin = plugin;
+            break;
+        }
+    }
+    for (const route of runtime.routes) {
+        if (!routesBefore.has(route)) {
+            pushUniqueRef(ownership.routes, route);
+        }
+    }
+}
+/**
+ * Lazily-built tool-call cache for this runtime. Built once per runtime on
+ * first action registration so we can read the latest config and avoid
+ * paying the disk-tier setup cost when the cache is disabled or unused.
+ */
+function getOrBuildToolCallCache(runtime) {
+    const r = runtime;
+    if (r.__toolCallCacheBuilt) {
+        if (!r.__toolCallCache)
+            return null;
+        return { cache: r.__toolCallCache, cfg: r.__toolCallCacheCfg };
+    }
+    r.__toolCallCacheBuilt = true;
+    const character = runtime.character;
+    const cfg = character?.settings?.tools?.cache;
+    const cache = createToolCallCacheFromConfig(cfg);
+    r.__toolCallCache = cache;
+    r.__toolCallCacheCfg = cfg;
+    if (!cache)
+        return null;
+    return { cache, cfg };
+}
+export function installRuntimePluginLifecycle(runtime) {
+    const runtimeWithLifecycle = runtime;
+    if (runtimeWithLifecycle.__elizaPluginLifecycleInstalled) {
+        return;
+    }
+    if (typeof runtime.registerPlugin !== "function" ||
+        typeof runtime.registerAction !== "function" ||
+        typeof runtime.registerProvider !== "function" ||
+        typeof runtime.registerEvaluator !== "function" ||
+        typeof runtime.registerModel !== "function" ||
+        typeof runtime.registerEvent !== "function" ||
+        typeof runtime.registerService !== "function") {
+        return;
+    }
+    const privateState = getRuntimePrivateState(runtime);
+    const originalRegisterPlugin = runtime.registerPlugin.bind(runtime);
+    const originalRegisterAction = runtime.registerAction.bind(runtime);
+    const originalRegisterProvider = runtime.registerProvider.bind(runtime);
+    const originalRegisterEvaluator = runtime.registerEvaluator.bind(runtime);
+    const originalRegisterModel = runtime.registerModel.bind(runtime);
+    const originalRegisterEvent = runtime.registerEvent.bind(runtime);
+    const originalRegisterService = runtime.registerService.bind(runtime);
+    const originalRegisterDatabaseAdapter = typeof runtime.registerDatabaseAdapter === "function"
+        ? runtime.registerDatabaseAdapter.bind(runtime)
+        : null;
+    const originalRegisterSendHandler = typeof privateState.registerSendHandler === "function"
+        ? privateState.registerSendHandler.bind(runtime)
+        : null;
+    const originalRunServiceStart = typeof privateState._runServiceStart === "function"
+        ? privateState._runServiceStart.bind(runtime)
+        : null;
+    runtime.registerAction = ((action) => {
+        const capture = pluginRegistrationContext.getStore();
+        const actionName = action &&
+            typeof action === "object" &&
+            "name" in action &&
+            typeof action.name === "string"
+            ? action.name
+            : null;
+        if (actionName &&
+            runtime.actions.some((existingAction) => existingAction.name === actionName)) {
+            runtime.logger.debug?.({
+                src: "plugin-lifecycle",
+                agentId: runtime.agentId,
+                action: actionName,
+                plugin: capture?.ownership.plugin?.name,
+            }, "Skipping duplicate action before runtime registration");
+            return;
+        }
+        const actionsBefore = runtime.actions.length;
+        let effective = applyEffectiveActionContexts(action, getPluginContexts(capture?.ownership.plugin));
+        const toolCache = getOrBuildToolCallCache(runtime);
+        if (toolCache) {
+            effective = wrapActionWithCache(effective, toolCache.cache, toolCache.cfg);
+        }
+        originalRegisterAction(effective);
+        if (!capture || runtime.actions.length <= actionsBefore)
+            return;
+        for (const registeredAction of runtime.actions.slice(actionsBefore)) {
+            pushUniqueRef(capture.ownership.actions, registeredAction);
+        }
+    });
+    runtime.registerProvider = ((provider) => {
+        const capture = pluginRegistrationContext.getStore();
+        const providersBefore = runtime.providers.length;
+        originalRegisterProvider(applyEffectiveProviderContexts(provider, getPluginContexts(capture?.ownership.plugin)));
+        if (!capture || runtime.providers.length <= providersBefore)
+            return;
+        for (const registeredProvider of runtime.providers.slice(providersBefore)) {
+            pushUniqueRef(capture.ownership.providers, registeredProvider);
+        }
+    });
+    runtime.registerEvaluator = ((evaluator) => {
+        const capture = pluginRegistrationContext.getStore();
+        const evaluatorsBefore = runtime.evaluators.length;
+        originalRegisterEvaluator(evaluator);
+        if (!capture || runtime.evaluators.length <= evaluatorsBefore)
+            return;
+        for (const registeredEvaluator of runtime.evaluators.slice(evaluatorsBefore)) {
+            pushUniqueRef(capture.ownership.evaluators, registeredEvaluator);
+        }
+    });
+    runtime.registerModel = ((modelType, handler, provider, priority) => {
+        const capture = pluginRegistrationContext.getStore();
+        const modelKey = String(modelType);
+        const modelsBefore = privateState.models.get(modelKey)?.length ?? 0;
+        originalRegisterModel(modelType, handler, provider, priority);
+        if (!capture)
+            return;
+        const nextModels = privateState.models.get(modelKey) ?? [];
+        for (const registeredModel of nextModels.slice(modelsBefore)) {
+            pushUniqueModel(capture.ownership.models, {
+                modelType: modelKey,
+                handler: registeredModel.handler,
+                provider: registeredModel.provider,
+            });
+        }
+    });
+    runtime.registerEvent = ((event, handler) => {
+        const capture = pluginRegistrationContext.getStore();
+        const handlersBefore = runtime.events[event]?.length ?? 0;
+        originalRegisterEvent(event, handler);
+        if (!capture)
+            return;
+        const nextHandlers = runtime.events[event] ?? [];
+        for (const registeredHandler of nextHandlers.slice(handlersBefore)) {
+            pushUniqueEvent(capture.ownership.events, {
+                eventName: event,
+                handler: registeredHandler,
+            });
+        }
+    });
+    runtime.registerService = (async (serviceClass) => {
+        const capture = pluginRegistrationContext.getStore();
+        const serviceType = serviceClass.serviceType;
+        const serviceTypesBefore = privateState.serviceTypes.get(serviceType)?.length ?? 0;
+        await originalRegisterService(serviceClass);
+        if (!capture)
+            return;
+        const nextClasses = privateState.serviceTypes.get(serviceType) ?? [];
+        for (const registeredClass of nextClasses.slice(serviceTypesBefore)) {
+            serviceClassOwners.set(registeredClass, capture.ownership.pluginName);
+            pushUniqueService(capture.ownership.services, {
+                serviceType,
+                serviceClass: registeredClass,
+            });
+        }
+    });
+    if (originalRegisterDatabaseAdapter) {
+        runtime.registerDatabaseAdapter = ((adapter) => {
+            const capture = pluginRegistrationContext.getStore();
+            const adapterBefore = runtime.adapter;
+            originalRegisterDatabaseAdapter(adapter);
+            if (capture && runtime.adapter && runtime.adapter !== adapterBefore) {
+                capture.ownership.hasAdapter = true;
+            }
+        });
+    }
+    if (originalRegisterSendHandler) {
+        privateState.registerSendHandler = ((source, handler) => {
+            const hadSourceAlready = privateState.sendHandlers.has(source);
+            originalRegisterSendHandler(source, handler);
+            if (hadSourceAlready)
+                return;
+            const pluginName = pluginServiceStartContext.getStore()?.pluginName ??
+                pluginRegistrationContext.getStore()?.ownership.pluginName;
+            if (!pluginName)
+                return;
+            const ownership = getOwnershipTarget(runtimeWithLifecycle, pluginName);
+            if (!ownership)
+                return;
+            pushUniqueString(ownership.sendHandlerSources, source);
+        });
+    }
+    if (originalRunServiceStart) {
+        privateState._runServiceStart = (async (key, serviceType, serviceClass) => {
+            const pluginName = serviceClassOwners.get(serviceClass) ??
+                pluginRegistrationContext.getStore()?.ownership.pluginName;
+            if (!pluginName) {
+                return await originalRunServiceStart(key, serviceType, serviceClass);
+            }
+            return await pluginServiceStartContext.run({ pluginName }, async () => await originalRunServiceStart(key, serviceType, serviceClass));
+        });
+    }
+    runtime.registerPlugin = (async (plugin) => {
+        const pluginsBefore = new Set(runtime.plugins);
+        const routesBefore = new Set(runtime.routes);
+        const capture = {
+            ownership: createEmptyOwnership(plugin),
+            adapterBefore: runtime.adapter,
+        };
+        try {
+            await pluginRegistrationContext.run(capture, async () => {
+                await originalRegisterPlugin(plugin);
+            });
+            trackRoutesAndPluginRef(runtimeWithLifecycle, capture.ownership, pluginsBefore, routesBefore);
+            if (capture.ownership.registeredPlugin ||
+                capture.ownership.actions.length > 0 ||
+                capture.ownership.providers.length > 0 ||
+                capture.ownership.evaluators.length > 0 ||
+                capture.ownership.routes.length > 0 ||
+                capture.ownership.events.length > 0 ||
+                capture.ownership.models.length > 0 ||
+                capture.ownership.services.length > 0 ||
+                capture.ownership.sendHandlerSources.length > 0 ||
+                capture.ownership.hasAdapter) {
+                getPluginOwnershipStore(runtimeWithLifecycle).set(capture.ownership.pluginName, capture.ownership);
+            }
+        }
+        catch (error) {
+            trackRoutesAndPluginRef(runtimeWithLifecycle, capture.ownership, pluginsBefore, routesBefore);
+            await teardownPluginOwnership(runtimeWithLifecycle, capture.ownership, {
+                allowAdapterUnload: true,
+                removeOwnership: true,
+                adapterBefore: capture.adapterBefore,
+            });
+            throw error;
+        }
+    });
+    runtimeWithLifecycle.unloadPlugin = async (pluginName) => {
+        const ownership = getPluginOwnershipStore(runtimeWithLifecycle).get(pluginName);
+        if (!ownership) {
+            return null;
+        }
+        await teardownPluginOwnership(runtimeWithLifecycle, ownership, {
+            removeOwnership: true,
+        });
+        return ownership;
+    };
+    runtimeWithLifecycle.reloadPlugin = async (plugin) => {
+        const existingOwnership = getPluginOwnershipStore(runtimeWithLifecycle).get(plugin.name);
+        if (existingOwnership) {
+            await teardownPluginOwnership(runtimeWithLifecycle, existingOwnership, {
+                removeOwnership: true,
+            });
+        }
+        await runtime.registerPlugin(plugin);
+    };
+    runtimeWithLifecycle.applyPluginConfig = async (pluginName, config) => {
+        const ownership = getPluginOwnershipStore(runtimeWithLifecycle).get(pluginName);
+        if (!ownership) {
+            return false;
+        }
+        const pluginWithHooks = (ownership.registeredPlugin ??
+            ownership.plugin);
+        if (typeof pluginWithHooks.applyConfig !== "function") {
+            return false;
+        }
+        await pluginWithHooks.applyConfig(config, runtime);
+        return true;
+    };
+    runtimeWithLifecycle.getPluginOwnership = (pluginName) => getPluginOwnershipStore(runtimeWithLifecycle).get(pluginName) ?? null;
+    runtimeWithLifecycle.getAllPluginOwnership = () => Array.from(getPluginOwnershipStore(runtimeWithLifecycle).values());
+    runtimeWithLifecycle.__elizaPluginLifecycleInstalled = true;
+}
+export function supportsRuntimePluginLifecycle(runtime) {
+    return Boolean(runtime &&
+        typeof runtime.unloadPlugin ===
+            "function" &&
+        typeof runtime.reloadPlugin ===
+            "function" &&
+        typeof runtime.getPluginOwnership ===
+            "function");
+}

package/packages/agent/src/runtime/plugin-resolver.d.ts

@@ -0,0 +1,46 @@
+import { type ElizaConfig } from "../config/config.ts";
+import { type PluginModuleShape, type ResolvedPlugin } from "./plugin-types.ts";
+export declare function resolveRuntimePluginImportSpecifier(pluginName: string): string;
+/**
+ * Import a plugin module from its install directory on disk.
+ *
+ * Handles two install layouts:
+ *   1. npm layout:  <installPath>/node_modules/@scope/package/  (from `bun add`)
+ *   2. git layout:  <installPath>/ is the package root directly  (from `git clone`)
+ *
+ * @param installPath  Root directory of the installation (e.g. ~/.eliza/plugins/installed/foo/).
+ * @param packageName  The npm package name (e.g. "@elizaos/plugin-discord") — used
+ *                     to navigate directly into node_modules when present.
+ */
+export declare function importPluginModuleFromPath(installPath: string, packageName: string, exportSubpath?: string): Promise<PluginModuleShape>;
+export declare function getLastFailedPluginNames(): string[];
+/**
+ * Prune sibling plugin staging directories under `stagingBaseDir`, keeping
+ * only the `keepCount` newest by mtime. Each call to `stagePluginImportRoot`
+ * mints a new `mkdtemp` directory and the previous ones are never reused, so
+ * without this cleanup the directory grows unbounded — on long-running dev
+ * boxes the same plugin can accumulate thousands of stale installs (each
+ * carrying its own `node_modules` copy) and consume hundreds of GB.
+ *
+ * Failures are logged but never thrown — staging the new install must not be
+ * blocked by failure to clean up old ones.
+ *
+ * Exported for unit testing.
+ */
+export declare function pruneStalePluginInstances(stagingBaseDir: string, keepCount: number): Promise<void>;
+/**
+ * Resolve Eliza plugins from config and auto-enable logic.
+ * Returns an array of elizaOS Plugin instances ready for AgentRuntime.
+ *
+ * Handles three categories of plugins:
+ * 1. Built-in/npm plugins — imported by package name
+ * 2. User-installed plugins — from ~/.eliza/plugins/installed/
+ * 3. Custom/drop-in plugins — from ~/.eliza/plugins/custom/ and plugins.load.paths
+ *
+ * Each plugin is loaded inside an error boundary so a single failing plugin
+ * cannot crash the entire agent startup.
+ */
+export declare function resolvePlugins(config: ElizaConfig, opts?: {
+    quiet?: boolean;
+}): Promise<ResolvedPlugin[]>;
+//# sourceMappingURL=plugin-resolver.d.ts.map

package/packages/agent/src/runtime/plugin-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-resolver.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/plugin-resolver.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,qBAAqB,CAAC;AAYxE,OAAO,EAML,KAAK,iBAAiB,EACtB,KAAK,cAAc,EAMpB,MAAM,mBAAmB,CAAC;AA0C3B,wBAAgB,mCAAmC,CACjD,UAAU,EAAE,MAAM,GACjB,MAAM,CAMR;AAkiBD;;;;;;;;;;GAUG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,aAAa,SAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAkC5B;AAgCD,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAMnD;AAuPD;;;;;;;;;;;;GAYG;AACH,wBAAsB,yBAAyB,CAC7C,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAqCf;AA4RD;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GACzB,OAAO,CAAC,cAAc,EAAE,CAAC,CAkc3B"}