@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/agent/src/actions/inbox.js

@@ -1,856 +1 @@
-import { logger, ModelType } from "@elizaos/core";
-import { textIncludesKeywordTerm } from "@elizaos/shared/validation-keywords";
-import { loadInboxTriageConfig } from "../inbox/config.js";
-import { fetchAllMessages } from "../inbox/message-fetcher.js";
-import { looksLikeInboxConfirmation, reflectOnAutoReply, reflectOnSendConfirmation, } from "../inbox/reflection.js";
-import { InboxTriageRepository } from "../inbox/repository.js";
-import { applyTriageRules, classifyMessages, } from "../inbox/triage-classifier.js";
-import { hasAdminAccess } from "../security/access.js";
-import { INTERNAL_URL } from "./lifeops-google-helpers.js";
-import { resolveAdminEntityId } from "./send-message.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";
-}
-// ---------------------------------------------------------------------------
-// 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",
-    ],
-    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.",
-    validate: async (runtime, message) => hasAdminAccess(runtime, message),
-    handler: async (runtime, message, state, options) => {
-        if (!(await hasAdminAccess(runtime, message))) {
-            return {
-                text: "Permission denied: only the owner or 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 subaction = resolveSubaction(params, userText, state);
-        switch (subaction) {
-            case "triage":
-                return handleTriage(runtime, message, state, params);
-            case "digest":
-                return handleDigest(runtime, message, state, params);
-            case "respond":
-                return handleRespond(runtime, message, state, params);
-        }
-    },
-    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: "Check my inbox for new messages" },
-            },
-            {
-                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 daily inbox summary" },
-            },
-            {
-                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 Alice's Discord message" },
-            },
-            {
-                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.",
-                },
-            },
-        ],
-    ],
-};
-// ===========================================================================
-// 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 allMessages = await fetchAllMessages(runtime, {
-        sources: config.channels,
-        sinceIso,
-        limit: 200,
-    });
-    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" },
-        };
-    }
-    // 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);
-        }
-    }
-    // 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++) {
-        const result = llmResults[i];
-        if (result) {
-            llmResultMap.set(needsLlm[i].id, result);
-        }
-    }
-    // 6. Merge results and store
-    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;
-        if (!result)
-            continue;
-        if (result.classification === "ignore") {
-            countIgnored++;
-            continue;
-        }
-        // Store the triage entry
-        const entry = await repo.storeTriage({
-            source: msg.source,
-            sourceRoomId: msg.roomId,
-            sourceEntityId: 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++;
-        // 7. Escalate urgent items
-        if (result.classification === "urgent") {
-            try {
-                const { EscalationService } = await import("../services/escalation.js");
-                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("[INBOX] Escalation failed:", String(err));
-            }
-        }
-        // 8. 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++;
-        }
-    }
-    // 9. 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("[INBOX] Failed to deliver digest:", String(err));
-    }
-    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 repo = new InboxTriageRepository(runtime);
-    const userText = extractText(message);
-    // -- Check for pending draft confirmation --------------------------------
-    const pendingDraft = latestPendingDraft(state);
-    if (pendingDraft &&
-        (params.confirmed || looksLikeInboxConfirmation(userText))) {
-        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.",
-                success: true,
-                values: { success: true },
-                data: { actionName: ACTION_NAME, subaction: "respond" },
-            };
-        }
-        if (needsReply.length === 1) {
-            entry = needsReply[0];
-        }
-        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.`,
-                success: true,
-                values: { success: true, pendingCount: needsReply.length },
-                data: { actionName: ACTION_NAME, subaction: "respond" },
-            };
-        }
-    }
-    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.sourceRoomId ? entry.sourceRoomId : undefined,
-        targetEntityId: entry.sourceEntityId
-            ? entry.sourceEntityId
-            : undefined,
-        gmailMessageId: entry.source === "gmail"
-            ? (entry.sourceMessageId ?? undefined)
-            : undefined,
-        draftText,
-        deepLink: entry.deepLink,
-        channelName: entry.channelName,
-        senderName: entry.senderName ?? "Unknown",
-    };
-    return {
-        text: `I'll send this to **${draft.senderName}** on **${draft.channelName}** (${draft.source}):\n\n` +
-            `> ${draftText}\n\n` +
-            `Say **"send it"** to confirm, or tell me what to change.`,
-        success: true,
-        values: { success: true, awaitingConfirmation: true },
-        data: {
-            actionName: ACTION_NAME,
-            subaction: "respond",
-            inboxDraft: draft,
-        },
-    };
-}
-// ===========================================================================
-// 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.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("[INBOX] Auto-reply send failed:", String(err));
-        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 {
-        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
-    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.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 = stateRecord.recentMessagesData ?? stateRecord.recentMessages;
-    if (Array.isArray(recentMessagesData)) {
-        for (let i = recentMessagesData.length - 1; i >= 0; i--) {
-            const item = recentMessagesData[i];
-            if (!item)
-                continue;
-            const content = item.content;
-            if (!content)
-                continue;
-            const draft = content.inboxDraft ??
-                content.data?.inboxDraft;
-            if (draft?.triageEntryId && draft?.draftText) {
-                return draft;
-            }
-        }
-    }
-    return null;
-}
-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 : "";
-}
+export * from "@elizaos/app-lifeops/actions/inbox";