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

package/apps/app-lifeops/src/actions/inbox.js

@@ -1,115 +1,139 @@
-import { logger, ModelType } from "@elizaos/core";
-import { textIncludesKeywordTerm } from "@elizaos/shared/validation-keywords";
+import { logger, ModelType, parseJSONObjectFromText } from "@elizaos/core";
 import { loadInboxTriageConfig } from "../inbox/config.js";
 import { fetchAllMessages } from "../inbox/message-fetcher.js";
-import { looksLikeInboxConfirmation, reflectOnAutoReply, reflectOnSendConfirmation, } from "../inbox/reflection.js";
+import { reflectOnAutoReply, reflectOnSendConfirmation, } from "../inbox/reflection.js";
 import { InboxTriageRepository } from "../inbox/repository.js";
-import { applyTriageRules, classifyMessages, } from "../inbox/triage-classifier.js";
+import { classifyMessages } from "../inbox/triage-classifier.js";
 import { hasAdminAccess } from "@elizaos/agent/security/access";
 import { resolveAdminEntityId } from "@elizaos/agent/actions/send-message";
 import { INTERNAL_URL } from "./lifeops-google-helpers.js";
-// ---------------------------------------------------------------------------
-// Subaction inference
-// ---------------------------------------------------------------------------
-const TRIAGE_TERMS = [
-    "triage",
-    "check",
-    "scan",
-    "new messages",
-    "check inbox",
-    "检查",
-    "新消息",
-    "查看收件箱",
-    "확인",
-    "새 메시지",
-    "받은편지함",
-    "revisar",
-    "nuevos mensajes",
-    "bandeja de entrada",
-    "verificar",
-    "novas mensagens",
-    "caixa de entrada",
-    "kiểm tra",
-    "tin nhắn mới",
-    "hộp thư đến",
-    "tingnan",
-    "bagong mensahe",
-];
-const DIGEST_TERMS = [
-    "digest",
-    "summary",
-    "briefing",
-    "daily",
-    "overview",
-    "recap",
-    "report",
-    "摘要",
-    "简报",
-    "概览",
-    "总结",
-    "요약",
-    "브리핑",
-    "개요",
-    "resumen",
-    "informe",
-    "resúmen",
-    "resumo",
-    "relatório",
-    "relatorio",
-    "tóm tắt",
-    "báo cáo",
-    "tổng quan",
-    "buod",
-    "ulat",
-];
-const RESPOND_TERMS = [
-    "respond",
-    "reply",
-    "send",
-    "confirm",
-    "approve",
-    "回复",
-    "发送",
-    "确认",
-    "批准",
-    "답장",
-    "보내기",
-    "확인",
-    "승인",
-    "responder",
-    "enviar",
-    "confirmar",
-    "aprobar",
-    "responder",
-    "enviar",
-    "confirmar",
-    "aprovar",
-    "trả lời",
-    "gửi",
-    "xác nhận",
-    "phê duyệt",
-    "sumagot",
-    "ipadala",
-    "kumpirmahin",
-    "aprubahan",
-];
-function resolveSubaction(params, messageText, state) {
-    // 1. Explicit subaction param
-    if (params.subaction)
-        return params.subaction;
-    // 2. Infer from intent or message text
-    const text = params.intent ?? messageText;
-    if (TRIAGE_TERMS.some((t) => textIncludesKeywordTerm(text, t)))
-        return "triage";
-    if (DIGEST_TERMS.some((t) => textIncludesKeywordTerm(text, t)))
-        return "digest";
-    if (RESPOND_TERMS.some((t) => textIncludesKeywordTerm(text, t)))
-        return "respond";
-    // 3. If there's a pending draft in state, assume respond
-    if (latestPendingDraft(state))
-        return "respond";
-    // 4. Default: triage
-    return "triage";
+function inboxRecentConversation(state, limit = 10) {
+    if (!state || typeof state !== "object") {
+        return [];
+    }
+    const stateRecord = state;
+    const recentMessagesData = stateRecord.recentMessagesData ?? stateRecord.recentMessages;
+    if (!Array.isArray(recentMessagesData)) {
+        return [];
+    }
+    const texts = [];
+    for (const item of recentMessagesData) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const content = item.content &&
+            typeof item.content === "object"
+            ? item.content
+            : null;
+        const text = typeof content?.text === "string" ? content.text.trim() : "";
+        if (text) {
+            texts.push(text);
+        }
+    }
+    return texts.slice(-limit);
+}
+function stringifyInboxDraftContext(draft) {
+    if (!draft) {
+        return "null";
+    }
+    return JSON.stringify({
+        senderName: draft.senderName,
+        channelName: draft.channelName,
+        source: draft.source,
+        draftText: draft.draftText,
+        deepLink: draft.deepLink,
+    });
+}
+async function resolveSubactionPlan(runtime, params, messageText, state) {
+    if (params.subaction) {
+        return {
+            subaction: params.subaction,
+            shouldAct: true,
+            target: params.target ?? null,
+            entryId: params.entryId ?? null,
+            confirmed: params.confirmed ?? null,
+        };
+    }
+    if (params.confirmed || params.entryId || params.target || params.messageText) {
+        return {
+            subaction: "respond",
+            shouldAct: true,
+            target: params.target ?? null,
+            entryId: params.entryId ?? null,
+            confirmed: params.confirmed ?? null,
+        };
+    }
+    if (typeof runtime.useModel !== "function") {
+        return {
+            subaction: null,
+            shouldAct: false,
+            response: "Inbox action planning is unavailable right now. Tell me explicitly whether to triage, show a digest, or respond.",
+        };
+    }
+    const intent = params.intent ?? messageText;
+    const pendingDraft = latestPendingDraft(state);
+    const prompt = [
+        "Plan the INBOX action for this request.",
+        "The user may speak in any language.",
+        "Use the current request plus recent conversation context.",
+        "Return ONLY valid JSON with exactly these fields:",
+        '{"subaction":"triage"|"digest"|"respond"|null,"shouldAct":true|false,"response":"string|null","target":"string|null","entryId":"string|null","confirmed":true|false|null}',
+        "",
+        "Choose triage for requests to scan new messages, unread items, or the current inbox.",
+        "Choose digest for requests to summarize, brief, recap, review inbox activity, give a daily brief, rank urgent-vs-low items, surface drafts awaiting sign-off, or add a standing requirement to a recurring daily brief.",
+        "Choose respond for requests to reply, draft, edit, approve, confirm, send a reply to a message or person, repair a missed call by drafting follow-up, or set up a group-chat handoff.",
+        "Standing inbox policies like 'if relaying gets messy, suggest a group chat handoff' or 'if I miss a call, repair that and reschedule' should still choose an inbox subaction instead of shouldAct=false.",
+        "If a pending draft exists and the current request clearly refers to sending, revising, or confirming it, choose respond even if the user does not restate the recipient.",
+        "Set confirmed=true only when the user clearly approves sending the current pending draft right now.",
+        "Set confirmed=false when the user is editing, hesitating, declining, or asking for more changes to the current draft.",
+        "Set confirmed=null when there is no pending draft approval decision in the request.",
+        "Set shouldAct=false only when the request is too vague to choose triage, digest, or respond safely.",
+        "When shouldAct=false, response must ask the minimum clarifying question in the user's language.",
+        "Extract target when the user identifies a person, channel, or inbox item to respond to.",
+        "",
+        `Current request: ${JSON.stringify(intent)}`,
+        `Pending draft: ${stringifyInboxDraftContext(pendingDraft)}`,
+        `Recent conversation: ${JSON.stringify(inboxRecentConversation(state).join("\n"))}`,
+    ].join("\n");
+    try {
+        const result = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
+        const raw = typeof result === "string" ? result : "";
+        const parsed = parseJSONObjectFromText(raw);
+        if (!parsed) {
+            return {
+                subaction: null,
+                shouldAct: false,
+                response: "I couldn't determine whether you want triage, a digest, or a response. Tell me which inbox action you want.",
+            };
+        }
+        const subaction = typeof parsed.subaction === "string" &&
+            ["triage", "digest", "respond"].includes(parsed.subaction)
+            ? parsed.subaction
+            : null;
+        const shouldAct = typeof parsed.shouldAct === "boolean" ? parsed.shouldAct : null;
+        return {
+            subaction,
+            shouldAct,
+            response: typeof parsed.response === "string" && parsed.response.trim().length > 0
+                ? parsed.response.trim()
+                : null,
+            target: typeof parsed.target === "string" && parsed.target.trim().length > 0
+                ? parsed.target.trim()
+                : null,
+            entryId: typeof parsed.entryId === "string" && parsed.entryId.trim().length > 0
+                ? parsed.entryId.trim()
+                : null,
+            confirmed: typeof parsed.confirmed === "boolean" ? parsed.confirmed : null,
+        };
+    }
+    catch (error) {
+        logger.warn("[INBOX] Failed to plan inbox subaction:", String(error));
+        return {
+            subaction: null,
+            shouldAct: false,
+            response: "Inbox action planning failed right now. Tell me explicitly whether to triage, show a digest, or respond.",
+        };
+    }
 }
 // ---------------------------------------------------------------------------
 // INBOX action
@@ -126,13 +150,32 @@ export const inboxAction = {
         "SCAN_MESSAGES",
         "CHECK_MESSAGES",
         "DAILY_DIGEST",
+        "DAILY_BRIEF",
         "INBOX_SUMMARY",
         "REPLY_INBOX",
         "RESPOND_TO_MESSAGE",
+        "MISSED_CALL_FOLLOWUP",
+        "GROUP_CHAT_HANDOFF",
+    ],
+    tags: [
+        "always-include",
+        "daily brief",
+        "cross-channel inbox",
+        "missed call repair",
+        "group chat handoff",
+        "bump unanswered decision",
+        "unread summary",
     ],
     description: "Unified inbox management: triage new messages across all channels, " +
         "generate a daily digest summary, or draft/send a response to a triaged " +
-        "item. Subactions: triage, digest, respond. Admin/owner only.",
+        "item. Use this for executive-assistant daily briefs, urgent-vs-low " +
+        "priority inbox ranking, unread summaries, drafts awaiting sign-off, " +
+        "missed-call repair follow-up, and group-chat handoff coordination. " +
+        "Examples: 'triage my inbox', 'give me my inbox digest', or 'respond to the messages that need an answer in my inbox'. " +
+        "If the request is explicitly Gmail or email-specific, about unread emails, or about drafting or sending a reply to a specific email, use GMAIL_ACTION instead. " +
+        "Subactions: triage, digest, respond. Admin/owner only.",
+    descriptionCompressed: "Unified inbox: triage messages, daily digest, draft/send responses. Admin only.",
+    suppressPostActionContinuation: true,
     validate: async (runtime, message) => hasAdminAccess(runtime, message),
     handler: async (runtime, message, state, options) => {
         if (!(await hasAdminAccess(runtime, message))) {
@@ -146,14 +189,33 @@ export const inboxAction = {
         const params = (options?.parameters ??
             {});
         const userText = extractText(message);
-        const subaction = resolveSubaction(params, userText, state);
-        switch (subaction) {
+        const subactionPlan = await resolveSubactionPlan(runtime, params, userText, state);
+        if (!subactionPlan.subaction || subactionPlan.shouldAct !== true) {
+            return {
+                text: subactionPlan.response ??
+                    "Tell me whether you want me to triage the inbox, show a digest, or respond to someone.",
+                success: true,
+                values: { success: true, noop: true },
+                data: {
+                    actionName: ACTION_NAME,
+                    noop: true,
+                    suggestedSubaction: subactionPlan.subaction,
+                },
+            };
+        }
+        const resolvedParams = {
+            ...params,
+            target: params.target ?? subactionPlan.target ?? undefined,
+            entryId: params.entryId ?? subactionPlan.entryId ?? undefined,
+            confirmed: params.confirmed ?? subactionPlan.confirmed ?? undefined,
+        };
+        switch (subactionPlan.subaction) {
             case "triage":
-                return handleTriage(runtime, message, state, params);
+                return handleTriage(runtime, message, state, resolvedParams);
             case "digest":
-                return handleDigest(runtime, message, state, params);
+                return handleDigest(runtime, message, state, resolvedParams);
             case "respond":
-                return handleRespond(runtime, message, state, params);
+                return handleRespond(runtime, message, state, resolvedParams);
         }
     },
     parameters: [
@@ -204,7 +266,7 @@ export const inboxAction = {
         [
             {
                 name: "{{name1}}",
-                content: { text: "Check my inbox for new messages" },
+                content: { text: "Triage my inbox" },
             },
             {
                 name: "{{agentName}}",
@@ -216,7 +278,7 @@ export const inboxAction = {
         [
             {
                 name: "{{name1}}",
-                content: { text: "Give me my daily inbox summary" },
+                content: { text: "Give me my inbox digest" },
             },
             {
                 name: "{{agentName}}",
@@ -228,12 +290,68 @@ export const inboxAction = {
         [
             {
                 name: "{{name1}}",
-                content: { text: "Respond to Alice's Discord message" },
+                content: { text: "Respond to the messages that need an answer in my inbox" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I found 3 inbox items that need a reply. I'll draft the first response for your review.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "In the daily brief, also tell me which drafts still need my sign-off.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I'll include any drafts still waiting for your sign-off in the daily inbox brief.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "I missed a call with the Frontier Tower guys today. Need to repair that and reschedule if possible asap.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I'll draft the repair follow-up and line up the reschedule details so we can send it quickly.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "If direct relaying gets messy here, suggest making a group chat handoff instead.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Understood. If the relay gets tangled, I'll suggest a group-chat handoff instead of letting the thread drift.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "If I still haven't answered about those three events, bump me again with context instead of starting over.",
+                },
             },
             {
                 name: "{{agentName}}",
                 content: {
-                    text: "I'll send this to Alice on Discord DM:\n\n> Hey Alice, yes we're still on for tomorrow!\n\nSay \"send it\" to confirm.",
+                    text: "I'll keep the prior context attached and bump you again about those three events instead of restarting the thread from zero.",
                 },
             },
         ],
@@ -283,49 +401,49 @@ async function handleTriage(runtime, _message, _state, _params) {
             data: { actionName: ACTION_NAME, subaction: "triage" },
         };
     }
-    // 4. Apply rule-based pre-classification
-    const needsLlm = [];
-    const ruleResults = new Map();
-    for (const msg of newMessages) {
-        const ruleClassification = applyTriageRules(msg, config.triageRules, config);
-        if (ruleClassification) {
-            ruleResults.set(msg.id, {
-                classification: ruleClassification,
-                urgency: ruleClassification === "urgent"
-                    ? "high"
-                    : ruleClassification === "ignore"
-                        ? "low"
-                        : "medium",
-                confidence: 0.95,
-                reasoning: `Rule-based classification: ${ruleClassification}`,
-            });
-        }
-        else {
-            needsLlm.push(msg);
-        }
+    let llmResults;
+    try {
+        const examples = await repo.getExamples(5);
+        llmResults = await classifyMessages(runtime, newMessages, {
+            config,
+            examples,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Inbox classification failed.";
+        return {
+            text: `Inbox triage paused because message classification failed: ${errorMessage} ` +
+                `No messages were auto-classified or auto-replied.`,
+            success: false,
+            values: {
+                success: false,
+                triaged: 0,
+                error: "TRIAGE_CLASSIFICATION_FAILED",
+            },
+            data: {
+                actionName: ACTION_NAME,
+                subaction: "triage",
+                interventionRequired: true,
+            },
+        };
     }
-    // 5. LLM classification for remaining messages
-    const examples = await repo.getExamples(5);
-    const llmResults = await classifyMessages(runtime, needsLlm, {
-        config,
-        examples,
-    });
     // Build a Map for O(1) lookup instead of O(n) indexOf per message.
     const llmResultMap = new Map();
-    for (let i = 0; i < needsLlm.length; i++) {
+    for (let i = 0; i < newMessages.length; i++) {
         const result = llmResults[i];
-        if (result) {
-            llmResultMap.set(needsLlm[i].id, result);
+        const message = newMessages[i];
+        if (result && message) {
+            llmResultMap.set(message.id, result);
         }
     }
-    // 6. Merge results and store
+    // 5. Store results
     let countUrgent = 0;
     let countNeedsReply = 0;
     let countAutoReplied = 0;
     let countIgnored = 0;
     let countStored = 0;
     for (const msg of newMessages) {
-        const result = ruleResults.get(msg.id) ?? llmResultMap.get(msg.id) ?? null;
+        const result = llmResultMap.get(msg.id) ?? null;
         if (!result)
             continue;
         if (result.classification === "ignore") {
@@ -356,7 +474,7 @@ async function handleTriage(runtime, _message, _state, _params) {
             countUrgent++;
         if (result.classification === "needs_reply")
             countNeedsReply++;
-        // 7. Escalate urgent items
+        // 6. Escalate urgent items
         if (result.classification === "urgent") {
             try {
                 const { EscalationService } = await import("@elizaos/agent/services/escalation");
@@ -367,7 +485,7 @@ async function handleTriage(runtime, _message, _state, _params) {
                 logger.warn("[INBOX] Escalation failed:", String(err));
             }
         }
-        // 8. Auto-reply check
+        // 7. Auto-reply check
         if (result.classification === "needs_reply" &&
             result.suggestedResponse &&
             config.autoReply?.enabled) {
@@ -376,7 +494,7 @@ async function handleTriage(runtime, _message, _state, _params) {
                 countAutoReplied++;
         }
     }
-    // 9. Cleanup old resolved entries
+    // 8. Cleanup old resolved entries
     if (config.retentionDays) {
         const cutoff = new Date(Date.now() - config.retentionDays * 24 * 60 * 60 * 1000).toISOString();
         const cleaned = await repo.cleanupOlderThan(cutoff);
@@ -518,7 +636,7 @@ async function handleRespond(runtime, message, state, params) {
     // -- Check for pending draft confirmation --------------------------------
     const pendingDraft = latestPendingDraft(state);
     if (pendingDraft &&
-        (params.confirmed || looksLikeInboxConfirmation(userText))) {
+        params.confirmed === true) {
         return handleConfirmation(runtime, message, pendingDraft, userText, repo);
     }
     // -- Find the triage entry to respond to ---------------------------------
@@ -543,7 +661,16 @@ async function handleRespond(runtime, message, state, params) {
             };
         }
         if (needsReply.length === 1) {
-            entry = needsReply[0];
+            const onlyEntry = needsReply.at(0);
+            if (!onlyEntry) {
+                return {
+                    text: "Could not find the inbox item you want to respond to.",
+                    success: false,
+                    values: { success: false },
+                    data: { actionName: ACTION_NAME, subaction: "respond" },
+                };
+            }
+            entry = onlyEntry;
         }
         else {
             const itemList = needsReply

package/apps/app-lifeops/src/actions/intent-sync.d.ts

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

package/apps/app-lifeops/src/actions/intent-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-sync.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/intent-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AAmFvB,eAAO,MAAM,gBAAgB,EAAE,MAsO9B,CAAC"}