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

package/packages/typescript/src/features/trust/actions/recordTrustInteraction.js

@@ -0,0 +1,189 @@
+import { logger } from "../../../logger.js";
+import { parseJSONObjectFromText } from "../../../utils.js";
+import { TrustEvidenceType } from "../types/trust.js";
+import { hasTrustEngine } from "./hasTrustEngine.js";
+export const recordTrustInteractionAction = {
+    name: "RECORD_TRUST_INTERACTION",
+    description: "Records a trust-affecting interaction between entities",
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avKeywords = ["record", "trust", "interaction"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            __avKeywords.some((word) => word.length > 0 && __avText.includes(word));
+        const __avRegex = /\b(?:record|trust|interaction)\b/i;
+        const __avRegexOk = __avRegex.test(__avText);
+        const __avSource = String(message?.content?.source ?? "");
+        const __avExpectedSource = "";
+        const __avSourceOk = __avExpectedSource
+            ? __avSource === __avExpectedSource
+            : Boolean(__avSource ||
+                state ||
+                runtime?.agentId ||
+                runtime?.getService ||
+                runtime?.getSetting);
+        const __avOptions = options && typeof options === "object" ? options : {};
+        const __avInputOk = __avText.trim().length > 0 ||
+            Object.keys(__avOptions).length > 0 ||
+            Boolean(message?.content && typeof message.content === "object");
+        if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+            return false;
+        }
+        const __avLegacyValidate = async (legacyRuntime, legacyMessage, legacyState, legacyOptions) => {
+            const __avTextRaw = typeof legacyMessage?.content?.text === "string"
+                ? legacyMessage.content.text
+                : "";
+            const __avText = __avTextRaw.toLowerCase();
+            const __avKeywords = ["record", "trust", "interaction"];
+            const __avKeywordOk = __avKeywords.length > 0 &&
+                __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+            const __avRegex = /\b(?:record|trust|interaction)\b/i;
+            const __avRegexOk = __avRegex.test(__avText);
+            const __avSource = String(legacyMessage?.content?.source ?? "");
+            const __avExpectedSource = "";
+            const __avSourceOk = __avExpectedSource
+                ? __avSource === __avExpectedSource
+                : Boolean(__avSource ||
+                    legacyState ||
+                    legacyRuntime?.agentId ||
+                    legacyRuntime?.getService);
+            const __avOptions = legacyOptions && typeof legacyOptions === "object" ? legacyOptions : {};
+            const __avInputOk = __avText.trim().length > 0 ||
+                Object.keys(__avOptions).length > 0 ||
+                Boolean(legacyMessage?.content && typeof legacyMessage.content === "object");
+            if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+                return false;
+            }
+            try {
+                return hasTrustEngine(legacyRuntime);
+            }
+            catch {
+                return false;
+            }
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message, state, options));
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message) => {
+        const trustEngine = runtime.getService("trust-engine");
+        if (!trustEngine) {
+            throw new Error("Trust engine service not available");
+        }
+        const text = message.content.text || "";
+        let parsed = null;
+        try {
+            parsed = parseJSONObjectFromText(text);
+        }
+        catch {
+            // Not JSON
+        }
+        const parsedContent = parsed;
+        if (!parsedContent?.type) {
+            return {
+                success: false,
+                text: "Could not parse trust interaction details. Please provide type and optionally: targetEntityId, impact, description",
+                error: "Invalid or missing interaction type",
+            };
+        }
+        const evidenceType = parsedContent.type;
+        const targetEntityId = parsedContent.targetEntityId;
+        const impact = parsedContent.impact;
+        const validTypes = Object.values(TrustEvidenceType);
+        const normalizedType = evidenceType?.toUpperCase();
+        const matchedType = validTypes.find((type) => type.toUpperCase() === normalizedType);
+        if (!matchedType) {
+            logger.error({ evidenceType }, "[RecordTrustInteraction] Invalid evidence type:");
+            return {
+                success: false,
+                text: `Invalid interaction type. Valid types are: ${validTypes.join(", ")}`,
+                error: "Invalid evidence type provided",
+            };
+        }
+        const finalTargetEntityId = targetEntityId || runtime.agentId;
+        const finalImpact = impact ?? 10;
+        const interaction = {
+            sourceEntityId: message.entityId,
+            targetEntityId: finalTargetEntityId,
+            type: matchedType,
+            timestamp: Date.now(),
+            impact: finalImpact,
+            details: {
+                description: parsedContent.description || `Trust interaction: ${matchedType}`,
+                messageId: message.id,
+                roomId: message.roomId,
+            },
+            context: {
+                evaluatorId: runtime.agentId,
+                roomId: message.roomId,
+            },
+        };
+        try {
+            await trustEngine.recordInteraction(interaction);
+            logger.info({
+                type: matchedType,
+                source: message.entityId,
+                target: interaction.targetEntityId,
+                impact: interaction.impact,
+            }, "[RecordTrustInteraction] Recorded interaction:");
+            return {
+                success: true,
+                text: `Trust interaction recorded: ${matchedType} with impact ${interaction.impact > 0 ? "+" : ""}${interaction.impact}`,
+                data: {
+                    interaction,
+                    success: true,
+                },
+            };
+        }
+        catch (error) {
+            logger.error({ error }, "[RecordTrustInteraction] Error recording interaction:");
+            return {
+                success: false,
+                text: "Failed to record trust interaction. Please try again.",
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Record that Alice kept their promise to help with the project",
+                },
+            },
+            {
+                name: "{{name2}}",
+                content: {
+                    text: "Trust interaction recorded: PROMISE_KEPT with impact +15",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Log suspicious behavior from Bob who is spamming the channel",
+                },
+            },
+            {
+                name: "{{name2}}",
+                content: {
+                    text: "Trust interaction recorded: SPAM_BEHAVIOR with impact -10",
+                },
+            },
+        ],
+    ],
+    similes: [
+        "record trust event",
+        "log trust interaction",
+        "track behavior",
+        "note trustworthy action",
+        "report suspicious activity",
+        "document promise kept",
+        "mark helpful contribution",
+    ],
+};

package/packages/typescript/src/features/trust/actions/requestElevation.d.ts

@@ -0,0 +1,3 @@
+import type { Action as ElizaAction } from "../../../types/index.ts";
+export declare const requestElevationAction: ElizaAction;
+//# sourceMappingURL=requestElevation.d.ts.map

package/packages/typescript/src/features/trust/actions/requestElevation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestElevation.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/actions/requestElevation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,MAAM,IAAI,WAAW,EAGrB,MAAM,yBAAyB,CAAC;AAIjC,eAAO,MAAM,sBAAsB,EAAE,WAkOpC,CAAC"}

package/packages/typescript/src/features/trust/actions/requestElevation.js

@@ -0,0 +1,165 @@
+import { logger } from "../../../logger.js";
+import { parseJSONObjectFromText } from "../../../utils.js";
+export const requestElevationAction = {
+    name: "REQUEST_ELEVATION",
+    description: "Request temporary elevation of permissions for a specific action",
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avLegacyContextOk = Boolean(runtime?.getService?.("contextual-permissions"));
+        const __avKeywords = ["request", "elevation"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            (__avKeywords.some((word) => word.length > 0 && __avText.includes(word)) ||
+                __avLegacyContextOk);
+        const __avRegex = /\b(?:request|elevation)\b/i;
+        const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
+        const __avSource = String(message?.content?.source ?? "");
+        const __avExpectedSource = "";
+        const __avSourceOk = __avExpectedSource
+            ? __avSource === __avExpectedSource
+            : Boolean(__avSource ||
+                state ||
+                runtime?.agentId ||
+                runtime?.getService ||
+                runtime?.getSetting);
+        const __avOptions = options && typeof options === "object" ? options : {};
+        const __avInputOk = __avText.trim().length > 0 ||
+            Object.keys(__avOptions).length > 0 ||
+            Boolean(message?.content && typeof message.content === "object");
+        if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+            return false;
+        }
+        const __avLegacyValidate = async (legacyRuntime, _legacyMessage, _legacyState, _legacyOptions) => {
+            const permissionSystem = legacyRuntime.getService("contextual-permissions");
+            return !!permissionSystem;
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message, state, options));
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message) => {
+        const permissionSystem = runtime.getService("contextual-permissions");
+        const trustEngine = runtime.getService("trust-engine");
+        if (!permissionSystem || !trustEngine) {
+            throw new Error("Required services not available");
+        }
+        const text = message.content.text || "";
+        let parsed = null;
+        try {
+            parsed = parseJSONObjectFromText(text);
+        }
+        catch {
+            // Not JSON
+        }
+        const requestData = parsed;
+        if (!requestData?.action) {
+            return {
+                success: false,
+                text: 'Please specify the action you need elevated permissions for. Example: "I need to manage roles to help moderate the channel"',
+                error: "No action specified",
+            };
+        }
+        const trustProfile = await trustEngine.evaluateTrust(message.entityId, runtime.agentId, {
+            roomId: message.roomId,
+        });
+        const elevationRequest = {
+            entityId: message.entityId,
+            requestedPermission: {
+                action: requestData.action,
+                resource: requestData.resource || "*",
+            },
+            justification: requestData.justification || text,
+            context: {
+                roomId: message.roomId,
+                platform: "discord",
+            },
+            duration: (requestData.duration || 60) * 60 * 1000,
+        };
+        try {
+            const result = await permissionSystem.requestElevation(elevationRequest);
+            if (result.allowed) {
+                const expiryTime = result.ttl
+                    ? new Date(Date.now() + result.ttl).toLocaleString()
+                    : "session end";
+                return {
+                    success: true,
+                    text: `Elevation approved! You have been granted temporary ${requestData.action} permissions until ${expiryTime}.
+
+Please use these permissions responsibly. All actions will be logged for audit.`,
+                    data: {
+                        approved: true,
+                        expiresAt: result.ttl ? Date.now() + result.ttl : undefined,
+                        method: result.method,
+                    },
+                };
+            }
+            else {
+                let denialMessage = `Elevation request denied: ${result.reason}`;
+                denialMessage += `\n\nYour current trust score is ${trustProfile.overallTrust}/100.`;
+                if (result.suggestions && result.suggestions.length > 0) {
+                    denialMessage += `\n\nSuggestions:\n${result.suggestions.map((s) => `- ${s}`).join("\n")}`;
+                }
+                return {
+                    success: false,
+                    text: denialMessage,
+                    data: {
+                        approved: false,
+                        reason: result.reason,
+                        currentTrust: trustProfile.overallTrust,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            logger.error({ error }, "[RequestElevation] Error processing elevation request:");
+            return {
+                success: false,
+                text: "Failed to process elevation request. Please try again.",
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "I need permission to manage roles to help moderate spam in the channel",
+                },
+            },
+            {
+                name: "{{name2}}",
+                content: {
+                    text: "Elevation approved! You have been granted temporary manage_roles permissions until 12/20/2024, 5:30:00 PM.\n\nPlease use these permissions responsibly. All actions will be logged for audit.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Grant me admin access",
+                },
+            },
+            {
+                name: "{{name2}}",
+                content: {
+                    text: "Elevation request denied: Insufficient justification provided\n\nYour current trust score is 45/100. You need 15 more trust points for this permission.\n\nSuggestions:\n- Provide a specific justification for why you need admin access\n- Build trust through consistent positive contributions\n- Request more specific permissions instead of full admin access",
+                },
+            },
+        ],
+    ],
+    similes: [
+        "request elevated permissions",
+        "need temporary access",
+        "request higher privileges",
+        "need admin permission",
+        "elevate my permissions",
+        "grant me access",
+        "temporary permission request",
+        "need special access",
+    ],
+};

package/packages/typescript/src/features/trust/actions/roles.d.ts

@@ -0,0 +1,3 @@
+import { type Action as ElizaAction } from "../../../types/index.ts";
+export declare const updateRoleAction: ElizaAction;
+//# sourceMappingURL=roles.d.ts.map

package/packages/typescript/src/features/trust/actions/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/actions/roles.ts"],"names":[],"mappings":"AAEA,OAAO,EAIN,KAAK,MAAM,IAAI,WAAW,EAS1B,MAAM,yBAAyB,CAAC;AA2DjC,eAAO,MAAM,gBAAgB,EAAE,WA+S9B,CAAC"}

package/packages/typescript/src/features/trust/actions/roles.js

@@ -0,0 +1,295 @@
+import dedent from "dedent";
+import { logger } from "../../../logger.js";
+import { ChannelType, ModelType, Role, } from "../../../types/index.js";
+import { composePrompt } from "../../../utils.js";
+const canModifyRole = (currentRole, targetRole, newRole) => {
+    if (targetRole === currentRole)
+        return false;
+    switch (currentRole) {
+        case Role.OWNER:
+            return true;
+        case Role.ADMIN:
+            return newRole !== Role.OWNER;
+        default:
+            return false;
+    }
+};
+const _extractionTemplate = `# Task: Extract role assignments from the conversation
+
+# Current Server Members:
+{{serverMembers}}
+
+# Available Roles:
+- OWNER: Full control over the organization
+- ADMIN: Administrative privileges
+- NONE: Standard member access
+
+# Recent Conversation:
+{{recentMessages}}
+
+# Current speaker role: {{speakerRole}}
+
+# Instructions: Analyze the conversation and extract any role assignments being made by the speaker.
+Only extract role assignments if:
+1. The speaker has appropriate permissions to make the change
+2. The role assignment is clearly stated
+3. The target user is a valid server member
+4. The new role is one of: OWNER, ADMIN, or NONE
+
+Return the results in this JSON format:
+{
+"roleAssignments": [
+  {
+    "entityId": "<UUID of the entity being assigned to>",
+    "newRole": "ROLE_NAME"
+  }
+]
+}
+
+If no valid role assignments are found, return an empty array.`;
+export const updateRoleAction = {
+    name: "UPDATE_ROLE",
+    similes: ["CHANGE_ROLE", "SET_PERMISSIONS", "ASSIGN_ROLE", "MAKE_ADMIN"],
+    description: "Assigns a role (Admin, Owner, None) to a user or list of users in a channel.",
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avLegacyContextOk = Boolean((message?.content?.channelType === ChannelType.GROUP ||
+            message?.content?.channelType === ChannelType.WORLD) &&
+            message?.content?.serverId);
+        const __avKeywords = ["update", "role", "roles"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            (__avKeywords.some((word) => word.length > 0 && __avText.includes(word)) ||
+                __avLegacyContextOk);
+        const __avRegex = /\b(?:update|role|roles)\b/i;
+        const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
+        const __avSource = String(message?.content?.source ?? "");
+        const __avExpectedSource = "";
+        const __avSourceOk = __avExpectedSource
+            ? __avSource === __avExpectedSource
+            : Boolean(__avSource ||
+                state ||
+                runtime?.agentId ||
+                runtime?.getService ||
+                runtime?.getSetting ||
+                __avLegacyContextOk ||
+                message?.content);
+        const __avOptions = options && typeof options === "object" ? options : {};
+        const __avInputOk = __avText.trim().length > 0 ||
+            Object.keys(__avOptions).length > 0 ||
+            Boolean(message?.content && typeof message.content === "object");
+        if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+            return false;
+        }
+        const __avLegacyValidate = async (_runtime, message, _state) => {
+            const channelType = message.content.channelType;
+            const serverId = message.content.serverId;
+            return ((channelType === ChannelType.GROUP ||
+                channelType === ChannelType.WORLD) &&
+                !!serverId);
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message, state));
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message, state, _options, callback) => {
+        if (!state) {
+            logger.error("State is required for role assignment");
+            throw new Error("State is required for role assignment");
+        }
+        const { roomId } = message;
+        const serverId = message.content.serverId;
+        const worldId = runtime.getSetting("WORLD_ID");
+        let world = null;
+        if (worldId) {
+            world = await runtime.getWorld(worldId);
+        }
+        if (!world) {
+            logger.error("World not found");
+            await callback?.({
+                text: "I couldn't find the world. This action only works in a world.",
+            });
+            return {
+                success: false,
+                data: {
+                    success: false,
+                    error: "World not found",
+                },
+            };
+        }
+        if (!world.metadata?.roles) {
+            world.metadata = world.metadata || {};
+            world.metadata.roles = {};
+        }
+        const entities = await runtime.getEntitiesForRoom(roomId);
+        const requesterRole = world.metadata.roles[message.entityId] || Role.NONE;
+        const extractionPrompt = composePrompt({
+            state: {
+                ...state.values,
+                content: state.text,
+            },
+            template: dedent `
+				# Task: Parse Role Assignment
+
+				I need to extract user role assignments from the input text. Users can be referenced by name, username, or mention.
+
+				The available role types are:
+				- OWNER: Full control over the server and all settings
+				- ADMIN: Ability to manage channels and moderate content
+				- NONE: Regular user with no special permissions
+
+				# Current context:
+				{{content}}
+
+				Format your response as a JSON array of objects, each with:
+				- entityId: The name or ID of the user
+				- newRole: The role to assign (OWNER, ADMIN, or NONE)
+
+				Example:
+				\`\`\`json
+				[
+					{
+						"entityId": "John",
+						"newRole": "ADMIN"
+					},
+					{
+						"entityId": "Sarah",
+						"newRole": "OWNER"
+					}
+				]
+				\`\`\`
+			`,
+        });
+        const result = await runtime.useModel(ModelType.OBJECT_LARGE, {
+            prompt: extractionPrompt,
+            schema: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        entityId: { type: "string" },
+                        newRole: {
+                            type: "string",
+                            enum: Object.values(Role),
+                        },
+                    },
+                    required: ["entityId", "newRole"],
+                },
+            },
+            output: "array",
+        });
+        if (!result?.length) {
+            await callback?.({
+                text: "No valid role assignments found in the request.",
+                actions: ["UPDATE_ROLE"],
+                source: "discord",
+            });
+            return {
+                success: false,
+                data: {
+                    success: false,
+                    message: "No valid role assignments found",
+                },
+            };
+        }
+        let worldUpdated = false;
+        const updatedRoles = [];
+        for (const assignment of result) {
+            const targetEntity = entities.find((e) => e.id === assignment.entityId);
+            if (!targetEntity) {
+                logger.error("Could not find an ID to assign to");
+                continue;
+            }
+            const currentRole = world.metadata.roles[assignment.entityId];
+            if (!canModifyRole(requesterRole, currentRole, assignment.newRole)) {
+                await callback?.({
+                    text: `You don't have permission to change ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
+                    actions: ["UPDATE_ROLE"],
+                    source: "discord",
+                });
+                continue;
+            }
+            world.metadata.roles[assignment.entityId] = assignment.newRole;
+            worldUpdated = true;
+            updatedRoles.push({
+                entityName: targetEntity.names[0] || "Unknown",
+                entityId: assignment.entityId,
+                newRole: assignment.newRole,
+            });
+            await callback?.({
+                text: `Updated ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
+                actions: ["UPDATE_ROLE"],
+                source: "discord",
+            });
+        }
+        if (worldUpdated) {
+            await runtime.updateWorld(world);
+            logger.info(`Updated roles in world metadata for server ${serverId}`);
+        }
+        return {
+            success: worldUpdated,
+            data: {
+                success: worldUpdated,
+                updatedRoles,
+                totalProcessed: result.length,
+                totalUpdated: updatedRoles.length,
+            },
+            text: worldUpdated
+                ? `Successfully updated ${updatedRoles.length} role(s).`
+                : "No roles were updated.",
+        };
+    },
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Make {{name2}} an ADMIN",
+                    source: "discord",
+                },
+            },
+            {
+                name: "{{name3}}",
+                content: {
+                    text: "Updated {{name2}}'s role to ADMIN.",
+                    actions: ["UPDATE_ROLE"],
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Set @alice and @bob as admins",
+                    source: "discord",
+                },
+            },
+            {
+                name: "{{name3}}",
+                content: {
+                    text: "Updated alice's role to ADMIN.\nUpdated bob's role to ADMIN.",
+                    actions: ["UPDATE_ROLE"],
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Ban @troublemaker",
+                    source: "discord",
+                },
+            },
+            {
+                name: "{{name3}}",
+                content: {
+                    text: "I cannot ban users.",
+                    actions: ["REPLY"],
+                },
+            },
+        ],
+    ],
+};

package/packages/typescript/src/features/trust/actions/settings.d.ts

@@ -0,0 +1,5 @@
+import { type Action as ElizaAction, type IAgentRuntime, type WorldSettings } from "../../../types/index.ts";
+export declare function getWorldSettings(runtime: IAgentRuntime, serverId: string): Promise<WorldSettings | null>;
+export declare function updateWorldSettings(runtime: IAgentRuntime, serverId: string, worldSettings: WorldSettings): Promise<boolean>;
+export declare const updateSettingsAction: ElizaAction;
+//# sourceMappingURL=settings.d.ts.map

package/packages/typescript/src/features/trust/actions/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/actions/settings.ts"],"names":[],"mappings":"AAIA,OAAO,EAKN,KAAK,MAAM,IAAI,WAAW,EAE1B,KAAK,aAAa,EAKlB,KAAK,aAAa,EAClB,MAAM,yBAAyB,CAAC;AAkIjC,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAc/B;AAED,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,aAAa,GAC1B,OAAO,CAAC,OAAO,CAAC,CAuBlB;AAyWD,eAAO,MAAM,oBAAoB,EAAE,WAqOlC,CAAC"}