fix(outlook-mail,gmail): correct calendar-reply threading id + Message-ID sanitization

outlook-mail: sendCalendarEventReplyFn's subsequent-reply branch passed the
stored internetMessageId to createReplyDraft, but that Graph endpoint
requires a real item id, so every reply after the first 404'd
(ErrorInvalidIdMalformed) and surfaced as a failed send. Resolve the actual
target message from the conversation via getConversationMessages instead,
falling back to starting a fresh conversation if it comes back empty.

gmail: the seed Message-ID for a calendar-thread reply spliced the raw
iCalUID into `<plot-cal-${iCalUID}-...@plot.day>`; since iCalUIDs are often
themselves email-shaped (e.g. "abc@google.com"), this produced a malformed
double-`@` Message-ID. Sanitize non-token characters in the local part only
— the X-Plot-Event-UID header still carries the raw iCalUID.

Author: KrisBraun

connectors/gmail/src/sync.ts

@@ -1777,7 +1777,12 @@ export async function sendCalendarEventReplyFn(
 
   let sentId: string;
   if (!prior) {
-    const seedMessageId = `<plot-cal-${iCalUID}-${note.id}@plot.day>`;
+    // Sanitize only the Message-ID LOCAL PART: real iCalUIDs are often
+    // already an email-shaped string (e.g. "abc@google.com"), and splicing
+    // one in verbatim produces a double-`@` malformed Message-ID. The
+    // X-Plot-Event-UID header below still carries the raw iCalUID unchanged
+    // — only this synthetic Message-ID needs to be token-safe.
+    const seedMessageId = `<plot-cal-${iCalUID.replace(/[^A-Za-z0-9._-]/g, "-")}-${note.id}@plot.day>`;
     const raw = buildNewEmailMessage({
       to, cc, bcc, from, subject, body: note.content ?? "",
       extraHeaders: [`Message-ID: ${seedMessageId}`, uidHeader],

connectors/outlook-mail/src/calendar-reply.test.ts

@@ -6,6 +6,7 @@ const { graphApi } = vi.hoisted(() => ({
     createReplyDraft: vi.fn(),
     updateMessage: vi.fn(),
     getMessage: vi.fn(),
+    getConversationMessages: vi.fn(),
     send: vi.fn(),
   },
 }));
@@ -103,7 +104,15 @@ describe("outlook onNoteCreatedFn — calendar event thread", () => {
     expect(res).toEqual({ key: "<imid-1>" });
   });
 
-  it("second reply: threads via createReplyDraft into stored conversation", async () => {
+  it("second reply: threads via createReplyDraft using the REAL Graph item id from the conversation, not the stored internetMessageId", async () => {
+    // The prior code passed `prior.lastMessageId` (an RFC-822 Message-ID like
+    // "<imid-1>") straight to createReplyDraft, which Graph rejects with a
+    // 404 ErrorInvalidIdMalformed — createReplyDraft requires a real Graph
+    // item id (e.g. "AAMk..."). The fix resolves the target message from the
+    // conversation instead.
+    graphApi.getConversationMessages.mockResolvedValue([
+      { id: "AAMk-real-id", isDraft: false, internetMessageId: "<imid-1>" },
+    ]);
     graphApi.createReplyDraft.mockResolvedValue({ id: "d2", internetMessageId: "<imid-2>" });
     graphApi.updateMessage.mockResolvedValue(undefined);
     graphApi.getMessage.mockResolvedValue({
@@ -113,12 +122,14 @@ describe("outlook onNoteCreatedFn — calendar event thread", () => {
     });
     graphApi.send.mockResolvedValue(undefined);
     const { host } = makeHost({
-      "cal-reply:uid-123": { conversationId: "conv-1", lastMessageId: "seed-msg" },
+      "cal-reply:uid-123": { conversationId: "conv-1", lastMessageId: "<imid-1>" },
     });
 
     await onNoteCreatedFn(host, replyNote(["bob@x.com"]), calThread());
 
-    expect(graphApi.createReplyDraft).toHaveBeenCalledWith("seed-msg");
+    expect(graphApi.getConversationMessages).toHaveBeenCalledWith("conv-1");
+    expect(graphApi.createReplyDraft).toHaveBeenCalledWith("AAMk-real-id");
+    expect(graphApi.createReplyDraft).not.toHaveBeenCalledWith("<imid-1>");
     expect(graphApi.send).toHaveBeenCalledWith("d2");
   });
 });

connectors/outlook-mail/src/sync.ts

@@ -1865,8 +1865,7 @@ export async function sendCalendarEventReplyFn(
   const stateKey = `cal-reply:${iCalUID}`;
   const prior = await host.get<{ conversationId: string; lastMessageId: string }>(stateKey);
 
-  let draftId: string;
-  if (!prior) {
+  const sendFreshConversation = async (): Promise<NoteWriteBackResult | void> => {
     const created = await api.createDraft({
       subject: (thread.title as string) || "Event",
       body: bodyHtml,
@@ -1875,7 +1874,7 @@ export async function sendCalendarEventReplyFn(
       bccRecipients: bcc.map(addr),
       internetMessageHeaders: [{ name: "x-plot-event-uid", value: iCalUID }],
     });
-    draftId = created.id;
+    const draftId = created.id;
     let imid = created.internetMessageId;
     let conversationId = created.conversationId;
     if (!imid || !conversationId) {
@@ -1889,22 +1888,46 @@ export async function sendCalendarEventReplyFn(
     await host.set(stateKey, { conversationId, lastMessageId: key });
     await host.set(`sent:${key}`, true);
     return { key };
-  } else {
-    const draft = await api.createReplyDraft(prior.lastMessageId);
-    draftId = draft.id;
-    await api.updateMessage(draftId, {
-      body: bodyHtml,
-      toRecipients: to.map(addr),
-      ccRecipients: cc.map(addr),
-      ...(bcc.length > 0 ? { bccRecipients: bcc.map(addr) } : {}),
-    });
-    const refreshed = await api.getMessage(draftId, "id,internetMessageId,conversationId");
-    const key = refreshed?.internetMessageId ?? draft.internetMessageId ?? draftId;
-    await api.send(draftId);
-    await host.set(stateKey, { conversationId: prior.conversationId, lastMessageId: key });
-    await host.set(`sent:${key}`, true);
-    return { key };
+  };
+
+  if (!prior) {
+    return sendFreshConversation();
+  }
+
+  // Subsequent reply: thread into the stored conversation via a REAL Graph
+  // item id (`createReplyDraft` → POST /me/messages/{id}/createReply
+  // requires the item id, not an internetMessageId — the prior code passed
+  // `prior.lastMessageId`, an RFC-822 Message-ID, which Graph rejects with a
+  // 404 ErrorInvalidIdMalformed on every reply after the first).
+  const conversationMessages = (
+    await api.getConversationMessages(prior.conversationId)
+  ).filter((m) => !m.isDraft);
+  if (conversationMessages.length === 0) {
+    // Defensive: the stored conversation has no live messages to thread
+    // into (shouldn't normally happen — we sent a message there
+    // previously). Fall back to starting a fresh conversation rather than
+    // calling createReplyDraft with nothing to anchor to.
+    console.warn(
+      `[outlook-mail] calendar reply: conversation ${prior.conversationId} has no messages, starting a fresh one`
+    );
+    return sendFreshConversation();
   }
+  const target = conversationMessages[conversationMessages.length - 1];
+
+  const draft = await api.createReplyDraft(target.id);
+  const draftId = draft.id;
+  await api.updateMessage(draftId, {
+    body: bodyHtml,
+    toRecipients: to.map(addr),
+    ccRecipients: cc.map(addr),
+    ...(bcc.length > 0 ? { bccRecipients: bcc.map(addr) } : {}),
+  });
+  const refreshed = await api.getMessage(draftId, "id,internetMessageId,conversationId");
+  const key = refreshed?.internetMessageId ?? draft.internetMessageId ?? draftId;
+  await api.send(draftId);
+  await host.set(stateKey, { conversationId: prior.conversationId, lastMessageId: key });
+  await host.set(`sent:${key}`, true);
+  return { key };
 }
 
 /**