@elizaos/agent 2.0.0-alpha.358 → 2.0.0-alpha.376

package/apps/app-lifeops/src/actions/x-read.js

@@ -0,0 +1,561 @@
+import { logger, ModelType, parseJSONObjectFromText, parseKeyValueXml, } from "@elizaos/core";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+import { recentConversationTexts as collectRecentConversationTexts } from "./life-recent-context.js";
+import { hasLifeOpsAccess, messageText } from "./lifeops-google-helpers.js";
+function normalizeSubaction(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "read_dms" || normalized === "dms")
+        return "read_dms";
+    if (normalized === "read_feed" || normalized === "feed")
+        return "read_feed";
+    if (normalized === "search")
+        return "search";
+    return null;
+}
+function normalizeFeedType(value) {
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "home_timeline" ||
+            normalized === "home" ||
+            normalized === "timeline") {
+            return "home_timeline";
+        }
+        if (normalized === "mentions")
+            return "mentions";
+        if (normalized === "search")
+            return "search";
+    }
+    return "home_timeline";
+}
+function normalizeOptionalFeedType(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return undefined;
+    }
+    return normalizeFeedType(value);
+}
+function normalizeLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    return Math.min(100, Math.floor(value));
+}
+function normalizeShouldAct(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return null;
+}
+function normalizePlannerResponse(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+async function resolveXReadPlanWithLlm(args) {
+    const recentConversation = (await collectRecentConversationTexts({
+        runtime: args.runtime,
+        message: args.message,
+        state: args.state,
+        limit: 8,
+    })).join("\n");
+    const currentMessage = messageText(args.message).trim();
+    const prompt = [
+        "Plan the X read action for this request.",
+        "The user may speak in any language.",
+        "Use the current request plus recent conversation context.",
+        "Return a JSON object with exactly these fields:",
+        "  subaction: one of read_dms, read_feed, search, or null",
+        "  feedType: one of home_timeline or mentions when subaction is read_feed, otherwise null",
+        "  query: short search query when subaction is search, otherwise empty or null",
+        "  limit: optional integer 1-100 when the user explicitly requests an amount",
+        "  shouldAct: boolean",
+        "  response: short natural-language reply when shouldAct is false or clarification is needed",
+        "",
+        "Use read_dms for direct messages or inbox reads.",
+        "Use read_feed for the timeline or mentions feed.",
+        "Use search only when the user is explicitly asking to find posts by keyword, phrase, author, or topic.",
+        "Set feedType=mentions when the user asks for mentions; otherwise use home_timeline for feed reads.",
+        "Set shouldAct=false when the user is vague or only asks for general X help.",
+        "",
+        "Examples:",
+        '  "check my X DMs" -> {"subaction":"read_dms","feedType":null,"query":null,"limit":null,"shouldAct":true,"response":null}',
+        '  "show me my mentions" -> {"subaction":"read_feed","feedType":"mentions","query":null,"limit":null,"shouldAct":true,"response":null}',
+        '  "search X for Milady" -> {"subaction":"search","feedType":null,"query":"Milady","limit":null,"shouldAct":true,"response":null}',
+        '  "help me with X" -> {"subaction":null,"feedType":null,"query":null,"limit":null,"shouldAct":false,"response":"Do you want me to read your X DMs, timeline, mentions, or run a search?"}',
+        "",
+        "Return ONLY valid JSON.",
+        `Current request: ${JSON.stringify(currentMessage)}`,
+        `Resolved intent: ${JSON.stringify(args.intent)}`,
+        `Recent conversation: ${JSON.stringify(recentConversation)}`,
+    ].join("\n");
+    try {
+        // biome-ignore lint/correctness/useHookAtTopLevel: runtime.useModel is an elizaOS model API, not a React hook.
+        const result = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const rawResponse = typeof result === "string" ? result : "";
+        const parsed = parseKeyValueXml(rawResponse) ??
+            parseJSONObjectFromText(rawResponse);
+        if (!parsed) {
+            return {
+                subaction: null,
+                shouldAct: null,
+            };
+        }
+        return {
+            subaction: normalizeSubaction(parsed.subaction),
+            query: typeof parsed.query === "string" && parsed.query.trim().length > 0
+                ? parsed.query.trim()
+                : undefined,
+            feedType: normalizeOptionalFeedType(parsed.feedType),
+            limit: normalizeLimit(parsed.limit),
+            shouldAct: normalizeShouldAct(parsed.shouldAct),
+            response: normalizePlannerResponse(parsed.response),
+        };
+    }
+    catch (error) {
+        args.runtime.logger?.warn?.({
+            src: "action:x-read",
+            error: error instanceof Error ? error.message : String(error),
+        }, "X read planning model call failed");
+        return {
+            subaction: null,
+            shouldAct: null,
+        };
+    }
+}
+const ACTION_PHRASE_PATTERN = /\b(urgent|asap|blocked|help|deadline|today|tonight|tomorrow|confirm|review|send|reply|respond|need|can you|could you|please|important)\b/i;
+function clip(text, maxLength = 220) {
+    const trimmed = text.replace(/\s+/g, " ").trim();
+    if (trimmed.length <= maxLength) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, maxLength - 3).trimEnd()}...`;
+}
+function formatWhen(value) {
+    if (!value)
+        return "";
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        return "";
+    const ageHours = Math.max(0, (Date.now() - parsed) / 3_600_000);
+    if (ageHours < 1)
+        return "just now";
+    if (ageHours < 24)
+        return `${Math.floor(ageHours)}h ago`;
+    return `${Math.floor(ageHours / 24)}d ago`;
+}
+function rankDm(dm) {
+    const reasons = [];
+    let score = 0;
+    if (dm.isInbound) {
+        score += 35;
+        reasons.push("incoming");
+    }
+    if (dm.readAt === null) {
+        score += 15;
+        reasons.push("unread");
+    }
+    if (dm.repliedAt === null && dm.isInbound) {
+        score += 15;
+        reasons.push("not replied");
+    }
+    if (dm.text.includes("?")) {
+        score += 15;
+        reasons.push("question");
+    }
+    if (ACTION_PHRASE_PATTERN.test(dm.text)) {
+        score += 25;
+        reasons.push("action requested");
+    }
+    const when = Date.parse(dm.receivedAt);
+    if (Number.isFinite(when) && Date.now() - when <= 24 * 3_600_000) {
+        score += 15;
+        reasons.push("recent");
+    }
+    const participantIds = Array.isArray(dm.metadata?.participantIds)
+        ? dm.metadata.participantIds
+        : [];
+    if (participantIds.length > 2) {
+        score += 10;
+        reasons.push("group DM");
+    }
+    return { item: dm, score, reasons };
+}
+function rankFeedItem(item) {
+    const reasons = [];
+    let score = 0;
+    if (ACTION_PHRASE_PATTERN.test(item.text)) {
+        score += 25;
+        reasons.push("action language");
+    }
+    if (item.text.includes("?")) {
+        score += 15;
+        reasons.push("question");
+    }
+    const raw = (item.metadata?.raw ?? {});
+    const referenceTypes = (raw.referenced_tweets ?? [])
+        .map((reference) => reference.type)
+        .filter((type) => typeof type === "string");
+    if (referenceTypes.includes("replied_to")) {
+        score += 25;
+        reasons.push("reply");
+    }
+    if (referenceTypes.includes("quoted")) {
+        score += 15;
+        reasons.push("quote");
+    }
+    const metrics = raw.public_metrics ?? {};
+    const engagement = (metrics.like_count ?? 0) +
+        (metrics.reply_count ?? 0) * 3 +
+        (metrics.retweet_count ?? 0) * 2 +
+        (metrics.quote_count ?? 0) * 2;
+    if (engagement >= 25) {
+        score += 20;
+        reasons.push("high engagement");
+    }
+    else if (engagement >= 5) {
+        score += 10;
+        reasons.push("some engagement");
+    }
+    const when = Date.parse(item.createdAtSource);
+    if (Number.isFinite(when) && Date.now() - when <= 24 * 3_600_000) {
+        score += 10;
+        reasons.push("recent");
+    }
+    return { item, score, reasons };
+}
+function formatDmLine(dm, reasons) {
+    const who = dm.senderHandle
+        ? `@${dm.senderHandle}`
+        : dm.senderId || "unknown";
+    const when = formatWhen(dm.receivedAt);
+    const suffix = reasons.length > 0 ? ` (${reasons.join(", ")})` : "";
+    return `- ${who}${when ? `, ${when}` : ""}: ${clip(dm.text)}${suffix}`;
+}
+function formatFeedLine(item, reasons) {
+    const who = item.authorHandle
+        ? `@${item.authorHandle}`
+        : item.authorId || "unknown";
+    const when = formatWhen(item.createdAtSource);
+    const suffix = reasons.length > 0 ? ` (${reasons.join(", ")})` : "";
+    return `- ${who}${when ? `, ${when}` : ""}: ${clip(item.text)}${suffix}`;
+}
+function summarizeDms(dms) {
+    if (dms.length === 0)
+        return "No X DMs found.";
+    const ranked = dms.map(rankDm).sort((a, b) => b.score - a.score);
+    const actionNeeded = ranked.filter((entry) => entry.score >= 60).slice(0, 5);
+    const otherRecent = ranked
+        .filter((entry) => !actionNeeded.includes(entry))
+        .slice(0, 5);
+    const lines = [`X DM rundown (${dms.length} messages)`];
+    lines.push(actionNeeded.length > 0
+        ? [
+            "Action-needed",
+            ...actionNeeded.map((entry) => formatDmLine(entry.item, entry.reasons)),
+        ].join("\n")
+        : "Action-needed\n- No obvious urgent or reply-needed DMs.");
+    if (otherRecent.length > 0) {
+        lines.push([
+            "Other recent",
+            ...otherRecent.map((entry) => formatDmLine(entry.item, entry.reasons)),
+        ].join("\n"));
+    }
+    const nextSteps = actionNeeded.length > 0
+        ? "Next steps\n- Draft replies for the action-needed DMs, or ask me to schedule a specific X DM reply."
+        : "Next steps\n- No reply looks required from this batch.";
+    lines.push(nextSteps);
+    return lines.join("\n\n");
+}
+function summarizeFeedItems(items, feedType) {
+    if (items.length === 0)
+        return `No items in X ${feedType}.`;
+    const ranked = items.map(rankFeedItem).sort((a, b) => b.score - a.score);
+    const important = ranked.filter((entry) => entry.score >= 35).slice(0, 6);
+    const replies = ranked
+        .filter((entry) => entry.reasons.includes("reply"))
+        .slice(0, 5);
+    const recent = ranked.slice(0, 6);
+    const lines = [`X ${feedType} rundown (${items.length} items)`];
+    lines.push(important.length > 0
+        ? [
+            "Interesting or important",
+            ...important.map((entry) => formatFeedLine(entry.item, entry.reasons)),
+        ].join("\n")
+        : "Interesting or important\n- No high-signal posts stood out in this batch.");
+    if (feedType === "mentions" || replies.length > 0) {
+        lines.push(replies.length > 0
+            ? [
+                "Replies or mentions to review",
+                ...replies.map((entry) => formatFeedLine(entry.item, entry.reasons)),
+            ].join("\n")
+            : "Replies or mentions to review\n- No replies or mentions needing review were found.");
+    }
+    lines.push([
+        "Recent context",
+        ...recent.map((entry) => formatFeedLine(entry.item, entry.reasons)),
+    ].join("\n"));
+    lines.push(important.length > 0
+        ? "Next steps\n- Ask me to search deeper, read DMs, or draft a response for a specific post."
+        : "Next steps\n- Nothing here appears urgent; ask for a narrower search if you want more signal.");
+    return lines.join("\n\n");
+}
+export const xReadAction = {
+    name: "X_READ",
+    similes: [
+        "READ_X",
+        "READ_TWITTER",
+        "CHECK_TWITTER_DMS",
+        "TWITTER_TIMELINE",
+        "X_TIMELINE",
+        "TWITTER_MENTIONS",
+        "SEARCH_TWITTER",
+        "X_DMS",
+        "X_FEED",
+        "X_SEARCH",
+    ],
+    description: "Read X/Twitter DMs, the home timeline or mentions feed, or run a recent search. " +
+        "Use this for requests like 'check my Twitter DMs', 'what's on my X timeline?', 'show me my mentions', or 'search Twitter for posts about elizaOS'. " +
+        "Use this for retrieving content from X, not posting. Do not reply that X/Twitter access is unavailable when this action is registered and visible.",
+    suppressPostActionContinuation: true,
+    validate: async (runtime, message) => {
+        if (!(await hasLifeOpsAccess(runtime, message)))
+            return false;
+        const service = new LifeOpsService(runtime);
+        try {
+            const status = await service.getXConnectorStatus();
+            return Boolean(status.grant &&
+                (status.feedRead ||
+                    status.dmRead ||
+                    status.grantedCapabilities.includes("x.read")));
+        }
+        catch (error) {
+            logger.warn({
+                boundary: "lifeops",
+                component: "x-read",
+                detail: error instanceof Error ? error.message : String(error),
+            }, "[x-read] getXConnectorStatus failed; action validation defaulting to false");
+            return false;
+        }
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            return {
+                text: "",
+                success: false,
+                data: { error: "PERMISSION_DENIED" },
+            };
+        }
+        const params = (options?.parameters ?? {});
+        const intent = (params.intent ?? messageText(message) ?? "").trim();
+        const explicitSubaction = normalizeSubaction(params.subaction);
+        const llmPlan = await resolveXReadPlanWithLlm({
+            runtime,
+            message,
+            state,
+            intent,
+        });
+        const subaction = explicitSubaction ?? llmPlan.subaction;
+        const feedType = normalizeFeedType(params.feedType ?? llmPlan.feedType);
+        const limit = normalizeLimit(params.limit ?? llmPlan.limit);
+        const query = typeof params.query === "string" && params.query.trim().length > 0
+            ? params.query.trim()
+            : (llmPlan.query ?? "");
+        const service = new LifeOpsService(runtime);
+        const respond = async (payload) => {
+            await callback?.({
+                text: payload.text ?? "",
+                source: "action",
+                action: "X_READ",
+            });
+            return payload;
+        };
+        if (llmPlan.shouldAct === false &&
+            !explicitSubaction &&
+            !params.query &&
+            !params.feedType &&
+            params.limit === undefined) {
+            return respond({
+                success: false,
+                text: llmPlan.response ??
+                    "Do you want me to read your X DMs, timeline, mentions, or run a search?",
+                values: {
+                    success: false,
+                    error: "PLANNER_SHOULDACT_FALSE",
+                    noop: true,
+                },
+                data: { noop: true, error: "PLANNER_SHOULDACT_FALSE" },
+            });
+        }
+        if (!subaction) {
+            return respond({
+                success: false,
+                text: llmPlan.response ??
+                    "Do you want me to read your X DMs, timeline, mentions, or run a search?",
+                data: { error: "MISSING_SUBACTION" },
+            });
+        }
+        try {
+            if (subaction === "read_dms") {
+                const syncResult = await service.syncXDms({ limit });
+                const dms = await service.getXDms({ limit });
+                return respond({
+                    success: true,
+                    text: summarizeDms(dms),
+                    data: {
+                        subaction,
+                        synced: syncResult.synced,
+                        items: dms,
+                    },
+                });
+            }
+            if (subaction === "search") {
+                if (query.length === 0) {
+                    return respond({
+                        success: false,
+                        text: "Please provide a search query.",
+                        data: { subaction, error: "MISSING_QUERY" },
+                    });
+                }
+                const results = await service.searchXPosts(query, { limit });
+                return respond({
+                    success: true,
+                    text: summarizeFeedItems(results, "search"),
+                    data: {
+                        subaction,
+                        query,
+                        items: results,
+                    },
+                });
+            }
+            const effectiveFeedType = feedType === "search" ? "home_timeline" : feedType;
+            const syncResult = await service.syncXFeed(effectiveFeedType, { limit });
+            const items = await service.getXFeedItems(effectiveFeedType, { limit });
+            return respond({
+                success: true,
+                text: summarizeFeedItems(items, effectiveFeedType),
+                data: {
+                    subaction,
+                    feedType: effectiveFeedType,
+                    synced: syncResult.synced,
+                    items,
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof LifeOpsServiceError) {
+                return respond({
+                    success: false,
+                    text: error.message,
+                    data: {
+                        subaction,
+                        error: "X_READ_FAILED",
+                        status: error.status,
+                    },
+                });
+            }
+            throw error;
+        }
+    },
+    parameters: [
+        {
+            name: "subaction",
+            description: "X read operation. read_dms for direct messages, read_feed for timeline/mentions, search for recent tweet search.",
+            required: false,
+            schema: {
+                type: "string",
+                enum: ["read_dms", "read_feed", "search"],
+            },
+        },
+        {
+            name: "intent",
+            description: 'Free-text description of the request, e.g. "check my X DMs", "show my mentions", "search X for elizaOS".',
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "query",
+            description: "Search query string for the search subaction.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "feedType",
+            description: "Feed to read for read_feed. One of home_timeline (default), mentions, or search.",
+            required: false,
+            schema: {
+                type: "string",
+                enum: ["home_timeline", "mentions", "search"],
+            },
+        },
+        {
+            name: "limit",
+            description: "Max items to return (1-100).",
+            required: false,
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Check my X DMs." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X DMs (2):\n- @alice: hey!\n- @bob: see you tomorrow",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "What's on my X timeline?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X home_timeline (5):\n- @carol: great post!",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "What are my recent X mentions?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X mentions (3):\n- @carol: great post!",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Search Twitter for posts about elizaOS." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X search (5):\n- @dev: elizaOS is shipping fast",
+                },
+            },
+        ],
+    ],
+};

package/apps/app-lifeops/src/activity-profile/activity-tracker-service.d.ts

@@ -0,0 +1,36 @@
+/**
+ * T8d — Activity tracker service.
+ *
+ * Starts the macOS Swift collector (when available) and writes focus events
+ * to `life_activity_events`. On non-Darwin platforms the service is a no-op
+ * that logs "no events" once at startup and returns empty reports via the
+ * action layer.
+ *
+ * The service does not mutate any cached profile state; reporting runs on
+ * demand via {@link getActivityReport}.
+ */
+import { type IAgentRuntime, Service } from "@elizaos/core";
+export type ActivityTrackerMode = "running" | "disabled-config" | "disabled-non-darwin" | "stopped" | "failed";
+export declare class ActivityTrackerService extends Service {
+    static readonly serviceType = "activity_tracker";
+    capabilityDescription: string;
+    private handle;
+    private mode;
+    private writeFailures;
+    private writeQueue;
+    static start(runtime: IAgentRuntime): Promise<ActivityTrackerService>;
+    stop(): Promise<void>;
+    getMode(): ActivityTrackerMode;
+    private startCollector;
+    private enqueueEvent;
+    private persistEvent;
+    private enqueueIdleSample;
+    /**
+     * Persist a HID idle sample as a `desktop_interaction` activity signal.
+     * The scorer reads `idleTimeSeconds` from the latest signal to distinguish
+     * passive-media (high idle) from active-use (low idle) per the
+     * shared-device-safety rule in `awake-probability.ts`.
+     */
+    private persistIdleSample;
+}
+//# sourceMappingURL=activity-tracker-service.d.ts.map

package/apps/app-lifeops/src/activity-profile/activity-tracker-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-tracker-service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/activity-tracker-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAU,OAAO,EAAE,MAAM,eAAe,CAAC;AAepE,MAAM,MAAM,mBAAmB,GAC3B,SAAS,GACT,iBAAiB,GACjB,qBAAqB,GACrB,SAAS,GACT,QAAQ,CAAC;AAEb,qBAAa,sBAAuB,SAAQ,OAAO;IACjD,gBAAyB,WAAW,sBAAsB;IAEjD,qBAAqB,SAC0F;IAExH,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,IAAI,CAA8C;IAC1D,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAAoC;WAEhC,KAAK,CACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,sBAAsB,CAAC;IAMnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQpC,OAAO,IAAI,mBAAmB;YAIhB,cAAc;IA2D5B,OAAO,CAAC,YAAY;YAON,YAAY;IAiC1B,OAAO,CAAC,iBAAiB;IAOzB;;;;;OAKG;YACW,iBAAiB;CA+ChC"}