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

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

@@ -1,602 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}