@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.5

package/providers/pending-permissions-provider.js

@@ -0,0 +1,110 @@
+/**
+ * Pending-permissions provider.
+ *
+ * Position `-5` — runs after the dynamic skill provider (`-10`) but before
+ * neutral-priority providers so the planner sees pending permission state
+ * alongside the active skill match.
+ *
+ * Surfaces only when `registry.pending()` is non-empty so we never bloat the
+ * prompt for the steady state. Each line names the permission, current status,
+ * and the most recent feature that was blocked.
+ */
+import { PERMISSIONS_REGISTRY_SERVICE } from "../services/permissions-registry.js";
+/** Service id used by the concrete permissions registry service. */
+export const PERMISSIONS_REGISTRY_SERVICE_ID = PERMISSIONS_REGISTRY_SERVICE;
+const LEGACY_PERMISSIONS_REGISTRY_SERVICE_ID = "PERMISSIONS_REGISTRY_SERVICE";
+function resolveRegistry(runtime) {
+    const svc = (runtime.getService(PERMISSIONS_REGISTRY_SERVICE_ID) ??
+        runtime.getService(LEGACY_PERMISSIONS_REGISTRY_SERVICE_ID));
+    if (!svc)
+        return null;
+    if (typeof svc.pending === "function") {
+        return svc;
+    }
+    if (typeof svc.getRegistry === "function") {
+        try {
+            return svc.getRegistry();
+        }
+        catch {
+            return null;
+        }
+    }
+    return svc.registry ?? null;
+}
+const RELATIVE_TIME_MIN = 60_000;
+const RELATIVE_TIME_HOUR = 60 * RELATIVE_TIME_MIN;
+const RELATIVE_TIME_DAY = 24 * RELATIVE_TIME_HOUR;
+function formatRelativeTime(now, then) {
+    const delta = Math.max(0, now - then);
+    if (delta < RELATIVE_TIME_MIN)
+        return "just now";
+    if (delta < RELATIVE_TIME_HOUR) {
+        const m = Math.floor(delta / RELATIVE_TIME_MIN);
+        return `${m} minute${m === 1 ? "" : "s"} ago`;
+    }
+    if (delta < RELATIVE_TIME_DAY) {
+        const h = Math.floor(delta / RELATIVE_TIME_HOUR);
+        return `${h} hour${h === 1 ? "" : "s"} ago`;
+    }
+    const d = Math.floor(delta / RELATIVE_TIME_DAY);
+    return `${d} day${d === 1 ? "" : "s"} ago`;
+}
+export function formatPendingPermissionLine(state, now) {
+    const id = state.id;
+    const block = state.lastBlockedFeature;
+    if (state.status === "denied" && block) {
+        const when = formatRelativeTime(now, block.at);
+        return `- ${id}: denied ${when} (${block.app}.${block.action})`;
+    }
+    if (state.status === "denied") {
+        return `- ${id}: denied`;
+    }
+    if (state.status === "not-determined") {
+        return `- ${id}: not-determined`;
+    }
+    if (state.status === "restricted") {
+        const why = state.restrictedReason ?? "restricted";
+        return `- ${id}: restricted (${why})`;
+    }
+    return `- ${id}: ${state.status}`;
+}
+export function buildPendingPermissionsContext(states, now = Date.now()) {
+    if (states.length === 0)
+        return "";
+    const body = states
+        .map((s) => formatPendingPermissionLine(s, now))
+        .join("\n");
+    return `PENDING PERMISSIONS:\n${body}`;
+}
+export const pendingPermissionsProvider = {
+    name: "elizaPendingPermissions",
+    description: "Surfaces permissions blocked or not-yet-granted so the planner can decide whether to re-request.",
+    descriptionCompressed: "surface blocked permission for planner",
+    dynamic: true,
+    position: -5,
+    cacheStable: false,
+    cacheScope: "turn",
+    async get(runtime, _message, _state) {
+        const registry = resolveRegistry(runtime);
+        if (!registry)
+            return { text: "", values: {}, data: {} };
+        const pending = registry.pending();
+        if (!Array.isArray(pending) || pending.length === 0) {
+            return { text: "", values: {}, data: {} };
+        }
+        const text = buildPendingPermissionsContext(pending);
+        return {
+            text,
+            values: { pendingPermissionCount: pending.length },
+            data: {
+                pendingPermissions: pending.map((s) => ({
+                    id: s.id,
+                    status: s.status,
+                    feature: s.lastBlockedFeature
+                        ? `${s.lastBlockedFeature.app}.${s.lastBlockedFeature.action}`
+                        : undefined,
+                })),
+            },
+        };
+    },
+};

package/providers/recent-conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recent-conversations.d.ts","sourceRoot":"","sources":["../../src/providers/recent-conversations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAKT,MAAM,eAAe,CAAC;AAkBvB,eAAO,MAAM,2BAA2B,EAAE,QAoHzC,CAAC"}

package/providers/recent-conversations.js

@@ -0,0 +1,100 @@
+import { logger } from "@elizaos/core";
+import { getValidationKeywordTerms } from "@elizaos/shared";
+import { extractConversationMetadataFromRoom, isAutomationConversationMetadata, isPageScopedConversationMetadata, } from "../api/conversation-metadata.js";
+import { hasAdminAccess } from "../security/access.js";
+import { formatRelativeTimestamp, formatSpeakerLabel, roomSourceTag, } from "../shared/conversation-format.js";
+const MAX_RECENT_MESSAGES = 10;
+const MAX_ROOMS_TO_SCAN = 10;
+export const recentConversationsProvider = {
+    name: "recent-conversations",
+    description: "Recent messages from the user's conversations across all connected platforms.",
+    descriptionCompressed: "recent message user conversation across connect platform",
+    dynamic: true,
+    position: 5,
+    relevanceKeywords: getValidationKeywordTerms("provider.recentConversations.relevance", {
+        includeAllLocales: true,
+    }),
+    contexts: ["memory", "messaging"],
+    contextGate: { anyOf: ["memory", "messaging"] },
+    cacheStable: false,
+    cacheScope: "turn",
+    roleGate: { minRole: "USER" },
+    async get(runtime, message, _state) {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return { text: "", values: {}, data: {} };
+        }
+        const entityId = message.entityId;
+        if (!entityId) {
+            return { text: "", values: {}, data: {} };
+        }
+        try {
+            const currentRoom = await runtime.getRoom(message.roomId);
+            const currentMeta = extractConversationMetadataFromRoom(currentRoom);
+            if (isAutomationConversationMetadata(currentMeta) ||
+                isPageScopedConversationMetadata(currentMeta)) {
+                return { text: "", values: {}, data: {} };
+            }
+            const roomIds = await runtime.getRoomsForParticipant(entityId);
+            if (!roomIds || roomIds.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            // Take most recent rooms (limited to avoid scanning too many)
+            const scanRoomIds = roomIds.slice(0, MAX_ROOMS_TO_SCAN);
+            const memories = await runtime.getMemoriesByRoomIds({
+                tableName: "messages",
+                roomIds: scanRoomIds,
+                limit: MAX_RECENT_MESSAGES,
+            });
+            if (!memories || memories.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            // Sort newest first
+            const sorted = memories
+                .filter((m) => m.content.text)
+                .sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))
+                .slice(0, MAX_RECENT_MESSAGES);
+            if (sorted.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            // Resolve room details for display
+            const roomCache = new Map();
+            for (const mem of sorted) {
+                const rid = mem.roomId;
+                if (rid && !roomCache.has(rid)) {
+                    try {
+                        roomCache.set(rid, await runtime.getRoom(rid));
+                    }
+                    catch {
+                        roomCache.set(rid, null);
+                    }
+                }
+            }
+            const lines = ["Recent conversations:"];
+            for (const mem of sorted) {
+                const room = roomCache.get(mem.roomId) ?? null;
+                const tag = roomSourceTag(room);
+                const ts = formatRelativeTimestamp(mem.createdAt);
+                const speaker = formatSpeakerLabel(runtime, mem);
+                const text = (mem.content.text ?? "").slice(0, 200);
+                lines.push(`${tag} (${ts}) ${speaker}: ${text}`);
+            }
+            return {
+                text: lines.join("\n"),
+                values: { recentConversationCount: sorted.length },
+                data: {
+                    messages: sorted.map((m) => ({
+                        id: m.id,
+                        roomId: m.roomId,
+                        entityId: m.entityId,
+                        text: m.content.text,
+                        createdAt: m.createdAt,
+                    })),
+                },
+            };
+        }
+        catch (error) {
+            logger.error("[recent-conversations] Error:", error instanceof Error ? error.message : String(error));
+            return { text: "", values: {}, data: {} };
+        }
+    },
+};

package/providers/relevant-conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relevant-conversations.d.ts","sourceRoot":"","sources":["../../src/providers/relevant-conversations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAIT,MAAM,eAAe,CAAC;AAgBvB,eAAO,MAAM,6BAA6B,EAAE,QAsH3C,CAAC"}

package/providers/relevant-conversations.js

@@ -0,0 +1,99 @@
+import { logger, ModelType } from "@elizaos/core";
+import { getValidationKeywordTerms } from "@elizaos/shared";
+import { extractConversationMetadataFromRoom, isAutomationConversationMetadata, } from "../api/conversation-metadata.js";
+import { formatRelativeTimestamp, formatSpeakerLabel, roomSourceTag, } from "../shared/conversation-format.js";
+const MAX_RELEVANT_RESULTS = 10;
+const MATCH_THRESHOLD = 0.7;
+export const relevantConversationsProvider = {
+    name: "relevant-conversations",
+    description: "Semantically relevant conversation snippets from across all platforms, re-ranked by similarity to the current message.",
+    descriptionCompressed: "relevant conversation snippets across platforms; rerank by current message",
+    dynamic: true,
+    position: 6,
+    relevanceKeywords: getValidationKeywordTerms("provider.relevantConversations.relevance", {
+        includeAllLocales: true,
+    }),
+    contexts: ["memory", "messaging"],
+    contextGate: { anyOf: ["memory", "messaging"] },
+    cacheStable: false,
+    cacheScope: "turn",
+    roleGate: { minRole: "USER" },
+    async get(runtime, message, _state) {
+        const text = message.content.text;
+        if (!text || text.trim().length < 5) {
+            return { text: "", values: {}, data: {} };
+        }
+        try {
+            const currentRoom = await runtime.getRoom(message.roomId);
+            if (isAutomationConversationMetadata(extractConversationMetadataFromRoom(currentRoom))) {
+                return { text: "", values: {}, data: {} };
+            }
+            // Embed the current message for semantic search
+            const embeddingResult = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+                text,
+            });
+            const embedding = Array.isArray(embeddingResult)
+                ? embeddingResult
+                : embeddingResult?.embedding;
+            if (!embedding || !Array.isArray(embedding) || embedding.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            const results = await runtime.searchMemories({
+                embedding,
+                tableName: "messages",
+                match_threshold: MATCH_THRESHOLD,
+                limit: MAX_RELEVANT_RESULTS + 5, // fetch extra to filter current room
+            });
+            if (!results || results.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            // Filter out messages from the current conversation to avoid echo
+            const currentRoomId = message.roomId;
+            const filtered = results
+                .filter((m) => m.content.text && m.roomId !== currentRoomId)
+                .slice(0, MAX_RELEVANT_RESULTS);
+            if (filtered.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            // Resolve room details
+            const roomCache = new Map();
+            for (const mem of filtered) {
+                const rid = mem.roomId;
+                if (rid && !roomCache.has(rid)) {
+                    try {
+                        roomCache.set(rid, await runtime.getRoom(rid));
+                    }
+                    catch {
+                        roomCache.set(rid, null);
+                    }
+                }
+            }
+            const lines = ["Relevant past conversations:"];
+            for (const mem of filtered) {
+                const room = roomCache.get(mem.roomId) ?? null;
+                const tag = roomSourceTag(room);
+                const ts = formatRelativeTimestamp(mem.createdAt);
+                const speaker = formatSpeakerLabel(runtime, mem);
+                const msgText = (mem.content.text ?? "").slice(0, 200);
+                lines.push(`${tag} (${ts}) ${speaker}: ${msgText}`);
+            }
+            return {
+                text: lines.join("\n"),
+                values: { relevantConversationCount: filtered.length },
+                data: {
+                    messages: filtered.map((m) => ({
+                        id: m.id,
+                        roomId: m.roomId,
+                        entityId: m.entityId,
+                        text: m.content.text,
+                        createdAt: m.createdAt,
+                    })),
+                },
+            };
+        }
+        catch (error) {
+            logger.error("[relevant-conversations] Error:", error instanceof Error ? error.message : String(error));
+            return { text: "", values: {}, data: {} };
+        }
+    },
+};

package/providers/role-backfill.d.ts

@@ -0,0 +1,18 @@
+/**
+ * World creation role backfill provider.
+ *
+ * Problem: When a new connector creates a new world after roles bootstrap,
+ * the owner's role is not set in that world because `ensureOwnerRole()` only
+ * runs at boot.
+ *
+ * Solution: On every message, if the current world has an ownerId but no
+ * OWNER role entry, backfill it. This is idempotent -- after the first backfill,
+ * later runs on the same world have nothing to update.
+ *
+ * Runs as a lightweight provider with a high position number (early/low
+ * priority) so it does not add latency to prompt construction. Produces no
+ * visible text in the agent context.
+ */
+import { type Provider } from "@elizaos/core";
+export declare const roleBackfillProvider: Provider;
+//# sourceMappingURL=role-backfill.d.ts.map

package/providers/role-backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-backfill.d.ts","sourceRoot":"","sources":["../../src/providers/role-backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAML,KAAK,QAAQ,EAMd,MAAM,eAAe,CAAC;AAQvB,eAAO,MAAM,oBAAoB,EAAE,QAuFlC,CAAC"}

package/providers/role-backfill.js

@@ -0,0 +1,86 @@
+/**
+ * World creation role backfill provider.
+ *
+ * Problem: When a new connector creates a new world after roles bootstrap,
+ * the owner's role is not set in that world because `ensureOwnerRole()` only
+ * runs at boot.
+ *
+ * Solution: On every message, if the current world has an ownerId but no
+ * OWNER role entry, backfill it. This is idempotent -- after the first backfill,
+ * later runs on the same world have nothing to update.
+ *
+ * Runs as a lightweight provider with a high position number (early/low
+ * priority) so it does not add latency to prompt construction. Produces no
+ * visible text in the agent context.
+ */
+import { hasConfiguredCanonicalOwner, logger, normalizeRole, resolveCanonicalOwnerId, } from "@elizaos/core";
+export const roleBackfillProvider = {
+    name: "roleBackfill",
+    description: "Lazily backfills OWNER role for new worlds created after roles bootstrap.",
+    descriptionCompressed: "lazily backfill OWNER role new world create after role bootstrap",
+    dynamic: true,
+    // High position number = runs after the main roles provider (position 10).
+    position: 11,
+    contexts: ["admin", "settings"],
+    contextGate: { anyOf: ["admin", "settings"] },
+    cacheStable: false,
+    cacheScope: "turn",
+    roleGate: { minRole: "ADMIN" },
+    async get(runtime, message, _state) {
+        const empty = { text: "", values: {}, data: {} };
+        try {
+            const room = await runtime.getRoom(message.roomId);
+            if (!room?.worldId)
+                return empty;
+            const world = await runtime.getWorld(room.worldId);
+            if (!world)
+                return empty;
+            const metadata = (world.metadata ?? {});
+            const ownerId = resolveCanonicalOwnerId(runtime, metadata);
+            if (!ownerId)
+                return empty;
+            const roles = metadata.roles ?? {};
+            const roleSources = metadata.roleSources ?? {};
+            const currentOwnerRole = normalizeRole(roles[ownerId]);
+            const needsOwnershipSync = metadata.ownership?.ownerId !== ownerId;
+            const needsOwnerSourceSync = roleSources[ownerId] !== "owner";
+            const configuredOwner = hasConfiguredCanonicalOwner(runtime);
+            const hasStaleOwners = configuredOwner
+                ? Object.entries(roles).some(([entityId, role]) => entityId !== ownerId && normalizeRole(role) === "OWNER")
+                : false;
+            // Already has OWNER role; nothing to update.
+            if (currentOwnerRole === "OWNER" &&
+                !needsOwnershipSync &&
+                !needsOwnerSourceSync &&
+                !hasStaleOwners) {
+                return empty;
+            }
+            // Backfill: set OWNER role for the world owner
+            metadata.ownership = { ...(metadata.ownership ?? {}), ownerId };
+            roles[ownerId] = "OWNER";
+            roleSources[ownerId] = "owner";
+            if (configuredOwner) {
+                for (const [entityId, role] of Object.entries(roles)) {
+                    if (entityId !== ownerId && normalizeRole(role) === "OWNER") {
+                        delete roles[entityId];
+                        delete roleSources[entityId];
+                    }
+                }
+            }
+            const updatedMetadata = {
+                ...metadata,
+                roles,
+                roleSources,
+            };
+            await runtime.updateWorld({
+                ...world,
+                metadata: updatedMetadata,
+            });
+            logger.info(`[roles] Backfill: set OWNER role for entity ${ownerId} in world ${world.id}`);
+        }
+        catch (err) {
+            logger.warn(`[roles] Role backfill failed: ${String(err)}`);
+        }
+        return empty;
+    },
+};

package/providers/rolodex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rolodex.d.ts","sourceRoot":"","sources":["../../src/providers/rolodex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAMT,MAAM,eAAe,CAAC;AA8BvB,eAAO,MAAM,eAAe,EAAE,QAwF7B,CAAC"}

package/providers/rolodex.js

@@ -0,0 +1,90 @@
+import { logger } from "@elizaos/core";
+import { getValidationKeywordTerms } from "@elizaos/shared";
+import { hasAdminAccess } from "../security/access.js";
+const MAX_CONTACTS = 10;
+function formatPerson(person) {
+    const platforms = person.platforms.length > 0 ? person.platforms.join(", ") : "no platforms";
+    const parts = [
+        `${person.displayName}${person.isOwner ? " [OWNER]" : ""} (${platforms})`,
+    ];
+    if (person.preferredCommunicationChannel) {
+        parts.push(`prefers: ${person.preferredCommunicationChannel}`);
+    }
+    if (person.aliases.length > 0) {
+        parts.push(`aka: ${person.aliases.slice(0, 3).join(", ")}`);
+    }
+    if (person.lastInteractionAt) {
+        parts.push(`last: ${person.lastInteractionAt.slice(0, 10)}`);
+    }
+    if (person.factCount > 0) {
+        parts.push(`${person.factCount} facts`);
+    }
+    return `- ${parts.join(" | ")}`;
+}
+export const rolodexProvider = {
+    name: "rolodex",
+    description: "Known contacts and relationships across all connected platforms (the Rolodex).",
+    descriptionCompressed: "known contact relationship across connect platform (Rolodex)",
+    dynamic: true,
+    position: 7,
+    relevanceKeywords: getValidationKeywordTerms("provider.rolodex.relevance", {
+        includeAllLocales: true,
+    }),
+    contexts: ["contacts", "memory"],
+    contextGate: { anyOf: ["contacts", "memory"] },
+    cacheStable: false,
+    cacheScope: "turn",
+    roleGate: { minRole: "USER" },
+    async get(runtime, _message, _state) {
+        if (!(await hasAdminAccess(runtime, _message))) {
+            return { text: "", values: {}, data: {} };
+        }
+        try {
+            const graphService = runtime.getService("relationships");
+            if (!graphService) {
+                return { text: "", values: {}, data: {} };
+            }
+            const snapshot = await graphService.getGraphSnapshot({
+                limit: MAX_CONTACTS,
+            });
+            if (!snapshot) {
+                return {
+                    text: "Rolodex: No known contacts yet.",
+                    values: { rolodexCount: 0 },
+                    data: { contacts: [] },
+                };
+            }
+            if (snapshot.people.length === 0) {
+                return {
+                    text: "Rolodex: No known contacts yet.",
+                    values: { rolodexCount: 0 },
+                    data: { contacts: [], stats: snapshot.stats },
+                };
+            }
+            const lines = [
+                `Rolodex (${snapshot.stats.totalPeople} contacts, ${snapshot.stats.totalIdentities} identities):`,
+            ];
+            for (const person of snapshot.people) {
+                lines.push(formatPerson(person));
+            }
+            if (snapshot.stats.totalPeople > MAX_CONTACTS) {
+                lines.push(`... and ${snapshot.stats.totalPeople - MAX_CONTACTS} more. Use SEARCH_ENTITY to find specific contacts.`);
+            }
+            return {
+                text: lines.join("\n"),
+                values: {
+                    rolodexCount: snapshot.stats.totalPeople,
+                    rolodexIdentityCount: snapshot.stats.totalIdentities,
+                },
+                data: {
+                    contacts: snapshot.people,
+                    stats: snapshot.stats,
+                },
+            };
+        }
+        catch (error) {
+            logger.error("[rolodex] Error:", error instanceof Error ? error.message : String(error));
+            return { text: "", values: {}, data: {} };
+        }
+    },
+};

package/providers/session-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-bridge.d.ts","sourceRoot":"","sources":["../../src/providers/session-bridge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAER,IAAI,EAEL,MAAM,eAAe,CAAC;AAOvB;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,IAAI,EACV,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,MAAM,CAWR;AAED,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,QAAQ,CAyDX"}

package/providers/session-bridge.js

@@ -0,0 +1,71 @@
+/**
+ * Bridges Eliza session keys with elizaOS rooms.
+ *
+ * Eliza keys: agent:{agentId}:main (DMs), agent:{agentId}:{channel}:group:{id} (groups)
+ * elizaOS rooms: per-agent UUIDs via createUniqueUuid(runtime, channelId)
+ */
+import { buildAgentMainSessionKey, ChannelType, parseAgentSessionKey, } from "@elizaos/core";
+/**
+ * Resolve an Eliza session key from an elizaOS room.
+ *
+ * DMs -> agent:{agentId}:main
+ * Groups -> agent:{agentId}:{channel}:group:{groupId}
+ * Channels -> agent:{agentId}:{channel}:channel:{channelId}
+ * Threads append :thread:{threadId}
+ */
+export function resolveSessionKeyFromRoom(agentId, room, meta) {
+    const channel = meta?.channel ?? room.source;
+    if (room.type === ChannelType.DM || room.type === ChannelType.SELF) {
+        return buildAgentMainSessionKey({ agentId, mainKey: "main" });
+    }
+    const id = meta?.groupId ?? room.channelId ?? room.id;
+    const kind = room.type === ChannelType.GROUP ? "group" : "channel";
+    const base = `agent:${agentId}:${channel}:${kind}:${id}`;
+    return meta?.threadId ? `${base}:thread:${meta.threadId}` : base;
+}
+export function createSessionKeyProvider(options) {
+    const agentId = options?.defaultAgentId ?? "main";
+    return {
+        name: "elizaSessionBridge",
+        description: "Eliza session key (DM/group/thread isolation)",
+        dynamic: true,
+        position: 5,
+        contexts: ["general", "messaging"],
+        contextGate: { anyOf: ["general", "messaging"] },
+        cacheStable: false,
+        cacheScope: "turn",
+        roleGate: { minRole: "USER" },
+        async get(runtime, message, _state) {
+            const meta = (message.metadata ?? {});
+            const existing = typeof meta.sessionKey === "string" ? meta.sessionKey : undefined;
+            if (existing) {
+                const parsed = parseAgentSessionKey(existing);
+                return {
+                    text: `Session: ${existing}`,
+                    values: { sessionKey: existing, agentId: parsed?.agentId ?? agentId },
+                    data: { sessionKey: existing },
+                };
+            }
+            const room = await runtime.getRoom(message.roomId);
+            if (!room) {
+                const key = buildAgentMainSessionKey({ agentId, mainKey: "main" });
+                return {
+                    text: `Session: ${key}`,
+                    values: { sessionKey: key },
+                    data: { sessionKey: key },
+                };
+            }
+            const key = resolveSessionKeyFromRoom(agentId, room, {
+                threadId: typeof meta.threadId === "string" ? meta.threadId : undefined,
+                groupId: typeof meta.groupId === "string" ? meta.groupId : undefined,
+                channel: (typeof meta.channel === "string" ? meta.channel : undefined) ??
+                    room.source,
+            });
+            return {
+                text: `Session: ${key}`,
+                values: { sessionKey: key, isGroup: room.type === ChannelType.GROUP },
+                data: { sessionKey: key },
+            };
+        },
+    };
+}

package/providers/session-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Session utility functions for the eliza plugin.
+ *
+ * Session providers are owned by @elizaos/core; this module re-exports the
+ * canonical collection and adds the agent-local store-path resolution used to
+ * point those providers at this agent's session store.
+ */
+import { getSessionProviders } from "@elizaos/core";
+export { getSessionProviders };
+/**
+ * Resolve the default session store path.
+ */
+export declare function resolveDefaultSessionStorePath(agentId?: string): string;
+//# sourceMappingURL=session-utils.d.ts.map

package/providers/session-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-utils.d.ts","sourceRoot":"","sources":["../../src/providers/session-utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,mBAAmB,EAAmB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAY/B;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAEvE"}

package/providers/session-utils.js

@@ -0,0 +1,24 @@
+/**
+ * Session utility functions for the eliza plugin.
+ *
+ * Session providers are owned by @elizaos/core; this module re-exports the
+ * canonical collection and adds the agent-local store-path resolution used to
+ * point those providers at this agent's session store.
+ */
+import * as path from "node:path";
+import { getSessionProviders, resolveStateDir } from "@elizaos/core";
+export { getSessionProviders };
+const DEFAULT_AGENT_ID = "main";
+/**
+ * Resolve the sessions directory for an agent.
+ */
+function resolveAgentSessionsDir(agentId) {
+    const id = agentId ?? DEFAULT_AGENT_ID;
+    return path.join(resolveStateDir(), "agents", id, "sessions");
+}
+/**
+ * Resolve the default session store path.
+ */
+export function resolveDefaultSessionStorePath(agentId) {
+    return path.join(resolveAgentSessionsDir(agentId), "sessions.json");
+}

package/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/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/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,QAmH/B,CAAC"}