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

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

@@ -0,0 +1,603 @@
+import dedent from "dedent";
+import { createUniqueUuid } from "../../../entities.js";
+import { logger } from "../../../logger.js";
+import { findWorldsForOwner } from "../../../roles.js";
+import { ChannelType, ModelType, } from "../../../types/index.js";
+import { composePrompt, composePromptFromState, parseJSONObjectFromText, } from "../../../utils.js";
+const messageCompletionFooter = `\n# Instructions: Write the next message for {{agentName}}. Include the appropriate action from the list: {{actionNames}}
+Response format should be formatted in a valid JSON block like this:
+\`\`\`json
+{ "name": "{{agentName}}", "text": "<string>", "thought": "<string>", "actions": ["<string>", "<string>", "<string>"] }
+\`\`\`
+Do not including any thinking or internal reflection in the "text" field.
+"thought" should be a short description of what the agent is thinking about before responding, including a brief justification for the response.`;
+const successTemplate = `# Task: Generate a response for successful setting updates
+{{providers}}
+
+# Update Information:
+- Updated Settings: {{updateMessages}}
+- Next Required Setting: {{nextSetting.name}}
+- Remaining Required Settings: {{remainingRequired}}
+
+# Instructions:
+1. Acknowledge the successful update of settings
+2. Maintain {{agentName}}'s personality and tone
+3. Provide clear guidance on the next setting that needs to be configured
+4. Explain what the next setting is for and how to set it
+5. If appropriate, mention how many required settings remain
+
+Write a natural, conversational response that {{agentName}} would send about the successful update and next steps.
+Include the actions array ["SETTING_UPDATED"] in your response.
+${messageCompletionFooter}`;
+const failureTemplate = `# Task: Generate a response for failed setting updates
+
+# About {{agentName}}:
+{{bio}}
+
+# Current Settings Status:
+{{settingsStatus}}
+
+# Next Required Setting:
+- Name: {{nextSetting.name}}
+- Description: {{nextSetting.description}}
+- Required: Yes
+- Remaining Required Settings: {{remainingRequired}}
+
+# Recent Conversation:
+{{recentMessages}}
+
+# Instructions:
+1. Express that you couldn't understand or process the setting update
+2. Maintain {{agentName}}'s personality and tone
+3. Provide clear guidance on what setting needs to be configured next
+4. Explain what the setting is for and how to set it properly
+5. Use a helpful, patient tone
+
+Write a natural, conversational response that {{agentName}} would send about the failed update and how to proceed.
+Include the actions array ["SETTING_UPDATE_FAILED"] in your response.
+${messageCompletionFooter}`;
+const errorTemplate = `# Task: Generate a response for an error during setting updates
+
+# About {{agentName}}:
+{{bio}}
+
+# Recent Conversation:
+{{recentMessages}}
+
+# Instructions:
+1. Apologize for the technical difficulty
+2. Maintain {{agentName}}'s personality and tone
+3. Suggest trying again or contacting support if the issue persists
+4. Keep the message concise and helpful
+
+Write a natural, conversational response that {{agentName}} would send about the error.
+Include the actions array ["SETTING_UPDATE_ERROR"] in your response.
+${messageCompletionFooter}`;
+const completionTemplate = `# Task: Generate a response for settings completion
+
+# About {{agentName}}:
+{{bio}}
+
+# Settings Status:
+{{settingsStatus}}
+
+# Recent Conversation:
+{{recentMessages}}
+
+# Instructions:
+1. Congratulate the user on completing the settings process
+2. Maintain {{agentName}}'s personality and tone
+3. Summarize the key settings that have been configured
+4. Explain what functionality is now available
+5. Provide guidance on what the user can do next
+6. Express enthusiasm about working together
+
+Write a natural, conversational response that {{agentName}} would send about the successful completion of settings.
+Include the actions array ["ONBOARDING_COMPLETE"] in your response.
+${messageCompletionFooter}`;
+const _extractionTemplate = `# Task: Extract Setting Changes from User Input
+
+I need to extract settings that the user wants to change based on their message.
+
+Available Settings:
+{{settingsContext}}
+
+User message: {{content}}
+
+For each setting mentioned in the user's input, extract the key and its new value.
+Format your response as a JSON array of objects, each with 'key' and 'value' properties.
+
+Example response:
+\`\`\`json
+[
+  { "key": "SETTING_NAME", "value": "extracted value" },
+  { "key": "ANOTHER_SETTING", "value": "another value" }
+]
+\`\`\`
+
+IMPORTANT: Only include settings from the Available Settings list above. Ignore any other potential settings.`;
+export async function getWorldSettings(runtime, serverId) {
+    try {
+        const worldId = createUniqueUuid(runtime, serverId);
+        const world = await runtime.getWorld(worldId);
+        if (!world?.metadata?.settings) {
+            return null;
+        }
+        return world.metadata.settings;
+    }
+    catch (error) {
+        logger.error(`Error getting settings state: ${error}`);
+        return null;
+    }
+}
+export async function updateWorldSettings(runtime, serverId, worldSettings) {
+    try {
+        const worldId = createUniqueUuid(runtime, serverId);
+        const world = await runtime.getWorld(worldId);
+        if (!world) {
+            logger.error(`No world found for server ${serverId}`);
+            return false;
+        }
+        if (!world.metadata) {
+            world.metadata = {};
+        }
+        world.metadata.settings = worldSettings;
+        await runtime.updateWorld(world);
+        return true;
+    }
+    catch (error) {
+        logger.error(`Error updating settings state: ${error}`);
+        return false;
+    }
+}
+function formatSettingsList(worldSettings) {
+    const settings = Object.entries(worldSettings)
+        .filter(([key, setting]) => !key.startsWith("_") && setting != null)
+        .map(([key, setting]) => {
+        const status = setting.value !== null ? "Configured" : "Not configured";
+        const required = setting.required ? "Required" : "Optional";
+        return `- ${setting.name} (${key}): ${status}, ${required}`;
+    })
+        .join("\n");
+    return settings || "No settings available";
+}
+function categorizeSettings(worldSettings) {
+    const configured = [];
+    const requiredUnconfigured = [];
+    const optionalUnconfigured = [];
+    for (const [key, setting] of Object.entries(worldSettings)) {
+        if (key.startsWith("_"))
+            continue;
+        if (setting.value !== null) {
+            configured.push([key, setting]);
+        }
+        else if (setting.required) {
+            requiredUnconfigured.push([key, setting]);
+        }
+        else {
+            optionalUnconfigured.push([key, setting]);
+        }
+    }
+    return { configured, requiredUnconfigured, optionalUnconfigured };
+}
+async function extractSettingValues(runtime, _message, state, worldSettings) {
+    const { requiredUnconfigured, optionalUnconfigured } = categorizeSettings(worldSettings);
+    const settingsContext = requiredUnconfigured
+        .concat(optionalUnconfigured)
+        .map(([key, setting]) => {
+        const requiredStr = setting.required ? "Required." : "Optional.";
+        return `${key}: ${setting.description} ${requiredStr}`;
+    })
+        .join("\n");
+    const basePrompt = dedent `
+    I need to extract settings values from the user's message.
+
+    Available settings:
+    ${settingsContext}
+
+    User message: ${state.text}
+
+    For each setting mentioned in the user's message, extract the value.
+
+    Only return settings that are clearly mentioned in the user's message.
+    If a setting is mentioned but no clear value is provided, do not include it.
+    `;
+    try {
+        const result = await runtime.useModel(ModelType.OBJECT_LARGE, {
+            prompt: basePrompt,
+            output: "array",
+            schema: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        value: { type: "string" },
+                    },
+                    required: ["key", "value"],
+                },
+            },
+        });
+        if (!result) {
+            return [];
+        }
+        function extractValidSettings(obj, worldSettings) {
+            const extracted = [];
+            function traverse(node) {
+                if (Array.isArray(node)) {
+                    for (const item of node) {
+                        traverse(item);
+                    }
+                }
+                else if (typeof node === "object" && node !== null) {
+                    for (const [key, value] of Object.entries(node)) {
+                        if (worldSettings[key] && typeof value !== "object") {
+                            extracted.push({ key, value });
+                        }
+                        else {
+                            traverse(value);
+                        }
+                    }
+                }
+            }
+            traverse(obj);
+            return extracted;
+        }
+        const extractedSettings = extractValidSettings(result, worldSettings);
+        return extractedSettings;
+    }
+    catch (error) {
+        logger.error({ error }, "Error extracting settings:");
+        return [];
+    }
+}
+async function processSettingUpdates(runtime, serverId, worldSettings, updates) {
+    if (!updates.length) {
+        return { updatedAny: false, messages: [] };
+    }
+    const messages = [];
+    let updatedAny = false;
+    try {
+        const updatedState = { ...worldSettings };
+        for (const update of updates) {
+            const setting = updatedState[update.key];
+            if (!setting)
+                continue;
+            if (setting.dependsOn?.length) {
+                const dependenciesMet = setting.dependsOn.every((dep) => updatedState[dep]?.value !== null);
+                if (!dependenciesMet) {
+                    messages.push(`Cannot update ${setting.name} - dependencies not met`);
+                    continue;
+                }
+            }
+            updatedState[update.key] = {
+                ...setting,
+                value: update.value,
+            };
+            messages.push(`Updated ${setting.name} successfully`);
+            updatedAny = true;
+            if (setting.onSetAction) {
+                const actionMessage = setting.onSetAction(update.value);
+                if (actionMessage) {
+                    messages.push(actionMessage);
+                }
+            }
+        }
+        if (updatedAny) {
+            const saved = await updateWorldSettings(runtime, serverId, updatedState);
+            if (!saved) {
+                throw new Error("Failed to save updated state to world metadata");
+            }
+            const savedState = await getWorldSettings(runtime, serverId);
+            if (!savedState) {
+                throw new Error("Failed to verify state save");
+            }
+        }
+        return { updatedAny, messages };
+    }
+    catch (error) {
+        logger.error({ error }, "Error processing setting updates:");
+        return {
+            updatedAny: false,
+            messages: ["Error occurred while updating settings"],
+        };
+    }
+}
+async function handleOnboardingComplete(runtime, worldSettings, _state, callback) {
+    try {
+        const prompt = composePrompt({
+            state: {
+                settingsStatus: formatSettingsList(worldSettings),
+            },
+            template: completionTemplate,
+        });
+        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt,
+        });
+        const responseContent = parseJSONObjectFromText(response);
+        await callback({
+            text: responseContent.text,
+            actions: ["ONBOARDING_COMPLETE"],
+            source: "discord",
+        });
+    }
+    catch (error) {
+        logger.error(`Error handling settings completion: ${error}`);
+        await callback({
+            text: "Great! All required settings have been configured. Your server is now fully set up and ready to use.",
+            actions: ["ONBOARDING_COMPLETE"],
+            source: "discord",
+        });
+    }
+}
+async function generateSuccessResponse(runtime, worldSettings, state, messages, callback) {
+    try {
+        const { requiredUnconfigured } = categorizeSettings(worldSettings);
+        if (requiredUnconfigured.length === 0) {
+            await handleOnboardingComplete(runtime, worldSettings, state, callback);
+            return;
+        }
+        const requiredUnconfiguredString = requiredUnconfigured
+            .map(([key, setting]) => `${key}: ${setting.name}`)
+            .join("\n");
+        const prompt = composePrompt({
+            state: {
+                updateMessages: messages.join("\n"),
+                nextSetting: requiredUnconfiguredString,
+                remainingRequired: requiredUnconfigured.length.toString(),
+            },
+            template: successTemplate,
+        });
+        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt,
+        });
+        const responseContent = parseJSONObjectFromText(response);
+        await callback({
+            text: responseContent.text,
+            actions: ["SETTING_UPDATED"],
+            source: "discord",
+        });
+    }
+    catch (error) {
+        logger.error(`Error generating success response: ${error}`);
+        await callback({
+            text: "Settings updated successfully. Please continue with the remaining configuration.",
+            actions: ["SETTING_UPDATED"],
+            source: "discord",
+        });
+    }
+}
+async function generateFailureResponse(runtime, worldSettings, state, callback) {
+    try {
+        const { requiredUnconfigured } = categorizeSettings(worldSettings);
+        if (requiredUnconfigured.length === 0) {
+            await handleOnboardingComplete(runtime, worldSettings, state, callback);
+            return;
+        }
+        const requiredUnconfiguredString = requiredUnconfigured
+            .map(([key, setting]) => `${key}: ${setting.name}`)
+            .join("\n");
+        const prompt = composePrompt({
+            state: {
+                nextSetting: requiredUnconfiguredString,
+                remainingRequired: requiredUnconfigured.length.toString(),
+            },
+            template: failureTemplate,
+        });
+        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt,
+        });
+        const responseContent = parseJSONObjectFromText(response);
+        await callback({
+            text: responseContent.text,
+            actions: ["SETTING_UPDATE_FAILED"],
+            source: "discord",
+        });
+    }
+    catch (error) {
+        logger.error(`Error generating failure response: ${error}`);
+        await callback({
+            text: "I couldn't understand your settings update. Please try again with a clearer format.",
+            actions: ["SETTING_UPDATE_FAILED"],
+            source: "discord",
+        });
+    }
+}
+async function generateErrorResponse(runtime, state, callback) {
+    try {
+        const prompt = composePromptFromState({
+            state,
+            template: errorTemplate,
+        });
+        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt,
+        });
+        const responseContent = parseJSONObjectFromText(response);
+        await callback({
+            text: responseContent.text,
+            actions: ["SETTING_UPDATE_ERROR"],
+            source: "discord",
+        });
+    }
+    catch (error) {
+        logger.error(`Error generating error response: ${error}`);
+        await callback({
+            text: "I'm sorry, but I encountered an error while processing your request. Please try again or contact support if the issue persists.",
+            actions: ["SETTING_UPDATE_ERROR"],
+            source: "discord",
+        });
+    }
+}
+export const updateSettingsAction = {
+    name: "UPDATE_SETTINGS",
+    similes: ["UPDATE_SETTING", "SAVE_SETTING", "SET_CONFIGURATION", "CONFIGURE"],
+    description: "Saves a configuration setting during the onboarding process, or update an existing setting. Use this when you are onboarding with a world owner or admin.",
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avKeywords = ["update", "settings"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+        const __avRegex = /\b(?:update|settings)\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);
+        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) => {
+            try {
+                if (legacyMessage.content.channelType !== ChannelType.DM) {
+                    return false;
+                }
+                const worlds = await findWorldsForOwner(legacyRuntime, legacyMessage.entityId);
+                if (!worlds) {
+                    return false;
+                }
+                const world = worlds.find((world) => world.metadata?.settings);
+                const worldSettings = world?.metadata?.settings;
+                if (!worldSettings) {
+                    return false;
+                }
+                return true;
+            }
+            catch (error) {
+                logger.error(`Error validating settings action: ${error}`);
+                return false;
+            }
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message, state));
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message, state, _options, callback) => {
+        try {
+            if (!state) {
+                throw new Error("State is required for settings handler");
+            }
+            if (!message) {
+                throw new Error("Message is required for settings handler");
+            }
+            if (!callback) {
+                throw new Error("Callback is required for settings handler");
+            }
+            const worlds = await findWorldsForOwner(runtime, message.entityId);
+            const serverOwnership = worlds?.find((world) => world.metadata?.settings);
+            if (!serverOwnership) {
+                await generateErrorResponse(runtime, state, callback);
+                return {
+                    success: false,
+                    text: "No server found where you are the owner",
+                    data: { error: "NO_SERVER_OWNERSHIP" },
+                };
+            }
+            const serverId = serverOwnership?.messageServerId;
+            if (!serverId) {
+                return {
+                    success: false,
+                    text: "No server ID found",
+                    data: { error: "NO_SERVER_ID" },
+                };
+            }
+            const worldSettings = await getWorldSettings(runtime, serverId);
+            if (!worldSettings) {
+                await generateErrorResponse(runtime, state, callback);
+                return {
+                    success: false,
+                    text: "No settings state found for server",
+                    data: { error: "NO_SETTINGS_STATE" },
+                };
+            }
+            const extractedSettings = await extractSettingValues(runtime, message, state, worldSettings);
+            const updateResults = await processSettingUpdates(runtime, serverId, worldSettings, extractedSettings);
+            if (updateResults.updatedAny) {
+                const updatedWorldSettings = await getWorldSettings(runtime, serverId);
+                if (!updatedWorldSettings) {
+                    await generateErrorResponse(runtime, state, callback);
+                    return {
+                        success: false,
+                        text: "Failed to retrieve updated settings state",
+                        data: { error: "SETTINGS_RETRIEVAL_FAILED" },
+                    };
+                }
+                await generateSuccessResponse(runtime, updatedWorldSettings, state, updateResults.messages, callback);
+                return {
+                    success: true,
+                    text: updateResults.messages.join(". "),
+                    data: {
+                        success: true,
+                        updatedSettings: extractedSettings,
+                        messages: updateResults.messages,
+                    },
+                };
+            }
+            else {
+                await generateFailureResponse(runtime, worldSettings, state, callback);
+                return {
+                    success: false,
+                    text: "No settings were updated from your message",
+                    data: {
+                        success: false,
+                        reason: "NO_VALID_SETTINGS_FOUND",
+                    },
+                };
+            }
+        }
+        catch (error) {
+            logger.error(`Error in settings handler: ${error}`);
+            if (state && callback) {
+                await generateErrorResponse(runtime, state, callback);
+            }
+            return {
+                success: false,
+                text: "An error occurred while updating settings",
+                data: {
+                    error: error instanceof Error ? error.message : "UNKNOWN_ERROR",
+                },
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "I want to set up the welcome channel to #general",
+                    source: "discord",
+                },
+            },
+            {
+                name: "{{name2}}",
+                content: {
+                    text: "Perfect! I've updated your welcome channel to #general. Next, we should configure the automated greeting message.",
+                    actions: ["SETTING_UPDATED"],
+                    source: "discord",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Let's set the bot prefix to !", source: "discord" },
+            },
+            {
+                name: "{{name2}}",
+                content: {
+                    text: "Great choice! I've set the command prefix to '!'. Now you can use commands like !help, !info, etc.",
+                    actions: ["SETTING_UPDATED"],
+                    source: "discord",
+                },
+            },
+        ],
+    ],
+};

package/packages/typescript/src/features/trust/evaluators/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./reflection.ts";
+export * from "./securityEvaluator.ts";
+export * from "./trustChangeEvaluator.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/trust/evaluators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/evaluators/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC"}

package/packages/typescript/src/features/trust/evaluators/index.js

@@ -0,0 +1,3 @@
+export * from "./reflection.js";
+export * from "./securityEvaluator.js";
+export * from "./trustChangeEvaluator.js";

package/packages/typescript/src/features/trust/evaluators/reflection.d.ts

@@ -0,0 +1,3 @@
+import { type Evaluator } from "../../../types/index.ts";
+export declare const reflectionEvaluator: Evaluator;
+//# sourceMappingURL=reflection.d.ts.map

package/packages/typescript/src/features/trust/evaluators/reflection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/evaluators/reflection.ts"],"names":[],"mappings":"AAEA,OAAO,EAEN,KAAK,SAAS,EAQd,MAAM,yBAAyB,CAAC;AAkTjC,eAAO,MAAM,mBAAmB,EAAE,SAyFjC,CAAC"}