@elizaos/plugin-inbox 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/inbox/gmail-normalize.js

@@ -0,0 +1,937 @@
+import crypto from "node:crypto";
+import {
+  fail,
+  GOOGLE_CALENDAR_CACHE_TTL_MS,
+  GOOGLE_GMAIL_CACHE_TTL_MS,
+  LIFEOPS_GMAIL_BULK_OPERATIONS,
+  LIFEOPS_GMAIL_DRAFT_TONES,
+  LIFEOPS_GMAIL_SPAM_REVIEW_STATUSES,
+  normalizeEnumValue,
+  normalizeFiniteNumber,
+  normalizeOptionalString,
+  requireNonEmptyString
+} from "@elizaos/shared";
+function normalizeGmailSearchQuery(value) {
+  const query = requireNonEmptyString(value, "query");
+  if (query.length > 500) {
+    fail(400, "query must be 500 characters or fewer");
+  }
+  return query;
+}
+function normalizeGmailBulkOperation(value) {
+  return normalizeEnumValue(value, "operation", LIFEOPS_GMAIL_BULK_OPERATIONS);
+}
+function normalizeGmailUnrespondedOlderThanDays(value) {
+  if (value === void 0 || value === null || value === "") {
+    return 3;
+  }
+  const days = Math.trunc(normalizeFiniteNumber(value, "olderThanDays"));
+  if (days < 1 || days > 3650) {
+    fail(400, "olderThanDays must be between 1 and 3650");
+  }
+  return days;
+}
+function parseGmailRelativeDuration(value) {
+  const match = value.trim().toLowerCase().match(/^(\d+)([dmy])$/);
+  if (!match) {
+    return null;
+  }
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return null;
+  }
+  const unit = match[2];
+  const days = unit === "d" ? amount : unit === "m" ? amount * 30 : amount * 365;
+  return days * 24 * 60 * 60 * 1e3;
+}
+function parseGmailDateBoundary(value) {
+  const normalized = value.trim().replace(/\//g, "-");
+  const match = normalized.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+  if (!match) {
+    return null;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day) || month < 1 || month > 12 || day < 1 || day > 31) {
+    return null;
+  }
+  return Date.UTC(year, month - 1, day, 0, 0, 0, 0);
+}
+function splitMailboxLikeList(value) {
+  const parts = [];
+  let current = "";
+  let inQuotes = false;
+  let angleDepth = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    const next = value[index + 1];
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (!inQuotes && char === "<") {
+      angleDepth += 1;
+      current += char;
+      continue;
+    }
+    if (!inQuotes && char === ">") {
+      angleDepth = Math.max(0, angleDepth - 1);
+      current += char;
+      continue;
+    }
+    if (!inQuotes && angleDepth === 0 && char === "|" && next === "|") {
+      const trimmed2 = current.trim();
+      if (trimmed2.length > 0) {
+        parts.push(trimmed2);
+      }
+      current = "";
+      index += 1;
+      continue;
+    }
+    if (!inQuotes && angleDepth === 0 && (char === "," || char === ";" || char === "\n")) {
+      const trimmed2 = current.trim();
+      if (trimmed2.length > 0) {
+        parts.push(trimmed2);
+      }
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  const trimmed = current.trim();
+  if (trimmed.length > 0) {
+    parts.push(trimmed);
+  }
+  return parts;
+}
+function extractNormalizedEmailAddress(value) {
+  const trimmed = value.trim().replace(/^mailto:/i, "");
+  if (!trimmed) {
+    return null;
+  }
+  const angleMatch = trimmed.match(/<\s*([^<>\s@]+@[^<>\s@]+)\s*>/u);
+  const rawCandidate = angleMatch?.[1] ?? trimmed.match(/([^\s<>()"';,]+@[^\s<>()"';,]+)/u)?.[1] ?? trimmed;
+  const normalized = rawCandidate.trim().replace(/^["']+|["']+$/g, "").replace(/[>;,\s]+$/g, "").toLowerCase();
+  return /^[^@\s]+@[^@\s]+\.[^@\s]+$/u.test(normalized) ? normalized : null;
+}
+function normalizeOptionalMessageIdArray(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    fail(400, `${field} must be an array`);
+  }
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of value.entries()) {
+    const item = requireNonEmptyString(candidate, `${field}[${index}]`);
+    if (seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    items.push(item);
+  }
+  if (items.length > 50) {
+    fail(400, `${field} must contain 50 items or fewer`);
+  }
+  return items;
+}
+function normalizeOptionalGmailLabelIdArray(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    fail(400, `${field} must be an array`);
+  }
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of value.entries()) {
+    const item = requireNonEmptyString(candidate, `${field}[${index}]`);
+    if (item.length > 128) {
+      fail(400, `${field}[${index}] must be 128 characters or fewer`);
+    }
+    if (!/^[A-Za-z0-9_:-]+$/.test(item)) {
+      fail(400, `${field}[${index}] is not a valid Gmail label id`);
+    }
+    if (seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    items.push(item);
+  }
+  if (items.length > 20) {
+    fail(400, `${field} must contain 20 items or fewer`);
+  }
+  return items;
+}
+function normalizeGmailSearchQueryMatches(query, message) {
+  const all = [
+    message.subject,
+    message.from,
+    message.fromEmail ?? "",
+    message.replyTo ?? "",
+    message.snippet,
+    ...message.to,
+    ...message.cc,
+    ...message.labels
+  ].join(" ").toLowerCase();
+  const sender = [message.from, message.fromEmail ?? "", message.replyTo ?? ""].join(" ").toLowerCase();
+  const subject = message.subject.toLowerCase();
+  const to = message.to.join(" ").toLowerCase();
+  const cc = message.cc.join(" ").toLowerCase();
+  const labels = message.labels.join(" ").toLowerCase();
+  const receivedAtMs = Date.parse(message.receivedAt);
+  const nowMs = Date.now();
+  const tokens = [];
+  let current = "";
+  let inQuotes = false;
+  let braceDepth = 0;
+  for (const char of query.trim()) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (!inQuotes && char === "{") {
+      braceDepth += 1;
+      current += char;
+      continue;
+    }
+    if (!inQuotes && char === "}") {
+      braceDepth = Math.max(0, braceDepth - 1);
+      current += char;
+      continue;
+    }
+    if (!inQuotes && braceDepth === 0 && /\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  if (tokens.length === 0) {
+    return false;
+  }
+  const matchesToken = (token) => {
+    const normalizedToken = token.trim();
+    if (normalizedToken.length === 0) {
+      return true;
+    }
+    const isNegated = normalizedToken.startsWith("-");
+    const tokenBody = isNegated ? normalizedToken.slice(1).trim() : normalizedToken;
+    if (!tokenBody) {
+      return true;
+    }
+    if (tokenBody.startsWith("{") && tokenBody.endsWith("}")) {
+      const groupMembers = tokenBody.slice(1, -1).trim().split(/\s+/).map((entry) => entry.trim()).filter(Boolean);
+      if (groupMembers.length === 0) {
+        return true;
+      }
+      const groupMatched = groupMembers.some((entry) => matchesToken(entry));
+      return isNegated ? !groupMatched : groupMatched;
+    }
+    const operatorMatch = tokenBody.match(/^([a-z_]+):(.*)$/i);
+    const rawValue = operatorMatch?.[2] ?? tokenBody;
+    const value = rawValue.replace(/^"|"$/g, "").trim().toLowerCase();
+    if (value.length === 0) {
+      return true;
+    }
+    const labelTokens = message.labels.map((label) => label.toLowerCase());
+    const hasAttachment = typeof message.metadata.hasAttachments === "boolean" ? message.metadata.hasAttachments === true : /\battach(?:ed|ment|ments)?\b/i.test(
+      `${message.subject} ${message.snippet}`
+    );
+    const matched = (() => {
+      if (!operatorMatch) {
+        return all.includes(value);
+      }
+      const operator = (operatorMatch[1] ?? "").toLowerCase();
+      switch (operator) {
+        case "from":
+          if (value === "me") {
+            return labelTokens.includes("sent");
+          }
+          return sender.includes(value);
+        case "subject":
+          return subject.includes(value);
+        case "to":
+          return to.includes(value);
+        case "cc":
+          return cc.includes(value);
+        case "label":
+        case "labels":
+          return labels.includes(value);
+        case "category":
+          return labelTokens.includes(`category_${value}`);
+        case "in":
+          return value === "anywhere" ? true : labelTokens.includes(value);
+        case "has":
+          return value === "attachment" ? hasAttachment : all.includes(value);
+        case "is":
+          if (value === "unread") {
+            return message.isUnread;
+          }
+          if (value === "read") {
+            return !message.isUnread;
+          }
+          if (value === "important") {
+            return message.isImportant;
+          }
+          if (value === "starred") {
+            return labelTokens.includes("starred");
+          }
+          return all.includes(value);
+        case "newer_than": {
+          const relativeMs = parseGmailRelativeDuration(value);
+          return relativeMs === null ? all.includes(value) : receivedAtMs >= nowMs - relativeMs;
+        }
+        case "older_than": {
+          const relativeMs = parseGmailRelativeDuration(value);
+          return relativeMs === null ? all.includes(value) : receivedAtMs <= nowMs - relativeMs;
+        }
+        case "after": {
+          const boundary = parseGmailDateBoundary(value);
+          return boundary === null ? all.includes(value) : receivedAtMs >= boundary;
+        }
+        case "before": {
+          const boundary = parseGmailDateBoundary(value);
+          return boundary === null ? all.includes(value) : receivedAtMs < boundary;
+        }
+        default:
+          return all.includes(value);
+      }
+    })();
+    return isNegated ? !matched : matched;
+  };
+  return tokens.every((token) => {
+    const normalizedToken = token.trim();
+    if (normalizedToken.length === 0) {
+      return true;
+    }
+    const operatorMatch = normalizedToken.match(/^([a-z_]+):(.*)$/i);
+    const operator = operatorMatch?.[1]?.toLowerCase();
+    const operatorValue = operatorMatch?.[2];
+    if (operator === "or" && operatorValue) {
+      return matchesToken(operatorValue);
+    }
+    return matchesToken(normalizedToken);
+  });
+}
+function filterGmailMessagesBySearch(args) {
+  const query = normalizeOptionalString(args.query);
+  const filtered = query ? args.messages.filter(
+    (message) => normalizeGmailSearchQueryMatches(query, message)
+  ) : args.messages;
+  const replyNeededOnly = args.replyNeededOnly === true;
+  return filtered.filter((message) => !replyNeededOnly || message.likelyReplyNeeded).sort(compareGmailMessagePriority);
+}
+function compareGmailMessagePriority(left, right) {
+  if (left.isImportant !== right.isImportant) {
+    return right.isImportant ? 1 : -1;
+  }
+  if (left.likelyReplyNeeded !== right.likelyReplyNeeded) {
+    return right.likelyReplyNeeded ? 1 : -1;
+  }
+  if (left.isUnread !== right.isUnread) {
+    return right.isUnread ? 1 : -1;
+  }
+  return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
+}
+function normalizeGmailDraftTone(value) {
+  return normalizeEnumValue(
+    value ?? "neutral",
+    "tone",
+    LIFEOPS_GMAIL_DRAFT_TONES
+  );
+}
+function normalizeOptionalStringArray(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const rawValues = Array.isArray(value) ? value : typeof value === "string" ? splitMailboxLikeList(value) : fail(400, `${field} must be an array or string`);
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of rawValues.entries()) {
+    const source = requireNonEmptyString(candidate, `${field}[${index}]`);
+    const item = extractNormalizedEmailAddress(source);
+    if (!item) {
+      fail(400, `${field}[${index}] must be a valid email address`);
+    }
+    if (seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    items.push(item);
+  }
+  return items;
+}
+function normalizeGmailReplyBody(value) {
+  const body = requireNonEmptyString(value, "bodyText");
+  if (body.length > 8e3) {
+    fail(400, "bodyText must be 8000 characters or fewer");
+  }
+  return body;
+}
+function summarizeGmailSearch(messages) {
+  return {
+    totalCount: messages.length,
+    unreadCount: messages.filter((message) => message.isUnread).length,
+    importantCount: messages.filter((message) => message.isImportant).length,
+    replyNeededCount: messages.filter((message) => message.likelyReplyNeeded).length
+  };
+}
+function summarizeGmailBatchReplyDrafts(drafts) {
+  return {
+    totalCount: drafts.length,
+    sendAllowedCount: drafts.filter((draft) => draft.sendAllowed).length,
+    requiresConfirmationCount: drafts.filter(
+      (draft) => draft.requiresConfirmation
+    ).length
+  };
+}
+function collectCalendarEventContactEmails(event) {
+  const emails = /* @__PURE__ */ new Set();
+  const organizerEmail = typeof event.organizer?.email === "string" ? event.organizer.email.trim().toLowerCase() : "";
+  if (organizerEmail) {
+    emails.add(organizerEmail);
+  }
+  for (const attendee of event.attendees) {
+    const email = attendee.email?.trim().toLowerCase() || "";
+    if (email) {
+      emails.add(email);
+    }
+  }
+  return emails;
+}
+function extractSubjectTokens(subject) {
+  return subject.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 4);
+}
+function findLinkedMailForCalendarEvent(event, messages) {
+  const relatedEmails = collectCalendarEventContactEmails(event);
+  const subjectTokens = new Set(extractSubjectTokens(event.title));
+  return messages.filter((message) => {
+    if (message.fromEmail && relatedEmails.has(message.fromEmail.toLowerCase())) {
+      return true;
+    }
+    if (message.to.some(
+      (entry) => relatedEmails.has(entry.trim().toLowerCase())
+    ) || message.cc.some(
+      (entry) => relatedEmails.has(entry.trim().toLowerCase())
+    )) {
+      return true;
+    }
+    const messageTokens = extractSubjectTokens(message.subject);
+    return messageTokens.some((token) => subjectTokens.has(token));
+  }).sort((left, right) => {
+    const receivedDelta = Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
+    if (receivedDelta !== 0) {
+      return receivedDelta;
+    }
+    return compareGmailMessagePriority(left, right);
+  }).slice(0, 3);
+}
+function isGmailSyncStateFresh(args) {
+  const syncedAtMs = Date.parse(args.syncedAt);
+  if (!Number.isFinite(syncedAtMs)) {
+    return false;
+  }
+  if (args.now.getTime() - syncedAtMs > GOOGLE_GMAIL_CACHE_TTL_MS) {
+    return false;
+  }
+  return args.maxResults >= args.requestedMaxResults;
+}
+function summarizeGmailTriage(messages) {
+  return {
+    unreadCount: messages.filter((message) => message.isUnread).length,
+    importantNewCount: messages.filter(
+      (message) => message.isUnread && message.isImportant
+    ).length,
+    likelyReplyNeededCount: messages.filter(
+      (message) => message.likelyReplyNeeded
+    ).length
+  };
+}
+function summarizeGmailNeedsResponse(messages) {
+  return {
+    totalCount: messages.length,
+    unreadCount: messages.filter((message) => message.isUnread).length,
+    importantCount: messages.filter((message) => message.isImportant).length
+  };
+}
+function summarizeGmailUnresponded(threads) {
+  return {
+    totalCount: threads.length,
+    oldestDaysWaiting: threads.length > 0 ? Math.max(...threads.map((thread) => thread.daysWaiting)) : null
+  };
+}
+function recommendationMessage(message) {
+  return {
+    messageId: message.id,
+    subject: message.subject,
+    from: message.from,
+    fromEmail: message.fromEmail,
+    receivedAt: message.receivedAt,
+    snippet: message.snippet,
+    labels: message.labels
+  };
+}
+function hasGmailLabel(message, labelId) {
+  const normalized = labelId.trim().toUpperCase();
+  return message.labels.some(
+    (label) => label.trim().toUpperCase() === normalized
+  );
+}
+function isGmailSpamReviewCandidate(message) {
+  const metadata = message.metadata;
+  const metadataClassification = typeof metadata.spamClassification === "string" ? metadata.spamClassification.trim().toLowerCase() : "";
+  const metadataThreat = typeof metadata.threatCategory === "string" ? metadata.threatCategory.trim().toLowerCase() : "";
+  const triageReason = message.triageReason.trim().toLowerCase();
+  return hasGmailLabel(message, "SPAM") || hasGmailLabel(message, "PHISHING") || metadata.spam === true || metadata.phishing === true || metadataClassification === "spam" || metadataClassification === "phishing" || metadataThreat === "phishing" || /\b(?:spam|phish(?:ing)?)\b/.test(triageReason);
+}
+function buildGmailSpamReviewItem(args) {
+  const message = args.message;
+  const isPhishing = hasGmailLabel(message, "PHISHING") || message.metadata.phishing === true || message.metadata.spamClassification === "phishing" || message.metadata.threatCategory === "phishing" || /\bphish(?:ing)?\b/i.test(message.triageReason);
+  const isGmailSpam = hasGmailLabel(message, "SPAM");
+  const rationale = isPhishing ? "Gmail or upstream triage flagged this message as a phishing candidate; review it before reporting spam." : isGmailSpam ? "Gmail labels this message as spam; review it before reporting or deleting." : "LifeOps classified this Gmail message as a spam candidate; review it before reporting spam.";
+  const confidence = isGmailSpam ? 0.92 : isPhishing ? 0.88 : 0.76;
+  return {
+    id: createGmailSpamReviewItemId(
+      message.agentId,
+      message.provider,
+      message.side,
+      args.grantId,
+      message.externalId
+    ),
+    agentId: message.agentId,
+    provider: message.provider,
+    side: message.side,
+    grantId: args.grantId,
+    accountEmail: args.accountEmail,
+    messageId: message.id,
+    externalMessageId: message.externalId,
+    threadId: message.threadId,
+    subject: message.subject,
+    from: message.from,
+    fromEmail: message.fromEmail,
+    receivedAt: message.receivedAt,
+    snippet: message.snippet,
+    labels: message.labels,
+    rationale,
+    confidence,
+    status: "pending",
+    createdAt: args.now,
+    updatedAt: args.now,
+    reviewedAt: null
+  };
+}
+function normalizeGmailSpamReviewStatus(value, field = "status") {
+  return normalizeEnumValue(value, field, LIFEOPS_GMAIL_SPAM_REVIEW_STATUSES);
+}
+function summarizeGmailSpamReviewItems(items) {
+  return {
+    totalCount: items.length,
+    pendingCount: items.filter((item) => item.status === "pending").length,
+    confirmedSpamCount: items.filter((item) => item.status === "confirmed_spam").length,
+    notSpamCount: items.filter((item) => item.status === "not_spam").length,
+    dismissedCount: items.filter((item) => item.status === "dismissed").length
+  };
+}
+function isAutomatedLowValueGmailMessage(message) {
+  const precedence = typeof message.metadata.precedence === "string" ? message.metadata.precedence.trim().toLowerCase() : "";
+  return !message.likelyReplyNeeded && (Boolean(message.metadata.listId) || precedence === "bulk" || precedence === "list" || hasGmailLabel(message, "CATEGORY_PROMOTIONS"));
+}
+function metadataString(metadata, field) {
+  const value = metadata[field];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function metadataBoolean(metadata, field) {
+  return metadata[field] === true;
+}
+function uniqueStrings(values) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    items.push(value);
+  }
+  return items;
+}
+function hasGmailBodyTextContext(message) {
+  return ["bodyText", "plainTextBody", "bodyPlainText", "textBody"].some(
+    (field) => metadataString(message.metadata, field) !== null
+  );
+}
+function hasGmailReplyHeaderContext(message) {
+  return metadataString(message.metadata, "messageIdHeader") !== null || metadataString(message.metadata, "referencesHeader") !== null;
+}
+function gmailPolicySignalsForMessage(message) {
+  const precedence = metadataString(message.metadata, "precedence")?.toLowerCase().replace(/\s+/g, "_");
+  const autoSubmitted = metadataString(message.metadata, "autoSubmitted")?.toLowerCase().replace(/\s+/g, "_");
+  const spamClassification = metadataString(
+    message.metadata,
+    "spamClassification"
+  )?.toLowerCase().replace(/\s+/g, "_");
+  const threatCategory = metadataString(message.metadata, "threatCategory")?.toLowerCase().replace(/\s+/g, "_");
+  const triageReason = message.triageReason.toLowerCase();
+  return uniqueStrings([
+    message.likelyReplyNeeded ? "likely_reply_needed" : "reply_not_needed",
+    message.isUnread ? "unread" : "read",
+    message.isImportant ? "important" : "not_important",
+    hasGmailLabel(message, "INBOX") ? "label:inbox" : null,
+    hasGmailLabel(message, "SPAM") ? "label:spam" : null,
+    hasGmailLabel(message, "PHISHING") ? "label:phishing" : null,
+    hasGmailLabel(message, "CATEGORY_PROMOTIONS") ? "label:category_promotions" : null,
+    metadataString(message.metadata, "listId") !== null ? "header:list_id" : null,
+    precedence ? `header:precedence:${precedence}` : null,
+    autoSubmitted ? `header:auto_submitted:${autoSubmitted}` : null,
+    metadataBoolean(message.metadata, "spam") ? "metadata:spam" : null,
+    metadataBoolean(message.metadata, "phishing") ? "metadata:phishing" : null,
+    spamClassification ? `metadata:spam_classification:${spamClassification}` : null,
+    threatCategory ? `metadata:threat_category:${threatCategory}` : null,
+    triageReason.includes("direct-unread-reply-needed") ? "triage:direct_unread_reply_needed" : null,
+    triageReason.includes("automated-header") ? "triage:automated_header" : null
+  ]);
+}
+function buildGmailRecommendationContextReadiness(args) {
+  const bodyAvailableCount = args.messages.filter(
+    hasGmailBodyTextContext
+  ).length;
+  const snippetAvailableCount = args.messages.filter(
+    (message) => message.snippet.trim().length > 0
+  ).length;
+  const threadLinkAvailableCount = args.messages.filter(
+    (message) => message.htmlLink !== null
+  ).length;
+  const replyHeaderAvailableCount = args.messages.filter(
+    hasGmailReplyHeaderContext
+  ).length;
+  const requiresBodyReadBeforeDraft = args.kind === "reply";
+  const bodyStatus = bodyAvailableCount === args.messages.length ? "available" : snippetAvailableCount > 0 ? "summary_only" : "missing";
+  return {
+    bodyStatus,
+    bodyAvailableCount,
+    snippetAvailableCount,
+    threadLinkAvailableCount,
+    replyHeaderAvailableCount,
+    requiresBodyReadBeforeDraft,
+    summaryFields: uniqueStrings([
+      "subject",
+      "sender",
+      "recipients",
+      "received_at",
+      "labels",
+      "triage_reason",
+      snippetAvailableCount > 0 ? "snippet" : null,
+      threadLinkAvailableCount > 0 ? "thread_link" : null,
+      replyHeaderAvailableCount > 0 ? "reply_headers" : null
+    ]),
+    missingContext: uniqueStrings([
+      bodyAvailableCount === args.messages.length ? null : "body_text",
+      requiresBodyReadBeforeDraft && replyHeaderAvailableCount === 0 ? "reply_headers" : null
+    ])
+  };
+}
+function buildRecommendation(args) {
+  const messageIds = args.messages.map((message) => message.id);
+  if (messageIds.length === 0) {
+    return null;
+  }
+  const destructive = args.destructive === true;
+  return {
+    id: args.id,
+    kind: args.kind,
+    title: args.title,
+    rationale: args.rationale,
+    operation: args.operation,
+    messageIds,
+    query: args.query ?? null,
+    labelIds: args.labelIds ?? [],
+    affectedCount: messageIds.length,
+    destructive,
+    requiresConfirmation: true,
+    confidence: args.confidence,
+    sampleMessages: args.messages.slice(0, 5).map(recommendationMessage),
+    policy: {
+      grouping: args.grouping,
+      signals: uniqueStrings(
+        args.messages.flatMap(
+          (message) => gmailPolicySignalsForMessage(message)
+        )
+      ),
+      reasons: args.policyReasons,
+      exclusionReasons: args.exclusionReasons,
+      operationAllowed: args.operation !== null,
+      requiresHumanConfirmation: true,
+      emailContentIsUntrusted: true
+    },
+    contextReadiness: buildGmailRecommendationContextReadiness({
+      kind: args.kind,
+      messages: args.messages
+    })
+  };
+}
+function buildGmailRecommendations(messages) {
+  const recommendations = [];
+  const replyMessages = messages.filter(
+    (message) => message.likelyReplyNeeded && !isGmailSpamReviewCandidate(message)
+  ).slice(0, 25);
+  recommendations.push(
+    buildRecommendation({
+      id: "gmail-reply-needed",
+      kind: "reply",
+      title: "Draft replies for messages that need you",
+      rationale: "These direct unread Gmail threads look reply-worthy; spam and phishing candidates stay in review.",
+      operation: null,
+      messages: replyMessages,
+      grouping: "reply_needed",
+      policyReasons: [
+        "Only messages classified as likely reply-needed are included.",
+        "No mailbox mutation is attached; this recommendation prepares draft work only.",
+        "Full message bodies should be read before asking a model to draft replies."
+      ],
+      exclusionReasons: [
+        "Spam and phishing candidates are excluded from reply drafting.",
+        "Automated, list, and promotional mail is excluded by the reply-needed classifier."
+      ],
+      confidence: replyMessages.length > 0 ? 0.84 : 0
+    })
+  );
+  const archiveMessages = messages.filter(
+    (message) => hasGmailLabel(message, "INBOX") && !isGmailSpamReviewCandidate(message) && isAutomatedLowValueGmailMessage(message)
+  ).slice(0, 50);
+  recommendations.push(
+    buildRecommendation({
+      id: "gmail-archive-low-value",
+      kind: "archive",
+      title: "Archive low-value automated mail",
+      rationale: "These inbox messages carry list, bulk, or promotions signals; reply-needed and spam-review messages are excluded.",
+      operation: "archive",
+      messages: archiveMessages,
+      grouping: "automated_low_value",
+      policyReasons: [
+        "Only current inbox messages are eligible for archive recommendations.",
+        "Automated, list, bulk, or promotions signals are required.",
+        "Messages that look reply-worthy are not archived by this recommendation."
+      ],
+      exclusionReasons: [
+        "Spam and phishing candidates are routed to review instead of archive.",
+        "Personal or ambiguous messages without automated-mail signals are excluded."
+      ],
+      confidence: archiveMessages.length > 0 ? 0.78 : 0
+    })
+  );
+  const markReadMessages = messages.filter(
+    (message) => message.isUnread && !message.isImportant && !message.likelyReplyNeeded && !isGmailSpamReviewCandidate(message) && isAutomatedLowValueGmailMessage(message)
+  ).slice(0, 50);
+  recommendations.push(
+    buildRecommendation({
+      id: "gmail-mark-read-low-value",
+      kind: "mark_read",
+      title: "Mark low-value automated mail as read",
+      rationale: "These unread messages are automated or promotional; important, reply-needed, and spam-review messages are excluded.",
+      operation: "mark_read",
+      messages: markReadMessages,
+      grouping: "automated_low_value",
+      policyReasons: [
+        "Only unread automated or promotional messages are eligible.",
+        "Important and reply-needed messages remain visible to the owner.",
+        "Mark-read does not delete or move messages."
+      ],
+      exclusionReasons: [
+        "Spam and phishing candidates are routed to review instead of mark-read.",
+        "Important messages and likely reply-needed threads are excluded."
+      ],
+      confidence: markReadMessages.length > 0 ? 0.74 : 0
+    })
+  );
+  const spamMessages = messages.filter(isGmailSpamReviewCandidate).slice(0, 25);
+  recommendations.push(
+    buildRecommendation({
+      id: "gmail-review-spam",
+      kind: "review_spam",
+      title: "Review spam folder candidates",
+      rationale: "These messages carry Gmail spam, phishing, or upstream spam-review signals and need review before mutation.",
+      operation: null,
+      messages: spamMessages,
+      grouping: "spam_review",
+      policyReasons: [
+        "Spam and phishing signals are collected into a review-only recommendation.",
+        "No delete, trash, or report-spam operation is preselected.",
+        "Human confirmation is required before any destructive mailbox action."
+      ],
+      exclusionReasons: [
+        "Spam-review candidates are excluded from archive, mark-read, and reply-draft groups."
+      ],
+      destructive: false,
+      confidence: spamMessages.length > 0 ? 0.9 : 0
+    })
+  );
+  return recommendations.filter(
+    (recommendation) => recommendation !== null
+  );
+}
+function summarizeGmailRecommendations(recommendations) {
+  return {
+    totalCount: recommendations.length,
+    replyCount: recommendations.filter(
+      (recommendation) => recommendation.kind === "reply"
+    ).length,
+    archiveCount: recommendations.filter(
+      (recommendation) => recommendation.kind === "archive"
+    ).length,
+    markReadCount: recommendations.filter(
+      (recommendation) => recommendation.kind === "mark_read"
+    ).length,
+    spamReviewCount: recommendations.filter(
+      (recommendation) => recommendation.kind === "review_spam"
+    ).length,
+    destructiveCount: recommendations.filter(
+      (recommendation) => recommendation.destructive
+    ).length
+  };
+}
+import { wrapUntrustedEmailContent } from "@elizaos/shared";
+function buildFallbackGmailReplyDraftBody(args) {
+  const recipientLabel = args.message.from.split("<")[0]?.trim() || args.message.fromEmail || "";
+  const greeting = recipientLabel ? `${recipientLabel},` : "";
+  const subject = args.message.subject.trim() || "your message";
+  const bodyCore = args.intent?.trim() ? args.intent.trim() : args.tone === "brief" ? `Thanks for the note about ${subject}. I saw it and will follow up shortly.` : args.tone === "warm" ? `Thanks for reaching out about ${subject}. I reviewed your note and wanted to follow up.` : `Thanks for the note about ${subject}. I reviewed your message and wanted to follow up.`;
+  const bodyLines = [greeting, bodyCore, args.senderName].filter(
+    (line) => line.trim().length > 0
+  );
+  if (args.includeQuotedOriginal && args.message.snippet.trim().length > 0) {
+    bodyLines.push(
+      "",
+      ...args.message.snippet.trim().split("\n").map((line) => `> ${line.trim()}`)
+    );
+  }
+  return bodyLines.join("\n");
+}
+function normalizeGeneratedGmailReplyDraftBody(value) {
+  const withoutThink = value.replace(/<think>[\s\S]*?<\/think>/gi, " ").trim();
+  if (!withoutThink) {
+    return null;
+  }
+  const withoutCodeFences = withoutThink.replace(/^```[a-z0-9_-]*\s*/i, "").replace(/\s*```$/i, "").trim();
+  const withoutSubject = withoutCodeFences.replace(/^subject:\s*.+\n+/i, "");
+  const normalized = withoutSubject.replace(/\r\n/g, "\n").replace(/^["'`]+|["'`]+$/g, "").replace(/\n{3,}/g, "\n\n").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function buildGmailReplyPreviewLines(bodyText) {
+  const lines = bodyText.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, 3);
+  return lines.length > 0 ? lines : [bodyText.trim()].filter(Boolean);
+}
+function buildGmailReplyDraft(args) {
+  const recipient = args.message.replyTo ?? args.message.fromEmail ?? null;
+  if (!recipient) {
+    fail(409, "The selected Gmail message has no replyable sender.");
+  }
+  return {
+    messageId: args.message.id,
+    threadId: args.message.threadId,
+    subject: args.message.subject,
+    to: [recipient.toLowerCase()],
+    cc: [],
+    bodyText: args.bodyText,
+    previewLines: buildGmailReplyPreviewLines(args.bodyText),
+    sendAllowed: args.sendAllowed,
+    requiresConfirmation: true
+  };
+}
+function createCalendarEventId(agentId, provider, side, calendarId, externalId) {
+  const digest = crypto.createHash("sha256").update(`${agentId}:${provider}:${side}:${calendarId}:${externalId}`).digest("hex");
+  return `life-calendar-${digest.slice(0, 32)}`;
+}
+function createGmailMessageId(agentId, provider, side, grantId, externalMessageId) {
+  const digest = crypto.createHash("sha256").update(
+    `${agentId}:${provider}:${side}:gmail:${grantId}:${externalMessageId}`
+  ).digest("hex");
+  return `life-gmail-${digest.slice(0, 32)}`;
+}
+function createGmailSpamReviewItemId(agentId, provider, side, grantId, externalMessageId) {
+  const digest = crypto.createHash("sha256").update(
+    `${agentId}:${provider}:${side}:gmail-spam-review:${grantId}:${externalMessageId}`
+  ).digest("hex");
+  return `life-gmail-spam-${digest.slice(0, 32)}`;
+}
+function materializeGmailMessageSummary(args) {
+  return {
+    id: createGmailMessageId(
+      args.agentId,
+      "google",
+      args.side,
+      args.grantId,
+      args.message.externalId
+    ),
+    agentId: args.agentId,
+    provider: "google",
+    side: args.side,
+    ...args.message,
+    grantId: args.grantId,
+    accountEmail: args.accountEmail ?? void 0,
+    syncedAt: args.syncedAt,
+    updatedAt: args.syncedAt
+  };
+}
+function isCalendarSyncStateFresh(args) {
+  const syncedAtMs = Date.parse(args.syncedAt);
+  if (!Number.isFinite(syncedAtMs)) {
+    return false;
+  }
+  if (args.now.getTime() - syncedAtMs > GOOGLE_CALENDAR_CACHE_TTL_MS) {
+    return false;
+  }
+  return Date.parse(args.windowStartAt) <= Date.parse(args.timeMin) && Date.parse(args.windowEndAt) >= Date.parse(args.timeMax);
+}
+export {
+  buildFallbackGmailReplyDraftBody,
+  buildGmailRecommendations,
+  buildGmailReplyDraft,
+  buildGmailReplyPreviewLines,
+  buildGmailSpamReviewItem,
+  collectCalendarEventContactEmails,
+  compareGmailMessagePriority,
+  createCalendarEventId,
+  createGmailMessageId,
+  createGmailSpamReviewItemId,
+  extractNormalizedEmailAddress,
+  extractSubjectTokens,
+  filterGmailMessagesBySearch,
+  findLinkedMailForCalendarEvent,
+  isCalendarSyncStateFresh,
+  isGmailSpamReviewCandidate,
+  isGmailSyncStateFresh,
+  materializeGmailMessageSummary,
+  normalizeGeneratedGmailReplyDraftBody,
+  normalizeGmailBulkOperation,
+  normalizeGmailDraftTone,
+  normalizeGmailReplyBody,
+  normalizeGmailSearchQuery,
+  normalizeGmailSearchQueryMatches,
+  normalizeGmailSpamReviewStatus,
+  normalizeGmailUnrespondedOlderThanDays,
+  normalizeOptionalGmailLabelIdArray,
+  normalizeOptionalMessageIdArray,
+  normalizeOptionalStringArray,
+  parseGmailDateBoundary,
+  parseGmailRelativeDuration,
+  splitMailboxLikeList,
+  summarizeGmailBatchReplyDrafts,
+  summarizeGmailNeedsResponse,
+  summarizeGmailRecommendations,
+  summarizeGmailSearch,
+  summarizeGmailSpamReviewItems,
+  summarizeGmailTriage,
+  summarizeGmailUnresponded,
+  wrapUntrustedEmailContent
+};
+//# sourceMappingURL=gmail-normalize.js.map