gogcli-mcp-gmail 2.4.0 → 2.4.1

package/dist/index.js

@@ -31297,7 +31297,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.4.0" : "0.0.0";
+var VERSION = true ? "2.4.1" : "0.0.0";
 function createServer(options) {
   return new McpServer({
     name: options?.name ?? "gogcli",
@@ -31478,7 +31478,7 @@ function registerExtraGmailTools(server2) {
     return runOrDiagnose(args, { account });
   });
   server2.registerTool("gog_gmail_thread_get", {
-    description: "Get a Gmail thread with all messages. For long threads that overflow context, use latestN to fetch only the most recent messages and/or snippetsOnly for a lightweight per-message headers+snippet view; sanitizeContent strips raw payloads/HTML and is the biggest size reducer when you do need bodies.",
+    description: "Get a Gmail thread with all messages. For long threads that overflow context, use latestN to fetch only the most recent messages and/or snippetsOnly for a lightweight per-message headers+snippet view; sanitizeContent strips raw payloads/HTML and is the biggest size reducer when you do need bodies. Note each message carries two distinct id concepts: the top-level `id` (the Gmail short hex message id \u2014 pass THIS as replyToMessageId to reply) and the `Message-Id` header (the RFC822 `<\u2026@host>` value used in In-Reply-To/References) \u2014 don't confuse either with the `threadId`. To reply to the thread itself, pass the thread's id as replyToThreadId on gog_gmail_drafts_create.",
     annotations: { readOnlyHint: true },
     inputSchema: {
       threadId: external_exports.string().describe("Gmail thread ID"),
@@ -31630,9 +31630,10 @@ function registerExtraGmailTools(server2) {
     subject: external_exports.string().describe("Subject"),
     body: external_exports.string().describe("Body (plain text)"),
     bodyHtml: external_exports.string().optional().describe("Body (HTML; optional)"),
-    replyToMessageId: external_exports.string().optional().describe("Reply to Gmail message ID (sets In-Reply-To/References and thread)"),
+    replyToMessageId: external_exports.string().optional().describe("Reply to a specific Gmail MESSAGE id \u2014 the short hex `id` field from gog_gmail_get / _search / _thread_get (e.g. 19e7593d77fd9636), NOT a thread id and NOT the RFC822 `<\u2026@host>` Message-Id header. Anchors In-Reply-To/References to that exact message. To reply to a thread when you don't know the latest message, use replyToThreadId instead. If both are given, replyToMessageId wins."),
+    replyToThreadId: external_exports.string().optional().describe(`Reply to a Gmail THREAD id \u2014 the wrapper resolves the thread's most recent message and anchors the reply (In-Reply-To/References) to it. This is what "reply to this thread" almost always means. Mutually exclusive with replyToMessageId (which wins if both are set). Thread ids and message ids are both 16-hex strings and easy to confuse \u2014 use this param, not replyToMessageId, when the id came from a thread.`),
     replyTo: external_exports.string().optional().describe("Reply-To header address"),
-    quote: external_exports.boolean().optional().describe("Include quoted original message in reply (requires replyToMessageId)"),
+    quote: external_exports.boolean().optional().describe("Include quoted original message in reply (requires replyToMessageId or replyToThreadId)"),
     attach: external_exports.array(external_exports.string()).optional().describe("Attachment file paths (repeatable)"),
     from: external_exports.string().optional().describe("Send from this email address (must be a verified send-as alias)"),
     omitRecipients: external_exports.boolean().optional().describe("Create the draft with no recipients even if to/cc/bcc are supplied \u2014 an accidental-send guard. Populate recipients in a later update before sending."),
@@ -31654,6 +31655,23 @@ function registerExtraGmailTools(server2) {
     if (f.attach) for (const path of f.attach) args.push(`--attach=${path}`);
     if (f.from) args.push(`--from=${f.from}`);
   }
+  async function resolveReplyTarget(replyToMessageId, replyToThreadId, account) {
+    if (replyToMessageId) return { messageId: replyToMessageId };
+    if (!replyToThreadId) return { messageId: void 0 };
+    const threadResult = await runOrDiagnose(["gmail", "thread", "get", replyToThreadId], { account });
+    let parsed;
+    try {
+      parsed = JSON.parse(threadResult.content[0].text);
+    } catch {
+      return { error: threadResult };
+    }
+    const messages = parsed.thread?.messages;
+    const latest = Array.isArray(messages) ? messages[messages.length - 1] : void 0;
+    if (!latest?.id) {
+      return { error: toText(`Error: thread ${replyToThreadId} has no message to reply to`) };
+    }
+    return { messageId: latest.id };
+  }
   async function writeDraft(args, account, returnFull, knownDraftId) {
     const result = await runOrDiagnose(args, { account });
     if (!returnFull) return result;
@@ -31668,23 +31686,27 @@ function registerExtraGmailTools(server2) {
     return runOrDiagnose(["gmail", "drafts", "get", draftId], { account });
   }
   server2.registerTool("gog_gmail_drafts_create", {
-    description: "Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard.",
+    description: "Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard. For replies, prefer replyToThreadId (anchors to the thread's latest message) or replyToMessageId (a specific message) \u2014 don't pass a thread id into replyToMessageId, which mis-threads silently.",
     inputSchema: draftWriteSchema
-  }, async ({ account, returnFull, ...flags }) => {
+  }, async ({ account, returnFull, replyToThreadId, ...flags }) => {
+    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
+    if ("error" in resolved) return resolved.error;
     const args = ["gmail", "drafts", "create"];
-    appendDraftFlags(args, flags);
+    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
     return writeDraft(args, account, returnFull);
   });
   server2.registerTool("gog_gmail_drafts_update", {
-    description: "Update an existing Gmail draft.",
+    description: "Update an existing Gmail draft. For replies, prefer replyToThreadId (anchors to the thread's latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId.",
     annotations: { destructiveHint: true },
     inputSchema: {
       draftId: external_exports.string().describe("Draft ID"),
       ...draftWriteSchema
     }
-  }, async ({ draftId, account, returnFull, ...flags }) => {
+  }, async ({ draftId, account, returnFull, replyToThreadId, ...flags }) => {
+    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
+    if ("error" in resolved) return resolved.error;
     const args = ["gmail", "drafts", "update", draftId];
-    appendDraftFlags(args, flags);
+    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
     return writeDraft(args, account, returnFull, draftId);
   });
   server2.registerTool("gog_gmail_drafts_delete", {

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-gmail",
   "display_name": "gogcli (Gmail)",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Extended Gmail for Claude via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": {
     "name": "Chris Hall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-gmail",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "mcpName": "io.github.chrischall/gogcli-mcp-gmail",
   "description": "Extended Gmail MCP server via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/src/tools/gmail-extra.ts

@@ -208,7 +208,7 @@ export function registerExtraGmailTools(server: McpServer): void {
   });
 
   server.registerTool('gog_gmail_thread_get', {
-    description: 'Get a Gmail thread with all messages. For long threads that overflow context, use latestN to fetch only the most recent messages and/or snippetsOnly for a lightweight per-message headers+snippet view; sanitizeContent strips raw payloads/HTML and is the biggest size reducer when you do need bodies.',
+    description: 'Get a Gmail thread with all messages. For long threads that overflow context, use latestN to fetch only the most recent messages and/or snippetsOnly for a lightweight per-message headers+snippet view; sanitizeContent strips raw payloads/HTML and is the biggest size reducer when you do need bodies. Note each message carries two distinct id concepts: the top-level `id` (the Gmail short hex message id — pass THIS as replyToMessageId to reply) and the `Message-Id` header (the RFC822 `<…@host>` value used in In-Reply-To/References) — don\'t confuse either with the `threadId`. To reply to the thread itself, pass the thread\'s id as replyToThreadId on gog_gmail_drafts_create.',
     annotations: { readOnlyHint: true },
     inputSchema: {
       threadId: z.string().describe('Gmail thread ID'),
@@ -371,9 +371,10 @@ export function registerExtraGmailTools(server: McpServer): void {
     subject: z.string().describe('Subject'),
     body: z.string().describe('Body (plain text)'),
     bodyHtml: z.string().optional().describe('Body (HTML; optional)'),
-    replyToMessageId: z.string().optional().describe('Reply to Gmail message ID (sets In-Reply-To/References and thread)'),
+    replyToMessageId: z.string().optional().describe('Reply to a specific Gmail MESSAGE id — the short hex `id` field from gog_gmail_get / _search / _thread_get (e.g. 19e7593d77fd9636), NOT a thread id and NOT the RFC822 `<…@host>` Message-Id header. Anchors In-Reply-To/References to that exact message. To reply to a thread when you don\'t know the latest message, use replyToThreadId instead. If both are given, replyToMessageId wins.'),
+    replyToThreadId: z.string().optional().describe('Reply to a Gmail THREAD id — the wrapper resolves the thread\'s most recent message and anchors the reply (In-Reply-To/References) to it. This is what "reply to this thread" almost always means. Mutually exclusive with replyToMessageId (which wins if both are set). Thread ids and message ids are both 16-hex strings and easy to confuse — use this param, not replyToMessageId, when the id came from a thread.'),
     replyTo: z.string().optional().describe('Reply-To header address'),
-    quote: z.boolean().optional().describe('Include quoted original message in reply (requires replyToMessageId)'),
+    quote: z.boolean().optional().describe('Include quoted original message in reply (requires replyToMessageId or replyToThreadId)'),
     attach: z.array(z.string()).optional().describe('Attachment file paths (repeatable)'),
     from: z.string().optional().describe('Send from this email address (must be a verified send-as alias)'),
     omitRecipients: z.boolean().optional().describe('Create the draft with no recipients even if to/cc/bcc are supplied — an accidental-send guard. Populate recipients in a later update before sending.'),
@@ -412,6 +413,40 @@ export function registerExtraGmailTools(server: McpServer): void {
     if (f.from) args.push(`--from=${f.from}`);
   }
 
+  // Resolve the effective reply target for a draft write. A draft can only
+  // thread off a specific MESSAGE id, but callers usually have a THREAD id and
+  // mean "reply to this thread". gog's `drafts create/update` has no --thread-id
+  // (unlike `gmail send`), so we resolve thread -> latest message here and pass
+  // that message id — gog then sets In-Reply-To/References from its RFC822
+  // Message-Id. replyToMessageId always wins; when only a thread id is given we
+  // fetch the thread and reply to its most recent message. Returns either the
+  // resolved message id (possibly undefined when neither was supplied) or an
+  // error ToolResult that the handler surfaces instead of writing a
+  // mis-threaded draft. (When upstream adds --thread-id to drafts — openclaw/
+  // gogcli#673 — this can pass it through directly with no MCP surface change.)
+  async function resolveReplyTarget(
+    replyToMessageId: string | undefined,
+    replyToThreadId: string | undefined,
+    account: string | undefined,
+  ): Promise<{ messageId?: string } | { error: ToolResult }> {
+    if (replyToMessageId) return { messageId: replyToMessageId };
+    if (!replyToThreadId) return { messageId: undefined };
+    const threadResult = await runOrDiagnose(['gmail', 'thread', 'get', replyToThreadId], { account });
+    let parsed: { thread?: { messages?: GmailMessage[] } };
+    try {
+      parsed = JSON.parse(threadResult.content[0].text) as { thread?: { messages?: GmailMessage[] } };
+    } catch {
+      // Non-JSON output means the thread fetch itself errored — surface it.
+      return { error: threadResult };
+    }
+    const messages = parsed.thread?.messages;
+    const latest = Array.isArray(messages) ? messages[messages.length - 1] : undefined;
+    if (!latest?.id) {
+      return { error: toText(`Error: thread ${replyToThreadId} has no message to reply to`) };
+    }
+    return { messageId: latest.id };
+  }
+
   // Run a draft write, then — when returnFull is set — re-fetch the stored
   // draft so the caller can verify subject/body/recipients persisted without a
   // separate gog_gmail_drafts_get round trip. For updates the id is known up
@@ -441,24 +476,28 @@ export function registerExtraGmailTools(server: McpServer): void {
   }
 
   server.registerTool('gog_gmail_drafts_create', {
-    description: 'Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard.',
+    description: 'Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard. For replies, prefer replyToThreadId (anchors to the thread\'s latest message) or replyToMessageId (a specific message) — don\'t pass a thread id into replyToMessageId, which mis-threads silently.',
     inputSchema: draftWriteSchema,
-  }, async ({ account, returnFull, ...flags }) => {
+  }, async ({ account, returnFull, replyToThreadId, ...flags }) => {
+    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
+    if ('error' in resolved) return resolved.error;
     const args = ['gmail', 'drafts', 'create'];
-    appendDraftFlags(args, flags);
+    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
     return writeDraft(args, account, returnFull);
   });
 
   server.registerTool('gog_gmail_drafts_update', {
-    description: 'Update an existing Gmail draft.',
+    description: 'Update an existing Gmail draft. For replies, prefer replyToThreadId (anchors to the thread\'s latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId.',
     annotations: { destructiveHint: true },
     inputSchema: {
       draftId: z.string().describe('Draft ID'),
       ...draftWriteSchema,
     },
-  }, async ({ draftId, account, returnFull, ...flags }) => {
+  }, async ({ draftId, account, returnFull, replyToThreadId, ...flags }) => {
+    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
+    if ('error' in resolved) return resolved.error;
     const args = ['gmail', 'drafts', 'update', draftId];
-    appendDraftFlags(args, flags);
+    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
     return writeDraft(args, account, returnFull, draftId);
   });
 

package/tests/tools/gmail-extra.test.ts

@@ -545,6 +545,86 @@ describe('gog_gmail_drafts_create', () => {
   });
 });
 
+describe('gmail draft reply threading (replyToThreadId resolution)', () => {
+  const threadJson = (ids: (string | undefined)[]) =>
+    toText(JSON.stringify({ thread: { messages: ids.map((id) => (id ? { id } : {})) } }));
+
+  it('resolves replyToThreadId to the thread\'s latest message id on create', async () => {
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: string[]) => {
+      if (args[1] === 'thread' && args[2] === 'get') return threadJson(['m1', 'm2', 'mLatest']);
+      return toText('{"draftId":"d1"}');
+    });
+    await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'Re: roof', body: 'Sounds good', replyToThreadId: '19dffe06f9668b28', account: 'me@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'thread', 'get', '19dffe06f9668b28'], { account: 'me@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'create', '--subject=Re: roof', '--body=Sounds good', '--reply-to-message-id=mLatest'],
+      { account: 'me@x.com' },
+    );
+  });
+
+  it('resolves replyToThreadId on update too', async () => {
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: string[]) => {
+      if (args[1] === 'thread' && args[2] === 'get') return threadJson(['a', 'b']);
+      return toText('{"draftId":"d1"}');
+    });
+    await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1', subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--reply-to-message-id=b'],
+      { account: undefined },
+    );
+  });
+
+  it('replyToMessageId wins when both ids are supplied (no thread fetch)', async () => {
+    await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'S', body: 'B', replyToMessageId: 'mExplicit', replyToThreadId: 't1',
+    });
+    // Only the create call — the thread was never fetched.
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'create', '--subject=S', '--body=B', '--reply-to-message-id=mExplicit'],
+      { account: undefined },
+    );
+  });
+
+  it('surfaces the thread-fetch error and does not write a mis-threaded draft', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('Error: thread t1 not found'));
+    const result = await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    expect(result.content[0].text).toBe('Error: thread t1 not found');
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1); // only the thread fetch; no create
+  });
+
+  it('errors when the thread has no message to reply to', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText(JSON.stringify({ thread: { messages: [] } })));
+    const result = await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    expect(result.content[0].text).toBe('Error: thread t1 has no message to reply to');
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+  });
+
+  it('errors when the thread payload has no messages array', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('{}'));
+    const result = await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    expect(result.content[0].text).toBe('Error: thread t1 has no message to reply to');
+  });
+
+  it('errors when the latest message has no id', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(threadJson(['m1', undefined]));
+    const result = await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    expect(result.content[0].text).toBe('Error: thread t1 has no message to reply to');
+  });
+});
+
 describe('gog_gmail_drafts_update', () => {
   it('calls runOrDiagnose with draftId and updated fields', async () => {
     await handlers.get('gog_gmail_drafts_update')!({