@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-lifeops/src/dossier/service.js

@@ -0,0 +1,346 @@
+/**
+ * T7f — Meeting dossier generator (plan §6.7).
+ *
+ * DossierService builds a briefing payload for an upcoming calendar event.
+ * It collects:
+ *   1. The resolved calendar event (by id or fuzzy title match).
+ *   2. Attendee enrichment via the RelationshipsService (structural).
+ *   3. Recent Gmail threads for attendees whose emails match (structural).
+ *   4. Prior dossiers for the same attendees (memories, tableName=reminders,
+ *      content.type === "meeting_dossier").
+ *   5. A well-formedness check on any meeting link (not a network fetch).
+ *
+ * Every external dependency is optional and the service degrades gracefully
+ * to an empty list when the dependency is not registered. The returned
+ * payload carries an explicit `degraded` map so downstream consumers can
+ * reason about partial data — no silent fallbacks that fake completeness.
+ */
+import { logger } from "@elizaos/core";
+const DEFAULT_WINDOW_DAYS = 7;
+const MAX_GMAIL_THREADS_PER_ATTENDEE = 3;
+const MAX_PRIOR_DOSSIER_LOOKBACK = 20;
+export const DOSSIER_MEMORY_TABLE = "reminders";
+export const DOSSIER_MEMORY_TYPE = "meeting_dossier";
+export class DossierService {
+    runtime;
+    deps;
+    constructor(runtime, deps) {
+        this.runtime = runtime;
+        this.deps = deps;
+    }
+    async generateDossier(eventIdOrTitleFuzzy, windowDays = DEFAULT_WINDOW_DAYS) {
+        const trimmed = eventIdOrTitleFuzzy.trim();
+        if (trimmed.length === 0) {
+            throw new Error("[DossierService] eventIdOrTitleFuzzy is required");
+        }
+        const effectiveWindowDays = Number.isFinite(windowDays) && windowDays > 0
+            ? Math.floor(windowDays)
+            : DEFAULT_WINDOW_DAYS;
+        const now = new Date();
+        const event = await this.resolveEvent(trimmed, now, effectiveWindowDays);
+        if (!event) {
+            throw new Error(`[DossierService] no calendar event matched "${trimmed}"`);
+        }
+        const degraded = {
+            relationships: !this.deps.relationships,
+            gmail: !this.deps.gmail,
+            memories: false,
+            identityCluster: false,
+        };
+        const rawAttendees = [];
+        for (const attendee of event.attendees) {
+            const summary = await this.buildAttendeeSummary(attendee, effectiveWindowDays);
+            rawAttendees.push(summary);
+        }
+        const attendees = await this.dedupeByIdentityCluster(rawAttendees, degraded);
+        const priorDossierIds = new Set();
+        try {
+            const memoryIdsByAttendee = await this.findPriorDossierMemoryIds(attendees.map((a) => a.email).filter((e) => Boolean(e)));
+            for (const [email, ids] of memoryIdsByAttendee.entries()) {
+                for (const a of attendees) {
+                    if (a.email && a.email.toLowerCase() === email) {
+                        a.priorDossierMemoryIds = ids;
+                    }
+                }
+                for (const id of ids)
+                    priorDossierIds.add(id);
+            }
+        }
+        catch (err) {
+            degraded.memories = true;
+            logger.warn(`[DossierService] memory lookup failed — marking degraded: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const meetingLink = checkMeetingLink(event.conferenceLink);
+        const payload = {
+            eventId: event.id,
+            eventTitle: event.title,
+            eventStartAt: event.startAt,
+            eventEndAt: event.endAt,
+            windowDays: effectiveWindowDays,
+            attendees,
+            meetingLink,
+            priorDossiersCount: priorDossierIds.size,
+            degraded,
+            generatedAt: now.toISOString(),
+        };
+        const text = renderDossierMarkdown(payload);
+        return { text, data: payload };
+    }
+    async resolveEvent(eventIdOrTitleFuzzy, now, windowDays) {
+        const url = new URL("internal://dossier/resolve");
+        const timeMin = new Date(now.getTime() - windowDays * 24 * 60 * 60 * 1000)
+            .toISOString();
+        const timeMax = new Date(now.getTime() + windowDays * 24 * 60 * 60 * 1000)
+            .toISOString();
+        const feed = await this.deps.calendar.getCalendarFeed(url, { timeMin, timeMax }, now);
+        const normalizedQuery = eventIdOrTitleFuzzy.toLowerCase().trim();
+        if (normalizedQuery === "next" ||
+            normalizedQuery === "next meeting" ||
+            normalizedQuery === "next event" ||
+            normalizedQuery === "my next meeting" ||
+            normalizedQuery === "my next event") {
+            const nextEvent = [...feed.events]
+                .filter((event) => event.status !== "cancelled")
+                .filter((event) => {
+                const endAt = Date.parse(event.endAt);
+                return Number.isFinite(endAt) && endAt >= now.getTime();
+            })
+                .sort((left, right) => Date.parse(left.startAt) - Date.parse(right.startAt))[0];
+            if (nextEvent)
+                return nextEvent;
+        }
+        const exact = feed.events.find((e) => e.id === eventIdOrTitleFuzzy || e.externalId === eventIdOrTitleFuzzy);
+        if (exact)
+            return exact;
+        const lower = eventIdOrTitleFuzzy.toLowerCase();
+        const byTitle = feed.events
+            .map((e) => ({ e, score: fuzzyTitleScore(e.title.toLowerCase(), lower) }))
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score);
+        return byTitle[0]?.e ?? null;
+    }
+    async buildAttendeeSummary(attendee, _windowDays) {
+        const summary = {
+            email: attendee.email,
+            displayName: attendee.displayName,
+            contactId: null,
+            categories: [],
+            tags: [],
+            lastInteractionAt: null,
+            cadenceHealth: null,
+            recentGmailThreads: [],
+            priorDossierMemoryIds: [],
+        };
+        const relService = this.deps.relationships;
+        if (relService && attendee.email) {
+            const contact = await relService.findByHandle("email", attendee.email);
+            if (contact) {
+                summary.contactId = contact.entityId;
+                summary.categories = contact.categories;
+                summary.tags = contact.tags;
+                summary.lastInteractionAt = contact.lastInteractionAt ?? null;
+                const progress = await relService.getRelationshipProgress(contact.entityId);
+                if (progress) {
+                    summary.cadenceHealth = progress.cadenceHealth;
+                    summary.lastInteractionAt = progress.lastInteractionAt;
+                }
+            }
+        }
+        const gmail = this.deps.gmail;
+        if (gmail && attendee.email) {
+            const threads = await gmail.searchThreadsByParticipant({
+                email: attendee.email,
+                windowDays: _windowDays,
+                maxResults: MAX_GMAIL_THREADS_PER_ATTENDEE,
+            });
+            summary.recentGmailThreads = threads.slice(0, MAX_GMAIL_THREADS_PER_ATTENDEE);
+        }
+        return summary;
+    }
+    /**
+     * Collapse attendees that belong to the same cross-platform identity
+     * cluster. Two attendees with different emails may actually be the same
+     * person (jill@work.com and jill.personal@gmail.com linked via discord
+     * handle). Without this dedup, the dossier double-counts history and
+     * presents the same person twice.
+     *
+     * Only attendees with a resolved contactId participate — unknown
+     * attendees stay as-is.
+     *
+     * If the relationships service does not expose resolvePrimaryEntityId
+     * we leave the list unchanged and flag degraded.identityCluster so the
+     * consumer can tell the dedup was skipped.
+     */
+    async dedupeByIdentityCluster(attendees, degraded) {
+        const relService = this.deps.relationships;
+        if (!relService || typeof relService.resolvePrimaryEntityId !== "function") {
+            if (attendees.some((a) => a.contactId !== null)) {
+                degraded.identityCluster = true;
+            }
+            return attendees;
+        }
+        const primaryByContact = new Map();
+        for (const attendee of attendees) {
+            if (!attendee.contactId)
+                continue;
+            try {
+                const primary = await relService.resolvePrimaryEntityId(attendee.contactId);
+                primaryByContact.set(attendee.contactId, primary);
+            }
+            catch (err) {
+                degraded.identityCluster = true;
+                logger.warn(`[DossierService] resolvePrimaryEntityId failed for ${attendee.contactId}: ${err instanceof Error ? err.message : String(err)}`);
+                return attendees;
+            }
+        }
+        const seenPrimaries = new Set();
+        const deduped = [];
+        for (const attendee of attendees) {
+            if (!attendee.contactId) {
+                deduped.push(attendee);
+                continue;
+            }
+            const primary = primaryByContact.get(attendee.contactId);
+            if (!primary) {
+                deduped.push(attendee);
+                continue;
+            }
+            if (seenPrimaries.has(primary)) {
+                continue;
+            }
+            seenPrimaries.add(primary);
+            deduped.push(attendee);
+        }
+        return deduped;
+    }
+    async findPriorDossierMemoryIds(emails) {
+        const result = new Map();
+        if (emails.length === 0)
+            return result;
+        const adapter = this.runtime.adapter;
+        const getMemories = adapter?.getMemories;
+        if (typeof getMemories !== "function") {
+            throw new Error("runtime.adapter.getMemories not available");
+        }
+        const memories = await getMemories.call(adapter, {
+            agentId: String(this.runtime.agentId),
+            tableName: DOSSIER_MEMORY_TABLE,
+            count: MAX_PRIOR_DOSSIER_LOOKBACK,
+        });
+        const normalizedEmails = new Set(emails.map((e) => e.toLowerCase()));
+        for (const mem of memories) {
+            const content = mem.content;
+            if (content?.type !== DOSSIER_MEMORY_TYPE)
+                continue;
+            const memAttendees = Array.isArray(content.attendees)
+                ? content.attendees
+                : [];
+            for (const a of memAttendees) {
+                if (typeof a !== "string")
+                    continue;
+                const key = a.toLowerCase();
+                if (!normalizedEmails.has(key))
+                    continue;
+                const existing = result.get(key) ?? [];
+                existing.push(mem.id);
+                result.set(key, existing);
+            }
+        }
+        return result;
+    }
+}
+function fuzzyTitleScore(title, query) {
+    if (!title || !query)
+        return 0;
+    if (title === query)
+        return 100;
+    if (title.includes(query))
+        return 50;
+    const tokens = query.split(/\s+/).filter((t) => t.length > 1);
+    if (tokens.length === 0)
+        return 0;
+    const hits = tokens.filter((t) => title.includes(t)).length;
+    return hits / tokens.length;
+}
+function checkMeetingLink(url) {
+    if (!url)
+        return null;
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+            return {
+                url,
+                wellFormed: false,
+                reason: `unsupported protocol ${parsed.protocol}`,
+            };
+        }
+        return { url, wellFormed: true };
+    }
+    catch {
+        return { url, wellFormed: false, reason: "unparseable URL" };
+    }
+}
+function renderDossierMarkdown(payload) {
+    const lines = [];
+    lines.push(`# Meeting Dossier — ${payload.eventTitle}`);
+    lines.push(`- Start: ${payload.eventStartAt}`);
+    lines.push(`- End: ${payload.eventEndAt}`);
+    if (payload.meetingLink) {
+        const mark = payload.meetingLink.wellFormed ? "ok" : "malformed";
+        lines.push(`- Meeting link: ${payload.meetingLink.url} (${mark})`);
+    }
+    lines.push(`- Context window: ${payload.windowDays}d`);
+    if (payload.attendees.length === 0) {
+        lines.push("\n## Attendees\n(none on file)");
+    }
+    else {
+        lines.push("\n## Attendees");
+        for (const a of payload.attendees) {
+            const name = a.displayName ?? a.email ?? "(unknown)";
+            lines.push(`### ${name}`);
+            if (a.email)
+                lines.push(`- Email: ${a.email}`);
+            if (a.contactId) {
+                lines.push(`- Relationship: ${a.cadenceHealth ?? "unknown"}${a.lastInteractionAt ? ` (last contacted ${a.lastInteractionAt})` : ""}`);
+                if (a.tags.length > 0)
+                    lines.push(`- Tags: ${a.tags.join(", ")}`);
+            }
+            else {
+                lines.push("- Relationship: no contact on file");
+            }
+            if (a.recentGmailThreads.length > 0) {
+                lines.push("- Recent email threads:");
+                for (const t of a.recentGmailThreads) {
+                    lines.push(`  - ${t.subject ?? "(no subject)"} (${t.threadId})`);
+                }
+            }
+            if (a.priorDossierMemoryIds.length > 0) {
+                lines.push(`- Prior dossiers: ${a.priorDossierMemoryIds.length}`);
+            }
+        }
+    }
+    const degradedNotes = [];
+    if (payload.degraded.relationships)
+        degradedNotes.push("relationships service unavailable");
+    if (payload.degraded.gmail)
+        degradedNotes.push("gmail service unavailable");
+    if (payload.degraded.memories)
+        degradedNotes.push("memory lookup failed");
+    if (payload.degraded.identityCluster)
+        degradedNotes.push("cross-platform identity dedup unavailable");
+    if (degradedNotes.length > 0) {
+        lines.push(`\n_Degraded: ${degradedNotes.join("; ")}_`);
+    }
+    return lines.join("\n");
+}
+export function getRelationshipsServiceLike(runtime) {
+    const service = runtime.getService("relationships");
+    if (!service)
+        return null;
+    const candidate = service;
+    if (typeof candidate.findByHandle !== "function" ||
+        typeof candidate.getRelationshipProgress !== "function") {
+        return null;
+    }
+    return candidate;
+}

package/apps/app-lifeops/src/followup/actions/listOverdueFollowups.d.ts

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

package/apps/app-lifeops/src/followup/actions/listOverdueFollowups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listOverdueFollowups.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/followup/actions/listOverdueFollowups.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAGP,MAAM,eAAe,CAAC;AAOvB,eAAO,MAAM,0BAA0B,EAAE,MAoDxC,CAAC"}

package/apps/app-lifeops/src/followup/actions/listOverdueFollowups.js

@@ -0,0 +1,47 @@
+import { hasOwnerAccess } from "@elizaos/agent/security/access";
+import { FOLLOWUP_DEFAULT_THRESHOLD_DAYS, computeOverdueFollowups, } from "../followup-tracker.js";
+export const listOverdueFollowupsAction = {
+    name: "LIST_OVERDUE_FOLLOWUPS",
+    similes: [
+        "OVERDUE_FOLLOWUPS",
+        "WHO_TO_FOLLOW_UP",
+        "WHO_HAVEN_T_I_TALKED_TO",
+        "LIST_FOLLOWUPS",
+        "FOLLOWUP_LIST",
+    ],
+    description: "List contacts whose last-contacted-at timestamp exceeds their follow-up threshold. " +
+        "Returns an empty list when the RelationshipsService is not available.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime) => {
+        const digest = await computeOverdueFollowups(runtime, Date.now(), FOLLOWUP_DEFAULT_THRESHOLD_DAYS);
+        if (digest.overdue.length === 0) {
+            return {
+                success: true,
+                text: "No overdue follow-ups.",
+                data: { digest },
+            };
+        }
+        const lines = digest.overdue.map((entry) => `${entry.displayName}: last contacted ${entry.lastContactedAt} (+${entry.daysOverdue}d over ${entry.thresholdDays}d threshold)`);
+        return {
+            success: true,
+            text: lines.join("\n"),
+            data: { digest },
+        };
+    },
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Who should I follow up with?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Carol Patel: last contacted ... (+30d over 30d threshold)",
+                    action: "LIST_OVERDUE_FOLLOWUPS",
+                },
+            },
+        ],
+    ],
+};

package/apps/app-lifeops/src/followup/actions/markFollowupDone.d.ts

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

package/apps/app-lifeops/src/followup/actions/markFollowupDone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markFollowupDone.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/followup/actions/markFollowupDone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAkDvB,eAAO,MAAM,sBAAsB,EAAE,MAiKpC,CAAC"}

package/apps/app-lifeops/src/followup/actions/markFollowupDone.js

@@ -0,0 +1,172 @@
+import { asUUID, logger } from "@elizaos/core";
+import { hasOwnerAccess } from "@elizaos/agent/security/access";
+import { getRelationshipsServiceLike, } from "../followup-tracker.js";
+async function resolveDisplayName(runtime, contact) {
+    const explicit = contact.customFields.displayName;
+    if (typeof explicit === "string" && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    const entity = await runtime.getEntityById(contact.entityId);
+    return entity?.names?.[0] ?? String(contact.entityId);
+}
+async function findByName(runtime, service, rawName) {
+    const needle = rawName.trim().toLowerCase();
+    if (needle.length === 0)
+        return [];
+    const contacts = await service.searchContacts({});
+    const matches = [];
+    for (const contact of contacts) {
+        const displayName = await resolveDisplayName(runtime, contact);
+        if (displayName.toLowerCase().includes(needle)) {
+            matches.push({ contact, displayName });
+        }
+    }
+    return matches;
+}
+export const markFollowupDoneAction = {
+    name: "MARK_FOLLOWUP_DONE",
+    similes: [
+        "FOLLOWED_UP",
+        "FOLLOWUP_DONE",
+        "CONTACTED",
+        "MARK_CONTACTED",
+        "RECORD_INTERACTION",
+    ],
+    description: "Mark a contact as followed-up-with (updates lastContactedAt to now). " +
+        "Requires either an explicit contactId (UUID) or an unambiguous contactName. " +
+        "Ambiguous names return a clarifying response without modifying any contact.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, _message, _state, options) => {
+        const params = (options?.parameters ?? {});
+        const contactId = typeof params.contactId === "string" && params.contactId.length > 0
+            ? params.contactId
+            : null;
+        const contactName = typeof params.contactName === "string" ? params.contactName : "";
+        const note = typeof params.note === "string" ? params.note : undefined;
+        const service = getRelationshipsServiceLike(runtime);
+        if (!service) {
+            return {
+                success: false,
+                text: "Cannot mark follow-up: RelationshipsService is not available.",
+            };
+        }
+        let resolvedContact = null;
+        let resolvedDisplayName = "";
+        if (contactId) {
+            let typedId;
+            try {
+                typedId = asUUID(contactId);
+            }
+            catch {
+                return {
+                    success: false,
+                    text: `Invalid contactId: ${contactId}. Must be a UUID.`,
+                };
+            }
+            resolvedContact = await service.getContact(typedId);
+            if (!resolvedContact) {
+                return {
+                    success: false,
+                    text: `No contact found with id ${contactId}.`,
+                };
+            }
+            resolvedDisplayName = await resolveDisplayName(runtime, resolvedContact);
+        }
+        else if (contactName.trim().length > 0) {
+            const matches = await findByName(runtime, service, contactName);
+            if (matches.length === 0) {
+                return {
+                    success: false,
+                    text: `No contact found matching "${contactName}".`,
+                };
+            }
+            if (matches.length > 1) {
+                const candidateNames = matches
+                    .map((m) => `${m.displayName} (${m.contact.entityId})`)
+                    .join(", ");
+                return {
+                    success: false,
+                    text: `Ambiguous contact name "${contactName}" — matches ${matches.length} contacts: ${candidateNames}. Please specify contactId.`,
+                    data: {
+                        ambiguous: true,
+                        candidates: matches.map((m) => ({
+                            entityId: String(m.contact.entityId),
+                            displayName: m.displayName,
+                        })),
+                    },
+                };
+            }
+            const match = matches[0];
+            if (!match) {
+                return {
+                    success: false,
+                    text: `No contact found matching "${contactName}".`,
+                };
+            }
+            resolvedContact = match.contact;
+            resolvedDisplayName = match.displayName;
+        }
+        else {
+            return {
+                success: false,
+                text: "MARK_FOLLOWUP_DONE requires either contactId or contactName.",
+            };
+        }
+        const nowIso = new Date().toISOString();
+        const nextFields = {
+            ...resolvedContact.customFields,
+            lastContactedAt: nowIso,
+        };
+        if (note) {
+            nextFields.lastFollowupNote = note;
+        }
+        await service.updateContact(resolvedContact.entityId, {
+            customFields: nextFields,
+        });
+        logger.info(`[MARK_FOLLOWUP_DONE] Marked ${resolvedDisplayName} (${resolvedContact.entityId}) as contacted at ${nowIso}`);
+        return {
+            success: true,
+            text: `Marked ${resolvedDisplayName} as followed up at ${nowIso}.`,
+            data: {
+                entityId: String(resolvedContact.entityId),
+                displayName: resolvedDisplayName,
+                lastContactedAt: nowIso,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "contactId",
+            description: "UUID of the contact. Preferred when known — eliminates name ambiguity.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "contactName",
+            description: "Human-readable contact name. Must be unambiguous across stored contacts.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "note",
+            description: "Optional note about the interaction.",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "I just talked to Alice, mark it done" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Marked Alice Chen as followed up at ...",
+                    action: "MARK_FOLLOWUP_DONE",
+                },
+            },
+        ],
+    ],
+};

package/apps/app-lifeops/src/followup/actions/setFollowupThreshold.d.ts

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

package/apps/app-lifeops/src/followup/actions/setFollowupThreshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setFollowupThreshold.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/followup/actions/setFollowupThreshold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AA0BvB,eAAO,MAAM,0BAA0B,EAAE,MAgLxC,CAAC"}