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

package/packages/typescript/src/features/basic-capabilities/providers/actionState.d.ts

@@ -0,0 +1,7 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Provider for sharing action execution state and plan between actions
+ * Makes previous action results and execution plan available to subsequent actions
+ */
+export declare const actionStateProvider: Provider;
+//# sourceMappingURL=actionState.d.ts.map

package/packages/typescript/src/features/basic-capabilities/providers/actionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionState.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/basic-capabilities/providers/actionState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIX,QAAQ,EAER,MAAM,yBAAyB,CAAC;AAmBjC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAyRjC,CAAC"}

package/packages/typescript/src/features/basic-capabilities/providers/actionState.js

@@ -0,0 +1,232 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+import { sliceToFitBudget } from "../../../utils/slice-to-fit-budget.js";
+import { addHeader } from "../../../utils.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("ACTION_STATE");
+// ~10k tokens combined budget for action state context
+const ACTION_RESULTS_TARGET_CHARS = 20000;
+const ACTION_HISTORY_TARGET_CHARS = 20000;
+const MAX_RUNS = 3;
+const MAX_THOUGHT_CHARS = 2000;
+const MAX_RESULT_TEXT_CHARS = 4000;
+/**
+ * Provider for sharing action execution state and plan between actions
+ * Makes previous action results and execution plan available to subsequent actions
+ */
+export const actionStateProvider = {
+    name: spec.name,
+    description: spec.description,
+    position: spec.position ?? 150,
+    get: async (runtime, message, state) => {
+        const actionResults = state.data.actionResults ?? [];
+        const actionPlan = state.data.actionPlan;
+        const workingMemory = state.data.workingMemory;
+        // Format action plan for display
+        let planText = "";
+        if (actionPlan && actionPlan.totalSteps > 1) {
+            const completedSteps = actionPlan.steps.filter((s) => s.status === "completed").length;
+            const failedSteps = actionPlan.steps.filter((s) => s.status === "failed").length;
+            planText = addHeader("# Action Execution Plan", [
+                `**Plan:** ${actionPlan.thought}`,
+                `**Progress:** Step ${actionPlan.currentStep} of ${actionPlan.totalSteps}`,
+                `**Status:** ${completedSteps} completed, ${failedSteps} failed`,
+                "",
+                "## Steps:",
+                ...actionPlan.steps.map((step, index) => {
+                    const icon = step.status === "completed"
+                        ? "✓"
+                        : step.status === "failed"
+                            ? "✗"
+                            : index < actionPlan.currentStep - 1
+                                ? "○"
+                                : index === actionPlan.currentStep - 1
+                                    ? "→"
+                                    : "○";
+                    const status = step.status === "pending" && index === actionPlan.currentStep - 1
+                        ? "in progress"
+                        : step.status;
+                    let stepText = `${icon} **Step ${index + 1}:** ${step.action} (${status})`;
+                    if (step.error) {
+                        stepText += `\n   Error: ${step.error}`;
+                    }
+                    if (step.result?.text) {
+                        stepText += `\n   Result: ${step.result.text}`;
+                    }
+                    return stepText;
+                }),
+                "",
+            ].join("\n"));
+        }
+        // Format previous action results
+        let resultsText = "";
+        if (actionResults.length > 0) {
+            const selectedResults = sliceToFitBudget(actionResults, (result) => String(result.text || "").length +
+                String(result.error || "").length +
+                (() => {
+                    try {
+                        return JSON.stringify(result.values || {}).length;
+                    }
+                    catch {
+                        return 0;
+                    }
+                })() +
+                80, ACTION_RESULTS_TARGET_CHARS);
+            const formattedResults = selectedResults
+                .map((result, index) => {
+                const actionNameValue = result.data?.actionName;
+                const actionName = typeof actionNameValue === "string"
+                    ? actionNameValue
+                    : "Unknown Action";
+                const success = result.success;
+                const status = success ? "Success" : "Failed";
+                let resultText = `**${index + 1}. ${actionName}** - ${status}`;
+                if (result.text) {
+                    const truncated = result.text.length > MAX_RESULT_TEXT_CHARS
+                        ? `${result.text.slice(0, MAX_RESULT_TEXT_CHARS)}…`
+                        : result.text;
+                    resultText += `\n   Output: ${truncated}`;
+                }
+                if (result.error) {
+                    const errorMsg = result.error instanceof Error
+                        ? result.error.message
+                        : result.error;
+                    resultText += `\n   Error: ${errorMsg}`;
+                }
+                if (result.values && Object.keys(result.values).length > 0) {
+                    const values = Object.entries(result.values)
+                        .map(([key, value]) => `   - ${key}: ${JSON.stringify(value)}`)
+                        .join("\n");
+                    resultText += `\n   Values:\n${values}`;
+                }
+                return resultText;
+            })
+                .join("\n\n");
+            resultsText = addHeader("# Previous Action Results", formattedResults);
+        }
+        else {
+            resultsText = "";
+        }
+        // Format working memory
+        let memoryText = "";
+        if (workingMemory && Object.keys(workingMemory).length > 0) {
+            const entries = Object.entries(workingMemory);
+            const topEntries = [];
+            for (const entry of entries) {
+                if (topEntries.length < 10) {
+                    topEntries.push(entry);
+                    topEntries.sort((a, b) => b[1].timestamp - a[1].timestamp);
+                    continue;
+                }
+                if (entry[1].timestamp > topEntries[9][1].timestamp) {
+                    topEntries[9] = entry;
+                    topEntries.sort((a, b) => b[1].timestamp - a[1].timestamp);
+                }
+            }
+            const memoryEntries = topEntries
+                .map(([key, entry]) => {
+                const result = entry.result;
+                const resultText = typeof result.text === "string" && result.text.trim().length > 0
+                    ? result.text
+                    : result.data
+                        ? JSON.stringify(result.data)
+                        : "(no output)";
+                return `**${entry.actionName || key}**: ${resultText}`;
+            })
+                .join("\n");
+            memoryText = addHeader("# Working Memory", memoryEntries);
+        }
+        // Get recent action result memories from the database
+        // Get messages with type 'action_result' from the room
+        const recentMessages = await runtime.getMemories({
+            tableName: "messages",
+            roomId: message.roomId,
+            limit: 20,
+            unique: false,
+        });
+        const recentActionMemories = recentMessages.filter((msg) => msg.content && msg.content.type === "action_result");
+        // Format recent action memories
+        let actionMemoriesText = "";
+        if (recentActionMemories.length > 0) {
+            // Group by runId using Map
+            const groupedByRun = new Map();
+            for (const mem of recentActionMemories) {
+                const runId = String(mem.content?.runId || "unknown");
+                if (!groupedByRun.has(runId)) {
+                    groupedByRun.set(runId, []);
+                }
+                const memories = groupedByRun.get(runId);
+                if (memories) {
+                    memories.push(mem);
+                }
+            }
+            // Take only the most recent runs, then apply budget trimming
+            const allRuns = Array.from(groupedByRun.entries());
+            const recentRuns = allRuns.slice(-MAX_RUNS);
+            const selectedRuns = sliceToFitBudget(recentRuns, ([runId, memories]) => {
+                const textChars = memories.reduce((sum, memory) => {
+                    const content = memory.content;
+                    return (sum +
+                        String(content?.actionName || "").length +
+                        String(content?.actionStatus || "").length +
+                        String(content?.planStep || "").length +
+                        Math.min(String(content?.text || "").length, MAX_RESULT_TEXT_CHARS));
+                }, 0);
+                return textChars + runId.length + 80;
+            }, ACTION_HISTORY_TARGET_CHARS, { fromEnd: true });
+            const formattedMemories = selectedRuns
+                .map(([runId, memories]) => {
+                const sortedMemories = memories.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+                const runText = sortedMemories
+                    .map((mem) => {
+                    const memContent = mem.content;
+                    const actionName = memContent?.actionName || "Unknown";
+                    const status = memContent?.actionStatus || "unknown";
+                    const planStep = memContent?.planStep || "";
+                    const rawText = memContent?.text || "";
+                    const text = rawText.length > MAX_RESULT_TEXT_CHARS
+                        ? `${rawText.slice(0, MAX_RESULT_TEXT_CHARS)}…`
+                        : rawText;
+                    let memText = `  - ${actionName} (${status})`;
+                    if (planStep) {
+                        memText += ` [${planStep}]`;
+                    }
+                    if (text && text !== `Executed action: ${actionName}`) {
+                        memText += `: ${text}`;
+                    }
+                    return memText;
+                })
+                    .join("\n");
+                const firstMemory = sortedMemories[0];
+                const rawThought = String(firstMemory?.content?.planThought || "");
+                const thought = rawThought.length > MAX_THOUGHT_CHARS
+                    ? `${rawThought.slice(0, MAX_THOUGHT_CHARS)}…`
+                    : rawThought;
+                return `**Run ${runId.slice(0, 8)}**${thought ? ` - ${thought}` : ""}\n${runText}`;
+            })
+                .join("\n\n");
+            actionMemoriesText = addHeader("# Recent Action History", formattedMemories);
+        }
+        // Combine all text sections
+        const allText = [planText, resultsText, memoryText, actionMemoriesText]
+            .filter(Boolean)
+            .join("\n\n");
+        return {
+            data: {
+                actionResults,
+                actionPlan,
+                workingMemory,
+                recentActionMemories,
+            },
+            values: {
+                hasActionResults: actionResults.length > 0,
+                hasActionPlan: !!actionPlan,
+                currentActionStep: actionPlan?.currentStep || 0,
+                totalActionSteps: actionPlan?.totalSteps || 0,
+                actionResults: resultsText,
+                completedActions: actionResults.filter((r) => r.success).length,
+                failedActions: actionResults.filter((r) => !r.success).length,
+            },
+            text: allText || "No action state available",
+        };
+    },
+};

package/packages/typescript/src/features/basic-capabilities/providers/actions.d.ts

@@ -0,0 +1,35 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * A provider object that fetches possible response actions based on the provided runtime, message, and state.
+ * @type {Provider}
+ * @property {string} name - The name of the provider ("ACTIONS").
+ * @property {string} description - The description of the provider ("Possible response actions").
+ * @property {number} position - The position of the provider (-1).
+ * @property {Function} get - Asynchronous function that retrieves actions that validate for the given message.
+ * @param {IAgentRuntime} runtime - The runtime object.
+ * @param {Memory} message - The message memory.
+ * @param {State} state - The state object.
+ * @returns {Object} An object containing the actions data, values, and combined text sections.
+ */
+/**
+ * Provider for ACTIONS
+ *
+ * @typedef {import('./Provider').Provider} Provider
+ * @typedef {import('./Runtime').IAgentRuntime} IAgentRuntime
+ * @typedef {import('./Memory').Memory} Memory
+ * @typedef {import('./State').State} State
+ * @typedef {import('./Action').Action} Action
+ *
+ * @type {Provider}
+ * @property {string} name - The name of the provider
+ * @property {string} description - Description of the provider
+ * @property {number} position - The position of the provider
+ * @property {Function} get - Asynchronous function to get actions that validate for a given message
+ *
+ * @param {IAgentRuntime} runtime - The agent runtime
+ * @param {Memory} message - The message memory
+ * @param {State} state - The state of the agent
+ * @returns {Object} Object containing data, values, and text related to actions
+ */
+export declare const actionsProvider: Provider;
+//# sourceMappingURL=actions.d.ts.map

package/packages/typescript/src/features/basic-capabilities/providers/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/basic-capabilities/providers/actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAIX,QAAQ,EAER,MAAM,yBAAyB,CAAC;AAyBjC;;;;;;;;;;;GAWG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe,EAAE,QAiF7B,CAAC"}

package/packages/typescript/src/features/basic-capabilities/providers/actions.js

@@ -0,0 +1,104 @@
+import { formatActionNames, formatActions } from "../../../actions.js";
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+import { resolveActionContexts } from "../../../utils/context-catalog";
+import { CONTEXT_ROUTING_STATE_KEY, getActiveRoutingContexts, parseContextRoutingMetadata, shouldIncludeByContext, } from "../../../utils/context-routing.js";
+import { buildDeterministicSeed } from "../../../utils/deterministic";
+import { addHeader } from "../../../utils.js";
+import { looksLikeNonActionableChatter, looksLikeRelationshipFollowUpReminder, } from "./non-actionable-chatter.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("ACTIONS");
+const GENERIC_CHAT_ACTIONS = new Set(["REPLY", "IGNORE", "NONE"]);
+const RELATIONSHIP_FOLLOW_UP_ACTIONS = new Set([
+    "OWNER_RELATIONSHIP",
+    "REPLY",
+    "IGNORE",
+    "NONE",
+]);
+/**
+ * A provider object that fetches possible response actions based on the provided runtime, message, and state.
+ * @type {Provider}
+ * @property {string} name - The name of the provider ("ACTIONS").
+ * @property {string} description - The description of the provider ("Possible response actions").
+ * @property {number} position - The position of the provider (-1).
+ * @property {Function} get - Asynchronous function that retrieves actions that validate for the given message.
+ * @param {IAgentRuntime} runtime - The runtime object.
+ * @param {Memory} message - The message memory.
+ * @param {State} state - The state object.
+ * @returns {Object} An object containing the actions data, values, and combined text sections.
+ */
+/**
+ * Provider for ACTIONS
+ *
+ * @typedef {import('./Provider').Provider} Provider
+ * @typedef {import('./Runtime').IAgentRuntime} IAgentRuntime
+ * @typedef {import('./Memory').Memory} Memory
+ * @typedef {import('./State').State} State
+ * @typedef {import('./Action').Action} Action
+ *
+ * @type {Provider}
+ * @property {string} name - The name of the provider
+ * @property {string} description - Description of the provider
+ * @property {number} position - The position of the provider
+ * @property {Function} get - Asynchronous function to get actions that validate for a given message
+ *
+ * @param {IAgentRuntime} runtime - The agent runtime
+ * @param {Memory} message - The message memory
+ * @param {State} state - The state of the agent
+ * @returns {Object} Object containing data, values, and text related to actions
+ */
+export const actionsProvider = {
+    name: spec.name,
+    description: spec.description,
+    position: spec.position ?? -1,
+    get: async (runtime, message, state) => {
+        const activeContexts = getActiveRoutingContexts(parseContextRoutingMetadata(state?.values?.[CONTEXT_ROUTING_STATE_KEY]));
+        // Get actions that validate for this message
+        const actionPromises = runtime.actions.map(async (action) => {
+            if (!shouldIncludeByContext(resolveActionContexts(action), activeContexts)) {
+                return null;
+            }
+            const result = await action.validate(runtime, message, state);
+            if (result) {
+                return action;
+            }
+            return null;
+        });
+        const resolvedActions = await Promise.all(actionPromises);
+        const nonActionableChatter = looksLikeNonActionableChatter(message);
+        const relationshipFollowUpReminder = looksLikeRelationshipFollowUpReminder(message);
+        const availableActions = resolvedActions.filter(Boolean);
+        const hasRelationshipAction = availableActions.some((action) => action.name === "OWNER_RELATIONSHIP");
+        const actionsData = availableActions.filter((action) => {
+            if (nonActionableChatter && !GENERIC_CHAT_ACTIONS.has(action.name)) {
+                return false;
+            }
+            if (relationshipFollowUpReminder &&
+                hasRelationshipAction &&
+                !RELATIONSHIP_FOLLOW_UP_ACTIONS.has(action.name)) {
+                return false;
+            }
+            return true;
+        });
+        const actionSeed = buildDeterministicSeed(runtime.agentId, message.roomId, "ACTIONS");
+        // Format action-related texts
+        const actionNames = `Possible response actions: ${formatActionNames(actionsData, actionSeed)}`;
+        const actionsWithDescriptions = actionsData.length > 0
+            ? addHeader("# Available Actions", formatActions(actionsData, actionSeed))
+            : "";
+        const values = {
+            actionNames,
+            actionsWithDescriptions,
+        };
+        // Combine all text sections - now including actionsWithDescriptions
+        const text = [actionNames, actionsWithDescriptions]
+            .filter(Boolean)
+            .join("\n\n");
+        return {
+            data: {
+                actionsData,
+            },
+            values,
+            text,
+        };
+    },
+};

package/packages/typescript/src/features/basic-capabilities/providers/attachments.d.ts

@@ -0,0 +1,20 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Provides a list of attachments in the current conversation.
+ * @param {IAgentRuntime} runtime - The agent runtime object.
+ * @param {Memory} message - The message memory object.
+ * @returns {Object} The attachments values, data, and text.
+ */
+/**
+ * Provides a list of attachments sent during the current conversation, including names, descriptions, and summaries.
+ * @type {Provider}
+ * @property {string} name - The name of the provider (ATTACHMENTS).
+ * @property {string} description - Description of the provider.
+ * @property {boolean} dynamic - Indicates if the provider is dynamic.
+ * @property {function} get - Asynchronous function that retrieves attachments based on the runtime and message provided.
+ * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+ * @param {Memory} message - The message object containing content and attachments.
+ * @returns {Object} An object containing values, data, and text about the attachments retrieved.
+ */
+export declare const attachmentsProvider: Provider;
+//# sourceMappingURL=attachments.d.ts.map

package/packages/typescript/src/features/basic-capabilities/providers/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/basic-capabilities/providers/attachments.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIX,QAAQ,EACR,MAAM,yBAAyB,CAAC;AA2CjC;;;;;GAKG;AACH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAuEjC,CAAC"}

package/packages/typescript/src/features/basic-capabilities/providers/attachments.js

@@ -0,0 +1,94 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+import { addHeader } from "../../../utils.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("ATTACHMENTS");
+const MAX_VISIBLE_ATTACHMENTS = 3;
+function mergeConversationAttachments(message, recentMessages) {
+    const attachmentsById = new Map();
+    const rememberAttachment = (attachment, createdAt) => {
+        const existing = attachmentsById.get(attachment.id);
+        if (existing && (existing._createdAt ?? 0) >= createdAt) {
+            return;
+        }
+        attachmentsById.set(attachment.id, {
+            ...attachment,
+            _createdAt: createdAt,
+        });
+    };
+    for (const attachment of message.content.attachments ?? []) {
+        rememberAttachment(attachment, message.createdAt ?? Date.now());
+    }
+    for (const recentMessage of recentMessages ?? []) {
+        for (const attachment of recentMessage.content.attachments ?? []) {
+            rememberAttachment(attachment, recentMessage.createdAt ?? Date.now());
+        }
+    }
+    return Array.from(attachmentsById.values()).sort((left, right) => (right._createdAt ?? 0) - (left._createdAt ?? 0));
+}
+/**
+ * Provides a list of attachments in the current conversation.
+ * @param {IAgentRuntime} runtime - The agent runtime object.
+ * @param {Memory} message - The message memory object.
+ * @returns {Object} The attachments values, data, and text.
+ */
+/**
+ * Provides a list of attachments sent during the current conversation, including names, descriptions, and summaries.
+ * @type {Provider}
+ * @property {string} name - The name of the provider (ATTACHMENTS).
+ * @property {string} description - Description of the provider.
+ * @property {boolean} dynamic - Indicates if the provider is dynamic.
+ * @property {function} get - Asynchronous function that retrieves attachments based on the runtime and message provided.
+ * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+ * @param {Memory} message - The message object containing content and attachments.
+ * @returns {Object} An object containing values, data, and text about the attachments retrieved.
+ */
+export const attachmentsProvider = {
+    name: spec.name,
+    description: spec.description,
+    dynamic: spec.dynamic ?? true,
+    get: async (runtime, message) => {
+        const { roomId } = message;
+        const conversationLength = runtime.getConversationLength();
+        const recentMessagesData = await runtime.getMemories({
+            roomId,
+            limit: conversationLength,
+            unique: false,
+            tableName: "messages",
+        });
+        const allAttachments = mergeConversationAttachments(message, Array.isArray(recentMessagesData) ? recentMessagesData : []);
+        const visibleAttachments = allAttachments.slice(0, MAX_VISIBLE_ATTACHMENTS);
+        const omittedCount = Math.max(0, allAttachments.length - visibleAttachments.length);
+        // Format attachments for display
+        const formattedAttachments = visibleAttachments
+            .map((attachment) => `ID: ${attachment.id}
+    Name: ${attachment.title}
+    URL: ${attachment.url}
+    Type: ${attachment.source}
+    Content Type: ${attachment.contentType ?? "unknown"}
+    Stored Content: ${attachment.text || attachment.description
+            ? "available via READ_ATTACHMENT"
+            : "none"}
+    `)
+            .join("\n");
+        const omissionNotice = omittedCount > 0
+            ? `Showing the ${visibleAttachments.length} most recent attachments. ${omittedCount} older attachment${omittedCount === 1 ? "" : "s"} omitted from context; use READ_ATTACHMENT to inspect one.`
+            : "";
+        // Create formatted text with header
+        const text = formattedAttachments && formattedAttachments.length > 0
+            ? addHeader("# Attachments", [formattedAttachments, omissionNotice].filter(Boolean).join("\n\n"))
+            : "";
+        const values = {
+            attachments: text,
+        };
+        const data = {
+            attachments: allAttachments,
+            visibleAttachments,
+            omittedCount,
+        };
+        return {
+            values,
+            data,
+            text,
+        };
+    },
+};

package/packages/typescript/src/features/basic-capabilities/providers/character.d.ts

@@ -0,0 +1,17 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Character provider object.
+ * @typedef {Object} Provider
+ * @property {string} name - The name of the provider ("CHARACTER").
+ * @property {string} description - Description of the character information.
+ * @property {Function} get - Async function to get character information.
+ */
+/**
+ * Provides character information.
+ * @param {IAgentRuntime} runtime - The agent runtime.
+ * @param {Memory} message - The message memory.
+ * @param {State} state - The state of the character.
+ * @returns {Object} Object containing values, data, and text sections.
+ */
+export declare const characterProvider: Provider;
+//# sourceMappingURL=character.d.ts.map

package/packages/typescript/src/features/basic-capabilities/providers/character.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/basic-capabilities/providers/character.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,QAAQ,EAER,MAAM,yBAAyB,CAAC;AA4CjC;;;;;;GAMG;AACH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAiQ/B,CAAC"}