@mcinteerj/openclaw-gmail 1.6.1 → 1.7.0

package/README.md

@@ -106,12 +106,14 @@ Your gog installation is not affected and other accounts can continue using it.
           "allowFrom": ["*"],
           "pollIntervalMs": 60000,
           "includeQuotedReplies": true,        // default: true
+          "includeThreadContext": false,        // default: false
           "allowOutboundTo": ["@company.com"],  // optional
           "threadReplyPolicy": "allowlist"      // default: "open"
         }
       },
       "defaults": {
-        "includeQuotedReplies": true
+        "includeQuotedReplies": true,
+        "includeThreadContext": false
       }
     }
   }
@@ -125,6 +127,7 @@ Your gog installation is not affected and other accounts can continue using it.
 | `allowFrom` | string[] | `[]` | Sender allowlist. `["*"]` allows all. |
 | `pollIntervalMs` | number | `60000` | Polling interval in milliseconds |
 | `includeQuotedReplies` | boolean | `true` | Include thread history as quoted text in replies |
+| `includeThreadContext` | boolean | `false` | When an allowed sender replies in a thread containing messages from non-allowed senders, include those earlier messages as context. See [Thread Context](#thread-context). |
 | `allowOutboundTo` | string[] | (falls back to `allowFrom`) | Restrict who the bot can send to. Supports domain wildcards (`@company.com`). |
 | `threadReplyPolicy` | `"open"` \| `"allowlist"` \| `"sender-only"` | `"open"` | Controls reply restrictions |
 
@@ -134,6 +137,31 @@ Your gog installation is not affected and other accounts can continue using it.
 - **`allowlist`**: All thread participants must be in `allowOutboundTo`.
 - **`sender-only`**: Only checks if the original thread sender is allowed.
 
+### Thread Context
+
+When `includeThreadContext` is enabled, the plugin enriches inbound messages with prior thread history that the agent wouldn't otherwise see.
+
+**The problem:** If someone not on the allow list emails the agent, their message is quarantined (never seen). If an allowed sender then replies to that thread asking the agent to review it, the agent only sees the allowed sender's new message — the quoted content from the non-allowed sender is stripped during sanitization.
+
+**The solution:** With `includeThreadContext: true`, when an allowed sender's message arrives in a thread that contains earlier messages from non-allowed senders, those earlier messages are included as labelled context above the new message:
+
+```
+---
+**Thread context** (1 earlier message from senders not on your allow list):
+
+**From:** Hamish Smith <hamish@example.com>
+**Date:** Mon, 24 Feb 2026 10:30:00 +1300
+
+Hey Keith, can you book transfers for our Fiji trip?
+---
+
+[Thread Context: ID=abc123, Subject="Book Your Fast Fiji Transfers"]
+
+Keith, can you please review Hamish's request below and action it?
+```
+
+This is **disabled by default** to preserve the existing allow list behavior where non-allowed senders' content is never shown. Enable it per-account or in `defaults` when you want allowed senders to be able to surface thread context from outside the allow list.
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcinteerj/openclaw-gmail",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "Gmail channel plugin for OpenClaw - direct API or gog CLI",
   "type": "module",
   "main": "index.ts",

package/src/accounts.ts

@@ -10,6 +10,7 @@ export interface ResolvedGmailAccount extends ResolvedChannelAccount {
   historyId?: string;
   delegate?: string;
   pollIntervalMs?: number;
+  includeThreadContext?: boolean;
   backend?: "gog" | "api";
   oauth?: {
     clientId: string;
@@ -63,6 +64,8 @@ export function resolveGmailAccount(
     };
   }
 
+  const defaults = cfg.channels?.['openclaw-gmail']?.defaults;
+
   return {
     accountId: resolvedId,
     name: account.name || account.email,
@@ -72,6 +75,7 @@ export function resolveGmailAccount(
     delegate: account.delegate,
     allowFrom: account.allowFrom,
     pollIntervalMs: account.pollIntervalMs,
+    includeThreadContext: account.includeThreadContext ?? (defaults as any)?.includeThreadContext ?? false,
     backend: account.backend,
     oauth: account.oauth,
   };

package/src/channel.ts

@@ -190,6 +190,7 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
               historyId: { type: "string" },
               delegate: { type: "string" },
               archiveOnReply: { type: "boolean", default: true },
+              includeThreadContext: { type: "boolean", default: false },
               backend: { type: "string", enum: ["gog", "api"] },
               oauth: {
                 type: "object",
@@ -209,6 +210,7 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
           properties: {
             allowFrom: { type: "array", items: { type: "string" } },
             archiveOnReply: { type: "boolean", default: true },
+            includeThreadContext: { type: "boolean", default: false },
           },
         },
       },

package/src/config.ts

@@ -16,6 +16,7 @@ export const GmailAccountSchema = z.object({
   allowOutboundTo: z.array(z.string()).optional(), // Who we can SEND to (if not set, falls back to allowFrom)
   threadReplyPolicy: z.enum(["open", "allowlist", "sender-only"]).optional(), // Default: "open" for backwards compat
   archiveOnReply: z.boolean().optional(), // Archive thread after reply (default: true)
+  includeThreadContext: z.boolean().optional(), // Include prior thread messages from non-allowed senders when an allowed sender replies (default: false)
   backend: z.enum(["gog", "api"]).optional(), // Gmail backend: gog CLI (default) or googleapis
   oauth: z.object({
     clientId: z.string(),
@@ -34,6 +35,7 @@ export const GmailConfigSchema = z.object({
     allowOutboundTo: z.array(z.string()).optional(), // Global default for outbound allowlist
     threadReplyPolicy: z.enum(["open", "allowlist", "sender-only"]).optional(), // Global default
     archiveOnReply: z.boolean().optional(), // Global default for archive on reply (default: true)
+    includeThreadContext: z.boolean().optional(), // Global default for thread context inclusion (default: false)
   }).optional(),
 });
 

package/src/monitor.ts

@@ -9,6 +9,7 @@ import { extractAttachments } from "./attachments.js";
 import { isAllowed } from "./normalize.js";
 import type { GmailClient } from "./gmail-client.js";
 import { GogGmailClient } from "./gog-client.js";
+import { extractTextBody } from "./strip-quotes.js";
 
 // Polling interval: Default 60s, override via env for testing
 const DEFAULT_POLL_INTERVAL = 60_000;
@@ -54,6 +55,78 @@ async function markAsRead(id: string, threadId: string | undefined, log: Channel
   }
 }
 
+/**
+ * Enrich an inbound message with prior thread messages that Keith hasn't seen.
+ *
+ * When `includeThreadContext` is enabled and an allowed sender replies in a thread
+ * that contains earlier messages from non-allowed senders (which were quarantined),
+ * this fetches the full thread and prepends those unseen messages as context.
+ *
+ * This solves the case where e.g. Hamish (not allowed) emails, gets quarantined,
+ * then Laura (allowed) replies asking Keith to review — Keith now sees Hamish's
+ * message as thread context above Laura's new message.
+ */
+async function enrichWithThreadContext(
+  msg: InboundMessage,
+  account: ResolvedGmailAccount,
+  log: ChannelLogSink,
+  client: GmailClient,
+): Promise<InboundMessage> {
+  if (!account.includeThreadContext) return msg;
+  if (!msg.threadId) return msg;
+
+  try {
+    const thread = await client.getThread(msg.threadId, { full: true });
+    if (!thread?.messages || thread.messages.length <= 1) return msg;
+
+    const allowList = account.allowFrom || [];
+
+    // Find messages in the thread that Keith hasn't seen (from non-allowed senders)
+    // Exclude the current message itself
+    const unseenMessages = thread.messages.filter((threadMsg) => {
+      if (threadMsg.id === msg.channelMessageId) return false;
+
+      // Extract sender email
+      const fromMatch = threadMsg.from.match(/<(.*)>/);
+      const senderEmail = fromMatch ? fromMatch[1] : threadMsg.from;
+
+      // Skip messages from the account itself (Keith's own replies)
+      if (senderEmail.toLowerCase() === account.email.toLowerCase()) return false;
+
+      // Only include messages from senders NOT on the allow list
+      return !isAllowed(senderEmail, allowList);
+    });
+
+    if (unseenMessages.length === 0) return msg;
+
+    // Build context block from unseen messages (oldest first)
+    const contextLines = unseenMessages.map((threadMsg) => {
+      // Strip quotes from thread message body to avoid nested repetition
+      const cleanBody = extractTextBody(threadMsg.bodyHtml, threadMsg.body, { stripSignature: true });
+      const body = cleanBody || threadMsg.body || "(no content)";
+      return `**From:** ${threadMsg.from}\n**Date:** ${threadMsg.date}\n\n${body}`;
+    });
+
+    const contextBlock = [
+      "---",
+      `**Thread context** (${unseenMessages.length} earlier message${unseenMessages.length > 1 ? "s" : ""} from senders not on your allow list):`,
+      "",
+      ...contextLines.map((c, i) => i > 0 ? `---\n${c}` : c),
+      "---",
+      "",
+    ].join("\n");
+
+    // Prepend thread context before the current message text
+    return {
+      ...msg,
+      text: contextBlock + msg.text,
+    };
+  } catch (err) {
+    log.error(`Failed to enrich thread context for ${msg.threadId}: ${String(err)}`);
+    return msg; // Graceful fallback — dispatch without context
+  }
+}
+
 /**
  * Prune old Gmail sessions and their associated attachments.
  */
@@ -251,7 +324,7 @@ async function performFullSync(
 
             // To get attachments, we need the full message details (search --include-body only gives text)
             const fullMsg = await fetchMessageDetails(msg.channelMessageId, account, log, client, true);
-            const msgToDispatch = fullMsg || msg;
+            let msgToDispatch = fullMsg || msg;
 
             try {
                 // Auto-download small attachments
@@ -263,6 +336,9 @@ async function performFullSync(
                     }
                 }
 
+                // Enrich with thread context from non-allowed senders if enabled
+                msgToDispatch = await enrichWithThreadContext(msgToDispatch, account, log, client);
+
                 await onMessage(msgToDispatch);
 
                 // CRITICAL: Only mark as read after successful dispatch