@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/messaging/providers/telegram-bot/send.test.ts

@@ -30,7 +30,8 @@ mock.module("./api.js", () => ({
 }));
 
 const { TelegramNonRetryableError } = await import("./api.js");
-const { sendTelegramReply, sendTelegramRichReply } = await import("./send.js");
+const { editTelegramMessage, sendTelegramReply, sendTelegramRichReply } =
+  await import("./send.js");
 const { telegramTransport } = await import("./transport.js");
 
 const approval: ApprovalUIMetadata = {
@@ -191,15 +192,15 @@ describe("telegramTransport.deliver routing", () => {
     } as ChannelReplyPayload;
   }
 
-  test("routes to the rich send when useBlocks is set", async () => {
-    await telegramTransport.deliver(ctx, payload({ useBlocks: true }));
+  test("routes to the rich send when a rich render is asked for", async () => {
+    await telegramTransport.deliver(ctx, payload({ renderRichly: true }));
 
     expect(callsTo("sendRichMessage")).toHaveLength(1);
     expect(callsTo("sendMessage")).toHaveLength(0);
   });
 
-  test("stays on the plain send when useBlocks is absent", async () => {
-    await telegramTransport.deliver(ctx, payload({ useBlocks: false }));
+  test("stays on the plain send when it is not", async () => {
+    await telegramTransport.deliver(ctx, payload({ renderRichly: false }));
 
     expect(callsTo("sendRichMessage")).toHaveLength(0);
     expect(callsTo("sendMessage")).toHaveLength(1);
@@ -208,7 +209,7 @@ describe("telegramTransport.deliver routing", () => {
   test("forwards approval metadata through the rich path", async () => {
     await telegramTransport.deliver(
       ctx,
-      payload({ useBlocks: true, approval } as Partial<ChannelReplyPayload>),
+      payload({ renderRichly: true, approval } as Partial<ChannelReplyPayload>),
     );
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendRichMessage", {
@@ -238,7 +239,7 @@ describe("telegramTransport topic targeting", () => {
   }
 
   test("plain replies target the topic from the callback threadId param", async () => {
-    await telegramTransport.deliver(topicCtx, payload({ useBlocks: false }));
+    await telegramTransport.deliver(topicCtx, payload({ renderRichly: false }));
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendMessage", {
       chat_id: "123",
@@ -248,7 +249,7 @@ describe("telegramTransport topic targeting", () => {
   });
 
   test("rich replies target the topic", async () => {
-    await telegramTransport.deliver(topicCtx, payload({ useBlocks: true }));
+    await telegramTransport.deliver(topicCtx, payload({ renderRichly: true }));
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendRichMessage", {
       chat_id: "123",
@@ -262,7 +263,7 @@ describe("telegramTransport topic targeting", () => {
       throw new TelegramNonRetryableError("rejected", "rejected");
     });
 
-    await telegramTransport.deliver(topicCtx, payload({ useBlocks: true }));
+    await telegramTransport.deliver(topicCtx, payload({ renderRichly: true }));
 
     expect(callTelegramBotApiMock).toHaveBeenNthCalledWith(2, "sendMessage", {
       chat_id: "123",
@@ -272,7 +273,10 @@ describe("telegramTransport topic targeting", () => {
   });
 
   test("typing indicators target the topic", async () => {
-    await telegramTransport.typing!(topicCtx, "123");
+    await telegramTransport.setActivity!(topicCtx, {
+      chatId: "123",
+      phase: "thinking",
+    });
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendChatAction", {
       chat_id: "123",
@@ -281,14 +285,32 @@ describe("telegramTransport topic targeting", () => {
     });
   });
 
+  // Telegram's chat action expires on its own, so a phase that is not running
+  // has nothing to say. Asserting the call count rather than the absence of a
+  // "stop" call is what catches a clearing request being invented later.
+  test.each(["idle", "awaiting_confirmation"] as const)(
+    "says nothing to Telegram for the %s phase",
+    async (phase) => {
+      await telegramTransport.setActivity!(topicCtx, {
+        chatId: "123",
+        phase,
+      });
+
+      expect(callTelegramBotApiMock).not.toHaveBeenCalled();
+    },
+  );
+
   test("a callback URL without threadId keeps sends thread-less", async () => {
     const bareCtx: CallbackContext = {
       callbackUrl: "/deliver/telegram",
       params: {},
     };
 
-    await telegramTransport.deliver(bareCtx, payload({ useBlocks: false }));
-    await telegramTransport.typing!(bareCtx, "123");
+    await telegramTransport.deliver(bareCtx, payload({ renderRichly: false }));
+    await telegramTransport.setActivity!(bareCtx, {
+      chatId: "123",
+      phase: "thinking",
+    });
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendMessage", {
       chat_id: "123",
@@ -300,3 +322,78 @@ describe("telegramTransport topic targeting", () => {
     });
   });
 });
+
+describe("editTelegramMessage", () => {
+  const ctx = { callbackUrl: "http://gw/deliver/telegram", params: {} };
+
+  const sendMessageCalls = () =>
+    callTelegramBotApiMock.mock.calls.filter(
+      (call) => call[0] === "sendMessage",
+    );
+
+  test("edits in place and never posts a new message", async () => {
+    await telegramTransport.edit!(ctx as CallbackContext, {
+      chatId: "123",
+      messageId: "456",
+      text: "revised",
+    });
+
+    expect(callTelegramBotApiMock).toHaveBeenCalledTimes(1);
+    const [method, body] = callTelegramBotApiMock.mock.calls[0]!;
+    expect(method).toBe("editMessageText");
+    // Telegram wants a numeric message id, where the capability carries the
+    // channel's id as a string.
+    expect(body).toEqual({
+      chat_id: "123",
+      message_id: 456,
+      text: "revised",
+      reply_markup: { inline_keyboard: [] },
+    });
+  });
+
+  test("clears the inline keyboard, so a settled message keeps no buttons", async () => {
+    await telegramTransport.edit!(ctx as CallbackContext, {
+      chatId: "123",
+      messageId: "456",
+      text: "\u2713 Approved",
+    });
+
+    const [, body] = callTelegramBotApiMock.mock.calls[0]!;
+    // Omitting reply_markup leaves an existing keyboard in place, which would
+    // leave live Approve and Reject buttons under text saying the request is
+    // already decided. The field has to be sent, and sent empty.
+    expect((body as Record<string, unknown>).reply_markup).toEqual({
+      inline_keyboard: [],
+    });
+  });
+
+  test("treats an unchanged message as already done", async () => {
+    callTelegramBotApiMock.mockImplementationOnce(async () => {
+      throw new TelegramNonRetryableError(
+        "Bad Request",
+        "Bad Request: message is not modified",
+      );
+    });
+
+    // The edit asked for a state the message is already in, which is the
+    // request satisfied rather than refused.
+    await expect(
+      editTelegramMessage("123", "456", "same"),
+    ).resolves.toBeUndefined();
+    expect(sendMessageCalls()).toHaveLength(0);
+  });
+
+  test("throws on any other rejection rather than posting a replacement", async () => {
+    callTelegramBotApiMock.mockImplementationOnce(async () => {
+      throw new TelegramNonRetryableError(
+        "Bad Request",
+        "Bad Request: message to edit not found",
+      );
+    });
+
+    // Posting instead would leave the original beside a duplicate, so the
+    // failure has to reach the caller.
+    await expect(editTelegramMessage("123", "456", "gone")).rejects.toThrow();
+    expect(sendMessageCalls()).toHaveLength(0);
+  });
+});

package/src/messaging/providers/telegram-bot/send.ts

@@ -137,6 +137,49 @@ export interface TelegramSendResult {
  * Send a Telegram text reply, splitting long messages and optionally
  * attaching inline keyboard buttons for approval prompts.
  */
+/**
+ * Replace a Telegram message in place.
+ *
+ * Telegram rejects an edit whose text already matches the message. That is the
+ * request having been satisfied rather than a failure, so it resolves. Every
+ * other rejection throws: an edit that quietly became a new message would
+ * leave the original sitting beside it, which reads as answering twice.
+ *
+ * Unlike a send, this cannot split long text across messages, because an edit
+ * addresses exactly one. Telegram rejects text past its limit, and that
+ * rejection reaches the caller rather than being papered over.
+ *
+ * The empty `reply_markup` is load-bearing. `editMessageText` leaves an
+ * existing inline keyboard alone when the field is omitted, so a message
+ * revised to read as settled would keep its live buttons beside that text.
+ * Every caller here edits a message into a settled state, and the approval
+ * interception path says so outright, so the keyboard goes with the revision.
+ */
+export async function editTelegramMessage(
+  chatId: string,
+  messageId: string,
+  text: string,
+): Promise<void> {
+  try {
+    await callTelegramBotApi<TelegramMessage>("editMessageText", {
+      chat_id: chatId,
+      message_id: Number(messageId),
+      text,
+      reply_markup: { inline_keyboard: [] },
+    });
+  } catch (err) {
+    if (
+      err instanceof TelegramNonRetryableError &&
+      err.description?.includes("message is not modified")
+    ) {
+      log.debug({ chatId, messageId }, "Telegram edit already applied");
+      return;
+    }
+    throw err;
+  }
+  log.debug({ chatId, messageId }, "Telegram message edited");
+}
+
 export async function sendTelegramReply(
   chatId: string,
   text: string,

package/src/messaging/providers/telegram-bot/transport.ts

@@ -5,8 +5,10 @@ import type {
   CallbackContext,
   ChannelTransport,
 } from "../channel-transport.js";
+import { isBusyActivityPhase } from "../channel-transport.js";
 import type { TelegramSendOptions } from "./send.js";
 import {
+  editTelegramMessage,
   sendTelegramAttachments,
   sendTelegramReply,
   sendTelegramRichReply,
@@ -27,16 +29,18 @@ function threadOptions(ctx: CallbackContext): TelegramSendOptions | undefined {
 export const telegramTransport: ChannelTransport = {
   channel: "telegram",
 
+  // Telegram clears a chat action after about five seconds.
+  activityRefreshMs: 4_000,
+
   async deliver(ctx, payload) {
     const { chatId, text, attachments, approval } = payload;
     const opts = threadOptions(ctx);
 
     if (text) {
-      // `useBlocks` is the channel-neutral "render richly" intent set by the
-      // delivery layer; the Telegram adapter honors it by forwarding markdown
-      // to `sendRichMessage`, degrading to plain text otherwise (and on any
-      // rich-send rejection).
-      if (payload.useBlocks) {
+      // Telegram answers a rich render by forwarding markdown to
+      // `sendRichMessage`, degrading to plain text otherwise and on any
+      // rich-send rejection.
+      if (payload.renderRichly) {
         await sendTelegramRichReply(chatId, text, approval, opts);
       } else {
         await sendTelegramReply(chatId, text, approval, opts);
@@ -67,9 +71,22 @@ export const telegramTransport: ChannelTransport = {
     return { ok: true };
   },
 
-  async typing(ctx, chatId) {
-    await sendTelegramTypingIndicator(chatId, threadOptions(ctx));
-    log.debug({ chatId }, "Telegram typing indicator delivered (direct)");
+  async edit(_ctx, target) {
+    await editTelegramMessage(target.chatId, target.messageId, target.text);
+    return { ok: true };
+  },
+
+  async setActivity(ctx, target) {
+    // Telegram's chat action expires by itself after a few seconds, so a phase
+    // that is not running needs no clearing call.
+    if (!isBusyActivityPhase(target.phase)) {
+      return { ok: true };
+    }
+    await sendTelegramTypingIndicator(target.chatId, threadOptions(ctx));
+    log.debug(
+      { chatId: target.chatId, phase: target.phase },
+      "Telegram typing indicator delivered (direct)",
+    );
     return { ok: true };
   },
 };

package/src/notifications/__tests__/assistant-reply-producer.test.ts

@@ -200,6 +200,17 @@ function makeMacOriginatedMessage(): MessageRow {
   });
 }
 
+function makeWindowsOriginatedMessage(): MessageRow {
+  return makeMessage({
+    metadata: JSON.stringify({
+      userMessageChannel: "vellum",
+      userMessageInterface: "web",
+      client: { os: "windows" },
+      clientOsFromRequest: true,
+    }),
+  });
+}
+
 /**
  * A turn opened from a plain browser tab, as opposed to the Electron desktop
  * renderer sharing the same web bundle: `client.os` is `"web"` only when
@@ -347,7 +358,7 @@ describe("emitAssistantReplyNotification", () => {
       desktopAttended = true;
     });
 
-    test("marks the signal source-active while a Mac reports itself attended", async () => {
+    test("marks the signal source-active while a desktop reports itself attended", async () => {
       await run();
 
       expect(emitCalls).toHaveLength(1);
@@ -357,7 +368,16 @@ describe("emitAssistantReplyNotification", () => {
       expect(desktopPresenceArgs).toEqual([[]]);
     });
 
-    test("leaves the signal live when no Mac is attended", async () => {
+    test("marks a Windows-originated signal source-active while attended", async () => {
+      initiatingRow = makeWindowsOriginatedMessage();
+
+      await run();
+
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].attentionHints.visibleInSourceNow).toBe(true);
+    });
+
+    test("leaves the signal live when no desktop is attended", async () => {
       desktopAttended = false;
 
       await run();
@@ -386,10 +406,13 @@ describe("emitAssistantReplyNotification", () => {
       expect(warnCalls).toHaveLength(1);
     });
 
-    // An attended Mac only speaks for a turn the Mac itself opened: the user
-    // can send from the phone minutes after last touching the keyboard, which
+    // An attended desktop only speaks for a turn that desktop itself opened.
+    // The user can send from the phone minutes after last touching the keyboard,
     // is exactly the reply this producer exists to push.
-    const NON_MAC_ORIGIN_CASES: Array<{ name: string; metadata: unknown }> = [
+    const NON_DESKTOP_ORIGIN_CASES: Array<{
+      name: string;
+      metadata: unknown;
+    }> = [
       {
         name: "the iOS app",
         metadata: { client: { os: "ios" }, clientOsFromRequest: true },
@@ -412,7 +435,7 @@ describe("emitAssistantReplyNotification", () => {
       // `macos` the conversation's live client state kept from an earlier
       // desktop send. Without the marker that OS names an earlier turn, not
       // this one, and the push the user is waiting for on their phone would
-      // be dropped by the attended Mac.
+      // be dropped by the attended desktop.
       {
         name: "a row whose macOS OS was inherited, not reported",
         metadata: { userMessageInterface: "web", client: { os: "macos" } },
@@ -424,7 +447,7 @@ describe("emitAssistantReplyNotification", () => {
       },
     ];
 
-    for (const { name, metadata } of NON_MAC_ORIGIN_CASES) {
+    for (const { name, metadata } of NON_DESKTOP_ORIGIN_CASES) {
       test(`leaves the signal live for a turn opened from ${name}`, async () => {
         initiatingRow = makeMessage({ metadata: JSON.stringify(metadata) });
 

package/src/notifications/adapters/telegram.ts

@@ -8,13 +8,18 @@
  * plain text with typed-command instructions.
  */
 
-import { sendTelegramReply } from "../../messaging/providers/telegram-bot/send.js";
+import {
+  editTelegramMessage,
+  sendTelegramReply,
+} from "../../messaging/providers/telegram-bot/send.js";
 import { ConfigError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import type {
   ChannelAdapter,
   ChannelDeliveryPayload,
   ChannelDestination,
+  ChannelUpdateContext,
+  ChannelUpdatePayload,
   DeliveryResult,
   NotificationChannel,
 } from "../types.js";
@@ -97,4 +102,46 @@ export class TelegramAdapter implements ChannelAdapter {
       return { success: false, error: message };
     }
   }
+
+  /**
+   * Replace a delivered notification in place, so a card that has been
+   * answered or withdrawn stops reading as still waiting.
+   *
+   * `editTelegramMessage` clears the card's inline keyboard as part of the
+   * revision, so a card rewritten to read as settled cannot keep live Approve
+   * and Reject buttons beside that text.
+   */
+  async update(
+    delivery: ChannelUpdateContext,
+    patch: ChannelUpdatePayload,
+  ): Promise<DeliveryResult> {
+    if (!delivery.messageId) {
+      return {
+        success: false,
+        error:
+          "missing_message_id: this delivery has no captured Telegram message id",
+      };
+    }
+    const text = patch.body?.trim() || patch.title?.trim();
+    if (!text) {
+      return { success: false, error: "no body or title supplied for update" };
+    }
+    try {
+      await editTelegramMessage(delivery.destination, delivery.messageId, text);
+      log.info(
+        { chatId: delivery.destination, messageId: delivery.messageId },
+        "Telegram notification updated",
+      );
+      // An edit keeps the message it addressed, so the delivery row's id
+      // still identifies the card.
+      return { success: true, messageId: delivery.messageId };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        { err, chatId: delivery.destination, messageId: delivery.messageId },
+        "Failed to update Telegram notification",
+      );
+      return { success: false, error: message };
+    }
+  }
 }

package/src/notifications/assistant-reply-producer.ts

@@ -23,7 +23,7 @@ import {
   parseMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import {
-  isMacOriginatedUserMessage,
+  isDesktopOriginatedUserMessage,
   isReplyPushIneligibleUserMessage,
   resolveConversationKind,
 } from "../persistence/conversation-types.js";
@@ -122,7 +122,7 @@ function readSuppressionMarkers(
  *
  * No `actorPrincipalId`: the platform delivers this push to the assistant
  * owner's device tokens, and a pod has exactly one owner, so any attended
- * macOS client is that owner's.
+ * desktop client is that owner's.
  */
 function readDesktopAttended(rlog: pino.Logger): boolean {
   try {
@@ -246,12 +246,12 @@ export async function emitAssistantReplyNotification(params: {
     );
 
     // Read as close to the emit as possible: nothing short-circuits on it.
-    // Presence only speaks for a turn the Mac itself opened, on that row's own
-    // OS evidence. A turn sent from the phone still needs its push while the
-    // Mac sits idle within the desktop client's attendance window.
+    // Presence only speaks for a turn the desktop itself opened, on that row's
+    // own OS evidence. A turn sent from the phone still needs its push while the
+    // desktop sits idle within the attendance window.
     const desktopAttended =
       isAssistantFeatureFlagEnabled(DESKTOP_PRESENCE_FLAG) &&
-      isMacOriginatedUserMessage(initiatingMetadata) &&
+      isDesktopOriginatedUserMessage(initiatingMetadata) &&
       readDesktopAttended(rlog);
 
     // Conversation-scoped web presence applies regardless of which device
@@ -276,7 +276,7 @@ export async function emitAssistantReplyNotification(params: {
         // opting into v2.
         urgency: "medium",
         isAsyncBackground: false,
-        // Read weakly, as "at the surface this landed on": the attended Mac
+        // Read weakly, as "at the surface this landed on": the attended desktop
         // or focused web tab that opened the turn renders the reply in-app,
         // so a redundant push would only duplicate what's already on screen.
         visibleInSourceNow: desktopAttended || webFocused,

package/src/notifications/conversation-seed-composer.ts

@@ -3,7 +3,7 @@
  *
  * Generates richer seed content for notification conversations than the concise
  * title/body used in native notification popups. Verbosity adapts to the
- * delivery surface: vellum/macos gets flowing prose, telegram gets compact.
+ * delivery surface: Vellum desktop gets flowing prose, Telegram gets compact.
  *
  * Composes from `copy.title/body` rather than hardcoded English templates
  * so LLM-localized copy is preserved for non-English users.
@@ -25,7 +25,12 @@ const CHANNEL_DEFAULT_INTERFACE: Record<string, InterfaceId> = {
   telegram: "telegram",
 };
 
-const RICH_INTERFACES = new Set<InterfaceId>(["macos", "ios", "web"]);
+const RICH_INTERFACES = new Set<InterfaceId>([
+  "macos",
+  "windows",
+  "ios",
+  "web",
+]);
 
 /**
  * Resolve verbosity level from delivery channel + optional interface hint.

package/src/oauth/byo-connection.test.ts

@@ -358,6 +358,43 @@ describe("BYOOAuthConnection", () => {
       expect(headers.get("Content-Type")).toBe("application/json");
     });
 
+    test("sends a string body verbatim under the caller's Content-Type", async () => {
+      await setupCredential("google");
+      const conn = createConnection();
+      const multipart =
+        "--boundary\r\nContent-Type: application/json\r\n\r\n{}\r\n--boundary--\r\n";
+
+      await conn.request({
+        method: "POST",
+        path: "/upload/drive/v3/files",
+        headers: { "Content-Type": "multipart/related; boundary=boundary" },
+        body: multipart,
+      });
+
+      const [, init] = mockFetch.mock.calls[0];
+      expect((init as RequestInit).body).toBe(multipart);
+      const headers = (init as RequestInit).headers as Headers;
+      expect(headers.get("Content-Type")).toBe(
+        "multipart/related; boundary=boundary",
+      );
+    });
+
+    test("does not force a JSON Content-Type onto a string body", async () => {
+      await setupCredential("google");
+      const conn = createConnection();
+
+      await conn.request({
+        method: "POST",
+        path: "/upload",
+        body: "name=sheet&kind=grid",
+      });
+
+      const [, init] = mockFetch.mock.calls[0];
+      expect((init as RequestInit).body).toBe("name=sheet&kind=grid");
+      const headers = (init as RequestInit).headers as Headers;
+      expect(headers.has("Content-Type")).toBe(false);
+    });
+
     test("retries once on 401 response", async () => {
       await setupCredential("google");
       const conn = createConnection();
@@ -420,6 +457,32 @@ describe("BYOOAuthConnection", () => {
       expect(result.body).toBe("plain text response");
     });
 
+    test("preserves non-ASCII binary bytes for media downloads", async () => {
+      await setupCredential("google");
+      const conn = createConnection();
+      const binary = Buffer.from([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0xff, 0xfe, 0x00,
+      ]);
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(binary, {
+            status: 200,
+            headers: { "content-type": "application/octet-stream" },
+          }),
+        ),
+      ) as unknown as typeof fetch;
+
+      const result = await conn.request({
+        method: "GET",
+        path: "/drive/v3/files/file-123?alt=media",
+      });
+
+      expect(result.status).toBe(200);
+      expect(Buffer.isBuffer(result.body)).toBe(true);
+      expect(Buffer.from(result.body as Uint8Array).equals(binary)).toBe(true);
+    });
+
     test("returns response headers", async () => {
       await setupCredential("google");
       const conn = createConnection();

package/src/oauth/byo-connection.ts

@@ -14,6 +14,7 @@ import type {
   OAuthConnectionRequest,
   OAuthConnectionResponse,
 } from "./connection.js";
+import { decodeOAuthResponseBytes } from "./connection.js";
 
 const log = getLogger("byo-oauth-connection");
 
@@ -80,10 +81,17 @@ export class BYOOAuthConnection implements OAuthConnection {
           "Making authenticated request",
         );
 
+        // A string body is already in its wire form (multipart, XML,
+        // form-encoded, or pre-serialized JSON) and travels verbatim under
+        // the caller's own Content-Type. Objects and arrays are serialized
+        // as JSON and get the JSON Content-Type by default.
+        const hasBody = req.body !== undefined && req.body !== null;
+        const rawBody = typeof req.body === "string" ? req.body : undefined;
+
         // Use the Headers API for case-insensitive merging. Set defaults
         // first so caller-supplied headers (in any casing) override them.
         const headers = new Headers();
-        if (req.body) {
+        if (hasBody && rawBody === undefined) {
           headers.set("Content-Type", "application/json");
         }
         if (req.headers) {
@@ -98,7 +106,7 @@ export class BYOOAuthConnection implements OAuthConnection {
         const resp = await fetch(fullUrl, {
           method: req.method,
           headers,
-          body: req.body ? JSON.stringify(req.body) : undefined,
+          body: hasBody ? (rawBody ?? JSON.stringify(req.body)) : undefined,
           signal: req.signal
             ? AbortSignal.any([
                 req.signal,
@@ -150,17 +158,10 @@ async function buildResponse(resp: Response): Promise<OAuthConnectionResponse> {
     headers[key] = value;
   });
 
-  let body: unknown;
-  const text = await resp.text().catch(() => "");
-  if (text) {
-    try {
-      body = JSON.parse(text);
-    } catch {
-      body = text;
-    }
-  } else {
-    body = null;
-  }
-
-  return { status: resp.status, headers, body };
+  const raw = Buffer.from(await resp.arrayBuffer());
+  return {
+    status: resp.status,
+    headers,
+    body: decodeOAuthResponseBytes(raw, headers["content-type"] ?? ""),
+  };
 }