@ozaiya/openclaw-channel 0.10.37 → 0.10.39

package/dist/src/channel.js

@@ -31,6 +31,8 @@ import { summarizeWithDoubao } from "./doubao.js";
 import { fetchXueqiuPost, searchXueqiuPosts } from "./xueqiu.js";
 import { fetchSocialMediaPost, searchSocialMedia, extractSocialMediaContent } from "./socialMedia.js";
 import { requestConfirmation, parseActionCallback, resolveConfirmation } from "./actionConfirmation.js";
+import { createBotEmailTool, emailAddonOf, newMailNotice, watchMailboxes } from "./botEmail.js";
+import { createBotMcpTool, mcpAddonOf } from "./botMcp.js";
 const DEFAULT_API_BASE_URL = "https://api.ozaiya.com";
 const DEFAULT_WEBHOOK_PATH = "/ozaiya/webhook";
 const DEFAULT_ACCOUNT_ID = "default";
@@ -104,6 +106,15 @@ function categorize(toolName) {
 }
 // Active dispatches keyed by accountId (one dispatch at a time per account)
 const activeDispatches = new Map();
+/** Bot id → the chat a new-mail turn is running in (the owner's chat with the bot). */
+const mailTurns = new Map();
+/** Bot id → its running mailbox watch, and the config it was started with. */
+const mailWatches = new Map();
+/** Bot id → new-mail turns run one after another. */
+const mailTurnQueues = new Map();
+/** Bot id → when its recent new-mail turns started (a flood of mail doesn't become a flood of turns). */
+const mailTurnTimes = new Map();
+const MAIL_TURNS_PER_HOUR = 20;
 function buildTaskProgressContent(dispatch, completed) {
     return {
         taskProgress: {
@@ -1509,6 +1520,17 @@ function buildChannelTools(account, cfg) {
     const summarizeTool = addonOn("web_research") ? createSummarizeUrlTool(cfg) : null;
     if (summarizeTool)
         tools.push(summarizeTool);
+    // The bot's own mailbox (email add-on): there only once the owner has added one.
+    const emailConfig = emailAddonOf(account);
+    if (emailConfig)
+        tools.push(createEmailToolFor(account, emailConfig));
+    // The owner's business systems over MCP (mcp add-on): one tool, write operations behind a card.
+    const mcpConfig = mcpAddonOf(account);
+    if (mcpConfig) {
+        tools.push(createBotMcpTool(account, mcpConfig, {
+            askOwner: async (label, params) => !!mcpConfig.ownerGroupId && requestConfirmation(makeConfirmationDeps(account), mcpConfig.ownerGroupId, "mcp", params, label),
+        }));
+    }
     // Plan tool: lets the agent declare + maintain a high-level task plan that the
     // app renders as a live "task progress N/M" checklist (distinct from tool steps).
     tools.push({
@@ -2090,10 +2112,12 @@ export const ozaiyaPlugin = {
                         recordState(botAccount.accountId, { running: false, lastStopAt: Date.now() });
                     });
                     ctx.log?.info(`[${botAccount.accountId}] registered webhook at ${botAccount.webhookPath}`);
+                    syncMailWatch(botAccount, ctx.cfg, stateDir, ctx.log);
                 };
                 const stopBotHandler = (botId) => {
                     botUnregisters.get(botId)?.();
                     botUnregisters.delete(botId);
+                    stopMailWatch(botId);
                     gatewayBotAccounts.delete(botId);
                 };
                 await startGatewayMode({
@@ -2170,6 +2194,7 @@ export const ozaiyaPlugin = {
                 groupToActivePhoneCall.clear();
                 for (const id of gatewayBotAccounts.keys()) {
                     recordState(id, { running: false, lastStopAt: Date.now() });
+                    stopMailWatch(id);
                 }
                 gatewayBotAccounts.clear();
                 recordState(account.accountId, { running: false, lastStopAt: Date.now() });
@@ -3106,6 +3131,148 @@ function createRequestUserApprovalTool(account) {
         },
     };
 }
+// ─── The bot's own mailbox (email add-on) ───────────────────────────────────
+/**
+ * The email tool for this bot. Its mailbox may only be looked into from the owner's own chat with
+ * the bot — the chat a message or new-mail turn is running in, when that is the only one running —
+ * and every approval card goes to that chat, whoever asked.
+ */
+function createEmailToolFor(account, config) {
+    const ownerGroupId = config.ownerGroupId;
+    return createBotEmailTool(account, config, {
+        inOwnerChat: () => {
+            const running = [activeDispatches.get(account.accountId)?.groupId, mailTurns.get(account.accountId)].filter(Boolean);
+            return !!ownerGroupId && running.length > 0 && running.every((groupId) => groupId === ownerGroupId);
+        },
+        askOwner: async (label, params) => {
+            if (!ownerGroupId)
+                return false;
+            return requestConfirmation(makeConfirmationDeps(account), ownerGroupId, "email", params, label);
+        },
+    });
+}
+/**
+ * New mail reached the bot's own mailbox: run a turn in the owner's chat with the bot, so it tells
+ * them and, where it may, answers. The mail's headers come in marked as outside data; the agent
+ * reads the rest with its email tool.
+ */
+async function handleNewMail(account, cfg, log, mailbox, mails) {
+    const config = emailAddonOf(account);
+    const groupId = config?.ownerGroupId;
+    if (!config || !groupId)
+        return;
+    const now = Date.now();
+    const recent = (mailTurnTimes.get(account.accountId) ?? []).filter((t) => now - t < 3_600_000);
+    if (recent.length >= MAIL_TURNS_PER_HOUR) {
+        log?.warn?.(`ozaiya: [${account.accountId}] ${mails.length} new email(s) in ${mailbox.email} not announced: over ${MAIL_TURNS_PER_HOUR} new-mail turns this hour`);
+        return;
+    }
+    mailTurnTimes.set(account.accountId, [...recent, now]);
+    recordState(account.accountId, { lastInboundAt: now });
+    await getGroupKeyOrThrow(account, groupId);
+    const ch = getOzaiyaRuntime().channel;
+    const route = ch.routing.resolveAgentRoute({
+        cfg,
+        channel: "ozaiya",
+        accountId: account.accountId,
+        peer: { kind: "group", id: groupId },
+    });
+    const fromAddress = `ozaiya:group:${groupId}`;
+    const conversationLabel = `group:${groupId}`;
+    const storePath = ch.session.resolveStorePath(undefined, { agentId: route.agentId });
+    const notice = newMailNotice(mailbox, mails, config.replyWithoutAsking !== false);
+    const body = ch.reply.formatAgentEnvelope({
+        channel: "Ozaiya",
+        from: `Email to ${mailbox.email} (${conversationLabel})`,
+        timestamp: now,
+        previousTimestamp: ch.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey }),
+        envelope: ch.reply.resolveEnvelopeFormatOptions(cfg),
+        body: notice,
+    });
+    const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
+        Body: body,
+        BodyForAgent: notice,
+        RawBody: notice,
+        // Mail text never runs as a command.
+        CommandBody: "",
+        From: fromAddress,
+        To: fromAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "direct",
+        ConversationLabel: conversationLabel,
+        GroupSubject: groupId,
+        SenderId: "ozaiya-email",
+        SenderName: "Email",
+        Provider: "ozaiya",
+        Surface: "ozaiya",
+        MessageSid: `email-${mailbox.id}-${mails[mails.length - 1]?.uid ?? 0}-${now}`,
+        Timestamp: now,
+        MessageText: notice,
+        CommandAuthorized: false,
+        OriginatingChannel: "ozaiya",
+        OriginatingTo: fromAddress,
+    });
+    void ch.session.recordInboundSession({
+        storePath,
+        sessionKey: route.sessionKey,
+        ctx: msgCtx,
+        onRecordError: (err) => log?.warn?.(`ozaiya: failed recording new-mail session: ${String(err)}`),
+    }).catch((err) => log?.warn?.(`ozaiya: failed recording new-mail session: ${String(err)}`));
+    mailTurns.set(account.accountId, groupId);
+    try {
+        await ch.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: msgCtx,
+            cfg,
+            dispatcherOptions: {
+                deliver: async (replyPayload, _info) => {
+                    const replyText = replyPayload.text;
+                    if (!replyText?.trim())
+                        return;
+                    await sendEncryptedChatContent({ account, groupId, content: { text: replyText }, log });
+                },
+                onError: (err) => log?.warn?.(`ozaiya: new-mail turn error: ${String(err)}`),
+            },
+            replyOptions: account.model ? { isHeartbeat: true, heartbeatModelOverride: account.model } : undefined,
+        });
+    }
+    finally {
+        mailTurns.delete(account.accountId);
+    }
+}
+/**
+ * Start, restart or stop a bot's mailbox watch to match its email add-on (gateway mode). A reload
+ * that leaves the mailboxes and the owner's chat as they were keeps the running watch.
+ */
+function syncMailWatch(account, cfg, stateDir, log) {
+    const config = emailAddonOf(account);
+    const signature = config?.ownerGroupId ? JSON.stringify([config.accounts, config.ownerGroupId]) : "";
+    const running = mailWatches.get(account.accountId);
+    if (running?.signature === signature)
+        return;
+    stopMailWatch(account.accountId);
+    if (!signature)
+        return;
+    const botId = account.accountId;
+    const stop = watchMailboxes(account, {
+        stateDir,
+        log: { info: (msg) => log?.info?.(msg), warn: (msg) => log?.warn?.(msg) },
+        onNewMail: (mailbox, mails) => {
+            // One new-mail turn at a time per bot, with the bot's config as it is by then.
+            const next = (mailTurnQueues.get(botId) ?? Promise.resolve())
+                .then(() => handleNewMail(gatewayBotAccounts.get(botId) ?? account, cfg, log, mailbox, mails))
+                .catch((err) => log?.warn?.(`ozaiya: [${botId}] new-mail turn failed: ${String(err)}`));
+            mailTurnQueues.set(botId, next);
+            return next;
+        },
+    });
+    mailWatches.set(botId, { signature, stop });
+}
+function stopMailWatch(botId) {
+    mailWatches.get(botId)?.stop();
+    mailWatches.delete(botId);
+}
 function createMakePhoneCallTool(account, cfg) {
     return {
         label: "Make Phone Call",