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

package/apps/app-lifeops/src/actions/screen-time.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LifeOps screen time action — query per-app and per-website dwell time.
+ *
+ * Subactions: summary, today, weekly, by_app, by_website.
+ */
+import type { Action } from "@elizaos/core";
+export declare const screenTimeAction: Action;
+//# sourceMappingURL=screen-time.d.ts.map

package/apps/app-lifeops/src/actions/screen-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-time.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/screen-time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAkEvB,eAAO,MAAM,gBAAgB,EAAE,MAqN9B,CAAC"}

package/apps/app-lifeops/src/actions/screen-time.js

@@ -0,0 +1,231 @@
+/**
+ * LifeOps screen time action — query per-app and per-website dwell time.
+ *
+ * Subactions: summary, today, weekly, by_app, by_website.
+ */
+import { LifeOpsService } from "../lifeops/service.js";
+import { hasLifeOpsAccess } from "./lifeops-google-helpers.js";
+function getParams(options) {
+    const params = options?.parameters;
+    return params ?? {};
+}
+function messageText(message) {
+    return (message?.content?.text ?? "").toString().toLowerCase();
+}
+function todayIso() {
+    return new Date().toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+    const d = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    return d.toISOString();
+}
+function formatSeconds(seconds) {
+    const s = Math.max(0, Math.floor(seconds));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (h > 0) {
+        return `${h}h ${m}m`;
+    }
+    return `${m}m`;
+}
+function inferSubaction(intent, messageBody) {
+    const text = `${intent ?? ""} ${messageBody}`.toLowerCase();
+    if (/\btoday\b/.test(text))
+        return "today";
+    if (/\b(this week|weekly|past (7|seven) days|last week)\b/.test(text)) {
+        return "weekly";
+    }
+    if (/\b(on|at|in|spent)\b.*\b(website|site|domain|url)\b/.test(text)) {
+        return "by_website";
+    }
+    if (/\b(in|on|using|app)\b/.test(text) && /\b(app|application)\b/.test(text)) {
+        return "by_app";
+    }
+    if (/\b(top|most used|top apps|top websites)\b/.test(text)) {
+        return "summary";
+    }
+    return "summary";
+}
+export const screenTimeAction = {
+    name: "SCREEN_TIME",
+    similes: ["SCREENTIME", "APP_USAGE", "WEBSITE_USAGE", "DWELL_TIME"],
+    description: "Query screen time summaries (per app, per website, daily). Subactions: summary, today, weekly, by_app, by_website.",
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, _state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            const text = "Screen time data is restricted to the owner.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+        }
+        const params = getParams(options);
+        const body = messageText(message);
+        const subaction = params.subaction ?? inferSubaction(params.intent, body);
+        const service = new LifeOpsService(runtime);
+        if (subaction === "today") {
+            const date = params.date ?? todayIso();
+            const daily = await service.getScreenTimeDaily({
+                date,
+                source: params.source,
+                limit: 10,
+            });
+            const total = daily.reduce((acc, row) => acc + row.totalSeconds, 0);
+            const text = daily.length === 0
+                ? `No screen time recorded for ${date}.`
+                : `Screen time for ${date} (total ${formatSeconds(total)}):\n${daily
+                    .map((row) => `- ${row.source}: ${row.identifier} — ${formatSeconds(row.totalSeconds)} (${row.sessionCount} session${row.sessionCount === 1 ? "" : "s"})`)
+                    .join("\n")}`;
+            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
+            return { text, success: true, data: { subaction, date, daily } };
+        }
+        if (subaction === "weekly") {
+            const until = new Date().toISOString();
+            const since = daysAgoIso(params.sinceDays ?? 7);
+            const summary = await service.getScreenTimeSummary({
+                since,
+                until,
+                source: params.source,
+                topN: 10,
+            });
+            const text = summary.items.length === 0
+                ? `No screen time recorded in the last ${params.sinceDays ?? 7} days.`
+                : `Top screen time over the last ${params.sinceDays ?? 7} days (total ${formatSeconds(summary.totalSeconds)}):\n${summary.items
+                    .map((item) => `- ${item.source}: ${item.displayName} — ${formatSeconds(item.totalSeconds)}`)
+                    .join("\n")}`;
+            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
+            return {
+                text,
+                success: true,
+                data: { subaction, since, until, summary },
+            };
+        }
+        if (subaction === "by_app" || subaction === "by_website") {
+            const source = subaction === "by_app" ? "app" : "website";
+            const until = new Date().toISOString();
+            const since = daysAgoIso(params.sinceDays ?? 1);
+            const summary = await service.getScreenTimeSummary({
+                since,
+                until,
+                source,
+                topN: 10,
+            });
+            const label = source === "app" ? "apps" : "websites";
+            const text = summary.items.length === 0
+                ? `No ${label} recorded in that window.`
+                : `Top ${label} (total ${formatSeconds(summary.totalSeconds)}):\n${summary.items
+                    .map((item) => `- ${item.displayName} — ${formatSeconds(item.totalSeconds)}`)
+                    .join("\n")}`;
+            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
+            return {
+                text,
+                success: true,
+                data: { subaction, source, since, until, summary },
+            };
+        }
+        // summary — default
+        const until = new Date().toISOString();
+        const since = daysAgoIso(params.sinceDays ?? 1);
+        const summary = await service.getScreenTimeSummary({
+            since,
+            until,
+            source: params.source,
+            topN: 10,
+        });
+        const text = summary.items.length === 0
+            ? "No screen time recorded in that window."
+            : `Screen time summary (total ${formatSeconds(summary.totalSeconds)}):\n${summary.items
+                .map((item) => `- ${item.source}: ${item.displayName} — ${formatSeconds(item.totalSeconds)}`)
+                .join("\n")}`;
+        await callback?.({ text, source: "action", action: "SCREEN_TIME" });
+        return {
+            text,
+            success: true,
+            data: { subaction: "summary", since, until, summary },
+        };
+    },
+    parameters: [
+        {
+            name: "subaction",
+            description: "Which screen time query to run: summary, today, weekly, by_app, by_website.",
+            schema: { type: "string" },
+        },
+        {
+            name: "intent",
+            description: "Free-form user intent used to infer subaction when not explicitly set.",
+            schema: { type: "string" },
+        },
+        {
+            name: "source",
+            description: "Restrict to 'app' or 'website'.",
+            schema: { type: "string" },
+        },
+        {
+            name: "identifier",
+            description: "Specific app bundle id or website domain when filtering to a single source.",
+            schema: { type: "string" },
+        },
+        {
+            name: "date",
+            description: "YYYY-MM-DD for 'today' / daily queries.",
+            schema: { type: "string" },
+        },
+        {
+            name: "sinceDays",
+            description: "Number of days back from now for summary windows.",
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "How much time did I spend on my computer today?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Screen time for 2026-04-16 (total 3h 42m): ...",
+                    action: "SCREEN_TIME",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "What are my top apps this week?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Top screen time over the last 7 days (total 28h 10m): ...",
+                    action: "SCREEN_TIME",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Which websites did I spend the most time on?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Top websites (total 5h 20m): ...",
+                    action: "SCREEN_TIME",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Show me a screen time summary." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Screen time summary (total 4h 08m): ...",
+                    action: "SCREEN_TIME",
+                },
+            },
+        ],
+    ],
+};

package/apps/app-lifeops/src/actions/search-across-channels.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SEARCH_ACROSS_CHANNELS action (WS1).
+ *
+ * LLM-driven param extraction (no regex, no English-only keyword
+ * matching) — feeds runUnifiedSearch() and returns a clipboard-ready
+ * payload citing the source platform + room + timestamp for each hit.
+ * Use this for cross-channel brief/context requests when the owner wants
+ * one person or topic searched across Gmail, chat connectors, calendar,
+ * and memory.
+ */
+import type { Action } from "@elizaos/core";
+export declare const searchAcrossChannelsAction: Action;
+//# sourceMappingURL=search-across-channels.d.ts.map

package/apps/app-lifeops/src/actions/search-across-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-across-channels.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/search-across-channels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,MAAM,EAOP,MAAM,eAAe,CAAC;AA0PvB,eAAO,MAAM,0BAA0B,EAAE,MA2LxC,CAAC"}

package/apps/app-lifeops/src/actions/search-across-channels.js

@@ -0,0 +1,340 @@
+/**
+ * SEARCH_ACROSS_CHANNELS action (WS1).
+ *
+ * LLM-driven param extraction (no regex, no English-only keyword
+ * matching) — feeds runUnifiedSearch() and returns a clipboard-ready
+ * payload citing the source platform + room + timestamp for each hit.
+ * Use this for cross-channel brief/context requests when the owner wants
+ * one person or topic searched across Gmail, chat connectors, calendar,
+ * and memory.
+ */
+import { ModelType, logger, parseJSONObjectFromText } from "@elizaos/core";
+import { hasAdminAccess } from "@elizaos/agent/security/access";
+import { UNIFIED_SEARCH_CHANNELS, runUnifiedSearch, } from "../lifeops/unified-search.js";
+const ACTION_NAME = "SEARCH_ACROSS_CHANNELS";
+function isUnifiedChannel(value) {
+    return (typeof value === "string" &&
+        UNIFIED_SEARCH_CHANNELS.includes(value));
+}
+function recentTexts(state, limit = 8) {
+    if (!state || typeof state !== "object") {
+        return [];
+    }
+    const stateRecord = state;
+    const recent = stateRecord.recentMessagesData ?? stateRecord.recentMessages;
+    if (!Array.isArray(recent)) {
+        return [];
+    }
+    const out = [];
+    for (const item of recent) {
+        if (!item || typeof item !== "object")
+            continue;
+        const content = item.content;
+        if (!content || typeof content !== "object")
+            continue;
+        const text = content.text;
+        if (typeof text === "string" && text.trim()) {
+            out.push(text.trim());
+        }
+    }
+    return out.slice(-limit);
+}
+function messageText(message) {
+    const text = message.content?.text;
+    return typeof text === "string" ? text.trim() : "";
+}
+async function extractSearchPlan(runtime, message, state, params) {
+    // If caller already provided a concrete query, trust it.
+    if (params.query && params.query.trim()) {
+        return {
+            query: params.query.trim(),
+            person: params.person ?? null,
+            startIso: params.startIso ?? null,
+            endIso: params.endIso ?? null,
+            channels: params.channels && params.channels.length > 0 ? params.channels : null,
+            shouldAct: true,
+            clarification: null,
+        };
+    }
+    if (typeof runtime.useModel !== "function") {
+        return {
+            query: null,
+            person: null,
+            startIso: null,
+            endIso: null,
+            channels: null,
+            shouldAct: false,
+            clarification: "Cross-channel search planning is unavailable right now — tell me what to search for.",
+        };
+    }
+    const intent = (params.intent ?? messageText(message)).trim();
+    const nowIso = new Date().toISOString();
+    const channelList = UNIFIED_SEARCH_CHANNELS.join(", ");
+    const prompt = [
+        "Plan a SEARCH_ACROSS_CHANNELS request.",
+        "The user may speak in any language. Do NOT translate the search query — keep the user's wording.",
+        "Return ONLY valid JSON with exactly these fields:",
+        '{"query":"string|null","person":"string|null","startIso":"ISO8601|null","endIso":"ISO8601|null","channels":["gmail"|"telegram"|"discord"|"imessage"|"whatsapp"|"signal"|"x-dm"|"calendly"|"calendar"|"memory"]|null,"shouldAct":true|false,"clarification":"string|null"}',
+        "",
+        "Rules:",
+        "- query: the substantive search phrase (entity, topic, keywords). Strip filler like 'find', 'search for', 'show me'.",
+        "- person: a named individual the search should focus on, or null.",
+        "- startIso / endIso: an ISO time window if the request specifies one (e.g. 'this week', 'yesterday', 'in March'). Otherwise null.",
+        `- Reference time: ${nowIso}.`,
+        "- channels: only set when the user explicitly limits the search to specific platforms.",
+        `- Allowed channel values: ${channelList}.`,
+        "- shouldAct: false ONLY if the request is too vague to derive a query.",
+        "- clarification: when shouldAct is false, ask the minimum clarifying question in the user's language.",
+        "",
+        `Current request: ${JSON.stringify(intent)}`,
+        `Recent conversation: ${JSON.stringify(recentTexts(state).join("\n"))}`,
+    ].join("\n");
+    const raw = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
+    const text = typeof raw === "string" ? raw : "";
+    const parsed = parseJSONObjectFromText(text);
+    if (!parsed) {
+        return {
+            query: null,
+            person: null,
+            startIso: null,
+            endIso: null,
+            channels: null,
+            shouldAct: false,
+            clarification: "I couldn't parse a search query from that — what should I look up?",
+        };
+    }
+    const query = typeof parsed.query === "string" && parsed.query.trim()
+        ? parsed.query.trim()
+        : null;
+    const person = typeof parsed.person === "string" && parsed.person.trim()
+        ? parsed.person.trim()
+        : null;
+    const startIso = typeof parsed.startIso === "string" && parsed.startIso.trim()
+        ? parsed.startIso.trim()
+        : null;
+    const endIso = typeof parsed.endIso === "string" && parsed.endIso.trim()
+        ? parsed.endIso.trim()
+        : null;
+    const channels = Array.isArray(parsed.channels)
+        ? parsed.channels.filter(isUnifiedChannel)
+        : null;
+    const shouldAct = typeof parsed.shouldAct === "boolean" ? parsed.shouldAct : query !== null;
+    const clarification = typeof parsed.clarification === "string" && parsed.clarification.trim()
+        ? parsed.clarification.trim()
+        : null;
+    return {
+        query,
+        person,
+        startIso,
+        endIso,
+        channels: channels && channels.length > 0 ? channels : null,
+        shouldAct,
+        clarification,
+    };
+}
+// ---------------------------------------------------------------------------
+// Format
+// ---------------------------------------------------------------------------
+function formatHitForClipboard(hit, index) {
+    const subjectPart = hit.subject ? ` ${hit.subject}` : "";
+    const ts = hit.timestamp.slice(0, 19);
+    const body = hit.text.replace(/\s+/g, " ").trim().slice(0, 240);
+    return `${String(index + 1).padStart(3, " ")} | [${hit.channel}] ${hit.citation.label} (${ts}) ${hit.speaker}:${subjectPart} ${body}`;
+}
+function formatResult(result) {
+    const lines = [];
+    lines.push(`Cross-channel search for "${result.query}" — ${result.hits.length} hits across ${result.channelsWithHits.length} channels`);
+    lines.push("─".repeat(60));
+    result.hits.forEach((hit, idx) => {
+        lines.push(formatHitForClipboard(hit, idx));
+    });
+    if (result.unsupported.length > 0) {
+        lines.push("");
+        lines.push("Unsupported channels (no native search adapter):");
+        for (const u of result.unsupported) {
+            lines.push(`  - ${u.channel}: ${u.reason}`);
+        }
+    }
+    if (result.degraded.length > 0) {
+        lines.push("");
+        lines.push("Degraded channels:");
+        for (const d of result.degraded) {
+            lines.push(`  - ${d.channel}: ${d.reason}`);
+        }
+    }
+    lines.push("");
+    lines.push("To save relevant results to clipboard, use CLIPBOARD_WRITE with the line range.");
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Action
+// ---------------------------------------------------------------------------
+export const searchAcrossChannelsAction = {
+    name: ACTION_NAME,
+    similes: [
+        "CROSS_CHANNEL_SEARCH",
+        "SEARCH_ALL_CHANNELS",
+        "SEARCH_EVERYWHERE",
+        "FIND_ACROSS_PLATFORMS",
+        "UNIFIED_SEARCH",
+    ],
+    description: "Search across every connected channel — Gmail, Telegram, Discord, " +
+        "iMessage, WhatsApp, Signal, X DMs, Calendly — plus agent memory. " +
+        "Returns merged hits with citations to source platform, room, and " +
+        "timestamp. Connectors without native search emit typed unsupported " +
+        "markers (no fabricated results). Admin/owner only.",
+    descriptionCompressed: "Cross-channel search with citations. Admin only.",
+    validate: async (runtime, message) => hasAdminAccess(runtime, message),
+    handler: async (runtime, message, state, options) => {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return {
+                text: "Permission denied: only the owner or admins may search across channels.",
+                success: false,
+                values: { success: false, error: "PERMISSION_DENIED" },
+                data: { actionName: ACTION_NAME },
+            };
+        }
+        const params = (options?.parameters ??
+            {});
+        const plan = await extractSearchPlan(runtime, message, state, params);
+        if (!plan.shouldAct || !plan.query) {
+            return {
+                text: plan.clarification ??
+                    "What do you want me to search for across your channels?",
+                success: true,
+                values: { success: true, noop: true },
+                data: { actionName: ACTION_NAME, noop: true },
+            };
+        }
+        const personRef = (() => {
+            if (params.primaryEntityId) {
+                return {
+                    primaryEntityId: params.primaryEntityId,
+                    displayName: plan.person ?? params.person ?? undefined,
+                };
+            }
+            const display = plan.person ?? params.person;
+            return display ? { displayName: display } : undefined;
+        })();
+        const timeWindow = (() => {
+            const startIso = plan.startIso ?? params.startIso;
+            const endIso = plan.endIso ?? params.endIso;
+            if (!startIso && !endIso)
+                return undefined;
+            return {
+                startIso: startIso ?? undefined,
+                endIso: endIso ?? undefined,
+            };
+        })();
+        const query = {
+            query: plan.query,
+            personRef,
+            timeWindow,
+            channels: plan.channels ?? params.channels,
+            worldId: params.worldId,
+            limit: params.limit,
+        };
+        try {
+            const result = await runUnifiedSearch(runtime, query);
+            const formatted = formatResult(result);
+            return {
+                text: formatted,
+                success: true,
+                values: {
+                    success: true,
+                    hitCount: result.hits.length,
+                    unsupportedCount: result.unsupported.length,
+                    degradedCount: result.degraded.length,
+                    channelsWithHits: result.channelsWithHits,
+                },
+                data: {
+                    actionName: ACTION_NAME,
+                    query: result.query,
+                    hits: result.hits.map((hit, idx) => ({
+                        line: idx + 1,
+                        channel: hit.channel,
+                        id: hit.id,
+                        sourceRef: hit.sourceRef,
+                        speaker: hit.speaker,
+                        timestamp: hit.timestamp,
+                        subject: hit.subject,
+                        text: hit.text,
+                        citation: hit.citation,
+                    })),
+                    unsupported: result.unsupported,
+                    degraded: result.degraded,
+                    channelsWithHits: result.channelsWithHits,
+                    resolvedPerson: result.resolvedPerson
+                        ? {
+                            primaryEntityId: result.resolvedPerson.primaryEntityId,
+                            displayName: result.resolvedPerson.displayName,
+                        }
+                        : null,
+                },
+            };
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            logger.error(`[${ACTION_NAME}] Search failed: ${errMsg}`);
+            return {
+                text: `Cross-channel search failed: ${errMsg}`,
+                success: false,
+                values: { success: false, error: "SEARCH_FAILED" },
+                data: { actionName: ACTION_NAME, query: plan.query },
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "query",
+            description: "Exact search phrase. When omitted, the LLM extracts a query from `intent`.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "intent",
+            description: "Natural-language description of what to search for. Multilingual.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "person",
+            description: "Display name of the person to focus the search on. Resolves via the relationships graph when available.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "primaryEntityId",
+            description: "Pre-resolved canonical cluster primary entity id (UUID).",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "startIso",
+            description: "Lower-bound timestamp (ISO 8601). Optional.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "endIso",
+            description: "Upper-bound timestamp (ISO 8601). Optional.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "channels",
+            description: "Channel allowlist. Allowed values: gmail, memory, telegram, discord, imessage, whatsapp, signal, x-dm, calendly, calendar.",
+            required: false,
+            schema: {
+                type: "array",
+                items: { type: "string" },
+            },
+        },
+        {
+            name: "limit",
+            description: "Per-channel hit cap (default 10).",
+            required: false,
+            schema: { type: "number" },
+        },
+    ],
+};

package/apps/app-lifeops/src/actions/start-remote-session.d.ts

@@ -0,0 +1,14 @@
+/**
+ * START_REMOTE_SESSION — control-plane action for T9a.
+ *
+ * Requires owner access. If MILADY_REMOTE_LOCAL_MODE=1, the pairing code is
+ * not required (but `confirmed: true` still is). Otherwise, a valid 6-digit
+ * pairing code issued via the cloud pair endpoint must be provided.
+ *
+ * Does not open a pixel transport. The data-plane ingress is resolved by
+ * RemoteSessionService; when no data plane is configured, the action returns
+ * an explicit `ingressUrl: null` with `reason: "data-plane-not-configured"`.
+ */
+import type { Action } from "@elizaos/core";
+export declare const startRemoteSessionAction: Action;
+//# sourceMappingURL=start-remote-session.d.ts.map

package/apps/app-lifeops/src/actions/start-remote-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-remote-session.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/start-remote-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AAqBvB,eAAO,MAAM,wBAAwB,EAAE,MA0ItC,CAAC"}