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

package/packages/typescript/src/features/basic-capabilities/index.js

@@ -0,0 +1,1027 @@
+/**
+ * Basic Capabilities
+ *
+ * Core functionality included by default as basic capabilities.
+ * These provide essential agent behavior:
+ * - Core providers (actions, character, entities, messages, etc.)
+ * - Basic actions (reply, ignore, none)
+ * - Essential services (task management, embeddings, trajectory logging)
+ * - Event handlers for runtime events
+ * - Plugin creation utilities
+ */
+import { v4 } from "uuid";
+import { withCanonicalActionDocs } from "../../action-docs.js";
+import { createUniqueUuid } from "../../entities.js";
+import { logger } from "../../logger.js";
+import { imageDescriptionTemplate, messageHandlerTemplate, postCreationTemplate, } from "../../prompts.js";
+import { EmbeddingGenerationService } from "../../services/embedding.js";
+import { OPTIMIZED_PROMPT_SERVICE, } from "../../services/optimized-prompt.js";
+import { resolveOptimizedPrompt } from "../../services/optimized-prompt-resolver.js";
+import { TaskService } from "../../services/task.js";
+import { isExplicitSelfModificationRequest } from "../../should-respond.js";
+import { EventType } from "../../types/events.js";
+import { MemoryType } from "../../types/memory.js";
+import { ModelType } from "../../types/model.js";
+import { ChannelType, ContentType } from "../../types/primitives.js";
+import { composePromptFromState, getLocalServerUrl, parseKeyValueXml, } from "../../utils.js";
+import * as autonomy from "../autonomy/index.js";
+const ROLE_OWNER = "OWNER";
+// Re-export action and provider modules
+export * from "./actions/index.js";
+export * from "./providers/index.js";
+// Import advanced capabilities
+import { advancedActions, advancedCapabilities, advancedEvaluators, advancedProviders, advancedServices, } from "../advanced-capabilities/index.js";
+// Import core capabilities (trust, secrets, plugin-manager)
+import { pluginManagerCapability, secretsCapability, trustCapability, } from "../index.js";
+// Import for local use
+import * as actions from "./actions/index.js";
+import * as providers from "./providers/index.js";
+// Re-export advanced capability modules
+export * from "../advanced-capabilities/actions/index.js";
+export * from "../advanced-capabilities/evaluators/index.js";
+// Re-export advanced capabilities
+export { advancedActions, advancedCapabilities, advancedEvaluators, advancedProviders, advancedServices, } from "../advanced-capabilities/index.js";
+export * from "../advanced-capabilities/providers/index.js";
+// Re-export autonomy
+export * from "../autonomy/index.js";
+// Re-export core capabilities (trust, secrets, plugin-manager)
+export { coreCapabilities, pluginManagerCapability, secretsCapability, trustCapability, } from "../index.js";
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function textContainsAgentName(text, names) {
+    if (!text) {
+        return false;
+    }
+    return names.some((name) => {
+        const candidate = name?.trim();
+        if (!candidate) {
+            return false;
+        }
+        const pattern = new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegex(candidate)}(?=$|[^\\p{L}\\p{N}])`, "iu");
+        return pattern.test(text);
+    });
+}
+function textContainsUserTag(text) {
+    if (!text) {
+        return false;
+    }
+    return /<@!?[^>]+>|@\w+/u.test(text);
+}
+export async function fetchMediaData(attachments) {
+    return Promise.all(attachments.map(async (attachment) => {
+        if (/^(http|https):\/\//.test(attachment.url)) {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch file: ${attachment.url}`);
+            }
+            const mediaBuffer = Buffer.from(await response.arrayBuffer());
+            const mediaType = attachment.contentType || "image/png";
+            return { data: mediaBuffer, mediaType };
+        }
+        throw new Error(`File not found: ${attachment.url}. Make sure the path is correct.`);
+    }));
+}
+/**
+ * Processes attachments by generating descriptions for supported media types.
+ * Currently supports image description generation.
+ *
+ * @param {Media[]} attachments - Array of attachments to process
+ * @param {IAgentRuntime} runtime - The agent runtime for accessing AI models
+ * @returns {Promise<Media[]>} - Returns a new array of processed attachments with added description, title, and text properties
+ */
+export async function processAttachments(attachments, runtime) {
+    if (!attachments || attachments.length === 0) {
+        return [];
+    }
+    runtime.logger.debug({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        count: attachments.length,
+    }, "Processing attachments");
+    const processedAttachments = [];
+    for (const attachment of attachments) {
+        const processedAttachment = { ...attachment };
+        const isRemote = /^(http|https):\/\//.test(attachment.url);
+        const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
+        if (attachment.contentType === ContentType.IMAGE &&
+            !attachment.description) {
+            runtime.logger.debug({
+                src: "basic-capabilities",
+                agentId: runtime.agentId,
+                url: attachment.url,
+            }, "Generating description for image");
+            let imageUrl = url;
+            if (!isRemote) {
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch image: ${res.statusText}`);
+                }
+                const arrayBuffer = await res.arrayBuffer();
+                const buffer = Buffer.from(arrayBuffer);
+                const contentType = res.headers.get("content-type") || "application/octet-stream";
+                imageUrl = `data:${contentType};base64,${buffer.toString("base64")}`;
+            }
+            let response;
+            try {
+                const optimizedMediaService = runtime.getService(OPTIMIZED_PROMPT_SERVICE);
+                const resolvedImageDescriptionPrompt = resolveOptimizedPrompt(optimizedMediaService, "media_description", imageDescriptionTemplate);
+                response = await runtime.useModel(ModelType.IMAGE_DESCRIPTION, {
+                    prompt: resolvedImageDescriptionPrompt,
+                    imageUrl,
+                });
+            }
+            catch (err) {
+                runtime.logger.error({
+                    src: "basic-capabilities",
+                    agentId: runtime.agentId,
+                    error: err instanceof Error ? err.message : String(err),
+                }, "Error generating image description");
+                // Continue with original attachment on error
+                processedAttachments.push(processedAttachment);
+                continue;
+            }
+            if (typeof response === "string") {
+                // Parse XML response
+                const parsedXml = parseKeyValueXml(response);
+                if (parsedXml && (parsedXml.description || parsedXml.text)) {
+                    processedAttachment.description = parsedXml.description ?? "";
+                    processedAttachment.title = parsedXml.title ?? "Image";
+                    processedAttachment.text =
+                        parsedXml.text ?? parsedXml.description ?? "";
+                    runtime.logger.debug({
+                        src: "basic-capabilities",
+                        agentId: runtime.agentId,
+                        descriptionPreview: processedAttachment.description?.substring(0, 100) || undefined,
+                    }, "Generated description");
+                }
+                else {
+                    // Fallback: Try simple regex parsing if parseKeyValueXml fails
+                    const responseStr = response;
+                    const titleMatch = responseStr.match(/<title>([^<]+)<\/title>/);
+                    const descMatch = responseStr.match(/<description>([^<]+)<\/description>/);
+                    const textMatch = responseStr.match(/<text>([^<]+)<\/text>/);
+                    if (titleMatch || descMatch || textMatch) {
+                        processedAttachment.title = titleMatch?.[1] || "Image";
+                        processedAttachment.description = descMatch?.[1] || "";
+                        processedAttachment.text = textMatch?.[1] || descMatch?.[1] || "";
+                        runtime.logger.debug({
+                            src: "basic-capabilities",
+                            agentId: runtime.agentId,
+                            descriptionPreview: processedAttachment.description?.substring(0, 100) ||
+                                undefined,
+                        }, "Used fallback XML parsing");
+                    }
+                    else {
+                        runtime.logger.warn({ src: "basic-capabilities", agentId: runtime.agentId }, "Failed to parse XML response for image description");
+                    }
+                }
+            }
+            else if (response &&
+                typeof response === "object" &&
+                "description" in response) {
+                // Handle object responses for backwards compatibility
+                const responseObj = response;
+                processedAttachment.description = responseObj.description;
+                processedAttachment.title = responseObj.title || "Image";
+                processedAttachment.text = responseObj.description;
+                runtime.logger.debug({
+                    src: "basic-capabilities",
+                    agentId: runtime.agentId,
+                    descriptionPreview: processedAttachment.description?.substring(0, 100) || undefined,
+                }, "Generated description");
+            }
+            else {
+                runtime.logger.warn({ src: "basic-capabilities", agentId: runtime.agentId }, "Unexpected response format for image description");
+            }
+        }
+        else if (attachment.contentType === ContentType.DOCUMENT &&
+            !attachment.text) {
+            const res = await fetch(url);
+            if (!res.ok) {
+                throw new Error(`Failed to fetch document: ${res.statusText}`);
+            }
+            const contentType = res.headers.get("content-type") || "";
+            const isPlainText = contentType.startsWith("text/plain");
+            if (isPlainText) {
+                runtime.logger.debug({
+                    src: "basic-capabilities",
+                    agentId: runtime.agentId,
+                    url: attachment.url,
+                }, "Processing plain text document");
+                const textContent = await res.text();
+                processedAttachment.text = textContent;
+                processedAttachment.title = processedAttachment.title || "Text File";
+                runtime.logger.debug({
+                    src: "basic-capabilities",
+                    agentId: runtime.agentId,
+                    textPreview: processedAttachment.text?.substring(0, 100) || undefined,
+                }, "Extracted text content");
+            }
+            else {
+                runtime.logger.warn({ src: "basic-capabilities", agentId: runtime.agentId, contentType }, "Skipping non-plain-text document");
+            }
+        }
+        processedAttachments.push(processedAttachment);
+    }
+    return processedAttachments;
+}
+export function shouldRespond(runtime, message, room, mentionContext) {
+    if (!room) {
+        return {
+            shouldRespond: false,
+            skipEvaluation: true,
+            reason: "no room context",
+        };
+    }
+    function normalizeEnvList(value) {
+        if (!value || typeof value !== "string") {
+            return [];
+        }
+        const cleaned = value.trim().replace(/^[[]|[\]]$/g, "");
+        return cleaned
+            .split(",")
+            .map((v) => v.trim())
+            .filter(Boolean);
+    }
+    const alwaysRespondChannels = [
+        ChannelType.DM,
+        ChannelType.VOICE_DM,
+        ChannelType.SELF,
+        ChannelType.API,
+    ];
+    const alwaysRespondSources = ["client_chat"];
+    const customChannels = normalizeEnvList(runtime.getSetting("ALWAYS_RESPOND_CHANNELS") ??
+        runtime.getSetting("SHOULD_RESPOND_BYPASS_TYPES"));
+    const customSources = normalizeEnvList(runtime.getSetting("ALWAYS_RESPOND_SOURCES") ??
+        runtime.getSetting("SHOULD_RESPOND_BYPASS_SOURCES"));
+    const respondChannels = new Set([...alwaysRespondChannels.map((t) => t.toString()), ...customChannels].map((s) => s.trim().toLowerCase()));
+    const respondSources = [...alwaysRespondSources, ...customSources].map((s) => s.trim().toLowerCase());
+    const roomType = room.type?.toString().toLowerCase() || undefined;
+    const messageContentSource = message.content.source;
+    const sourceStr = messageContentSource?.toLowerCase() || "";
+    const textMentionsAgentByName = textContainsUserTag(message.content.text) &&
+        textContainsAgentName(message.content.text, [
+            runtime.character.name,
+            runtime.character.username,
+        ]);
+    // 1. DM/VOICE_DM/API channels: always respond (private channels)
+    if (roomType && respondChannels.has(roomType)) {
+        return {
+            shouldRespond: true,
+            skipEvaluation: true,
+            reason: `private channel: ${roomType}`,
+        };
+    }
+    // 2. Specific sources (e.g., client_chat): always respond
+    if (respondSources.some((pattern) => sourceStr.includes(pattern))) {
+        return {
+            shouldRespond: true,
+            skipEvaluation: true,
+            reason: `whitelisted source: ${sourceStr}`,
+        };
+    }
+    // 3. Platform mentions and replies: always respond
+    // This is the key feature from mentionContext - platform-detected mentions/replies
+    const mentionContextIsMention = mentionContext?.isMention;
+    const mentionContextIsReply = mentionContext?.isReply;
+    const hasPlatformMention = !!(mentionContextIsMention || mentionContextIsReply);
+    if (hasPlatformMention) {
+        const mentionType = mentionContextIsMention ? "mention" : "reply";
+        return {
+            shouldRespond: true,
+            skipEvaluation: true,
+            reason: `platform ${mentionType}`,
+        };
+    }
+    // 4. Mixed-address messages should still reach the agent when the text
+    // explicitly names it alongside other user tags.
+    if (textMentionsAgentByName) {
+        return {
+            shouldRespond: true,
+            skipEvaluation: true,
+            reason: "text address with tagged participants",
+        };
+    }
+    // 5. Clear self-modification requests should bypass the ignore-biased
+    // classifier even in group chat, but only for narrow personality/style
+    // update phrasing to avoid broad false positives.
+    if (isExplicitSelfModificationRequest(message.content.text || "")) {
+        return {
+            shouldRespond: true,
+            skipEvaluation: true,
+            reason: "explicit self-modification request",
+        };
+    }
+    // 6. All other cases: let the LLM decide
+    // The LLM will handle: indirect questions, conversation context, etc.
+    return {
+        shouldRespond: false,
+        skipEvaluation: false,
+        reason: "needs LLM evaluation",
+    };
+}
+// ============================================================================
+// Event Handlers
+// ============================================================================
+const reactionReceivedHandler = async ({ runtime, message, }) => {
+    await runtime.createMemories([{ memory: message, tableName: "messages" }]);
+};
+const postGeneratedHandler = async ({ runtime, callback, worldId, userId, roomId, source, }) => {
+    const safeSource = source ?? "unknown";
+    const safeUserId = (userId ?? runtime.agentId);
+    runtime.logger.info({ src: "basic-capabilities", agentId: runtime.agentId }, "Generating new post");
+    // Ensure world exists first
+    await runtime.ensureWorldExists({
+        id: worldId,
+        name: `${runtime.character.name}'s Feed`,
+        agentId: runtime.agentId,
+        messageServerId: safeUserId,
+    });
+    await runtime.ensureRoomExists({
+        id: roomId,
+        name: `${runtime.character.name}'s Feed`,
+        source: safeSource,
+        type: ChannelType.FEED,
+        channelId: `${safeUserId}-home`,
+        messageServerId: safeUserId,
+        worldId,
+    });
+    const message = {
+        id: createUniqueUuid(runtime, `post-${Date.now()}`),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        roomId: roomId,
+        content: {},
+        metadata: {
+            entityName: runtime.character.name,
+            type: MemoryType.MESSAGE,
+        },
+    };
+    // generate thought of which providers to use using messageHandlerTemplate
+    // Compose state with relevant context for post generation
+    let state = await runtime.composeState(message, [
+        "PROVIDERS",
+        "CHARACTER",
+        "RECENT_MESSAGES",
+        "ENTITIES",
+    ]);
+    const entity = (await runtime.getEntitiesByIds([runtime.agentId]))[0] ?? null;
+    const entityMetadata = entity?.metadata;
+    const metadata = entityMetadata;
+    const metadataX = metadata?.x;
+    if (metadataX?.userName || metadata?.userName) {
+        state.values.xUserName =
+            metadataX?.userName || metadata?.userName || undefined;
+    }
+    const optimizedResponseService = runtime.getService(OPTIMIZED_PROMPT_SERVICE);
+    const baselineResponseTemplate = runtime.character.templates?.messageHandlerTemplate ||
+        messageHandlerTemplate;
+    const prompt = composePromptFromState({
+        state,
+        template: resolveOptimizedPrompt(optimizedResponseService, "response", baselineResponseTemplate),
+    });
+    let responseContent = null;
+    let retries = 0;
+    const maxRetries = 3;
+    while (retries < maxRetries &&
+        (!responseContent?.thought || !responseContent?.actions)) {
+        const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const parsedXml = parseKeyValueXml(response);
+        if (parsedXml) {
+            const actionsRaw = parsedXml.actions;
+            const providersRaw = parsedXml.providers;
+            // When actions is a raw XML string (preserved by parseKeyValueXml
+            // to avoid comma-splitting), extract action names from <name> tags.
+            // The downstream processActions code in message.ts has this same
+            // guard via normalizedActions.
+            const resolvedActions = Array.isArray(actionsRaw)
+                ? actionsRaw
+                : typeof actionsRaw === "string" && /<action[\s>/]/.test(actionsRaw)
+                    ? [
+                        ...actionsRaw.matchAll(/<action[^>]*>[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<\/action>/g),
+                    ]
+                        .map((m) => m[1].trim())
+                        .filter(Boolean)
+                    : actionsRaw
+                        ? [actionsRaw]
+                        : ["IGNORE"];
+            if (resolvedActions.length === 0 &&
+                typeof actionsRaw === "string" &&
+                /<action[\s>/]/.test(actionsRaw)) {
+                logger.warn({ src: "basic-capabilities" }, `No <name> tags found inside <action> elements, falling back to IGNORE. actionsRaw length: ${actionsRaw.length}`);
+            }
+            responseContent = {
+                thought: parsedXml.thought ?? "",
+                actions: resolvedActions.length > 0 ? resolvedActions : ["IGNORE"],
+                providers: Array.isArray(providersRaw)
+                    ? providersRaw
+                    : providersRaw
+                        ? [providersRaw]
+                        : [],
+                text: parsedXml.text ?? "",
+                simple: parsedXml.simple ?? false,
+            };
+        }
+        else {
+            responseContent = null;
+        }
+        retries++;
+        const responseContentThoughtAfter = responseContent?.thought;
+        const responseContentActionsAfter = responseContent?.actions;
+        if (!responseContentThoughtAfter || !responseContentActionsAfter) {
+            runtime.logger.warn({
+                src: "basic-capabilities",
+                agentId: runtime.agentId,
+                response,
+                parsedXml,
+                responseContent,
+            }, "Missing required fields, retrying");
+        }
+    }
+    const responseContentProviders = responseContent?.providers;
+    state = await runtime.composeState(message, responseContentProviders);
+    const postPrompt = composePromptFromState({
+        state,
+        template: runtime.character.templates?.postCreationTemplate || postCreationTemplate,
+    });
+    const xmlResponseText = await runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt: postPrompt,
+    });
+    const parsedXmlResponse = parseKeyValueXml(xmlResponseText);
+    if (!parsedXmlResponse) {
+        runtime.logger.error({ src: "basic-capabilities", agentId: runtime.agentId, xmlResponseText }, "Failed to parse XML response for post creation");
+        throw new Error("Failed to parse XML response for post creation");
+    }
+    function cleanupPostText(text) {
+        let cleanedText = text.replace(/^['"](.*)['"]$/, "$1");
+        cleanedText = cleanedText.replaceAll(/\\n/g, "\n\n");
+        cleanedText = cleanedText.replace(/([^\n])\n([^\n])/g, "$1\n\n$2");
+        return cleanedText;
+    }
+    const cleanedText = cleanupPostText(parsedXmlResponse.post ?? "");
+    const stateData = state.data;
+    const stateDataProviders = stateData?.providers;
+    const RM = stateDataProviders &&
+        stateDataProviders.RECENT_MESSAGES;
+    const RMData = RM?.data;
+    const RMDataRecentMessages = RMData?.recentMessages;
+    if (RMDataRecentMessages) {
+        for (const m of RMDataRecentMessages) {
+            if (cleanedText === m.content.text) {
+                runtime.logger.info({ src: "basic-capabilities", agentId: runtime.agentId, cleanedText }, "Already recently posted that, retrying");
+                postGeneratedHandler({
+                    runtime,
+                    callback,
+                    worldId,
+                    userId,
+                    roomId,
+                    source,
+                });
+                return; // don't call callbacks
+            }
+        }
+    }
+    // GPT 3.5/4: /(i\s+do\s+not|i'?m\s+not)\s+(feel\s+)?comfortable\s+generating\s+that\s+type\s+of\s+content|(inappropriate|explicit|offensive|communicate\s+respectfully|aim\s+to\s+(be\s+)?helpful)/i
+    const oaiRefusalRegex = /((i\s+do\s+not|i'm\s+not)\s+(feel\s+)?comfortable\s+generating\s+that\s+type\s+of\s+content)|(inappropriate|explicit|respectful|offensive|guidelines|aim\s+to\s+(be\s+)?helpful|communicate\s+respectfully)/i;
+    const anthropicRefusalRegex = /(i'?m\s+unable\s+to\s+help\s+with\s+that\s+request|due\s+to\s+safety\s+concerns|that\s+may\s+violate\s+(our\s+)?guidelines|provide\s+helpful\s+and\s+safe\s+responses|let'?s\s+try\s+a\s+different\s+direction|goes\s+against\s+(our\s+)?use\s+case\s+policies|ensure\s+safe\s+and\s+responsible\s+use)/i;
+    const googleRefusalRegex = /(i\s+can'?t\s+help\s+with\s+that|that\s+goes\s+against\s+(our\s+)?(policy|policies)|i'?m\s+still\s+learning|response\s+must\s+follow\s+(usage|safety)\s+policies|i'?ve\s+been\s+designed\s+to\s+avoid\s+that)/i;
+    //const cohereRefusalRegex = /(request\s+cannot\s+be\s+processed|violates\s+(our\s+)?content\s+policy|not\s+permitted\s+by\s+usage\s+restrictions)/i
+    const generalRefusalRegex = /(response\s+was\s+withheld|content\s+was\s+filtered|this\s+request\s+cannot\s+be\s+completed|violates\s+our\s+safety\s+policy|content\s+is\s+not\s+available)/i;
+    if (oaiRefusalRegex.test(cleanedText) ||
+        anthropicRefusalRegex.test(cleanedText) ||
+        googleRefusalRegex.test(cleanedText) ||
+        generalRefusalRegex.test(cleanedText)) {
+        runtime.logger.info({ src: "basic-capabilities", agentId: runtime.agentId, cleanedText }, "Got prompt moderation refusal, retrying");
+        postGeneratedHandler({
+            runtime,
+            callback,
+            worldId,
+            userId,
+            roomId,
+            source,
+        });
+        return; // don't call callbacks
+    }
+    // Create the response memory
+    const responseMessages = [
+        {
+            id: v4(),
+            entityId: runtime.agentId,
+            agentId: runtime.agentId,
+            content: {
+                text: cleanedText,
+                source,
+                channelType: ChannelType.FEED,
+                thought: parsedXmlResponse.thought ?? "",
+                type: "post",
+            },
+            roomId: message.roomId,
+            createdAt: Date.now(),
+        },
+    ];
+    for (const message of responseMessages) {
+        if (callback) {
+            await callback(message.content);
+        }
+    }
+};
+/**
+ * Syncs a single user into an entity
+ */
+const syncSingleUser = async (entityId, runtime, messageServerId, channelId, type, source) => {
+    const entity = (await runtime.getEntitiesByIds([entityId]))[0] ?? null;
+    runtime.logger.info({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        entityId,
+        username: entity?.metadata?.username || undefined,
+    }, "Syncing user");
+    // Ensure we're not using WORLD type and that we have a valid channelId
+    if (!channelId) {
+        runtime.logger.warn({
+            src: "basic-capabilities",
+            agentId: runtime.agentId,
+            entityId: entity?.id || undefined,
+        }, "Cannot sync user without a valid channelId");
+        return;
+    }
+    const roomId = createUniqueUuid(runtime, channelId);
+    const worldId = createUniqueUuid(runtime, messageServerId);
+    const worldMetadata = type === ChannelType.DM
+        ? {
+            ownership: {
+                ownerId: entityId,
+            },
+            roles: {
+                [entityId]: ROLE_OWNER,
+            },
+            settings: {}, // Initialize empty settings for onboarding
+        }
+        : undefined;
+    runtime.logger.info({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        type,
+        isDM: type === ChannelType.DM,
+        worldMetadata,
+    }, "syncSingleUser");
+    await runtime.ensureConnection({
+        entityId,
+        roomId,
+        name: (entity?.metadata?.name ||
+            entity?.metadata?.username ||
+            `User${entityId}`),
+        source,
+        channelId,
+        messageServerId,
+        type,
+        worldId,
+        metadata: worldMetadata,
+    });
+    const createdWorld = (await runtime.getWorldsByIds([worldId]))[0] ?? null;
+    runtime.logger.info({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        worldId,
+        metadata: createdWorld?.metadata || undefined,
+    }, "Created world check");
+    runtime.logger.success({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        agentName: runtime.character.name,
+        entityId: entity?.id || undefined,
+    }, "Successfully synced user");
+};
+/**
+ * Handles standardized server data for both WORLD_JOINED and WORLD_CONNECTED events
+ */
+const handleServerSync = async ({ runtime, world, rooms, entities, source, onComplete, }) => {
+    runtime.logger.debug({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        serverName: world.name,
+    }, "Handling server sync event");
+    const safeSource = source ?? "unknown";
+    await runtime.ensureConnections(entities, rooms, safeSource, world);
+    runtime.logger.debug({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        worldName: world.name,
+    }, "Successfully synced standardized world structure");
+    if (onComplete) {
+        onComplete();
+    }
+};
+const controlMessageHandler = async ({ runtime, message, }) => {
+    runtime.logger.debug({
+        src: "basic-capabilities",
+        agentId: runtime.agentId,
+        action: message.payload.action,
+        roomId: message.roomId,
+    }, "Processing control message");
+    const serviceNames = Array.from(runtime.getAllServices().keys());
+    const websocketServiceName = serviceNames.find((name) => name.toLowerCase().includes("websocket") ||
+        name.toLowerCase().includes("socket"));
+    if (websocketServiceName) {
+        const websocketService = runtime.getService(websocketServiceName);
+        if (websocketService && "sendMessage" in websocketService) {
+            await websocketService.sendMessage({
+                type: "controlMessage",
+                payload: {
+                    action: message.payload.action,
+                    target: message.payload.target,
+                    roomId: message.roomId,
+                },
+            });
+            runtime.logger.debug({
+                src: "basic-capabilities",
+                agentId: runtime.agentId,
+                action: message.payload.action,
+            }, "Control message sent successfully");
+        }
+        else {
+            runtime.logger.error({ src: "basic-capabilities", agentId: runtime.agentId }, "WebSocket service does not have sendMessage method");
+        }
+    }
+    else {
+        runtime.logger.error({ src: "basic-capabilities", agentId: runtime.agentId }, "No WebSocket service found to send control message");
+    }
+};
+// ============================================================================
+// Events Configuration
+// ============================================================================
+const events = {
+    [EventType.REACTION_RECEIVED]: [
+        async (payload) => {
+            await reactionReceivedHandler(payload);
+        },
+    ],
+    [EventType.POST_GENERATED]: [
+        async (payload) => {
+            await postGeneratedHandler(payload);
+        },
+    ],
+    [EventType.MESSAGE_SENT]: [
+        async (payload) => {
+            payload.runtime.logger.debug({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                text: payload.message.content.text,
+            }, "Message sent");
+        },
+    ],
+    [EventType.WORLD_JOINED]: [
+        async (payload) => {
+            await handleServerSync(payload);
+        },
+    ],
+    [EventType.WORLD_CONNECTED]: [
+        async (payload) => {
+            await handleServerSync(payload);
+        },
+    ],
+    [EventType.ENTITY_JOINED]: [
+        async (payload) => {
+            payload.runtime.logger.debug({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                entityId: payload.entityId,
+            }, "ENTITY_JOINED event received");
+            if (!payload.worldId) {
+                payload.runtime.logger.error({ src: "basic-capabilities", agentId: payload.runtime.agentId }, "No worldId provided for entity joined");
+                return;
+            }
+            if (!payload.roomId) {
+                payload.runtime.logger.error({ src: "basic-capabilities", agentId: payload.runtime.agentId }, "No roomId provided for entity joined");
+                return;
+            }
+            const payloadMetadata = payload.metadata;
+            if (!payloadMetadata?.type) {
+                payload.runtime.logger.error({ src: "basic-capabilities", agentId: payload.runtime.agentId }, "No type provided for entity joined");
+                return;
+            }
+            const channelType = payloadMetadata?.type;
+            if (typeof channelType !== "string") {
+                payload.runtime.logger.warn("Missing channel type in entity payload");
+                return;
+            }
+            const safeSource = payload.source ?? "unknown";
+            if (!payload.roomId) {
+                payload.runtime.logger.warn("Missing roomId in entity payload");
+                return;
+            }
+            await syncSingleUser(payload.entityId, payload.runtime, payload.worldId, payload.roomId, channelType, safeSource);
+        },
+    ],
+    [EventType.ENTITY_LEFT]: [
+        async (payload) => {
+            // Update entity to inactive
+            const entity = (await payload.runtime.getEntitiesByIds([payload.entityId]))[0] ?? null;
+            if (entity) {
+                entity.metadata = {
+                    ...entity.metadata,
+                    status: "INACTIVE",
+                    leftAt: Date.now(),
+                };
+                await payload.runtime.updateEntities([entity]);
+            }
+            payload.runtime.logger.info({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                entityId: payload.entityId,
+                worldId: payload.worldId,
+            }, "User left world");
+        },
+    ],
+    [EventType.ACTION_STARTED]: [
+        async (payload) => {
+            // Only notify for client_chat messages
+            const payloadContent = payload.content;
+            if (payloadContent && payloadContent.source === "client_chat") {
+                const messageBusService = payload.runtime.getService("message-bus-service");
+                if (messageBusService?.notifyActionStart) {
+                    await messageBusService.notifyActionStart(payload.roomId, payload.world, payload.content, payload.messageId);
+                }
+            }
+        },
+        async (payload) => {
+            const content = payload.content;
+            const contentActions = content?.actions;
+            const actionName = contentActions?.[0] ?? "unknown";
+            await payload.runtime.createLogs([
+                {
+                    entityId: payload.runtime.agentId,
+                    roomId: payload.roomId,
+                    type: "action_event",
+                    body: {
+                        runId: content?.runId ?? "",
+                        actionId: content?.actionId ?? "",
+                        actionName: actionName,
+                        roomId: payload.roomId,
+                        messageId: payload.messageId,
+                        timestamp: Date.now(),
+                        planStep: content?.planStep ?? "",
+                        source: "actionHandler",
+                    },
+                },
+            ]);
+            logger.debug({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                actionName: actionName,
+            }, "Logged ACTION_STARTED event");
+        },
+    ],
+    [EventType.ACTION_COMPLETED]: [
+        async (payload) => {
+            // Only notify for client_chat messages
+            const payloadContent = payload.content;
+            if (payloadContent && payloadContent.source === "client_chat") {
+                const messageBusService = payload.runtime.getService("message-bus-service");
+                if (messageBusService?.notifyActionUpdate) {
+                    await messageBusService.notifyActionUpdate(payload.roomId, payload.world, payload.content, payload.messageId);
+                }
+            }
+        },
+    ],
+    [EventType.EVALUATOR_STARTED]: [
+        async (payload) => {
+            logger.debug({
+                src: "basic-capabilities:evaluator",
+                agentId: payload.runtime.agentId,
+                evaluatorName: payload.evaluatorName,
+                evaluatorId: payload.evaluatorId,
+            }, "Evaluator started");
+        },
+    ],
+    [EventType.EVALUATOR_COMPLETED]: [
+        async (payload) => {
+            const status = payload.error ? "failed" : "completed";
+            logger.debug({
+                src: "basic-capabilities:evaluator",
+                agentId: payload.runtime.agentId,
+                status,
+                evaluatorName: payload.evaluatorName,
+                evaluatorId: payload.evaluatorId,
+                error: payload.error?.message || undefined,
+            }, "Evaluator completed");
+        },
+    ],
+    [EventType.RUN_STARTED]: [
+        async (payload) => {
+            await payload.runtime.createLogs([
+                {
+                    entityId: payload.entityId,
+                    roomId: payload.roomId,
+                    type: "run_event",
+                    body: {
+                        runId: payload.runId,
+                        status: payload.status,
+                        messageId: payload.messageId,
+                        roomId: payload.roomId,
+                        entityId: payload.entityId,
+                        startTime: payload.startTime,
+                        source: payload.source || "unknown",
+                    },
+                },
+            ]);
+            logger.debug({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                runId: payload.runId,
+            }, "Logged RUN_STARTED event");
+        },
+    ],
+    [EventType.RUN_ENDED]: [
+        async (payload) => {
+            await payload.runtime.createLogs([
+                {
+                    entityId: payload.entityId,
+                    roomId: payload.roomId,
+                    type: "run_event",
+                    body: {
+                        runId: payload.runId,
+                        status: payload.status,
+                        messageId: payload.messageId,
+                        roomId: payload.roomId,
+                        entityId: payload.entityId,
+                        startTime: payload.startTime,
+                        endTime: payload.endTime,
+                        duration: payload.duration,
+                        error: payload.error,
+                        source: payload.source || "unknown",
+                    },
+                },
+            ]);
+            logger.debug({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                runId: payload.runId,
+                status: payload.status,
+            }, "Logged RUN_ENDED event");
+        },
+    ],
+    [EventType.RUN_TIMEOUT]: [
+        async (payload) => {
+            await payload.runtime.createLogs([
+                {
+                    entityId: payload.entityId,
+                    roomId: payload.roomId,
+                    type: "run_event",
+                    body: {
+                        runId: payload.runId,
+                        status: payload.status,
+                        messageId: payload.messageId,
+                        roomId: payload.roomId,
+                        entityId: payload.entityId,
+                        startTime: payload.startTime,
+                        endTime: payload.endTime,
+                        duration: payload.duration,
+                        error: payload.error,
+                        source: payload.source || "unknown",
+                    },
+                },
+            ]);
+            logger.debug({
+                src: "basic-capabilities",
+                agentId: payload.runtime.agentId,
+                runId: payload.runId,
+            }, "Logged RUN_TIMEOUT event");
+        },
+    ],
+    [EventType.CONTROL_MESSAGE]: [
+        async (payload) => {
+            if (!payload.message) {
+                payload.runtime.logger.warn({ src: "basic-capabilities" }, "CONTROL_MESSAGE received without message property");
+                return;
+            }
+            await controlMessageHandler(payload);
+        },
+    ],
+};
+// ============================================================================
+// Basic Capabilities
+// ============================================================================
+/**
+ * Basic providers - core functionality for agent operation
+ */
+export const basicProviders = [
+    providers.actionsProvider,
+    providers.actionStateProvider,
+    providers.attachmentsProvider,
+    providers.characterProvider,
+    providers.choiceProvider,
+    providers.contextBenchProvider,
+    providers.currentTimeProvider,
+    providers.entitiesProvider,
+    providers.evaluatorsProvider,
+    providers.providersProvider,
+    providers.recentMessagesProvider,
+    providers.timeProvider,
+    providers.uiContextProvider,
+    providers.worldProvider,
+];
+/**
+ * Basic actions - fundamental response actions
+ */
+export const basicActions = [
+    withCanonicalActionDocs(actions.choiceAction),
+    withCanonicalActionDocs(actions.replyAction),
+    withCanonicalActionDocs(actions.ignoreAction),
+    withCanonicalActionDocs(actions.noneAction),
+];
+/**
+ * Basic evaluators - none by default (evaluators are typically advanced features)
+ */
+export const basicEvaluators = [];
+/**
+ * Basic services - essential infrastructure services
+ */
+export const basicServices = [
+    TaskService,
+    EmbeddingGenerationService,
+];
+/**
+ * Combined basic capabilities object
+ */
+export const basicCapabilities = {
+    providers: basicProviders,
+    actions: basicActions,
+    evaluators: basicEvaluators,
+    services: basicServices,
+};
+// Autonomy capabilities - opt-in
+// Provides autonomous operation with continuous agent thinking loop
+const autonomyCapabilities = {
+    providers: [autonomy.adminChatProvider, autonomy.autonomyStatusProvider],
+    actions: [withCanonicalActionDocs(autonomy.sendToAdminAction)],
+    evaluators: [],
+    services: [autonomy.AutonomyService],
+    routes: autonomy.autonomyRoutes,
+};
+// Legacy alias exports for backwards compatibility
+export { advancedCapabilities as extendedCapabilities, autonomyCapabilities };
+/**
+ * Creates the basic-capabilities plugin with the specified capability configuration.
+ * This is the main entry point for plugin creation.
+ */
+export function createBasicCapabilitiesPlugin(config = {}) {
+    // Support both enableExtended and advancedCapabilities as aliases
+    const useAdvanced = config.enableExtended || config.advancedCapabilities;
+    const filteredBasicProviders = config.skipCharacterProvider
+        ? basicProviders.filter((p) => p.name !== "CHARACTER")
+        : basicProviders;
+    // Build init chain for core capabilities that need initialization
+    const initFns = [];
+    if (config.enableTrust) {
+        initFns.push(trustCapability.init);
+    }
+    return {
+        name: "basic-capabilities",
+        description: "Agent basic capabilities with core actions and evaluators",
+        actions: [
+            ...(config.disableBasic ? [] : basicActions),
+            ...(useAdvanced ? advancedActions : []),
+            ...(config.enableAutonomy ? autonomyCapabilities.actions : []),
+            ...(config.enableTrust ? trustCapability.actions : []),
+            ...(config.enableSecretsManager ? secretsCapability.actions : []),
+            ...(config.enablePluginManager ? pluginManagerCapability.actions : []),
+        ],
+        providers: [
+            ...(config.disableBasic ? [] : filteredBasicProviders),
+            ...(useAdvanced ? advancedProviders : []),
+            ...(config.enableAutonomy ? autonomyCapabilities.providers : []),
+            ...(config.enableTrust ? trustCapability.providers : []),
+            ...(config.enableSecretsManager ? secretsCapability.providers : []),
+            ...(config.enablePluginManager ? pluginManagerCapability.providers : []),
+        ],
+        evaluators: [
+            ...(config.disableBasic ? [] : basicEvaluators),
+            ...(useAdvanced ? advancedEvaluators : []),
+            ...(config.enableAutonomy ? autonomyCapabilities.evaluators : []),
+        ],
+        services: [
+            ...(config.disableBasic ? [] : basicServices),
+            ...(useAdvanced ? advancedServices : []),
+            ...(config.enableAutonomy ? autonomyCapabilities.services : []),
+            ...(config.enableTrust ? trustCapability.services : []),
+            ...(config.enableSecretsManager ? secretsCapability.services : []),
+            ...(config.enablePluginManager ? pluginManagerCapability.services : []),
+        ],
+        routes: [...(config.enableAutonomy ? autonomyCapabilities.routes : [])],
+        events,
+        ...(initFns.length > 0
+            ? {
+                init: async (_config, runtime) => {
+                    for (const fn of initFns) {
+                        await fn(runtime);
+                    }
+                },
+            }
+            : {}),
+    };
+}
+export default basicCapabilities;