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

package/packages/typescript/src/features/advanced-capabilities/providers/facts.js

@@ -0,0 +1,162 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+import { ModelType } from "../../../types/index.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("FACTS");
+/**
+ * Half-life in milliseconds used to decay a fact's recency weight when ranking
+ * facts for the prompt. 30 days is short enough to deprioritize stale facts
+ * but long enough to keep durable preferences front-and-center.
+ */
+const RECENCY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
+const DEFAULT_FACT_CONFIDENCE = 0.6;
+function readMetadataRecord(memory) {
+    const meta = memory.metadata;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta))
+        return {};
+    return meta;
+}
+function readFactConfidence(memory) {
+    const value = readMetadataRecord(memory).confidence;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_FACT_CONFIDENCE;
+    }
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+function readLastReinforcedMs(memory) {
+    const meta = readMetadataRecord(memory);
+    const explicit = meta.lastReinforced;
+    if (typeof explicit === "string") {
+        const parsed = Date.parse(explicit);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    if (typeof memory.createdAt === "number" &&
+        Number.isFinite(memory.createdAt)) {
+        return memory.createdAt;
+    }
+    return null;
+}
+function recencyWeight(lastReinforcedMs, nowMs) {
+    if (lastReinforcedMs === null)
+        return 0.5;
+    const ageMs = Math.max(0, nowMs - lastReinforcedMs);
+    return 0.5 ** (ageMs / RECENCY_HALF_LIFE_MS);
+}
+function rankFacts(facts) {
+    const nowMs = Date.now();
+    const ranked = [...facts].sort((left, right) => {
+        const leftScore = readFactConfidence(left) *
+            recencyWeight(readLastReinforcedMs(left), nowMs);
+        const rightScore = readFactConfidence(right) *
+            recencyWeight(readLastReinforcedMs(right), nowMs);
+        return rightScore - leftScore;
+    });
+    return ranked;
+}
+/**
+ * Formats facts as `[conf=0.93] <text>` lines so the LLM can weigh
+ * conflicting information against the recorded confidence.
+ */
+function formatFacts(facts) {
+    const lines = [];
+    for (const fact of facts) {
+        const text = fact.content.text ?? "";
+        if (!text)
+            continue;
+        const confidence = readFactConfidence(fact).toFixed(2);
+        lines.push(`[conf=${confidence}] ${text}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Function to get key facts that the agent knows.
+ * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+ * @param {Memory} message - The message object containing relevant information.
+ * @param {State} [_state] - Optional state information.
+ * @returns {Object} An object containing values, data, and text related to the key facts.
+ */
+const factsProvider = {
+    name: spec.name,
+    description: spec.description,
+    dynamic: spec.dynamic ?? true,
+    get: async (runtime, message, _state) => {
+        // Parallelize initial data fetching operations including recentInteractions
+        const recentMessages = await runtime.getMemories({
+            tableName: "messages",
+            roomId: message.roomId,
+            limit: 10,
+            unique: false,
+        });
+        // join the text of the last 5 messages
+        const lastMessageLines = [];
+        for (let i = recentMessages.length - 1; i >= 0 && lastMessageLines.length < 5; i -= 1) {
+            lastMessageLines.push(recentMessages[i]?.content.text ?? "");
+        }
+        lastMessageLines.reverse();
+        const last5Messages = lastMessageLines.join("\n");
+        const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+            text: last5Messages,
+        });
+        const [relevantFacts, recentFactsData] = await Promise.all([
+            runtime.searchMemories({
+                tableName: "facts",
+                embedding,
+                roomId: message.roomId,
+                worldId: message.worldId,
+                limit: 6,
+                query: message.content.text,
+            }),
+            runtime.searchMemories({
+                embedding,
+                query: message.content.text,
+                tableName: "facts",
+                roomId: message.roomId,
+                entityId: message.entityId,
+                limit: 6,
+            }),
+        ]);
+        // join the two and deduplicate
+        const seenIds = new Set();
+        const dedupedFacts = [];
+        for (const fact of [...relevantFacts, ...recentFactsData]) {
+            const factId = fact.id ?? "";
+            if (factId && !seenIds.has(factId)) {
+                seenIds.add(factId);
+                dedupedFacts.push(fact);
+            }
+        }
+        // Re-order by confidence * recency-decay so the LLM sees the most
+        // trustworthy, recently-reinforced facts first.
+        const allFacts = rankFacts(dedupedFacts);
+        if (allFacts.length === 0) {
+            return {
+                values: {
+                    facts: "",
+                },
+                data: {
+                    facts: allFacts,
+                },
+                text: "No facts available.",
+            };
+        }
+        const formattedFacts = formatFacts(allFacts);
+        const agentName = runtime.character.name ?? "Agent";
+        const text = "Key facts that {{agentName}} knows:\n{{formattedFacts}}"
+            .replace("{{agentName}}", agentName)
+            .replace("{{formattedFacts}}", formattedFacts);
+        return {
+            values: {
+                facts: formattedFacts,
+            },
+            data: {
+                facts: allFacts,
+            },
+            text,
+        };
+    },
+};
+export { factsProvider };

package/packages/typescript/src/features/advanced-capabilities/providers/followUps.d.ts

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

package/packages/typescript/src/features/advanced-capabilities/providers/followUps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"followUps.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/followUps.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAKjC,eAAO,MAAM,iBAAiB,EAAE,QAoI/B,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/providers/followUps.js

@@ -0,0 +1,112 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("FOLLOW_UPS");
+export const followUpsProvider = {
+    name: spec.name,
+    description: spec.description,
+    get: async (runtime, _message, _state) => {
+        const followUpService = runtime.getService("follow_up");
+        if (!followUpService) {
+            runtime.logger.warn("[FollowUpsProvider] FollowUpService not available");
+            return { text: "", values: {}, data: {} };
+        }
+        // Get upcoming follow-ups for the next 7 days
+        const upcomingFollowUps = await followUpService.getUpcomingFollowUps(7, true);
+        if (upcomingFollowUps.length === 0) {
+            return {
+                text: "No upcoming follow-ups scheduled.",
+                values: { followUpCount: 0 },
+                data: {},
+            };
+        }
+        const now = Date.now();
+        const contactIds = Array.from(new Set(upcomingFollowUps.map((f) => f.contact.entityId)));
+        const entities = await Promise.all(contactIds.map((id) => runtime.getEntityById(id)));
+        const entityNames = new Map();
+        for (let i = 0; i < contactIds.length; i += 1) {
+            entityNames.set(contactIds[i], entities[i]?.names[0] || "Unknown");
+        }
+        const overdue = [];
+        const upcoming = [];
+        const scheduledAtMs = new Map();
+        for (const item of upcomingFollowUps) {
+            const scheduledAt = item.task.metadata?.scheduledAt
+                ? new Date(item.task.metadata.scheduledAt).getTime()
+                : 0;
+            if (item.task.id) {
+                scheduledAtMs.set(item.task.id, scheduledAt);
+            }
+            if (scheduledAt < now) {
+                overdue.push(item);
+            }
+            else {
+                upcoming.push(item);
+            }
+        }
+        // Build text summary
+        let textSummary = `You have ${upcomingFollowUps.length} follow-up${upcomingFollowUps.length !== 1 ? "s" : ""} scheduled:\n`;
+        if (overdue.length > 0) {
+            textSummary += `\nOverdue (${overdue.length}):\n`;
+            for (const f of overdue) {
+                const name = entityNames.get(f.contact.entityId) || "Unknown";
+                const scheduledAt = f.task.id ? (scheduledAtMs.get(f.task.id) ?? 0) : 0;
+                textSummary += `- ${name}`;
+                if (scheduledAt > 0) {
+                    const daysOverdue = Math.floor((now - scheduledAt) / (1000 * 60 * 60 * 24));
+                    textSummary += ` (${daysOverdue} day${daysOverdue !== 1 ? "s" : ""} overdue)`;
+                }
+                if (f.task.metadata?.reason) {
+                    textSummary += ` - ${f.task.metadata.reason}`;
+                }
+                textSummary += "\n";
+            }
+        }
+        if (upcoming.length > 0) {
+            textSummary += `\nUpcoming (${upcoming.length}):\n`;
+            for (const f of upcoming) {
+                const name = entityNames.get(f.contact.entityId) || "Unknown";
+                const scheduledAt = f.task.id ? (scheduledAtMs.get(f.task.id) ?? 0) : 0;
+                textSummary += `- ${name}`;
+                if (scheduledAt > 0) {
+                    const daysUntil = Math.ceil((scheduledAt - now) / (1000 * 60 * 60 * 24));
+                    if (daysUntil === 0) {
+                        textSummary += " (today)";
+                    }
+                    else if (daysUntil === 1) {
+                        textSummary += " (tomorrow)";
+                    }
+                    else {
+                        textSummary += ` (in ${daysUntil} days)`;
+                    }
+                }
+                if (f.task.metadata?.reason) {
+                    textSummary += ` - ${f.task.metadata.reason}`;
+                }
+                textSummary += "\n";
+            }
+        }
+        // Get follow-up suggestions
+        const suggestions = await followUpService.getFollowUpSuggestions();
+        if (suggestions.length > 0) {
+            textSummary += `\nSuggested follow-ups:\n`;
+            suggestions.slice(0, 3).forEach((s) => {
+                textSummary += `- ${s.entityName} (${s.daysSinceLastContact} days since last contact)\n`;
+            });
+        }
+        return {
+            text: textSummary.trim(),
+            values: {
+                followUpCount: upcomingFollowUps.length,
+                overdueCount: overdue.length,
+                upcomingCount: upcoming.length,
+                suggestionsCount: suggestions.length,
+            },
+            data: {
+                followUpCount: upcomingFollowUps.length,
+                overdueCount: overdue.length,
+                upcomingCount: upcoming.length,
+                suggestionsCount: suggestions.length,
+            },
+        };
+    },
+};

package/packages/typescript/src/features/advanced-capabilities/providers/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Advanced Providers
+ *
+ * Extended providers that can be enabled with `advancedCapabilities: true`.
+ */
+export { contactsProvider } from "./contacts.ts";
+export { factsProvider } from "./facts.ts";
+export { followUpsProvider } from "./followUps.ts";
+export { knowledgeProvider } from "./knowledge.ts";
+export { relationshipsProvider } from "./relationships.ts";
+export { roleProvider } from "./roles.ts";
+export { settingsProvider } from "./settings.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/providers/index.js

@@ -0,0 +1,12 @@
+/**
+ * Advanced Providers
+ *
+ * Extended providers that can be enabled with `advancedCapabilities: true`.
+ */
+export { contactsProvider } from "./contacts.js";
+export { factsProvider } from "./facts.js";
+export { followUpsProvider } from "./followUps.js";
+export { knowledgeProvider } from "./knowledge.js";
+export { relationshipsProvider } from "./relationships.js";
+export { roleProvider } from "./roles.js";
+export { settingsProvider } from "./settings.js";

package/packages/typescript/src/features/advanced-capabilities/providers/knowledge.d.ts

@@ -0,0 +1,9 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Knowledge Provider - Provides relevant knowledge from the agent's knowledge base.
+ *
+ * This provider retrieves and formats relevant knowledge entries
+ * based on the current context and message using semantic similarity search.
+ */
+export declare const knowledgeProvider: Provider;
+//# sourceMappingURL=knowledge.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/providers/knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/knowledge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAMjC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAoF/B,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/providers/knowledge.js

@@ -0,0 +1,83 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+import { ModelType } from "../../../types/index.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("KNOWLEDGE");
+/**
+ * Knowledge Provider - Provides relevant knowledge from the agent's knowledge base.
+ *
+ * This provider retrieves and formats relevant knowledge entries
+ * based on the current context and message using semantic similarity search.
+ */
+export const knowledgeProvider = {
+    name: spec.name,
+    description: spec.description,
+    dynamic: spec.dynamic ?? true,
+    get: async (runtime, message, _state) => {
+        const queryText = message.content?.text || "";
+        if (!queryText) {
+            return {
+                text: "",
+                values: {
+                    knowledgeCount: 0,
+                    hasKnowledge: false,
+                },
+                data: {
+                    entries: [],
+                    query: "",
+                },
+            };
+        }
+        // Search for relevant knowledge using searchMemories with knowledge table
+        const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+            text: queryText,
+        });
+        const relevantKnowledge = await runtime.searchMemories({
+            tableName: "knowledge",
+            embedding,
+            query: queryText,
+            limit: 5,
+        });
+        if (relevantKnowledge.length === 0) {
+            return {
+                text: "",
+                values: {
+                    knowledgeCount: 0,
+                    hasKnowledge: false,
+                },
+                data: {
+                    entries: [],
+                    query: queryText,
+                },
+            };
+        }
+        const sections = [];
+        const knowledgeEntries = [];
+        for (const entry of relevantKnowledge) {
+            const text = entry.content?.text;
+            if (!text)
+                continue;
+            let knowledgeText = text;
+            if (knowledgeText.length > 500) {
+                knowledgeText = `${knowledgeText.substring(0, 500)}...`;
+            }
+            knowledgeEntries.push({
+                id: entry.id?.toString() || "",
+                text: knowledgeText,
+                source: entry.metadata?.source || "unknown",
+            });
+            sections.push(`- ${knowledgeText}`);
+        }
+        const contextText = sections.length > 0 ? `# Relevant Knowledge\n${sections.join("\n")}` : "";
+        return {
+            text: contextText,
+            values: {
+                knowledgeCount: knowledgeEntries.length,
+                hasKnowledge: knowledgeEntries.length > 0,
+            },
+            data: {
+                entries: knowledgeEntries,
+                query: queryText,
+            },
+        };
+    },
+};

package/packages/typescript/src/features/advanced-capabilities/providers/relationships.d.ts

@@ -0,0 +1,15 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Provider for fetching relationships data.
+ *
+ * @type {Provider}
+ * @property {string} name - The name of the provider ("RELATIONSHIPS").
+ * @property {string} description - Description of the provider.
+ * @property {Function} get - Asynchronous function to fetch relationships data.
+ * @param {IAgentRuntime} runtime - The agent runtime object.
+ * @param {Memory} message - The message object containing entity ID.
+ * @returns {Promise<Object>} Object containing relationships data or error message.
+ */
+declare const relationshipsProvider: Provider;
+export { relationshipsProvider };
+//# sourceMappingURL=relationships.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/providers/relationships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/relationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAKX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAgGjC;;;;;;;;;;GAUG;AACH,QAAA,MAAM,qBAAqB,EAAE,QAiD5B,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/providers/relationships.js

@@ -0,0 +1,125 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("RELATIONSHIPS");
+/**
+ * Formats the provided relationships based on interaction strength and returns a string.
+ * @param {IAgentRuntime} runtime - The runtime object to interact with the agent.
+ * @param {Relationship[]} relationships - The relationships to format.
+ * @returns {string} The formatted relationships as a string.
+ */
+/**
+ * Asynchronously formats relationships based on their interaction strength.
+ *
+ * @param {IAgentRuntime} runtime The runtime instance.
+ * @param {Relationship[]} relationships The relationships to be formatted.
+ * @returns {Promise<string>} A formatted string of the relationships.
+ */
+async function formatRelationships(runtime, relationships, currentEntityId) {
+    // Sort relationships by interaction strength (descending)
+    const sortedRelationships = relationships
+        .filter((rel) => rel.metadata?.interactions)
+        .sort((a, b) => ((b.metadata && b.metadata.interactions) || 0) -
+        ((a.metadata && a.metadata.interactions) || 0))
+        .slice(0, 30); // Get top 30
+    if (sortedRelationships.length === 0) {
+        return "";
+    }
+    // Deduplicate target entity IDs to avoid redundant fetches
+    const uniqueEntityIds = Array.from(new Set(sortedRelationships.map((rel) => (rel.sourceEntityId === currentEntityId
+        ? rel.targetEntityId
+        : rel.sourceEntityId))));
+    // Fetch all required entities in a single batch operation
+    const entities = await Promise.all(uniqueEntityIds.map((id) => runtime.getEntityById(id)));
+    // Create a lookup map for efficient access
+    const entityMap = new Map();
+    entities.forEach((entity, index) => {
+        if (entity) {
+            entityMap.set(uniqueEntityIds[index], entity);
+        }
+    });
+    const formatMetadata = (metadata) => {
+        if (!metadata)
+            return "";
+        const lines = [];
+        for (const [key, value] of Object.entries(metadata)) {
+            if (value && typeof value === "object") {
+                lines.push(`${key}: ${JSON.stringify(value)}`);
+            }
+            else {
+                lines.push(`${key}: ${String(value)}`);
+            }
+        }
+        return lines.join("\n");
+    };
+    // Format relationships using the entity map
+    const formattedRelationships = [];
+    for (const rel of sortedRelationships) {
+        const counterpartEntityId = (rel.sourceEntityId === currentEntityId
+            ? rel.targetEntityId
+            : rel.sourceEntityId);
+        const entity = entityMap.get(counterpartEntityId);
+        if (!entity)
+            continue;
+        const names = entity.names.join(" aka ");
+        const tags = rel.tags ? rel.tags.join(", ") : "";
+        const metadata = formatMetadata(entity.metadata);
+        const parts = [names, tags, metadata].filter((part) => part.length > 0);
+        formattedRelationships.push(`${parts.join("\n")}\n`);
+    }
+    return formattedRelationships.join("\n");
+}
+/**
+ * Provider for fetching relationships data.
+ *
+ * @type {Provider}
+ * @property {string} name - The name of the provider ("RELATIONSHIPS").
+ * @property {string} description - Description of the provider.
+ * @property {Function} get - Asynchronous function to fetch relationships data.
+ * @param {IAgentRuntime} runtime - The agent runtime object.
+ * @param {Memory} message - The message object containing entity ID.
+ * @returns {Promise<Object>} Object containing relationships data or error message.
+ */
+const relationshipsProvider = {
+    name: spec.name,
+    description: spec.description,
+    dynamic: spec.dynamic ?? true,
+    get: async (runtime, message) => {
+        // Get all relationships for the current user
+        const relationships = await runtime.getRelationships({
+            entityIds: [message.entityId],
+        });
+        if (!relationships || relationships.length === 0) {
+            return {
+                data: {
+                    relationships: [],
+                },
+                values: {
+                    relationships: "No relationships found.",
+                },
+                text: "No relationships found.",
+            };
+        }
+        const formattedRelationships = await formatRelationships(runtime, relationships, message.entityId);
+        if (!formattedRelationships) {
+            return {
+                data: {
+                    relationships: [],
+                },
+                values: {
+                    relationships: "No relationships found.",
+                },
+                text: "No relationships found.",
+            };
+        }
+        return {
+            data: {
+                relationships: formattedRelationships,
+            },
+            values: {
+                relationships: formattedRelationships,
+            },
+            text: `# ${runtime.character.name} has observed ${message.content.senderName || message.content.name} interacting with these people:\n${formattedRelationships}`,
+        };
+    },
+};
+export { relationshipsProvider };

package/packages/typescript/src/features/advanced-capabilities/providers/roles.d.ts

@@ -0,0 +1,19 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Role provider that retrieves roles in the server based on the provided runtime, message, and state.
+ * * @type { Provider }
+ * @property { string } name - The name of the role provider.
+ * @property { string } description - A brief description of the role provider.
+ * @property { Function } get - Asynchronous function that retrieves and processes roles in the server.
+ * @param { IAgentRuntime } runtime - The agent runtime object.
+ * @param { Memory } message - The message memory object.
+ * @param { State } state - The state object.
+ * @returns {Promise<ProviderResult>} The result containing roles data, values, and text.
+ */
+/**
+ * A provider for retrieving and formatting the role hierarchy in a server.
+ * @type {Provider}
+ */
+export declare const roleProvider: Provider;
+export default roleProvider;
+//# sourceMappingURL=roles.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/providers/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/roles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGX,QAAQ,EAIR,MAAM,yBAAyB,CAAC;AAMjC;;;;;;;;;;GAUG;AACH;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,QA0M1B,CAAC;AAEF,eAAe,YAAY,CAAC"}