@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/providers/simple-mode.js

@@ -1,6 +1,5 @@
 import { ChannelType, } from "@elizaos/core";
-function resolveChannelProfile(message) {
-    const content = message.content;
+function resolveChannelProfile(content) {
     const channelType = content?.channelType;
     const conversationMode = typeof content?.conversationMode === "string"
         ? content.conversationMode.toLowerCase()
@@ -17,67 +16,32 @@ function resolveChannelProfile(message) {
     }
     return "default_full";
 }
+function compactContextForProfile(profile) {
+    return profile !== "default_full";
+}
 export function createChannelProfileProvider() {
     return {
         name: "elizaChannelProfile",
-        description: "Injects channel-derived execution profile guidance (voice/group/default).",
+        description: "Reports channel-derived execution profile state.",
         position: -50,
+        contexts: ["general"],
+        contextGate: { anyOf: ["general"] },
+        cacheStable: false,
+        cacheScope: "turn",
+        roleGate: { minRole: "USER" },
         async get(_runtime, message, _state) {
-            const profile = resolveChannelProfile(message);
-            if (profile === "voice_fast") {
-                return {
-                    text: [
-                        "Execution profile: VOICE_FAST.",
-                        "Prioritize low latency and conversational flow.",
-                        "Keep tool/provider usage minimal and avoid unnecessary context expansion.",
-                    ].join(" "),
-                    values: {
-                        executionProfile: "voice_fast",
-                        compactContext: true,
-                    },
-                    data: {
-                        profile: "voice_fast",
-                    },
-                };
-            }
-            if (profile === "text_fast") {
-                return {
-                    text: [
-                        "Execution profile: TEXT_FAST.",
-                        "Prioritize low latency for the current chat turn.",
-                        "Keep tool/provider usage minimal and avoid unnecessary context expansion.",
-                    ].join(" "),
-                    values: {
-                        executionProfile: "text_fast",
-                        compactContext: true,
-                    },
-                    data: {
-                        profile: "text_fast",
-                    },
-                };
-            }
-            if (profile === "group_compact") {
-                return {
-                    text: [
-                        "Execution profile: GROUP_COMPACT.",
-                        "Keep responses concise and context usage focused on the active group thread.",
-                    ].join(" "),
-                    values: {
-                        executionProfile: "group_compact",
-                        compactContext: true,
-                    },
-                    data: {
-                        profile: "group_compact",
-                    },
-                };
-            }
+            const content = message.content;
+            const profile = resolveChannelProfile(content);
+            const compactContext = compactContextForProfile(profile);
             return {
+                text: `channel_profile: profile=${profile} compact_context=${compactContext}`,
                 values: {
-                    executionProfile: "default_full",
-                    compactContext: false,
+                    executionProfile: profile,
+                    compactContext,
                 },
                 data: {
-                    profile: "default_full",
+                    profile,
+                    compactContext,
                 },
             };
         },

package/packages/agent/src/providers/skill-provider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dynamic skill provider with BM25-lite matching.
+ *
+ * Replaces the upstream plugin-agent-skills providers that dump ALL skills
+ * into every prompt. Instead, builds a lightweight inverted index at startup
+ * and scores the user's message + recent context to select only the most
+ * relevant skills per turn.
+ *
+ * Three tiers of injection:
+ *   - No match:  1-line footer (~25 tokens)
+ *   - Moderate:  Compact top-3 list (~150 tokens)
+ *   - Strong:    Full instructions of #1 match, capped at 2000 chars
+ */
+import type { Provider } from "@elizaos/core";
+export declare function createDynamicSkillProvider(): Provider;
+//# sourceMappingURL=skill-provider.d.ts.map

package/packages/agent/src/providers/skill-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-provider.d.ts","sourceRoot":"","sources":["../../../../../src/providers/skill-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAIT,MAAM,eAAe,CAAC;AAqSvB,wBAAgB,0BAA0B,IAAI,QAAQ,CAqIrD"}

package/packages/agent/src/providers/skill-provider.js

@@ -0,0 +1,353 @@
+/**
+ * Dynamic skill provider with BM25-lite matching.
+ *
+ * Replaces the upstream plugin-agent-skills providers that dump ALL skills
+ * into every prompt. Instead, builds a lightweight inverted index at startup
+ * and scores the user's message + recent context to select only the most
+ * relevant skills per turn.
+ *
+ * Three tiers of injection:
+ *   - No match:  1-line footer (~25 tokens)
+ *   - Moderate:  Compact top-3 list (~150 tokens)
+ *   - Strong:    Full instructions of #1 match, capped at 2000 chars
+ */
+import { getRecentMessagesData } from "@elizaos/shared";
+import { hasAdminAccess } from "../security/access.js";
+// ── Stopwords ────────────────────────────────────────────────────────────────
+const STOPWORDS = new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "this",
+    "that",
+    "from",
+    "will",
+    "can",
+    "are",
+    "use",
+    "when",
+    "how",
+    "what",
+    "your",
+    "you",
+    "our",
+    "has",
+    "have",
+    "been",
+    "not",
+    "but",
+    "all",
+    "also",
+    "more",
+    "than",
+    "into",
+    "does",
+    "did",
+    "was",
+    "were",
+    "would",
+    "could",
+    "should",
+    "about",
+    "just",
+    "like",
+    "some",
+    "other",
+    "any",
+    "each",
+    "make",
+    "made",
+    "get",
+    "set",
+    "put",
+    "take",
+    "see",
+    "way",
+    "may",
+    "then",
+    "its",
+    "too",
+    "very",
+    "after",
+    "before",
+    "between",
+    "through",
+    "during",
+    "here",
+    "there",
+    "where",
+    "which",
+    "who",
+    "whom",
+    "they",
+    "them",
+    "their",
+    "she",
+    "her",
+    "him",
+    "his",
+    // Agent/skill noise words
+    "skill",
+    "agent",
+    "search",
+    "install",
+    "plugin",
+    "using",
+    "used",
+    "help",
+    "want",
+    "need",
+    "please",
+]);
+// ── Tokenizer ────────────────────────────────────────────────────────────────
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !STOPWORDS.has(w));
+}
+const BM25_K1 = 1.5;
+const BM25_B = 0.75;
+const INDEX_TTL_MS = 60_000;
+function extractTriggers(description) {
+    const match = description.match(/Use (?:when|for|to)\s+([^.]+)/i);
+    if (!match)
+        return [];
+    return match[1]
+        .split(/[,;]/)
+        .map((t) => t.trim().toLowerCase())
+        .filter(Boolean);
+}
+function buildIndex(skills) {
+    const docs = [];
+    const postings = new Map();
+    const df = new Map();
+    let totalDl = 0;
+    for (let i = 0; i < skills.length; i++) {
+        const skill = skills[i];
+        const triggers = extractTriggers(skill.description);
+        const text = `${skill.name} ${skill.description} ${triggers.join(" ")}`;
+        const terms = tokenize(text);
+        const tf = new Map();
+        for (const term of terms) {
+            tf.set(term, (tf.get(term) ?? 0) + 1);
+        }
+        // Also index the slug tokens (e.g. "github" from slug "github")
+        for (const slugToken of skill.slug.split(/[-_]/)) {
+            if (slugToken.length > 2) {
+                const t = slugToken.toLowerCase();
+                tf.set(t, (tf.get(t) ?? 0) + 2); // Boost slug terms
+            }
+        }
+        const doc = {
+            slug: skill.slug,
+            name: skill.name,
+            description: skill.description,
+            triggers,
+            tf,
+            totalTerms: terms.length,
+        };
+        docs.push(doc);
+        totalDl += terms.length;
+        // Build postings
+        for (const term of tf.keys()) {
+            let set = postings.get(term);
+            if (!set) {
+                set = new Set();
+                postings.set(term, set);
+            }
+            set.add(i);
+            df.set(term, (df.get(term) ?? 0) + 1);
+        }
+    }
+    return {
+        docs,
+        postings,
+        df,
+        avgDl: docs.length > 0 ? totalDl / docs.length : 1,
+        builtAt: Date.now(),
+        skillCount: skills.length,
+    };
+}
+function scoreQuery(index, queryText) {
+    const queryTerms = tokenize(queryText);
+    if (queryTerms.length === 0)
+        return [];
+    const N = index.docs.length;
+    const scores = new Float64Array(N);
+    // BM25 scoring
+    for (const term of queryTerms) {
+        const docSet = index.postings.get(term);
+        if (!docSet)
+            continue;
+        const docFreq = index.df.get(term) ?? 0;
+        const idf = Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1);
+        for (const docIdx of docSet) {
+            const doc = index.docs[docIdx];
+            const termFreq = doc.tf.get(term) ?? 0;
+            const dlNorm = 1 - BM25_B + BM25_B * (doc.totalTerms / index.avgDl);
+            const tfScore = (termFreq * (BM25_K1 + 1)) / (termFreq + BM25_K1 * dlNorm);
+            scores[docIdx] += idf * tfScore;
+        }
+    }
+    // Exact-match bonuses (catches cases BM25 misses due to tokenization)
+    const queryLower = queryText.toLowerCase();
+    for (let i = 0; i < N; i++) {
+        const doc = index.docs[i];
+        if (queryLower.includes(doc.slug.toLowerCase()))
+            scores[i] += 10;
+        if (queryLower.includes(doc.name.toLowerCase()))
+            scores[i] += 8;
+        for (const trigger of doc.triggers) {
+            if (trigger && queryLower.includes(trigger))
+                scores[i] += 5;
+        }
+    }
+    // Collect and sort
+    const results = [];
+    for (let i = 0; i < N; i++) {
+        if (scores[i] > 0) {
+            const doc = index.docs[i];
+            results.push({
+                slug: doc.slug,
+                name: doc.name,
+                description: doc.description,
+                score: scores[i],
+            });
+        }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+// ── Recent context helper ────────────────────────────────────────────────────
+function getRecentContext(state) {
+    return getRecentMessagesData(state)
+        .slice(-5)
+        .map((message) => {
+        const content = message.content;
+        return content?.text ?? "";
+    })
+        .join(" ");
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function truncateDesc(desc, maxLen) {
+    if (desc.length <= maxLen)
+        return desc;
+    return `${desc.substring(0, maxLen - 3)}...`;
+}
+// ── Thresholds ───────────────────────────────────────────────────────────────
+const THRESHOLD_RELEVANT = 3;
+const THRESHOLD_HIGHLY_RELEVANT = 8;
+const MAX_INSTRUCTION_CHARS = 2000;
+const MAX_SKILL_MATCHES = 3;
+export function createDynamicSkillProvider() {
+    let indexCache = null;
+    return {
+        name: "elizaDynamicSkills",
+        description: "Lightweight dynamic skill matching — injects only relevant skills per turn",
+        descriptionCompressed: "lightweight dynamic skill match inject relevant skill per turn",
+        dynamic: true,
+        position: -10,
+        contexts: ["general", "agent_internal"],
+        contextGate: { anyOf: ["general", "agent_internal"] },
+        cacheStable: false,
+        cacheScope: "turn",
+        roleGate: { minRole: "USER" },
+        async get(runtime, message, state) {
+            try {
+                if (!(await hasAdminAccess(runtime, message))) {
+                    return { text: "", values: {}, data: {} };
+                }
+                const service = runtime.getService("AGENT_SKILLS_SERVICE");
+                if (!service)
+                    return { text: "", values: {}, data: {} };
+                const skills = service.getLoadedSkills();
+                if (skills.length === 0)
+                    return { text: "", values: {}, data: {} };
+                // Rebuild index if stale or skill count changed
+                if (!indexCache ||
+                    Date.now() - indexCache.builtAt > INDEX_TTL_MS ||
+                    indexCache.skillCount !== skills.length) {
+                    indexCache = buildIndex(skills);
+                }
+                // Score against current message + recent context
+                const messageText = message.content?.text ?? "";
+                const recentContext = getRecentContext(state);
+                const queryText = `${messageText} ${recentContext}`;
+                const scored = scoreQuery(indexCache, queryText);
+                const topMatch = scored[0];
+                // Tier 0: No relevant match — 1-line footer only
+                if (!topMatch || topMatch.score < THRESHOLD_RELEVANT) {
+                    return {
+                        text: `Skills: ${skills.length} installed. Ask "what can you do?" or describe a task to activate relevant skills.`,
+                        values: { skillMatchTier: "none" },
+                        data: { matchedSkills: [] },
+                    };
+                }
+                // Tier 1: Moderate match — compact top-3 list
+                const topMatches = scored
+                    .slice(0, MAX_SKILL_MATCHES)
+                    .filter((s) => s.score >= THRESHOLD_RELEVANT);
+                const compactList = topMatches
+                    .map((s) => `- **${s.name}** (${s.slug}): ${truncateDesc(s.description, 80)}`)
+                    .join("\n");
+                if (topMatch.score < THRESHOLD_HIGHLY_RELEVANT) {
+                    return {
+                        text: `## Relevant Skills\n\n${compactList}\n\n*Use USE_SKILL to invoke one, or SEARCH_SKILLS for more detail.*`,
+                        values: {
+                            skillMatchTier: "relevant",
+                            topSkill: topMatch.slug,
+                        },
+                        data: {
+                            matchedSkills: topMatches.map((s) => ({
+                                slug: s.slug,
+                                score: s.score,
+                            })),
+                        },
+                    };
+                }
+                // Tier 2: Strong match — full instructions of #1, capped
+                const instructions = service.getSkillInstructions(topMatch.slug);
+                let body = "";
+                if (instructions?.body) {
+                    body =
+                        instructions.body.length > MAX_INSTRUCTION_CHARS
+                            ? `${instructions.body.substring(0, MAX_INSTRUCTION_CHARS)}\n\n...[truncated — use USE_SKILL for full instructions]`
+                            : instructions.body;
+                }
+                const otherMatches = topMatches.length > 1
+                    ? `\n\nAlso relevant: ${topMatches
+                        .slice(1)
+                        .map((s) => s.name)
+                        .join(", ")}`
+                    : "";
+                return {
+                    text: `## Active Skill: ${topMatch.name}\n\n${body}${otherMatches}`,
+                    values: {
+                        skillMatchTier: "active",
+                        activeSkill: topMatch.slug,
+                        relevanceScore: topMatch.score,
+                    },
+                    data: {
+                        activeSkill: { slug: topMatch.slug, score: topMatch.score },
+                        otherMatches: topMatches
+                            .slice(1)
+                            .map((s) => ({ slug: s.slug, score: s.score })),
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    text: "",
+                    values: { skillMatchTier: "error" },
+                    data: {
+                        matchedSkills: [],
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                };
+            }
+        },
+    };
+}

package/packages/agent/src/providers/tasks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ongoing tasks provider — injects active task context into the agent prompt.
+ *
+ * Gives the agent awareness of pending workbench tasks and active scheduled
+ * automations so it can reference, update, or act on them in conversation.
+ */
+import type { Provider } from "@elizaos/core";
+export declare function createOngoingTasksProvider(): Provider;
+//# sourceMappingURL=tasks.d.ts.map

package/packages/agent/src/providers/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../../../../src/providers/tasks.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAIT,MAAM,eAAe,CAAC;AAuCvB,wBAAgB,0BAA0B,IAAI,QAAQ,CA4FrD"}

package/packages/agent/src/providers/tasks.js

@@ -0,0 +1,118 @@
+/**
+ * Ongoing tasks provider — injects active task context into the agent prompt.
+ *
+ * Gives the agent awareness of pending workbench tasks and active scheduled
+ * automations so it can reference, update, or act on them in conversation.
+ */
+import { isWorkbenchTodoTask, readTaskCompleted, } from "../api/workbench-helpers.js";
+import { listTriggerTasks, readTriggerConfig } from "../triggers/runtime.js";
+const MAX_TASKS_IN_CONTEXT = 20;
+const MAX_TRIGGERS_IN_CONTEXT = 10;
+function formatTaskForContext(task) {
+    const completed = readTaskCompleted(task);
+    const status = completed ? "completed" : "active";
+    const desc = typeof task.description === "string" && task.description.trim()
+        ? ` — ${task.description.trim()}`
+        : "";
+    return `- [${status}] ${task.name}${desc} (id: ${task.id})`;
+}
+function formatTriggerForContext(task) {
+    const trigger = readTriggerConfig(task);
+    if (!trigger)
+        return null;
+    const status = trigger.enabled ? "active" : "paused";
+    let schedule = "";
+    if (trigger.triggerType === "interval" && trigger.intervalMs) {
+        const mins = Math.round(trigger.intervalMs / 60_000);
+        schedule =
+            mins >= 60 ? `every ${Math.round(mins / 60)}h` : `every ${mins}m`;
+    }
+    else if (trigger.triggerType === "cron" && trigger.cronExpression) {
+        schedule = `cron: ${trigger.cronExpression}`;
+    }
+    else if (trigger.triggerType === "once") {
+        schedule = "one-time";
+    }
+    return `- [${status}] ${trigger.displayName} (${schedule}) — ${trigger.instructions} (id: ${task.id})`;
+}
+export function createOngoingTasksProvider() {
+    return {
+        name: "ongoingTasks",
+        description: "Provides context about the user's active tasks and scheduled tasks.",
+        position: 20,
+        contexts: ["tasks", "automation"],
+        contextGate: { anyOf: ["tasks", "automation"] },
+        cacheStable: false,
+        cacheScope: "turn",
+        roleGate: { minRole: "USER" },
+        async get(runtime, _message, _state) {
+            const sections = [];
+            try {
+                // Fetch all tasks
+                const allTasks = await runtime.getTasks({
+                    agentIds: [runtime.agentId],
+                });
+                // Separate workbench tasks from triggers and todos
+                const workbenchTasks = [];
+                for (const task of allTasks) {
+                    if (readTriggerConfig(task))
+                        continue; // skip triggers
+                    if (isWorkbenchTodoTask(task))
+                        continue; // skip todos
+                    workbenchTasks.push(task);
+                }
+                // Active (non-completed) tasks first
+                const activeTasks = workbenchTasks
+                    .filter((t) => !readTaskCompleted(t))
+                    .slice(0, MAX_TASKS_IN_CONTEXT);
+                const completedTasks = workbenchTasks
+                    .filter((t) => readTaskCompleted(t))
+                    .slice(0, 5);
+                if (activeTasks.length > 0 || completedTasks.length > 0) {
+                    sections.push("## Active Tasks");
+                    for (const task of activeTasks) {
+                        sections.push(formatTaskForContext(task));
+                    }
+                    if (completedTasks.length > 0) {
+                        sections.push("");
+                        sections.push("## Recently Completed Tasks");
+                        for (const task of completedTasks) {
+                            sections.push(formatTaskForContext(task));
+                        }
+                    }
+                }
+                // Fetch trigger tasks
+                const triggerTasks = await listTriggerTasks(runtime);
+                const activeTriggers = triggerTasks
+                    .filter((t) => {
+                    const cfg = readTriggerConfig(t);
+                    return cfg?.enabled;
+                })
+                    .slice(0, MAX_TRIGGERS_IN_CONTEXT);
+                if (activeTriggers.length > 0) {
+                    if (sections.length > 0)
+                        sections.push("");
+                    sections.push("## Active Automations");
+                    for (const task of activeTriggers) {
+                        const line = formatTriggerForContext(task);
+                        if (line)
+                            sections.push(line);
+                    }
+                }
+            }
+            catch (err) {
+                runtime.logger.debug({ src: "tasks-provider", error: String(err) }, "Failed to load tasks for context");
+                return { text: "" };
+            }
+            if (sections.length === 0) {
+                return { text: "" };
+            }
+            return {
+                text: sections.join("\n"),
+                values: {
+                    hasActiveTasks: true,
+                },
+            };
+        },
+    };
+}

package/packages/agent/src/providers/ui-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui-catalog.d.ts","sourceRoot":"","sources":["../../../../../src/providers/ui-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAEd,MAAM,eAAe,CAAC;AAsBvB,eAAO,MAAM,iBAAiB,EAAE,QA0G/B,CAAC"}
+{"version":3,"file":"ui-catalog.d.ts","sourceRoot":"","sources":["../../../../../src/providers/ui-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAEd,MAAM,eAAe,CAAC;AAwBvB,eAAO,MAAM,iBAAiB,EAAE,QAmF/B,CAAC"}

package/packages/agent/src/providers/ui-catalog.js

@@ -1,5 +1,7 @@
 import { ChannelType, } from "@elizaos/core";
-import { COMPONENT_CATALOG } from "../shared/ui-catalog-prompt";
+import { getValidationKeywordTerms } from "@elizaos/shared";
+import { hasAdminAccess } from "../security/access.js";
+import { COMPONENT_CATALOG } from "../shared/ui-catalog-prompt.js";
 // Core components to describe in detail — subset to keep context short.
 const DETAIL_COMPONENTS = new Set([
     "Card",
@@ -21,43 +23,15 @@ const DETAIL_COMPONENTS = new Set([
 export const uiCatalogProvider = {
     name: "uiCatalog",
     dynamic: true,
-    relevanceKeywords: [
-        "plugin",
-        "plugins",
-        "install",
-        "setup",
-        "set up",
-        "configure",
-        "config",
-        "enable",
-        "disable",
-        "activate",
-        "connect",
-        "integration",
-        "help me",
-        "how do i",
-        "how to",
-        "show me",
-        "dashboard",
-        "form",
-        "table",
-        "chart",
-        "metrics",
-        "ui",
-        "interface",
-        "polymarket",
-        "discord",
-        "openai",
-        "anthropic",
-        "telegram",
-        "twitch",
-        "youtube",
-        "twitter",
-        "api key",
-        "credentials",
-        "secret",
-    ],
-    get: async (_runtime, message, _state) => {
+    relevanceKeywords: getValidationKeywordTerms("provider.uiCatalog.relevance", {
+        includeAllLocales: true,
+    }),
+    contexts: ["general"],
+    contextGate: { anyOf: ["general"] },
+    cacheStable: true,
+    cacheScope: "agent",
+    roleGate: { minRole: "USER" },
+    get: async (runtime, message, _state) => {
         const channelType = message.content?.channelType;
         const isAllowedChannel = channelType === ChannelType.DM ||
             channelType === ChannelType.API ||
@@ -65,6 +39,9 @@ export const uiCatalogProvider = {
         if (!isAllowedChannel) {
             return { text: "" };
         }
+        if (!(await hasAdminAccess(runtime, message))) {
+            return { text: "" };
+        }
         // Build component summary — detailed for core set, brief for the rest.
         const componentLines = [];
         for (const [name, meta] of Object.entries(COMPONENT_CATALOG)) {