@elizaos/ui 2.0.0-alpha.382 → 2.0.0-alpha.385

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

@@ -1,1244 +0,0 @@
-import { hasAdminAccess, resolveAdminEntityId, } from "@elizaos/agent";
-import { logger, ModelType, parseJSONObjectFromText } from "@elizaos/core";
-import { getRecentMessagesData } from "@elizaos/shared";
-import { loadInboxTriageConfig } from "../inbox/config.js";
-import { fetchAllMessages } from "../inbox/message-fetcher.js";
-import { reflectOnAutoReply, reflectOnSendConfirmation, } from "../inbox/reflection.js";
-import { InboxTriageRepository } from "../inbox/repository.js";
-import { classifyMessages } from "../inbox/triage-classifier.js";
-import { createApprovalQueue } from "../lifeops/approval-queue.js";
-import { LifeOpsService } from "../lifeops/service.js";
-import { executeApprovedRequest } from "./approval.js";
-import { INTERNAL_URL } from "./lifeops-google-helpers.js";
-function inboxRecentConversation(state, limit = 10) {
-    const texts = [];
-    for (const item of getRecentMessagesData(state)) {
-        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,
-    });
-}
-function buildInboxPolicyAcknowledgement(userText) {
-    const normalized = userText.trim().toLowerCase();
-    if (!normalized) {
-        return null;
-    }
-    if (/\bgroup chat\b/u.test(normalized) &&
-        /\bhandoff\b/u.test(normalized) &&
-        /\b(?:relay|relaying|relays|coordination|messy|tangled)\b/u.test(normalized)) {
-        return {
-            text: "If the relay gets messy, I'll suggest a group-chat handoff with you and the other people involved so we can stop bouncing messages through you.",
-            success: true,
-            values: {
-                success: true,
-                policyRecorded: true,
-            },
-            data: {
-                actionName: ACTION_NAME,
-                subaction: "respond",
-                policyRecorded: true,
-                policyType: "group_chat_handoff",
-            },
-        };
-    }
-    if (/\bbump\b/u.test(normalized) &&
-        /\bcontext\b/u.test(normalized) &&
-        /\bstart(?:ing)? over\b/u.test(normalized)) {
-        return {
-            text: "If that thread is still unresolved, I'll bump you again with the existing context attached instead of restarting the explanation from zero.",
-            success: true,
-            values: {
-                success: true,
-                policyRecorded: true,
-            },
-            data: {
-                actionName: ACTION_NAME,
-                subaction: "respond",
-                policyRecorded: true,
-                policyType: "contextual_bump",
-            },
-        };
-    }
-    return null;
-}
-async function resolveSubactionPlan(runtime, params, messageText, state) {
-    const hasExplicitExecutionTarget = params.entryId !== undefined ||
-        params.target !== undefined ||
-        params.messageText !== undefined ||
-        params.confirmed !== undefined;
-    if (params.subaction && hasExplicitExecutionTarget) {
-        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.",
-        "For standing inbox policies that should be acknowledged now without triaging a live item, set shouldAct=true, choose the right subaction, and put the user-facing acknowledgement in response.",
-        "Extract target when the user identifies a person, channel, or inbox item to respond to.",
-        'Example: {"currentRequest":"If direct relaying gets messy here, suggest making a group chat handoff instead.","subaction":"respond","shouldAct":true,"response":"If the relay gets messy, I will suggest moving everyone into a group-chat handoff instead of continuing one-off relays.","target":null,"entryId":null,"confirmed":null}',
-        'Example: {"currentRequest":"I missed a call with the Frontier Tower guys today. Need to repair that and reschedule if possible asap.","subaction":"respond","shouldAct":true,"response":null,"target":"Frontier Tower guys","entryId":null,"confirmed":null}',
-        "",
-        `Planner hint subaction (non-binding): ${JSON.stringify(params.subaction ?? null)}`,
-        `Current request: ${JSON.stringify(intent)}`,
-        `Pending draft: ${stringifyInboxDraftContext(pendingDraft)}`,
-        `Recent conversation: ${JSON.stringify(inboxRecentConversation(state).join("\n"))}`,
-    ].join("\n");
-    try {
-        // biome-ignore lint/correctness/useHookAtTopLevel: runtime.useModel is an elizaOS model API, not a React hook.
-        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
-            : (params.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({
-            src: "action:inbox",
-            error: error instanceof Error ? error.message : String(error),
-        }, "[INBOX] failed to plan inbox subaction");
-        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
-// ---------------------------------------------------------------------------
-const ACTION_NAME = "INBOX";
-export const inboxAction = {
-    name: ACTION_NAME,
-    similes: [
-        "CHECK_INBOX",
-        "INBOX_TRIAGE",
-        "INBOX_DIGEST",
-        "INBOX_RESPOND",
-        "TRIAGE_INBOX",
-        "SCAN_MESSAGES",
-        "CHECK_MESSAGES",
-        "DAILY_DIGEST",
-        "INBOX_SUMMARY",
-        "REPLY_INBOX",
-        "RESPOND_TO_MESSAGE",
-        "MISSED_CALL_FOLLOWUP",
-        "MISSED_CALL_REPAIR",
-        "GROUP_CHAT_HANDOFF",
-        "CREATE_GROUP_CHAT",
-        "ADD_PARTICIPANTS_TO_GROUP_CHAT",
-        "GROUP_CHAT_POLICY",
-        "MESSY_RELAY_HANDOFF",
-        "BUMP_UNANSWERED_DECISION",
-        "GET_PENDING_ASSETS",
-    ],
-    tags: [
-        "always-include",
-        "daily brief",
-        "cross-channel inbox",
-        "missed call repair",
-        "group chat handoff",
-        "bump unanswered decision",
-        "pending assets",
-        "event asset checklist",
-        "unread summary",
-    ],
-    description: "Inbox management: triage new messages across all channels, " +
-        "generate a daily digest summary, or draft/send a response to a triaged " +
-        "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, unanswered-decision bump policies, event asset checklists, and group-chat handoff coordination. " +
-        "Standing inbox policies like 'if direct relaying gets messy here, suggest making a group chat handoff instead' should call this action instead of staying in plain chat. " +
-        "If the request sets a standing inbox policy or follow-up rule, still call this action on the first turn even when the action needs to acknowledge the policy before a live inbox item exists. " +
-        "Examples: 'triage my inbox', 'give me my inbox digest', or 'respond to the messages that need an answer in my inbox'. " +
-        "DO NOT use this action when the user is only complaining about email or messages without asking for triage, a digest, or a reply workflow. " +
-        "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: "Inbox: triage messages, daily digest, draft/send responses, missed-call repair, and group-chat handoff policies. Admin only.",
-    suppressPostActionContinuation: true,
-    validate: async (runtime, message) => {
-        return hasAdminAccess(runtime, message);
-    },
-    handler: async (runtime, message, state, options) => {
-        if (!(await hasAdminAccess(runtime, message))) {
-            return {
-                text: "Permission denied: only the owner or admin may use inbox actions.",
-                success: false,
-                values: { success: false, error: "PERMISSION_DENIED" },
-                data: { actionName: ACTION_NAME },
-            };
-        }
-        const params = (options?.parameters ??
-            {});
-        const userText = extractText(message);
-        const policyAcknowledgement = buildInboxPolicyAcknowledgement(userText);
-        if (policyAcknowledgement &&
-            (params.subaction === "respond" || params.subaction === undefined) &&
-            !params.entryId &&
-            !params.target &&
-            !params.messageText &&
-            params.confirmed !== true) {
-            return policyAcknowledgement;
-        }
-        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: false,
-                values: {
-                    success: false,
-                    error: "PLANNER_SHOULDACT_FALSE",
-                    noop: true,
-                },
-                data: {
-                    actionName: ACTION_NAME,
-                    noop: true,
-                    error: "PLANNER_SHOULDACT_FALSE",
-                    suggestedSubaction: subactionPlan.subaction,
-                },
-            };
-        }
-        const resolvedParams = {
-            ...params,
-            target: params.target ?? subactionPlan.target ?? undefined,
-            entryId: params.entryId ?? subactionPlan.entryId ?? undefined,
-            confirmed: params.confirmed ?? subactionPlan.confirmed ?? undefined,
-        };
-        const hasConcreteRespondTarget = resolvedParams.target !== undefined ||
-            resolvedParams.entryId !== undefined ||
-            resolvedParams.messageText !== undefined ||
-            resolvedParams.confirmed !== undefined;
-        if (typeof subactionPlan.response === "string" &&
-            subactionPlan.response.trim().length > 0 &&
-            !hasConcreteRespondTarget) {
-            return {
-                text: subactionPlan.response.trim(),
-                success: true,
-                values: { success: true, acknowledged: true },
-                data: {
-                    actionName: ACTION_NAME,
-                    subaction: subactionPlan.subaction,
-                    acknowledged: true,
-                },
-            };
-        }
-        switch (subactionPlan.subaction) {
-            case "triage":
-                return handleTriage(runtime, message, state, resolvedParams);
-            case "digest":
-                return handleDigest(runtime, message, state, resolvedParams);
-            case "respond":
-                return handleRespond(runtime, message, state, resolvedParams);
-        }
-    },
-    parameters: [
-        {
-            name: "subaction",
-            description: "Inbox operation to run: triage (scan channels for new messages), " +
-                "digest (daily summary), or respond (draft/send a reply).",
-            required: false,
-            schema: {
-                type: "string",
-                enum: ["triage", "digest", "respond"],
-            },
-        },
-        {
-            name: "intent",
-            description: 'Natural language inbox request. Examples: "check my inbox for new messages", ' +
-                '"give me my daily summary", "respond to Alice\'s Discord message".',
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "target",
-            description: "Who to respond to (for respond subaction). Can be a sender name, " +
-                "channel name, or source platform.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "entryId",
-            description: "Specific triage entry ID to respond to.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "messageText",
-            description: "Pre-composed message text for the response.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "confirmed",
-            description: "Set to true when the user is confirming a previously drafted response.",
-            required: false,
-            schema: { type: "boolean" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Triage my inbox" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Triaged 15 new messages: 2 urgent (escalated), 5 need reply, 3 auto-replied, 5 ignored.",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Give me my inbox digest" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: '# Daily Inbox Summary — Saturday, April 12, 2026\n\n## Urgent (2)\n- Discord DM from Alice: "Are we meeting tomorrow?"',
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                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 keep the prior context attached and bump you again about those three events instead of restarting the thread from zero.",
-                },
-            },
-        ],
-    ],
-};
-// ===========================================================================
-// Subaction: TRIAGE
-// ===========================================================================
-async function handleTriage(runtime, _message, _state, _params) {
-    const config = loadInboxTriageConfig();
-    const repo = new InboxTriageRepository(runtime);
-    // 1. "since" window: current time minus one hour (the triage interval).
-    //    Previous implementation used the most-recent unresolved entry's
-    //    createdAt, which could miss messages arriving after that entry.
-    const sinceIso = new Date(Date.now() - 60 * 60 * 1000).toISOString();
-    // 2. Fetch messages from all channels
-    const service = new LifeOpsService(runtime);
-    const allMessages = await fetchAllMessages(runtime, {
-        sources: config.channels,
-        sinceIso,
-        limit: 200,
-        gmailSource: service,
-        xDmSource: service,
-    });
-    if (allMessages.length === 0) {
-        return {
-            text: "No new messages to triage.",
-            success: true,
-            values: { success: true, triaged: 0 },
-            data: { actionName: ACTION_NAME, subaction: "triage" },
-        };
-    }
-    // 3. Deduplicate against already-triaged messages
-    const newMessages = [];
-    for (const msg of allMessages) {
-        const existing = await repo.getBySourceMessageId(msg.id);
-        if (!existing) {
-            newMessages.push(msg);
-        }
-    }
-    if (newMessages.length === 0) {
-        return {
-            text: "All recent messages have already been triaged.",
-            success: true,
-            values: {
-                success: true,
-                triaged: 0,
-                skippedDuplicates: allMessages.length,
-            },
-            data: { actionName: ACTION_NAME, subaction: "triage" },
-        };
-    }
-    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,
-            },
-        };
-    }
-    // Build a Map for O(1) lookup instead of O(n) indexOf per message.
-    const llmResultMap = new Map();
-    for (let i = 0; i < newMessages.length; i++) {
-        const result = llmResults[i];
-        const message = newMessages[i];
-        if (result && message) {
-            llmResultMap.set(message.id, result);
-        }
-    }
-    // 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 = llmResultMap.get(msg.id) ?? null;
-        if (!result)
-            continue;
-        if (result.classification === "ignore") {
-            countIgnored++;
-            continue;
-        }
-        // Store the triage entry
-        const entry = await repo.storeTriage({
-            source: msg.source,
-            sourceRoomId: msg.source === "x_dm" ? msg.xConversationId : msg.roomId,
-            sourceEntityId: msg.source === "x_dm" ? msg.xParticipantId : msg.entityId,
-            sourceMessageId: msg.id,
-            channelName: msg.channelName,
-            channelType: msg.channelType,
-            deepLink: msg.deepLink,
-            classification: result.classification,
-            urgency: result.urgency,
-            confidence: result.confidence,
-            snippet: msg.snippet,
-            senderName: msg.senderName,
-            threadContext: msg.threadMessages,
-            triageReasoning: result.reasoning,
-            suggestedResponse: result.suggestedResponse,
-        });
-        countStored++;
-        // Track counts
-        if (result.classification === "urgent")
-            countUrgent++;
-        if (result.classification === "needs_reply")
-            countNeedsReply++;
-        // 6. Escalate urgent items
-        if (result.classification === "urgent") {
-            try {
-                const { EscalationService } = await import("@elizaos/agent/services/escalation");
-                const linkText = msg.deepLink ? `\n${msg.deepLink}` : "";
-                await EscalationService.startEscalation(runtime, `Urgent message from ${msg.senderName} on ${msg.source}`, `[URGENT] ${msg.channelName}: "${msg.snippet}"${linkText}`);
-            }
-            catch (err) {
-                logger.warn({
-                    src: "action:inbox",
-                    error: err instanceof Error ? err.message : String(err),
-                    messageId: msg.id,
-                }, "[INBOX] escalation failed");
-            }
-        }
-        // 7. Auto-reply check
-        if (result.classification === "needs_reply" &&
-            result.suggestedResponse &&
-            config.autoReply?.enabled) {
-            const autoReplyResult = await tryAutoReply(runtime, msg, result, entry.id, config, repo);
-            if (autoReplyResult)
-                countAutoReplied++;
-        }
-    }
-    // 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);
-        if (cleaned > 0) {
-            logger.info(`[INBOX] Cleaned up ${cleaned} old triage entries`);
-        }
-    }
-    const summary = [
-        `Triaged ${newMessages.length} new messages:`,
-        countUrgent > 0 ? `${countUrgent} urgent (escalated)` : null,
-        countNeedsReply > 0 ? `${countNeedsReply} need reply` : null,
-        countAutoReplied > 0 ? `${countAutoReplied} auto-replied` : null,
-        countIgnored > 0 ? `${countIgnored} ignored` : null,
-        `${countStored} stored for review`,
-    ]
-        .filter(Boolean)
-        .join(", ");
-    return {
-        text: summary,
-        success: true,
-        values: {
-            success: true,
-            triaged: newMessages.length,
-            urgent: countUrgent,
-            needsReply: countNeedsReply,
-            autoReplied: countAutoReplied,
-            ignored: countIgnored,
-        },
-        data: { actionName: ACTION_NAME, subaction: "triage" },
-    };
-}
-// ===========================================================================
-// Subaction: DIGEST
-// ===========================================================================
-async function handleDigest(runtime, message, _state, _params) {
-    const config = loadInboxTriageConfig();
-    const repo = new InboxTriageRepository(runtime);
-    // 1. Get entries from the last 24 hours
-    const sinceIso = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
-    const entries = await repo.getRecentForDigest(sinceIso);
-    if (entries.length === 0) {
-        return {
-            text: "No inbox activity in the last 24 hours. All clear.",
-            success: true,
-            values: { success: true, entryCount: 0 },
-            data: { actionName: ACTION_NAME, subaction: "digest" },
-        };
-    }
-    // 2. Group by classification
-    const urgent = entries.filter((e) => e.classification === "urgent");
-    const needsReply = entries.filter((e) => e.classification === "needs_reply" && !e.resolved);
-    const notify = entries.filter((e) => e.classification === "notify");
-    const info = entries.filter((e) => e.classification === "info");
-    const autoReplied = entries.filter((e) => e.autoReplied);
-    const resolved = entries.filter((e) => e.resolved && !e.autoReplied);
-    // 3. Build digest
-    const today = new Date().toLocaleDateString("en-US", {
-        weekday: "long",
-        year: "numeric",
-        month: "long",
-        day: "numeric",
-    });
-    const lines = [`# Daily Inbox Summary — ${today}`];
-    lines.push(`\n${entries.length} messages triaged across ${countSources(entries)} channels.`);
-    if (urgent.length > 0) {
-        lines.push(`\n## Urgent (${urgent.length})`);
-        for (const e of urgent) {
-            lines.push(formatEntryLine(e));
-        }
-    }
-    if (needsReply.length > 0) {
-        lines.push(`\n## Needs Reply (${needsReply.length})`);
-        for (const e of needsReply) {
-            lines.push(formatEntryLine(e));
-        }
-    }
-    if (notify.length > 0) {
-        lines.push(`\n## Notifications (${notify.length})`);
-        for (const e of notify.slice(0, 10)) {
-            lines.push(formatEntryLine(e));
-        }
-        if (notify.length > 10) {
-            lines.push(`  ...and ${notify.length - 10} more`);
-        }
-    }
-    if (autoReplied.length > 0) {
-        lines.push(`\n## Auto-Replied (${autoReplied.length})`);
-        for (const e of autoReplied) {
-            const draft = e.draftResponse
-                ? ` — replied: "${e.draftResponse.slice(0, 60)}..."`
-                : "";
-            lines.push(`- **${e.channelName}** (${e.source}): "${e.snippet.slice(0, 80)}"${draft}`);
-        }
-    }
-    if (resolved.length > 0) {
-        lines.push(`\n## Resolved (${resolved.length})`);
-        lines.push(`  ${resolved.length} items were addressed during the day.`);
-    }
-    if (info.length > 0) {
-        lines.push(`\n## Informational (${info.length})`);
-        lines.push(`  ${info.length} informational messages were logged.`);
-    }
-    const digestText = lines.join("\n");
-    // 4. Send digest to owner
-    const deliveryChannel = config.digestDeliveryChannel ?? "client_chat";
-    try {
-        const adminEntityId = await resolveAdminEntityId(runtime, message);
-        await runtime.sendMessageToTarget({
-            source: deliveryChannel,
-            entityId: adminEntityId,
-        }, {
-            text: digestText,
-            source: deliveryChannel,
-            metadata: { digestType: "inbox_daily" },
-        });
-    }
-    catch (err) {
-        logger.warn({
-            src: "action:inbox",
-            error: err instanceof Error ? err.message : String(err),
-        }, "[INBOX] failed to deliver digest");
-    }
-    return {
-        text: digestText,
-        success: true,
-        values: {
-            success: true,
-            entryCount: entries.length,
-            urgent: urgent.length,
-            needsReply: needsReply.length,
-            autoReplied: autoReplied.length,
-        },
-        data: { actionName: ACTION_NAME, subaction: "digest" },
-    };
-}
-// ===========================================================================
-// Subaction: RESPOND
-// ===========================================================================
-async function handleRespond(runtime, message, state, params) {
-    const userText = extractText(message);
-    const policyAcknowledgement = buildInboxPolicyAcknowledgement(userText);
-    if (policyAcknowledgement &&
-        !params.entryId &&
-        !params.target &&
-        !params.messageText &&
-        params.confirmed !== true) {
-        return policyAcknowledgement;
-    }
-    const repo = new InboxTriageRepository(runtime);
-    // -- Check for pending draft confirmation --------------------------------
-    const pendingDraft = latestPendingDraft(state);
-    if (pendingDraft && params.confirmed === true) {
-        return handleConfirmation(runtime, message, pendingDraft, userText, repo);
-    }
-    // -- Find the triage entry to respond to ---------------------------------
-    let entry = null;
-    if (params.entryId) {
-        entry = await repo.getById(params.entryId);
-    }
-    if (!entry && params.target) {
-        const unresolved = await repo.getUnresolved({ limit: 50 });
-        entry = findBestMatch(unresolved, params.target);
-    }
-    if (!entry) {
-        // If no specific target, grab the most urgent unresolved item
-        const unresolved = await repo.getUnresolved({ limit: 5 });
-        const needsReply = unresolved.filter((e) => e.classification === "needs_reply" || e.classification === "urgent");
-        if (needsReply.length === 0) {
-            return {
-                text: "No pending inbox items need a reply right now. Use INBOX to triage for new messages.",
-                // The respond side effect did not happen — there was nothing to reply
-                // to. Report as a structured no-op rather than a success.
-                success: false,
-                values: {
-                    success: false,
-                    error: "NOOP_NOTHING_TO_DO",
-                    noop: true,
-                },
-                data: {
-                    actionName: ACTION_NAME,
-                    subaction: "respond",
-                    noop: true,
-                    error: "NOOP_NOTHING_TO_DO",
-                },
-            };
-        }
-        if (needsReply.length === 1) {
-            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
-                .map((e) => `- **${e.channelName}** (${e.source}): "${e.snippet.slice(0, 60)}"`)
-                .join("\n");
-            return {
-                text: `Multiple items need a reply. Which one?\n\n${itemList}\n\nSay "respond to [name/channel]" to pick one.`,
-                // The respond side effect did not happen — we need the user to
-                // disambiguate which item first. Report as a structured failure so
-                // downstream consumers don't treat this as a completed reply.
-                success: false,
-                values: {
-                    success: false,
-                    error: "DISAMBIGUATION_REQUIRED",
-                    pendingCount: needsReply.length,
-                },
-                data: {
-                    actionName: ACTION_NAME,
-                    subaction: "respond",
-                    error: "DISAMBIGUATION_REQUIRED",
-                    pendingCount: needsReply.length,
-                },
-            };
-        }
-    }
-    if (!entry) {
-        return {
-            text: "Could not find the inbox item you want to respond to.",
-            success: false,
-            values: { success: false, error: "NOT_FOUND" },
-            data: { actionName: ACTION_NAME, subaction: "respond" },
-        };
-    }
-    // -- Draft a response ----------------------------------------------------
-    const draftText = params.messageText
-        ? params.messageText
-        : await draftResponse(runtime, entry, userText);
-    const draft = {
-        triageEntryId: entry.id,
-        source: entry.source,
-        targetRoomId: entry.source !== "x_dm" && entry.sourceRoomId
-            ? entry.sourceRoomId
-            : undefined,
-        targetEntityId: entry.source !== "x_dm" && entry.sourceEntityId
-            ? entry.sourceEntityId
-            : undefined,
-        gmailMessageId: entry.source === "gmail"
-            ? (entry.sourceMessageId ?? undefined)
-            : undefined,
-        xConversationId: entry.source === "x_dm" ? (entry.sourceRoomId ?? undefined) : undefined,
-        xParticipantId: entry.source === "x_dm" ? (entry.sourceEntityId ?? undefined) : undefined,
-        draftText,
-        deepLink: entry.deepLink,
-        channelName: entry.channelName,
-        senderName: entry.senderName ?? "Unknown",
-    };
-    const approvalQueue = createApprovalQueue(runtime, {
-        agentId: runtime.agentId,
-    });
-    const approvalRequest = await approvalQueue.enqueue({
-        requestedBy: `inbox:${entry.id}`,
-        subjectUserId: String(message.entityId ?? runtime.agentId),
-        action: draft.source === "gmail" ? "send_email" : "send_message",
-        payload: draft.source === "gmail" && draft.gmailMessageId
-            ? {
-                action: "send_email",
-                to: [],
-                cc: [],
-                bcc: [],
-                subject: entry.channelName,
-                body: draft.draftText,
-                threadId: entry.sourceMessageId,
-                replyToMessageId: draft.gmailMessageId,
-            }
-            : {
-                action: "send_message",
-                recipient: draft.source === "x_dm" && draft.xConversationId
-                    ? `conversation:${draft.xConversationId}`
-                    : String(draft.targetRoomId ??
-                        draft.targetEntityId ??
-                        draft.xParticipantId ??
-                        ""),
-                body: draft.draftText,
-                replyToMessageId: entry.sourceMessageId,
-            },
-        channel: approvalChannelForInboxSource(entry.source),
-        reason: `Reply draft for ${draft.senderName} on ${draft.channelName}`,
-        expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
-    });
-    draft.approvalRequestId = approvalRequest.id;
-    return {
-        text: `I'll send this to **${draft.senderName}** on **${draft.channelName}** (${draft.source}):\n\n` +
-            `> ${draftText}\n\n` +
-            `It's queued for approval. Say **"send it"** or explicitly approve it to dispatch, or tell me what to change.`,
-        success: true,
-        values: { success: true, awaitingConfirmation: true },
-        data: {
-            actionName: ACTION_NAME,
-            subaction: "respond",
-            inboxDraft: draft,
-            approvalRequestId: approvalRequest.id,
-        },
-    };
-}
-// ===========================================================================
-// Shared helpers
-// ===========================================================================
-// -- Auto-reply (used by triage) -------------------------------------------
-async function tryAutoReply(runtime, msg, result, entryId, config, repo) {
-    const autoConfig = config.autoReply;
-    if (!autoConfig?.enabled)
-        return false;
-    const suggestedResponse = result.suggestedResponse;
-    if (!suggestedResponse)
-        return false;
-    const threshold = autoConfig.confidenceThreshold ?? 0.85;
-    if (result.confidence < threshold)
-        return false;
-    // Sender whitelist check
-    if (autoConfig.senderWhitelist?.length) {
-        const senderId = msg.entityId ?? msg.senderName;
-        if (!autoConfig.senderWhitelist.some((s) => s.toLowerCase() === senderId.toLowerCase())) {
-            return false;
-        }
-    }
-    // Channel whitelist check
-    if (autoConfig.channelWhitelist?.length) {
-        if (!autoConfig.channelWhitelist.includes(msg.source)) {
-            return false;
-        }
-    }
-    // Rate limit check
-    const maxPerHour = autoConfig.maxAutoRepliesPerHour ?? 5;
-    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
-    const recentAutoCount = await repo.countAutoRepliesSince(oneHourAgo);
-    if (recentAutoCount >= maxPerHour) {
-        logger.info("[INBOX] Auto-reply rate limit reached");
-        return false;
-    }
-    // Reflection safety check
-    const reflection = await reflectOnAutoReply(runtime, {
-        inboundText: msg.text,
-        replyText: suggestedResponse,
-        source: msg.source,
-        senderName: msg.senderName,
-    });
-    if (!reflection.approved) {
-        logger.info(`[INBOX] Auto-reply rejected by reflection: ${reflection.reasoning}`);
-        return false;
-    }
-    // Send the auto-reply
-    try {
-        if (msg.source === "gmail" && msg.gmailMessageId) {
-            const { LifeOpsService } = await import("../lifeops/service.js");
-            const service = new LifeOpsService(runtime);
-            await service.sendGmailReply(INTERNAL_URL, {
-                messageId: msg.gmailMessageId,
-                bodyText: suggestedResponse,
-            });
-        }
-        else if (msg.source === "x_dm" &&
-            (msg.xConversationId || msg.xParticipantId)) {
-            const service = new LifeOpsService(runtime);
-            if (msg.xConversationId) {
-                await service.sendXConversationMessage({
-                    conversationId: msg.xConversationId,
-                    text: suggestedResponse,
-                    confirmSend: true,
-                    side: "owner",
-                });
-            }
-            else if (msg.xParticipantId) {
-                await service.sendXDirectMessage({
-                    participantId: msg.xParticipantId,
-                    text: suggestedResponse,
-                    confirmSend: true,
-                    side: "owner",
-                });
-            }
-        }
-        else if (msg.roomId) {
-            await runtime.sendMessageToTarget({
-                source: msg.source,
-                roomId: msg.roomId,
-            }, { text: suggestedResponse, source: msg.source });
-        }
-        else {
-            return false;
-        }
-        await repo.markResolved(entryId, {
-            draftResponse: suggestedResponse,
-            autoReplied: true,
-        });
-        logger.info(`[INBOX] Auto-replied to ${msg.senderName} on ${msg.source}`);
-        return true;
-    }
-    catch (err) {
-        logger.warn({
-            src: "action:inbox",
-            error: err instanceof Error ? err.message : String(err),
-            messageId: msg.id,
-        }, "[INBOX] auto-reply send failed");
-        return false;
-    }
-}
-// -- Draft generation (used by respond) ------------------------------------
-async function draftResponse(runtime, entry, userHint) {
-    const seed = entry.suggestedResponse ?? "";
-    const contextLines = entry.threadContext
-        ? entry.threadContext.join("\n")
-        : "";
-    const prompt = [
-        "Draft a brief, natural response to the following message.",
-        "Match the tone and formality of the conversation.",
-        "",
-        `From: ${entry.senderName ?? "Unknown"}`,
-        `Channel: ${entry.channelName} (${entry.source})`,
-        `Their message: "${entry.snippet}"`,
-        contextLines ? `Recent context:\n${contextLines}` : "",
-        seed ? `Suggested starting point: "${seed}"` : "",
-        userHint ? `Owner's guidance: "${userHint}"` : "",
-        "",
-        "Write ONLY the response text. Do not include any explanation or metadata.",
-    ]
-        .filter(Boolean)
-        .join("\n");
-    try {
-        // biome-ignore lint/correctness/useHookAtTopLevel: runtime.useModel is an elizaOS model API, not a React hook.
-        const result = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
-        const text = typeof result === "string" ? result.trim() : "";
-        return (text || seed || "Thanks for reaching out. I'll get back to you soon.");
-    }
-    catch {
-        return seed || "Thanks for reaching out. I'll get back to you soon.";
-    }
-}
-// -- Confirmation handling (used by respond) --------------------------------
-async function handleConfirmation(runtime, message, draft, userText, repo) {
-    // Reflection safety check
-    const reflection = await reflectOnSendConfirmation(runtime, {
-        userMessage: userText,
-        draftText: draft.draftText,
-        channelName: draft.channelName,
-        recipientName: draft.senderName,
-    });
-    if (!reflection.confirmed) {
-        return {
-            text: `I wasn't sure you confirmed — ${reflection.reasoning}. Please say **"yes, send it"** to confirm.`,
-            success: true,
-            values: { success: true, awaitingConfirmation: true },
-            data: {
-                actionName: ACTION_NAME,
-                subaction: "respond",
-                inboxDraft: draft,
-            },
-        };
-    }
-    // Send the message through the original channel
-    if (draft.approvalRequestId) {
-        try {
-            const queue = createApprovalQueue(runtime, { agentId: runtime.agentId });
-            const approved = await queue.approve(draft.approvalRequestId, {
-                resolvedBy: String(message.entityId ?? runtime.agentId),
-                resolutionReason: userText.trim() || "user confirmed inbox draft",
-            });
-            const executed = await executeApprovedRequest({
-                runtime,
-                queue,
-                request: approved,
-            });
-            if (!executed.success) {
-                return executed;
-            }
-        }
-        catch (err) {
-            return {
-                text: `Failed to send message: ${String(err)}`,
-                success: false,
-                values: { success: false, error: "SEND_FAILED" },
-                data: { actionName: ACTION_NAME, subaction: "respond" },
-            };
-        }
-    }
-    else {
-        try {
-            if (draft.source === "gmail" && draft.gmailMessageId) {
-                const { LifeOpsService } = await import("../lifeops/service.js");
-                const service = new LifeOpsService(runtime);
-                await service.sendGmailReply(INTERNAL_URL, {
-                    messageId: draft.gmailMessageId,
-                    bodyText: draft.draftText,
-                });
-            }
-            else if (draft.source === "x_dm" &&
-                (draft.xConversationId || draft.xParticipantId)) {
-                const service = new LifeOpsService(runtime);
-                if (draft.xConversationId) {
-                    await service.sendXConversationMessage({
-                        conversationId: draft.xConversationId,
-                        text: draft.draftText,
-                        confirmSend: true,
-                        side: "owner",
-                    });
-                }
-                else if (draft.xParticipantId) {
-                    await service.sendXDirectMessage({
-                        participantId: draft.xParticipantId,
-                        text: draft.draftText,
-                        confirmSend: true,
-                        side: "owner",
-                    });
-                }
-            }
-            else if (draft.targetRoomId) {
-                await runtime.sendMessageToTarget({
-                    source: draft.source,
-                    roomId: draft.targetRoomId,
-                }, { text: draft.draftText, source: draft.source });
-            }
-            else {
-                return {
-                    text: "Cannot send: no target room or message ID available for this channel.",
-                    success: false,
-                    values: { success: false, error: "NO_TARGET" },
-                    data: { actionName: ACTION_NAME, subaction: "respond" },
-                };
-            }
-        }
-        catch (err) {
-            return {
-                text: `Failed to send message: ${String(err)}`,
-                success: false,
-                values: { success: false, error: "SEND_FAILED" },
-                data: { actionName: ACTION_NAME, subaction: "respond" },
-            };
-        }
-    }
-    // Mark resolved and store as example
-    await repo.markResolved(draft.triageEntryId, {
-        draftResponse: draft.draftText,
-    });
-    const entry = await repo.getById(draft.triageEntryId);
-    if (entry) {
-        await repo.storeExample({
-            source: entry.source,
-            snippet: entry.snippet,
-            classification: entry.classification,
-            ownerAction: "confirmed",
-            contextJson: {
-                senderName: entry.senderName,
-                channelName: entry.channelName,
-                draftResponse: draft.draftText,
-            },
-        });
-    }
-    return {
-        text: `Message sent to **${draft.senderName}** on **${draft.channelName}**.`,
-        success: true,
-        values: { success: true, sent: true },
-        data: { actionName: ACTION_NAME, subaction: "respond", sent: true },
-    };
-}
-// -- Digest formatters -----------------------------------------------------
-function formatEntryLine(entry) {
-    const resolvedTag = entry.resolved ? " [resolved]" : "";
-    const link = entry.deepLink ? `\n  ${entry.deepLink}` : "";
-    return (`- **${entry.channelName}** (${entry.source}): "${entry.snippet.slice(0, 100)}"${resolvedTag}` +
-        link);
-}
-function countSources(entries) {
-    return new Set(entries.map((e) => e.source)).size;
-}
-// -- State/text helpers ----------------------------------------------------
-function latestPendingDraft(state) {
-    if (!state || typeof state !== "object")
-        return null;
-    const stateRecord = state;
-    const data = stateRecord.data && typeof stateRecord.data === "object"
-        ? stateRecord.data
-        : undefined;
-    const actionResults = Array.isArray(data?.actionResults)
-        ? data.actionResults
-        : [];
-    // Check action results (newest first)
-    for (let i = actionResults.length - 1; i >= 0; i--) {
-        const draft = actionResults[i]?.data?.inboxDraft;
-        if (draft?.triageEntryId && draft?.draftText) {
-            return draft;
-        }
-    }
-    // Check recent messages
-    const recentMessagesData = getRecentMessagesData(state);
-    for (let i = recentMessagesData.length - 1; i >= 0; i--) {
-        const item = recentMessagesData[i];
-        if (!item)
-            continue;
-        const content = item.content && typeof item.content === "object"
-            ? item.content
-            : null;
-        if (!content)
-            continue;
-        const draft = content.inboxDraft ??
-            content.data?.inboxDraft;
-        if (draft?.triageEntryId && draft?.draftText) {
-            return draft;
-        }
-    }
-    return null;
-}
-function approvalChannelForInboxSource(source) {
-    switch (source) {
-        case "gmail":
-            return "email";
-        case "telegram":
-        case "discord":
-        case "imessage":
-        case "sms":
-        case "x_dm":
-            return source;
-        default:
-            return "internal";
-    }
-}
-function findBestMatch(entries, target) {
-    const lower = target.toLowerCase();
-    // Exact channel name match
-    const exact = entries.find((e) => e.channelName.toLowerCase() === lower);
-    if (exact)
-        return exact;
-    // Sender name match
-    const senderMatch = entries.find((e) => e.senderName?.toLowerCase().includes(lower));
-    if (senderMatch)
-        return senderMatch;
-    // Partial channel name match
-    const partial = entries.find((e) => e.channelName.toLowerCase().includes(lower));
-    if (partial)
-        return partial;
-    // Source match
-    const sourceMatch = entries.find((e) => e.source.toLowerCase() === lower);
-    if (sourceMatch)
-        return sourceMatch;
-    return null;
-}
-function extractText(message) {
-    const content = message.content;
-    return typeof content?.text === "string" ? content.text : "";
-}