@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/plugin-manager/providers/pluginConfigurationStatus.js

@@ -0,0 +1,104 @@
+import { PluginManagerServiceType } from "../types.js";
+import { buildProviderKeywords, COMMON_CONNECTOR_KEYWORDS, isProviderRelevant, keywordsFromPluginNames, PLUGIN_MANAGER_BASE_KEYWORDS, } from "./relevance.js";
+const PLUGIN_CONFIGURATION_STATUS_KEYWORDS = buildProviderKeywords(PLUGIN_MANAGER_BASE_KEYWORDS, COMMON_CONNECTOR_KEYWORDS, [
+    "plugin configuration",
+    "configuration status",
+    "config status",
+    "schema",
+    "config schema",
+    "missing keys",
+    "missing env",
+    "environment variable",
+    "environment variables",
+    "env var",
+    "env vars",
+    "setup",
+    "configure plugin",
+    "plugin settings",
+    "integration config",
+    "connector config",
+    "credential",
+    "credentials",
+    "secret",
+    "secrets",
+]);
+export const pluginConfigurationStatusProvider = {
+    name: "pluginConfigurationStatus",
+    description: "Provides plugin configuration status based on actual plugin config schemas",
+    dynamic: true,
+    relevanceKeywords: PLUGIN_CONFIGURATION_STATUS_KEYWORDS,
+    get: async (runtime, message, state) => {
+        const pluginManagerService = runtime.getService(PluginManagerServiceType.PLUGIN_MANAGER);
+        const dynamicPluginKeywords = pluginManagerService
+            ? keywordsFromPluginNames(pluginManagerService.getAllPlugins().map((plugin) => plugin.name))
+            : [];
+        const relevanceKeywords = buildProviderKeywords(PLUGIN_CONFIGURATION_STATUS_KEYWORDS, dynamicPluginKeywords);
+        if (!isProviderRelevant(message, state, relevanceKeywords)) {
+            return { text: "" };
+        }
+        const configService = runtime.getService(PluginManagerServiceType.PLUGIN_CONFIGURATION);
+        if (!configService || !pluginManagerService) {
+            return {
+                text: "Configuration or plugin manager service not available",
+                data: { available: false },
+                values: { configurationServicesAvailable: false },
+            };
+        }
+        const allPlugins = pluginManagerService.getAllPlugins();
+        let configuredCount = 0;
+        let needsConfigCount = 0;
+        const pluginStatuses = [];
+        for (const pluginState of allPlugins) {
+            if (!pluginState.plugin) {
+                pluginStatuses.push({
+                    name: pluginState.name,
+                    status: pluginState.status,
+                    configured: true,
+                    missingKeys: [],
+                    totalKeys: 0,
+                });
+                configuredCount++;
+                continue;
+            }
+            const configStatus = configService.getPluginConfigStatus(pluginState.plugin);
+            pluginStatuses.push({
+                name: pluginState.name,
+                status: pluginState.status,
+                configured: configStatus.configured,
+                missingKeys: configStatus.missingKeys,
+                totalKeys: configStatus.totalKeys,
+            });
+            if (configStatus.configured) {
+                configuredCount++;
+            }
+            else {
+                needsConfigCount++;
+            }
+        }
+        let statusText = "";
+        if (allPlugins.length === 0) {
+            statusText = "No plugins registered.";
+        }
+        else {
+            statusText += `Plugin Configuration Status:\n`;
+            statusText += `Total: ${allPlugins.length}, Configured: ${configuredCount}, Needs config: ${needsConfigCount}\n`;
+            if (needsConfigCount > 0) {
+                statusText += `\nPlugins needing configuration:\n`;
+                for (const ps of pluginStatuses.filter((p) => !p.configured)) {
+                    statusText += `- ${ps.name}: missing ${ps.missingKeys.join(", ")}\n`;
+                }
+            }
+        }
+        return {
+            text: statusText,
+            data: { plugins: pluginStatuses },
+            values: {
+                configurationServicesAvailable: true,
+                totalPlugins: allPlugins.length,
+                configuredPlugins: configuredCount,
+                needsConfiguration: needsConfigCount,
+                hasUnconfiguredPlugins: needsConfigCount > 0,
+            },
+        };
+    },
+};

package/packages/typescript/src/features/plugin-manager/providers/pluginStateProvider.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../../../types/components.ts";
+export declare const pluginStateProvider: Provider & {
+    relevanceKeywords: string[];
+};
+//# sourceMappingURL=pluginStateProvider.d.ts.map

package/packages/typescript/src/features/plugin-manager/providers/pluginStateProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginStateProvider.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/plugin-manager/providers/pluginStateProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,8BAA8B,CAAC;AAkC7E,eAAO,MAAM,mBAAmB,EAAE,QAAQ,GAAG;IAAE,iBAAiB,EAAE,MAAM,EAAE,CAAA;CAmIzE,CAAC"}

package/packages/typescript/src/features/plugin-manager/providers/pluginStateProvider.js

@@ -0,0 +1,105 @@
+import { PluginStatus } from "../types.js";
+import { buildProviderKeywords, COMMON_CONNECTOR_KEYWORDS, isProviderRelevant, keywordsFromPluginNames, PLUGIN_MANAGER_BASE_KEYWORDS, } from "./relevance.js";
+const PLUGIN_STATE_PROVIDER_KEYWORDS = buildProviderKeywords(PLUGIN_MANAGER_BASE_KEYWORDS, COMMON_CONNECTOR_KEYWORDS, [
+    "plugin state",
+    "plugin states",
+    "loaded plugins",
+    "unloaded plugins",
+    "ready plugins",
+    "plugin errors",
+    "enabled plugins",
+    "disabled plugins",
+    "protected plugins",
+    "original plugins",
+    "startup plugins",
+    "integration state",
+    "connector state",
+]);
+export const pluginStateProvider = {
+    name: "pluginState",
+    description: "Provides information about the current state of all plugins including loaded status, missing environment variables, and errors",
+    dynamic: true,
+    relevanceKeywords: PLUGIN_STATE_PROVIDER_KEYWORDS,
+    async get(runtime, message, state) {
+        const pluginManager = runtime.getService("plugin_manager");
+        const dynamicPluginKeywords = pluginManager
+            ? keywordsFromPluginNames(pluginManager.getAllPlugins().map((plugin) => plugin.name))
+            : [];
+        const relevanceKeywords = buildProviderKeywords(PLUGIN_STATE_PROVIDER_KEYWORDS, dynamicPluginKeywords);
+        if (!isProviderRelevant(message, state, relevanceKeywords)) {
+            return { text: "" };
+        }
+        if (!pluginManager) {
+            return {
+                text: "Plugin Manager service is not available",
+                values: {},
+                data: {
+                    error: "Plugin Manager service not found",
+                },
+            };
+        }
+        const plugins = pluginManager.getAllPlugins();
+        const loadedPlugins = plugins.filter((p) => p.status === PluginStatus.LOADED);
+        const errorPlugins = plugins.filter((p) => p.status === PluginStatus.ERROR);
+        const readyPlugins = plugins.filter((p) => p.status === PluginStatus.READY);
+        const unloadedPlugins = plugins.filter((p) => p.status === PluginStatus.UNLOADED);
+        const formatPlugin = (plugin) => {
+            const parts = [`${plugin.name} (${plugin.status})`];
+            if (plugin.error) {
+                parts.push(`Error: ${plugin.error}`);
+            }
+            if (plugin.loadedAt) {
+                parts.push(`Loaded at: ${new Date(plugin.loadedAt).toLocaleString()}`);
+            }
+            return parts.join(" - ");
+        };
+        const sections = [];
+        if (loadedPlugins.length > 0) {
+            sections.push(`**Loaded Plugins:**\n${loadedPlugins.map((p) => `- ${formatPlugin(p)}`).join("\n")}`);
+        }
+        if (errorPlugins.length > 0) {
+            sections.push(`**Plugins with Errors:**\n${errorPlugins.map((p) => `- ${formatPlugin(p)}`).join("\n")}`);
+        }
+        if (readyPlugins.length > 0) {
+            sections.push(`**Ready to Load:**\n${readyPlugins.map((p) => `- ${formatPlugin(p)}`).join("\n")}`);
+        }
+        if (unloadedPlugins.length > 0) {
+            sections.push(`**Unloaded:**\n${unloadedPlugins.map((p) => `- ${formatPlugin(p)}`).join("\n")}`);
+        }
+        const protectedPlugins = pluginManager.getProtectedPlugins();
+        const originalPlugins = pluginManager.getOriginalPlugins();
+        if (protectedPlugins.length > 0 || originalPlugins.length > 0) {
+            sections.push("**System Plugins:**\n" +
+                `- Protected: ${protectedPlugins.join(", ")}\n` +
+                `- Original (loaded at startup): ${originalPlugins.join(", ")}`);
+        }
+        const text = sections.length > 0
+            ? sections.join("\n\n")
+            : "No plugins registered in the Plugin Manager.";
+        return {
+            text,
+            values: {
+                totalPlugins: plugins.length,
+                loadedCount: loadedPlugins.length,
+                errorCount: errorPlugins.length,
+                readyCount: readyPlugins.length,
+                unloadedCount: unloadedPlugins.length,
+                protectedPlugins,
+                originalPlugins,
+            },
+            data: {
+                plugins: plugins.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    status: p.status,
+                    error: p.error,
+                    createdAt: p.createdAt,
+                    loadedAt: p.loadedAt,
+                    unloadedAt: p.unloadedAt,
+                    isProtected: protectedPlugins.includes(p.name),
+                    isOriginal: originalPlugins.includes(p.name),
+                })),
+            },
+        };
+    },
+};

package/packages/typescript/src/features/plugin-manager/providers/registryPluginsProvider.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../../../types/components.ts";
+export declare const registryPluginsProvider: Provider & {
+    relevanceKeywords: string[];
+};
+//# sourceMappingURL=registryPluginsProvider.d.ts.map

package/packages/typescript/src/features/plugin-manager/providers/registryPluginsProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registryPluginsProvider.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/plugin-manager/providers/registryPluginsProvider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,8BAA8B,CAAC;AAmC7E,eAAO,MAAM,uBAAuB,EAAE,QAAQ,GAAG;IAChD,iBAAiB,EAAE,MAAM,EAAE,CAAC;CA+F5B,CAAC"}

package/packages/typescript/src/features/plugin-manager/providers/registryPluginsProvider.js

@@ -0,0 +1,93 @@
+import { logger } from "../../../logger.js";
+import { getAllPlugins } from "../services/pluginRegistryService.js";
+import { buildProviderKeywords, COMMON_CONNECTOR_KEYWORDS, isProviderRelevant, keywordsFromPluginNames, PLUGIN_MANAGER_BASE_KEYWORDS, } from "./relevance.js";
+const REGISTRY_PROVIDER_KEYWORDS = buildProviderKeywords(PLUGIN_MANAGER_BASE_KEYWORDS, COMMON_CONNECTOR_KEYWORDS, [
+    "plugin registry",
+    "registry plugin",
+    "registry plugins",
+    "plugin catalog",
+    "plugin marketplace",
+    "discover plugins",
+    "search plugins",
+    "available plugins",
+    "installed plugins",
+    "plugin directory",
+    "integration directory",
+    "connector directory",
+    "connect plugin",
+    "install plugin",
+]);
+export const registryPluginsProvider = {
+    name: "registryPlugins",
+    description: "Provides available plugins from the ElizaOS registry (next branch), installed plugin status, and searchable plugin knowledge",
+    dynamic: true,
+    relevanceKeywords: REGISTRY_PROVIDER_KEYWORDS,
+    async get(runtime, message, state) {
+        const pluginManagerService = runtime.getService("plugin_manager");
+        const dynamicPluginKeywords = pluginManagerService
+            ? keywordsFromPluginNames(pluginManagerService.getAllPlugins().map((plugin) => plugin.name))
+            : [];
+        const relevanceKeywords = buildProviderKeywords(REGISTRY_PROVIDER_KEYWORDS, dynamicPluginKeywords);
+        if (!isProviderRelevant(message, state, relevanceKeywords)) {
+            return { text: "" };
+        }
+        if (!pluginManagerService) {
+            return {
+                text: "Plugin manager service not available",
+                data: { error: "Plugin manager service not available" },
+            };
+        }
+        let registryPlugins = [];
+        let registryError;
+        try {
+            registryPlugins = await getAllPlugins();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.warn(`[registryPluginsProvider] Failed to fetch registry: ${message}`);
+            registryError = message;
+        }
+        const installedPlugins = await pluginManagerService.listInstalledPlugins();
+        let text = "";
+        if (registryError) {
+            text += `**Registry unavailable:** ${registryError}\n`;
+        }
+        else if (registryPlugins.length === 0) {
+            text += "No plugins available in registry.\n";
+        }
+        else {
+            text += `**Available Plugins from Registry (${registryPlugins.length} total):**\n`;
+            for (const plugin of registryPlugins) {
+                text += `- **${plugin.name}**: ${plugin.description || "No description"}\n`;
+                if (plugin.tags && plugin.tags.length > 0) {
+                    text += `  Tags: ${plugin.tags.join(", ")}\n`;
+                }
+            }
+        }
+        if (installedPlugins.length > 0) {
+            text += "\n**Installed Registry Plugins:**\n";
+            for (const plugin of installedPlugins) {
+                text += `- **${plugin.name}** v${plugin.version} (Path: ${plugin.path})\n`;
+            }
+        }
+        return {
+            text,
+            data: {
+                availablePlugins: registryPlugins.map((p) => ({
+                    name: p.name,
+                    description: p.description,
+                    repository: p.repository,
+                    tags: p.tags || [],
+                    version: p.latestVersion,
+                })),
+                installedPlugins,
+                registryError,
+            },
+            values: {
+                availableCount: registryPlugins.length,
+                installedCount: installedPlugins.length,
+                registryAvailable: !registryError,
+            },
+        };
+    },
+};

package/packages/typescript/src/features/plugin-manager/providers/relevance.d.ts

@@ -0,0 +1,9 @@
+import type { Memory } from "../../../types/memory.ts";
+import type { State } from "../../../types/state.ts";
+export declare const PLUGIN_MANAGER_BASE_KEYWORDS: readonly ["plugin", "plugins", "plugin manager", "plugin-manager", "extension", "extensions", "module", "modules", "addon", "add-on", "add-ons", "integration", "integrations", "integrate", "integrated", "connect", "connected", "connection", "connector", "connectors", "adapter", "adapters", "bridge", "bridges", "interoperability", "orchestration", "compatibility", "ecosystem", "registry", "catalog", "directory", "marketplace", "index", "search", "discover", "install", "installed", "installation", "uninstall", "remove", "removed", "load", "loaded", "unload", "unloaded", "enable", "enabled", "disable", "disabled", "configure", "configuration", "config", "settings", "setup", "status", "state", "health", "available", "availability", "error", "errors", "package", "packages", "repo", "repository", "dependencies", "runtime", "provider", "providers", "service", "services", "tool", "tools", "workflow", "workflows"];
+export declare const COMMON_CONNECTOR_KEYWORDS: readonly ["discord", "telegram", "slack", "whatsapp", "twitter", "github", "farcaster", "nostr", "line", "matrix", "google chat", "msteams", "teams", "twilio", "imessage", "bluebubbles", "bluesky", "twitch", "instagram", "zalo", "nextcloud", "gmail", "openai", "anthropic", "groq", "ollama", "xai", "solana", "evm", "n8n", "mcp", "rss", "s3", "sql"];
+export declare function buildProviderKeywords(...groups: Array<readonly string[] | string[] | undefined>): string[];
+export declare function keywordsFromPluginNames(pluginNames: Iterable<string>): string[];
+export declare function buildKeywordRegex(keywords: readonly string[]): RegExp;
+export declare function isProviderRelevant(message: Memory, state: State | undefined, keywords: readonly string[]): boolean;
+//# sourceMappingURL=relevance.d.ts.map

package/packages/typescript/src/features/plugin-manager/providers/relevance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relevance.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/plugin-manager/providers/relevance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAoCrD,eAAO,MAAM,4BAA4B,w5BA4E/B,CAAC;AAEX,eAAO,MAAM,yBAAyB,+VAmC5B,CAAC;AAEX,wBAAgB,qBAAqB,CACpC,GAAG,MAAM,EAAE,KAAK,CAAC,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,GACxD,MAAM,EAAE,CAWV;AAED,wBAAgB,uBAAuB,CACtC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC3B,MAAM,EAAE,CAuBV;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYrE;AAgDD,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,QAAQ,EAAE,SAAS,MAAM,EAAE,GACzB,OAAO,CAWT"}

package/packages/typescript/src/features/plugin-manager/providers/relevance.js

@@ -0,0 +1,229 @@
+import { validateActionKeywords as coreValidateActionKeywords, validateActionRegex as coreValidateActionRegex, } from "../../../validation/keywords.js";
+/**
+ * Read the recent-messages memory array that `recentMessagesProvider` writes
+ * into `state.data.providers.RECENT_MESSAGES.data.recentMessages`.
+ *
+ * Inlined from @elizaos/shared to avoid a cross-package type import that
+ * breaks tsc declaration emit (rootDir constraint).
+ */
+function getRecentMessagesData(state) {
+    const messages = state?.data?.providers?.RECENT_MESSAGES?.data?.recentMessages;
+    return Array.isArray(messages) ? messages : [];
+}
+const IGNORED_PLUGIN_NAME_TOKENS = new Set([
+    "app",
+    "core",
+    "eliza",
+    "elizaos",
+    "manager",
+    "plugin",
+    "plugins",
+    "provider",
+    "providers",
+]);
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const normalizeKeyword = (value) => value.trim().toLowerCase();
+export const PLUGIN_MANAGER_BASE_KEYWORDS = [
+    "plugin",
+    "plugins",
+    "plugin manager",
+    "plugin-manager",
+    "extension",
+    "extensions",
+    "module",
+    "modules",
+    "addon",
+    "add-on",
+    "add-ons",
+    "integration",
+    "integrations",
+    "integrate",
+    "integrated",
+    "connect",
+    "connected",
+    "connection",
+    "connector",
+    "connectors",
+    "adapter",
+    "adapters",
+    "bridge",
+    "bridges",
+    "interoperability",
+    "orchestration",
+    "compatibility",
+    "ecosystem",
+    "registry",
+    "catalog",
+    "directory",
+    "marketplace",
+    "index",
+    "search",
+    "discover",
+    "install",
+    "installed",
+    "installation",
+    "uninstall",
+    "remove",
+    "removed",
+    "load",
+    "loaded",
+    "unload",
+    "unloaded",
+    "enable",
+    "enabled",
+    "disable",
+    "disabled",
+    "configure",
+    "configuration",
+    "config",
+    "settings",
+    "setup",
+    "status",
+    "state",
+    "health",
+    "available",
+    "availability",
+    "error",
+    "errors",
+    "package",
+    "packages",
+    "repo",
+    "repository",
+    "dependencies",
+    "runtime",
+    "provider",
+    "providers",
+    "service",
+    "services",
+    "tool",
+    "tools",
+    "workflow",
+    "workflows",
+];
+export const COMMON_CONNECTOR_KEYWORDS = [
+    "discord",
+    "telegram",
+    "slack",
+    "whatsapp",
+    "twitter",
+    "github",
+    "farcaster",
+    "nostr",
+    "line",
+    "matrix",
+    "google chat",
+    "msteams",
+    "teams",
+    "twilio",
+    "imessage",
+    "bluebubbles",
+    "bluesky",
+    "twitch",
+    "instagram",
+    "zalo",
+    "nextcloud",
+    "gmail",
+    "openai",
+    "anthropic",
+    "groq",
+    "ollama",
+    "xai",
+    "solana",
+    "evm",
+    "n8n",
+    "mcp",
+    "rss",
+    "s3",
+    "sql",
+];
+export function buildProviderKeywords(...groups) {
+    const deduped = new Set();
+    for (const group of groups) {
+        if (!group)
+            continue;
+        for (const raw of group) {
+            const keyword = normalizeKeyword(raw);
+            if (!keyword)
+                continue;
+            deduped.add(keyword);
+        }
+    }
+    return [...deduped];
+}
+export function keywordsFromPluginNames(pluginNames) {
+    const deduped = new Set();
+    for (const rawName of pluginNames) {
+        const name = normalizeKeyword(rawName);
+        if (!name)
+            continue;
+        deduped.add(name);
+        const withoutScope = name.replace(/^@[^/]+\//, "");
+        if (withoutScope)
+            deduped.add(withoutScope);
+        const withoutPrefix = withoutScope.replace(/^(plugin|app)[-_]/, "");
+        if (withoutPrefix)
+            deduped.add(withoutPrefix);
+        for (const token of withoutPrefix.split(/[^a-z0-9]+/)) {
+            if (!token || token.length < 2 || IGNORED_PLUGIN_NAME_TOKENS.has(token))
+                continue;
+            deduped.add(token);
+        }
+    }
+    return [...deduped];
+}
+export function buildKeywordRegex(keywords) {
+    const escapedKeywords = [
+        ...new Set(keywords.map(normalizeKeyword).filter(Boolean)),
+    ]
+        .sort((a, b) => b.length - a.length)
+        .map(escapeRegex);
+    if (escapedKeywords.length === 0) {
+        return /$^/;
+    }
+    return new RegExp(`\\b(${escapedKeywords.join("|")})\\b`, "i");
+}
+function getMemoryText(memory) {
+    if (!memory || typeof memory !== "object")
+        return "";
+    const content = memory.content;
+    if (!content || typeof content !== "object")
+        return "";
+    const text = content.text;
+    return typeof text === "string" ? text.toLowerCase() : "";
+}
+function getRecentMessageTexts(state) {
+    return getRecentMessages(state)
+        .map((message) => getMemoryText(message))
+        .filter((text) => text.length > 0);
+}
+function getRecentMessages(state) {
+    return getRecentMessagesData(state);
+}
+function validateKeywords(message, state, keywords) {
+    if (keywords.length === 0)
+        return false;
+    const texts = [getMemoryText(message), ...getRecentMessageTexts(state)];
+    if (texts.every((text) => !text))
+        return false;
+    return keywords.some((keyword) => {
+        const normalizedKeyword = normalizeKeyword(keyword);
+        if (!normalizedKeyword)
+            return false;
+        return texts.some((text) => text.includes(normalizedKeyword));
+    });
+}
+function validateRegex(message, state, regex) {
+    const texts = [getMemoryText(message), ...getRecentMessageTexts(state)];
+    return texts.some((text) => Boolean(text) && regex.test(text));
+}
+export function isProviderRelevant(message, state, keywords) {
+    const recentMessages = getRecentMessages(state);
+    const keywordRegex = buildKeywordRegex(keywords);
+    const hasKeywordMatch = coreValidateActionKeywords
+        ? coreValidateActionKeywords(message, recentMessages, [...keywords])
+        : validateKeywords(message, state, keywords);
+    const hasRegexMatch = coreValidateActionRegex
+        ? coreValidateActionRegex(message, recentMessages, keywordRegex)
+        : validateRegex(message, state, keywordRegex);
+    return hasKeywordMatch || hasRegexMatch;
+}

package/packages/typescript/src/features/plugin-manager/services/coreManagerService.d.ts

@@ -0,0 +1,76 @@
+import type { IAgentRuntime } from "../../../types/runtime.ts";
+import type { ServiceTypeName } from "../../../types/service.ts";
+import { Service } from "../../../types/service.ts";
+export interface UpstreamMetadata {
+    $schema: "milaidy-upstream-v1";
+    source: string;
+    gitUrl: string;
+    branch: string;
+    commitHash: string;
+    ejectedAt: string;
+    npmPackage: string;
+    npmVersion: string;
+    lastSyncAt: string | null;
+    localCommits: number;
+}
+export interface CoreEjectResult {
+    success: boolean;
+    ejectedPath: string;
+    upstreamCommit: string;
+    error?: string;
+}
+export interface CoreSyncResult {
+    success: boolean;
+    ejectedPath: string;
+    upstreamCommits: number;
+    localChanges: boolean;
+    conflicts: string[];
+    commitHash: string;
+    error?: string;
+}
+export interface CoreReinjectResult {
+    success: boolean;
+    removedPath: string;
+    error?: string;
+}
+export interface CoreStatus {
+    ejected: boolean;
+    ejectedPath: string;
+    monorepoPath: string;
+    corePackagePath: string;
+    coreDistPath: string;
+    version: string;
+    npmVersion: string;
+    commitHash: string | null;
+    localChanges: boolean;
+    upstream: UpstreamMetadata | null;
+}
+export declare class CoreManagerService extends Service {
+    static serviceType: ServiceTypeName;
+    capabilityDescription: string;
+    private ejectLock;
+    static start(runtime: IAgentRuntime): Promise<CoreManagerService>;
+    stop(): Promise<void>;
+    private serialise;
+    private coreBaseDir;
+    private coreMonorepoDir;
+    private corePackageDir;
+    private coreDistDir;
+    private upstreamFilePath;
+    private tsconfigFilePath;
+    private isWithinEjectedCoreDir;
+    private gitStdout;
+    private readCorePackageVersion;
+    private resolveInstalledCoreVersion;
+    private readUpstreamMetadata;
+    private writeUpstreamMetadata;
+    private readTsconfig;
+    private writeTsconfigCorePaths;
+    private runCoreInstallAndBuild;
+    private ensureEjectedCoreExists;
+    ejectCore(): Promise<CoreEjectResult>;
+    syncCore(): Promise<CoreSyncResult>;
+    reinjectCore(): Promise<CoreReinjectResult>;
+    getCoreStatus(): Promise<CoreStatus>;
+}
+//# sourceMappingURL=coreManagerService.d.ts.map

package/packages/typescript/src/features/plugin-manager/services/coreManagerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreManagerService.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/plugin-manager/services/coreManagerService.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAkBpD,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAClC;AAQD,qBAAa,kBAAmB,SAAQ,OAAO;IAC9C,OAAgB,WAAW,EAAE,eAAe,CAA6B;IAChE,qBAAqB,SACmC;IAEjE,OAAO,CAAC,SAAS,CAAoC;WAExC,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIjE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,sBAAsB;YAOhB,SAAS;YAQT,sBAAsB;YActB,2BAA2B;YAgC3B,oBAAoB;YA6CpB,qBAAqB;YAOrB,YAAY;YAQZ,sBAAsB;YAyBtB,sBAAsB;YAOtB,uBAAuB;IAkB/B,SAAS,IAAI,OAAO,CAAC,eAAe,CAAC;IAyGrC,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IA+InC,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAmC3C,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC;CA+D1C"}