@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/lifeops/service-mixin-gmail.js

@@ -0,0 +1,727 @@
+import crypto from "node:crypto";
+import {
+  accountIdForGrant,
+  googleSendEmailInput,
+  lifeOpsGmailMessageFromGoogle,
+  requireGoogleServiceMethod
+} from "./google-plugin-delegates.js";
+import { createLifeOpsGmailSyncState } from "./repository.js";
+import {
+  fail,
+  normalizeOptionalBoolean,
+  normalizeOptionalString,
+  requireNonEmptyString
+} from "./service-normalize.js";
+import {
+  normalizeOptionalConnectorMode,
+  normalizeOptionalConnectorSide
+} from "./service-normalize-connector.js";
+import {
+  buildFallbackGmailReplyDraftBody,
+  buildGmailReplyDraft,
+  normalizeGmailBulkOperation,
+  normalizeGmailDraftTone,
+  normalizeGmailReplyBody,
+  normalizeGmailSearchQuery,
+  normalizeGmailSpamReviewStatus,
+  normalizeGmailUnrespondedOlderThanDays,
+  normalizeOptionalGmailLabelIdArray,
+  normalizeOptionalMessageIdArray,
+  summarizeGmailBatchReplyDrafts,
+  summarizeGmailNeedsResponse,
+  summarizeGmailRecommendations,
+  summarizeGmailSearch,
+  summarizeGmailSpamReviewItems,
+  summarizeGmailTriage,
+  summarizeGmailUnresponded
+} from "./service-normalize-gmail.js";
+const GOOGLE_GMAIL_MAILBOX = "me";
+const DEFAULT_GMAIL_TRIAGE_MAX_RESULTS = 12;
+const DEFAULT_GMAIL_SEARCH_LIMIT = 25;
+function maxResults(value, fallback) {
+  return Math.max(
+    1,
+    Math.min(
+      100,
+      Number.isFinite(value) ? Math.trunc(value) : fallback
+    )
+  );
+}
+function bodyTextFromMessage(message) {
+  const record = message && typeof message === "object" ? message : {};
+  const bodyText = typeof record.bodyText === "string" ? record.bodyText : "";
+  const snippet = typeof record.snippet === "string" ? record.snippet : "";
+  return bodyText || snippet;
+}
+function externalMessageIdFromInput(messageId) {
+  const marker = ":gmail:";
+  const markerIndex = messageId.lastIndexOf(marker);
+  if (markerIndex >= 0) {
+    return messageId.slice(markerIndex + marker.length);
+  }
+  return messageId.startsWith("gmail:") ? messageId.slice("gmail:".length) : messageId;
+}
+function isDestructiveGmailOperation(operation) {
+  return operation === "trash" || operation === "delete" || operation === "report_spam";
+}
+function labelsAfterGmailManage(labels, operation, labelIds) {
+  const next = new Set(labels);
+  const add = (value) => next.add(value);
+  const remove = (value) => next.delete(value);
+  switch (operation) {
+    case "archive":
+      remove("INBOX");
+      break;
+    case "trash":
+      add("TRASH");
+      remove("INBOX");
+      break;
+    case "report_spam":
+      add("SPAM");
+      remove("INBOX");
+      break;
+    case "mark_read":
+      remove("UNREAD");
+      break;
+    case "mark_unread":
+      add("UNREAD");
+      break;
+    case "apply_label":
+      labelIds.forEach(add);
+      break;
+    case "remove_label":
+      labelIds.forEach(remove);
+      break;
+  }
+  return [...next];
+}
+function draftForMessage(message, args = {}) {
+  const bodyText = buildFallbackGmailReplyDraftBody({
+    message,
+    tone: args.tone ?? "neutral",
+    intent: args.intent,
+    includeQuotedOriginal: args.includeQuotedOriginal ?? false,
+    senderName: args.senderName ?? ""
+  });
+  return buildGmailReplyDraft({
+    message,
+    senderName: args.senderName ?? "",
+    sendAllowed: true,
+    bodyText
+  });
+}
+function withGmail(Base) {
+  const GmailBase = Base;
+  return class extends GmailBase {
+    async syncGmailMessages(args) {
+      const grant = await this.requireGoogleGmailGrant(
+        args.requestUrl,
+        args.mode,
+        args.side,
+        args.grantId
+      );
+      const searchMessages = requireGoogleServiceMethod(
+        this.runtime,
+        "searchMessages"
+      );
+      const syncedAt = (args.now ?? /* @__PURE__ */ new Date()).toISOString();
+      const googleMessages = await searchMessages({
+        accountId: accountIdForGrant(grant),
+        query: args.query,
+        limit: args.maxResults
+      });
+      const messages = googleMessages.map(
+        (message) => lifeOpsGmailMessageFromGoogle({
+          message,
+          grant,
+          agentId: this.agentId(),
+          syncedAt
+        })
+      );
+      for (const message of messages) {
+        await this.repository.upsertGmailMessage(message, grant.side);
+      }
+      await this.repository.upsertGmailSyncState(
+        createLifeOpsGmailSyncState({
+          agentId: this.agentId(),
+          provider: "google",
+          side: grant.side,
+          mailbox: GOOGLE_GMAIL_MAILBOX,
+          grantId: grant.id,
+          maxResults: args.maxResults,
+          syncedAt
+        })
+      );
+      return { grant, query: args.query, messages, syncedAt };
+    }
+    async getGmailTriage(requestUrl, request = {}, now = /* @__PURE__ */ new Date()) {
+      const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+      const side = normalizeOptionalConnectorSide(request.side, "side");
+      const limit = maxResults(
+        request.maxResults,
+        DEFAULT_GMAIL_TRIAGE_MAX_RESULTS
+      );
+      const synced = await this.syncGmailMessages({
+        requestUrl,
+        mode,
+        side,
+        grantId: request.grantId,
+        query: "in:inbox newer_than:30d",
+        maxResults: limit,
+        now
+      });
+      return {
+        messages: synced.messages,
+        source: "synced",
+        syncedAt: synced.syncedAt,
+        summary: summarizeGmailTriage(synced.messages)
+      };
+    }
+    async getGmailSearch(requestUrl, request, now = /* @__PURE__ */ new Date()) {
+      const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+      const side = normalizeOptionalConnectorSide(request.side, "side");
+      const query = normalizeGmailSearchQuery(request.query);
+      const limit = maxResults(request.maxResults, DEFAULT_GMAIL_SEARCH_LIMIT);
+      const synced = await this.syncGmailMessages({
+        requestUrl,
+        mode,
+        side,
+        grantId: request.grantId,
+        query: request.includeSpamTrash ? `${query} in:anywhere` : query,
+        maxResults: limit,
+        now
+      });
+      const messages = request.replyNeededOnly ? synced.messages.filter((message) => message.likelyReplyNeeded) : synced.messages;
+      return {
+        query,
+        messages,
+        source: "synced",
+        syncedAt: synced.syncedAt,
+        summary: summarizeGmailSearch(messages)
+      };
+    }
+    async readGmailMessage(requestUrl, request, now = /* @__PURE__ */ new Date()) {
+      const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+      const side = normalizeOptionalConnectorSide(request.side, "side");
+      const grant = await this.requireGoogleGmailGrant(
+        requestUrl,
+        mode,
+        side,
+        request.grantId
+      );
+      const getMessage = requireGoogleServiceMethod(this.runtime, "getMessage");
+      let messageId = normalizeOptionalString(request.messageId);
+      if (messageId) {
+        messageId = externalMessageIdFromInput(messageId);
+      }
+      let query = null;
+      if (!messageId) {
+        query = normalizeGmailSearchQuery(
+          request.query ?? "in:inbox newer_than:30d"
+        );
+        const search = await this.getGmailSearch(
+          requestUrl,
+          {
+            mode,
+            side,
+            grantId: request.grantId,
+            query,
+            maxResults: 1
+          },
+          now
+        );
+        messageId = search.messages[0]?.externalId ?? null;
+      }
+      if (!messageId) {
+        fail(404, "No Gmail message matched the request.");
+      }
+      const googleMessage = await getMessage({
+        accountId: accountIdForGrant(grant),
+        messageId,
+        includeBody: true
+      });
+      const syncedAt = now.toISOString();
+      const message = lifeOpsGmailMessageFromGoogle({
+        message: googleMessage,
+        grant,
+        agentId: this.agentId(),
+        syncedAt
+      });
+      await this.repository.upsertGmailMessage(message, grant.side);
+      return {
+        query,
+        message,
+        bodyText: bodyTextFromMessage(googleMessage),
+        source: "synced",
+        syncedAt
+      };
+    }
+    async getGmailNeedsResponse(requestUrl, request = {}, now = /* @__PURE__ */ new Date()) {
+      const triage = await this.getGmailTriage(requestUrl, request, now);
+      const messages = triage.messages.filter(
+        (message) => message.likelyReplyNeeded
+      );
+      return {
+        messages,
+        source: "synced",
+        syncedAt: triage.syncedAt,
+        summary: summarizeGmailNeedsResponse(messages)
+      };
+    }
+    async getGmailRecommendations(requestUrl, request = {}, now = /* @__PURE__ */ new Date()) {
+      const triage = await this.getGmailTriage(
+        requestUrl,
+        {
+          side: request.side,
+          mode: request.mode,
+          grantId: request.grantId,
+          forceSync: request.forceSync,
+          maxResults: request.maxResults
+        },
+        now
+      );
+      return {
+        recommendations: [],
+        messages: triage.messages,
+        source: "synced",
+        syncedAt: triage.syncedAt,
+        summary: summarizeGmailRecommendations([])
+      };
+    }
+    async getGmailSpamReviewItems(_requestUrl, request = {}) {
+      const side = normalizeOptionalConnectorSide(request.side, "side");
+      const status = request.status ? normalizeGmailSpamReviewStatus(request.status) : void 0;
+      const items = await this.repository.listGmailSpamReviewItems(
+        this.agentId(),
+        "google",
+        {
+          status,
+          maxResults: maxResults(request.maxResults, 100),
+          grantId: request.grantId
+        },
+        side
+      );
+      return { items, summary: summarizeGmailSpamReviewItems(items) };
+    }
+    async updateGmailSpamReviewItem(_requestUrl, itemId, request, now = /* @__PURE__ */ new Date()) {
+      const status = normalizeGmailSpamReviewStatus(request.status);
+      await this.repository.updateGmailSpamReviewItemStatus(
+        this.agentId(),
+        "google",
+        requireNonEmptyString(itemId, "itemId"),
+        status,
+        status === "pending" ? null : now.toISOString(),
+        now.toISOString()
+      );
+      const item = await this.repository.getGmailSpamReviewItem(
+        this.agentId(),
+        "google",
+        itemId
+      );
+      if (!item) {
+        fail(404, "Gmail spam review item not found.");
+      }
+      return { item };
+    }
+    async getGmailUnresponded(requestUrl, request = {}, now = /* @__PURE__ */ new Date()) {
+      const olderThanDays = normalizeGmailUnrespondedOlderThanDays(
+        request.olderThanDays
+      );
+      const query = `in:sent older_than:${olderThanDays}d`;
+      const synced = await this.syncGmailMessages({
+        requestUrl,
+        mode: normalizeOptionalConnectorMode(request.mode, "mode"),
+        side: normalizeOptionalConnectorSide(request.side, "side"),
+        grantId: request.grantId,
+        query,
+        maxResults: maxResults(request.maxResults, 25),
+        now
+      });
+      const threads = synced.messages.map((message) => ({
+        threadId: message.threadId,
+        messageId: message.id,
+        subject: message.subject,
+        to: message.to,
+        cc: message.cc,
+        lastOutboundAt: message.receivedAt,
+        lastInboundAt: null,
+        daysWaiting: Math.max(
+          olderThanDays,
+          Math.floor(
+            (now.getTime() - Date.parse(message.receivedAt)) / 864e5
+          )
+        ),
+        snippet: message.snippet,
+        labels: message.labels,
+        htmlLink: message.htmlLink,
+        grantId: message.grantId,
+        accountEmail: message.accountEmail
+      }));
+      return {
+        threads,
+        source: "synced",
+        syncedAt: synced.syncedAt,
+        summary: summarizeGmailUnresponded(threads)
+      };
+    }
+    async manageGmailMessages(requestUrl, request) {
+      const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+      const side = normalizeOptionalConnectorSide(request.side, "side");
+      const grantId = normalizeOptionalString(request.grantId);
+      const operation = normalizeGmailBulkOperation(request.operation);
+      const messageIds = normalizeOptionalMessageIdArray(request.messageIds, "messageIds") ?? [];
+      const query = request.query === void 0 || request.query === null ? null : normalizeGmailSearchQuery(request.query);
+      const labelIds = normalizeOptionalGmailLabelIdArray(request.labelIds, "labelIds") ?? [];
+      const destructive = isDestructiveGmailOperation(operation);
+      const confirmDestructive = normalizeOptionalBoolean(
+        request.confirmDestructive,
+        "confirmDestructive"
+      ) ?? false;
+      if (destructive && !confirmDestructive) {
+        fail(409, `${operation} requires explicit destructive confirmation.`);
+      }
+      if ((operation === "apply_label" || operation === "remove_label") && labelIds.length === 0) {
+        fail(400, `${operation} requires at least one Gmail label id.`);
+      }
+      if (messageIds.length === 0 && !query) {
+        fail(400, "Gmail management requires messageIds or query.");
+      }
+      const grant = await this.requireGoogleGmailGrant(
+        requestUrl,
+        mode,
+        side,
+        grantId
+      );
+      if (!grant.capabilities.includes("google.gmail.manage")) {
+        fail(
+          403,
+          "Gmail management access has not been granted. Reconnect Google through @elizaos/plugin-google with Gmail manage scope."
+        );
+      }
+      const max = maxResults(request.maxResults, DEFAULT_GMAIL_SEARCH_LIMIT);
+      const messages = messageIds.length > 0 ? await Promise.all(
+        messageIds.map(async (messageId) => {
+          const cached = await this.repository.getGmailMessage(
+            this.agentId(),
+            "google",
+            messageId,
+            grant.side,
+            grant.id
+          );
+          if (cached) {
+            return cached;
+          }
+          const externalId = externalMessageIdFromInput(messageId);
+          return {
+            id: messageId,
+            externalId,
+            agentId: this.agentId(),
+            provider: "google",
+            side: grant.side,
+            threadId: externalId,
+            subject: "",
+            from: "",
+            fromEmail: null,
+            replyTo: null,
+            to: [],
+            cc: [],
+            snippet: "",
+            receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            isUnread: false,
+            isImportant: false,
+            likelyReplyNeeded: false,
+            triageScore: 0,
+            triageReason: "",
+            labels: [],
+            htmlLink: null,
+            metadata: {},
+            syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            connectorAccountId: grant.connectorAccountId ?? void 0,
+            grantId: grant.id,
+            accountEmail: grant.identityEmail ?? void 0
+          };
+        })
+      ) : (await this.getGmailSearch(requestUrl, {
+        mode,
+        side,
+        grantId: grant.id,
+        // Guaranteed non-empty here: the guard above fails the request
+        // when there are no messageIds and no query, and this branch is
+        // the no-messageIds path. The `?? ""` only satisfies the type.
+        query: query ?? "",
+        maxResults: max,
+        includeSpamTrash: true
+      })).messages;
+      if (messages.length === 0) {
+        fail(404, "No Gmail messages matched the requested operation.");
+      }
+      const executionMode = request.executionMode ?? "execute";
+      const status = executionMode === "proposal" ? "proposed" : executionMode === "dry_run" ? "dry_run" : "executed";
+      if (executionMode === "execute") {
+        const modifyGmailMessages = requireGoogleServiceMethod(
+          this.runtime,
+          "modifyGmailMessages"
+        );
+        await modifyGmailMessages({
+          accountId: accountIdForGrant(grant),
+          messageIds: messages.map((message) => message.externalId),
+          operation,
+          labelIds
+        });
+        if (operation === "delete") {
+          await this.repository.deleteGmailMessages(
+            this.agentId(),
+            "google",
+            messages.map((message) => message.id),
+            grant.side,
+            grant.id
+          );
+        } else {
+          for (const message of messages) {
+            const labels = labelsAfterGmailManage(
+              message.labels,
+              operation,
+              labelIds
+            );
+            await this.repository.upsertGmailMessage(
+              {
+                ...message,
+                labels,
+                isUnread: labels.includes("UNREAD"),
+                updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              grant.side
+            );
+          }
+        }
+      }
+      await this.recordConnectorAudit(
+        grant.id,
+        "gmail messages managed through plugin-google",
+        {
+          operation,
+          query,
+          messageIds: messages.map((message) => message.id),
+          labelIds,
+          executionMode
+        },
+        {
+          affectedCount: messages.length,
+          destructive,
+          connectorAccountId: grant.connectorAccountId ?? null
+        }
+      );
+      return {
+        ok: true,
+        operation,
+        messageIds: messages.map((message) => message.id),
+        affectedCount: messages.length,
+        labelIds,
+        destructive,
+        grantId: grant.id,
+        accountEmail: grant.identityEmail ?? void 0,
+        executionMode,
+        status,
+        reason: request.reason,
+        approval: request.approval,
+        plan: request.plan,
+        selectedMessageSnapshots: request.selectedMessageSnapshots,
+        chunk: request.chunk ? {
+          chunkId: request.chunk.chunkId,
+          chunkIndex: request.chunk.chunkIndex,
+          chunkCount: request.chunk.chunkCount,
+          processedCount: messages.length,
+          remainingCount: 0,
+          nextCursor: null
+        } : void 0,
+        audit: request.audit ? {
+          auditEventId: request.audit.auditEventId ?? null,
+          auditRef: request.audit.auditRef ?? null,
+          actor: request.audit.actor ?? "user",
+          recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+        } : void 0,
+        undo: request.undo ? {
+          status: "not_available",
+          undoId: request.undo.undoId,
+          undoExpiresAt: null,
+          auditEventId: request.undo.auditEventId ?? null,
+          messageIds: messages.map((message) => message.id)
+        } : void 0
+      };
+    }
+    async ingestGmailEvent(requestUrl, request, now = /* @__PURE__ */ new Date()) {
+      const read = await this.readGmailMessage(
+        requestUrl,
+        {
+          mode: request.mode,
+          side: request.side,
+          grantId: request.grantId,
+          messageId: request.messageId
+        },
+        now
+      );
+      return {
+        ok: true,
+        event: {
+          id: crypto.randomUUID(),
+          kind: request.eventKind ?? "gmail.message.received",
+          occurredAt: request.occurredAt ?? now.toISOString(),
+          payload: {
+            messageId: read.message.id,
+            externalMessageId: read.message.externalId,
+            threadId: read.message.threadId,
+            subject: read.message.subject,
+            from: read.message.from
+          }
+        },
+        workflowRunIds: []
+      };
+    }
+    async createGmailReplyDraft(requestUrl, request) {
+      const tone = normalizeGmailDraftTone(request.tone);
+      const intent = normalizeOptionalString(request.intent);
+      const includeQuotedOriginal = normalizeOptionalBoolean(
+        request.includeQuotedOriginal,
+        "includeQuotedOriginal"
+      ) ?? false;
+      const read = await this.readGmailMessage(requestUrl, {
+        mode: request.mode,
+        side: request.side,
+        grantId: request.grantId,
+        messageId: request.messageId
+      });
+      return draftForMessage(read.message, {
+        tone,
+        intent,
+        includeQuotedOriginal
+      });
+    }
+    async createGmailBatchReplyDrafts(requestUrl, request, now = /* @__PURE__ */ new Date()) {
+      const messages = request.messageIds?.length ? await Promise.all(
+        request.messageIds.map(
+          async (messageId) => (await this.readGmailMessage(
+            requestUrl,
+            {
+              mode: request.mode,
+              side: request.side,
+              grantId: request.grantId,
+              messageId
+            },
+            now
+          )).message
+        )
+      ) : (await this.getGmailSearch(
+        requestUrl,
+        {
+          mode: request.mode,
+          side: request.side,
+          grantId: request.grantId,
+          query: request.query ?? "in:inbox newer_than:30d",
+          maxResults: request.maxResults,
+          replyNeededOnly: request.replyNeededOnly
+        },
+        now
+      )).messages;
+      const tone = normalizeGmailDraftTone(request.tone);
+      const intent = normalizeOptionalString(request.intent);
+      const includeQuotedOriginal = normalizeOptionalBoolean(
+        request.includeQuotedOriginal,
+        "includeQuotedOriginal"
+      ) ?? false;
+      const drafts = messages.map(
+        (message) => draftForMessage(message, {
+          tone,
+          intent,
+          includeQuotedOriginal
+        })
+      );
+      return {
+        query: request.query ?? null,
+        messages,
+        drafts,
+        source: "synced",
+        syncedAt: now.toISOString(),
+        summary: summarizeGmailBatchReplyDrafts(drafts)
+      };
+    }
+    async sendGmailReply(requestUrl, request) {
+      const confirmed = normalizeOptionalBoolean(request.confirmSend, "confirmSend") ?? false;
+      if (!confirmed) {
+        fail(409, "Gmail reply send requires confirmSend=true.");
+      }
+      const read = await this.readGmailMessage(requestUrl, {
+        mode: request.mode,
+        side: request.side,
+        grantId: request.grantId,
+        messageId: request.messageId
+      });
+      const grant = await this.requireGoogleGmailSendGrant(
+        requestUrl,
+        request.mode,
+        request.side,
+        request.grantId
+      );
+      const sendEmail = requireGoogleServiceMethod(this.runtime, "sendEmail");
+      await sendEmail(
+        googleSendEmailInput({
+          accountId: accountIdForGrant(grant),
+          to: request.to?.length ? request.to : read.message.fromEmail ? [read.message.fromEmail] : [],
+          cc: request.cc,
+          subject: request.subject ?? `Re: ${read.message.subject.replace(/^Re:\\s*/i, "")}`,
+          bodyText: normalizeGmailReplyBody(request.bodyText),
+          threadId: read.message.threadId
+        })
+      );
+      return { ok: true };
+    }
+    async sendGmailMessage(requestUrl, request) {
+      const confirmed = normalizeOptionalBoolean(request.confirmSend, "confirmSend") ?? false;
+      if (!confirmed) {
+        fail(409, "Gmail message send requires confirmSend=true.");
+      }
+      const grant = await this.requireGoogleGmailSendGrant(
+        requestUrl,
+        request.mode,
+        request.side,
+        request.grantId
+      );
+      const sendEmail = requireGoogleServiceMethod(this.runtime, "sendEmail");
+      await sendEmail(
+        googleSendEmailInput({
+          accountId: accountIdForGrant(grant),
+          to: request.to,
+          cc: request.cc,
+          bcc: request.bcc,
+          subject: requireNonEmptyString(request.subject, "subject"),
+          bodyText: normalizeGmailReplyBody(request.bodyText)
+        })
+      );
+      return { ok: true };
+    }
+    async sendGmailReplies(requestUrl, request) {
+      const confirmed = normalizeOptionalBoolean(request.confirmSend, "confirmSend") ?? false;
+      if (!confirmed) {
+        fail(409, "Batch Gmail reply send requires confirmSend=true.");
+      }
+      for (const item of request.items) {
+        await this.sendGmailReply(requestUrl, {
+          mode: request.mode,
+          side: request.side,
+          grantId: request.grantId,
+          messageId: item.messageId,
+          bodyText: item.bodyText,
+          subject: item.subject,
+          to: item.to,
+          cc: item.cc,
+          confirmSend: true
+        });
+      }
+      return { ok: true, sentCount: request.items.length };
+    }
+  };
+}
+export {
+  withGmail
+};
+//# sourceMappingURL=service-mixin-gmail.js.map