@elizaos/agent 0.25.9 → 2.0.0-alpha.151

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

@@ -0,0 +1,85 @@
+import { ChannelType, } from "@elizaos/core";
+function resolveChannelProfile(message) {
+    const content = message.content;
+    const channelType = content?.channelType;
+    const conversationMode = typeof content?.conversationMode === "string"
+        ? content.conversationMode.toLowerCase()
+        : null;
+    if (channelType === ChannelType.VOICE_DM ||
+        channelType === ChannelType.VOICE_GROUP) {
+        return "voice_fast";
+    }
+    if (channelType === ChannelType.GROUP) {
+        return "group_compact";
+    }
+    if (conversationMode === "simple") {
+        return "text_fast";
+    }
+    return "default_full";
+}
+export function createChannelProfileProvider() {
+    return {
+        name: "elizaChannelProfile",
+        description: "Injects channel-derived execution profile guidance (voice/group/default).",
+        position: -50,
+        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",
+                    },
+                };
+            }
+            return {
+                values: {
+                    executionProfile: "default_full",
+                    compactContext: false,
+                },
+                data: {
+                    profile: "default_full",
+                },
+            };
+        },
+    };
+}

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,EAGT,MAAM,eAAe,CAAC;AA0SvB,wBAAgB,0BAA0B,IAAI,QAAQ,CAgHrD"}

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

@@ -0,0 +1,336 @@
+/**
+ * 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 { 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) {
+    const recentMessages = state.recentMessages ??
+        state.recentMessagesData ??
+        [];
+    if (Array.isArray(recentMessages)) {
+        return recentMessages
+            .slice(-5)
+            .map((m) => {
+            const content = m.content;
+            return content?.text ?? "";
+        })
+            .join(" ");
+    }
+    return "";
+}
+// ── 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;
+export function createDynamicSkillProvider() {
+    let indexCache = null;
+    return {
+        name: "elizaDynamicSkills",
+        description: "Lightweight dynamic skill matching — injects only relevant skills per turn",
+        dynamic: true,
+        position: -10,
+        async get(runtime, message, state) {
+            if (!(await hasAdminAccess(runtime, message))) {
+                return { text: "", values: {}, data: {} };
+            }
+            const service = runtime.getService("AGENT_SKILLS_SERVICE");
+            if (!service)
+                return { text: "" };
+            const skills = service.getLoadedSkills();
+            if (skills.length === 0)
+                return { text: "" };
+            // 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 top3 = scored
+                .slice(0, 3)
+                .filter((s) => s.score >= THRESHOLD_RELEVANT);
+            const compactList = top3
+                .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 GET_SKILL_GUIDANCE for detailed instructions.*`,
+                    values: {
+                        skillMatchTier: "relevant",
+                        topSkill: topMatch.slug,
+                    },
+                    data: {
+                        matchedSkills: top3.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 GET_SKILL_GUIDANCE for full instructions]`
+                        : instructions.body;
+            }
+            const otherMatches = top3.length > 1
+                ? `\n\nAlso relevant: ${top3
+                    .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: top3
+                        .slice(1)
+                        .map((s) => ({ slug: s.slug, score: s.score })),
+                },
+            };
+        },
+    };
+}

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,CAsFrD"}

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

@@ -0,0 +1,113 @@
+/**
+ * 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,
+        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

@@ -0,0 +1,3 @@
+import { type Provider } from "@elizaos/core";
+export declare const uiCatalogProvider: Provider;
+//# sourceMappingURL=ui-catalog.d.ts.map

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

@@ -0,0 +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;AAwBvB,eAAO,MAAM,iBAAiB,EAAE,QA6E/B,CAAC"}

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

@@ -0,0 +1,95 @@
+import { ChannelType, } from "@elizaos/core";
+import { getValidationKeywordTerms } from "@elizaos/shared/validation-keywords";
+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",
+    "Stack",
+    "Grid",
+    "Text",
+    "Button",
+    "Input",
+    "Select",
+    "Textarea",
+    "Badge",
+    "Metric",
+    "Separator",
+    "Progress",
+    "Table",
+    "Alert",
+    "Tabs",
+]);
+export const uiCatalogProvider = {
+    name: "uiCatalog",
+    dynamic: true,
+    relevanceKeywords: getValidationKeywordTerms("provider.uiCatalog.relevance", {
+        includeAllLocales: true,
+    }),
+    get: async (runtime, message, _state) => {
+        const channelType = message.content?.channelType;
+        const isAllowedChannel = channelType === ChannelType.DM ||
+            channelType === ChannelType.API ||
+            !channelType;
+        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)) {
+            if (DETAIL_COMPONENTS.has(name)) {
+                const props = Object.entries(meta.props)
+                    .map(([k, p]) => `${k}: ${p.type}${p.required ? " (required)" : ""}`)
+                    .join(", ");
+                componentLines.push(`- **${name}**: ${meta.description} [props: ${props}]`);
+            }
+            else {
+                componentLines.push(`- ${name}: ${meta.description}`);
+            }
+        }
+        return {
+            text: `## Rich UI Output — you can render interactive components in your replies
+
+### Method 1 — Inline JSONL patches (for custom dashboards, forms, visualisations)
+Emit RFC 6902 JSON patch lines INLINE in your response (no code fences, no markdown):
+{"op":"add","path":"/root","value":"card-1"}
+{"op":"add","path":"/elements/card-1","value":{"type":"Card","props":{"title":"Plugin Setup"},"children":["body-1"]}}
+{"op":"add","path":"/elements/body-1","value":{"type":"Text","props":{"text":"Fill in the details below."},"children":[]}}
+
+Rules:
+- Always emit /root first, then /elements/<id>, then /state/<key>
+- Each patch must be on its own line, valid JSON, no trailing text on that line
+- Element IDs: unique kebab-case strings
+- state binding: set statePath prop on Input/Select/Textarea to a dot-path key
+- data binding in props: "$data.key.path" resolves from state at render time
+- Use this method when the user needs a form, table, metrics view, or custom UI
+
+### Method 2 — [CONFIG:pluginId] marker (for plugin configuration forms)
+Include EXACTLY this marker whenever a plugin is mentioned in any configuration, setup, or status context:
+[CONFIG:pluginId]
+Replace pluginId with the plugin's short ID (e.g. [CONFIG:polymarket], [CONFIG:discord], [CONFIG:anthropic], [CONFIG:openai], [CONFIG:twitch]).
+The UI will auto-generate a full configuration form from the plugin's parameter schema.
+
+**ALWAYS use [CONFIG:pluginId] when:**
+- User mentions a plugin by name ("discord", "polymarket", "openai", etc.)
+- User asks to show, view, check, set up, configure, enable, install, or activate a plugin
+- You mention that a plugin needs credentials, secrets, or setup steps
+- User asks "what plugins", "show me plugins", "check plugin status"
+- You would otherwise say "you need to configure X" or "set up X first"
+
+Do NOT describe configuration steps in text — just emit [CONFIG:pluginId] and let the UI handle it.
+
+### When to use rich UI
+- Any plugin mentioned by name → Method 2 ([CONFIG:pluginId]) — always
+- Forms, data entry, settings panels → Method 1 (JSONL patches with Input/Select)
+- Tables, metrics, dashboards → Method 1 (Table/Metric/ProgressBar)
+- Simple factual answers with no plugin/form involved → plain text only
+
+### Available components (${Object.keys(COMPONENT_CATALOG).length} total)
+${componentLines.join("\n")}`,
+        };
+    },
+};

package/packages/agent/src/providers/user-name.d.ts

@@ -0,0 +1,11 @@
+/**
+ * User name provider — injects the user's display name into the system prompt
+ * when chatting via the app (client_chat). Tells the agent the user's name if
+ * known, or hints that it can ask.
+ *
+ * Only active for `source === "client_chat"` so it never leaks into Telegram,
+ * Discord, or other connectors.
+ */
+import type { Provider } from "@elizaos/core";
+export declare function createUserNameProvider(): Provider;
+//# sourceMappingURL=user-name.d.ts.map