@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/__tests__/guardian-gateway-sim.ts

@@ -23,6 +23,7 @@
 import { randomUUID } from "node:crypto";
 
 import {
+  DELIVERY_STATUS,
   deriveGuardianRequestSourceType,
   isGuardianRequestExpired,
 } from "@vellumai/gateway-client";
@@ -177,7 +178,7 @@ export function createGuardianGatewaySim() {
       destinationConversationId: params.destinationConversationId ?? null,
       destinationChatId: params.destinationChatId ?? null,
       destinationMessageId: params.destinationMessageId ?? null,
-      status: params.status ?? "pending",
+      status: params.status ?? DELIVERY_STATUS.pending,
       createdAt: params.createdAt ?? now,
       updatedAt: params.updatedAt ?? now,
     };
@@ -290,6 +291,11 @@ export function createGuardianGatewaySim() {
     if (!row || row.status !== params.expectedStatus) {
       return { applied: false, reason: "status_conflict" };
     }
+    // Mirrors the gateway decide CAS: the deadline is part of the
+    // arbitration, so a decision arriving past expiresAt loses atomically.
+    if (isGuardianRequestExpired(row, Date.now())) {
+      return { applied: false, reason: "status_conflict" };
+    }
     if (state.outcomeError && params.aclOutcome) {
       // Gateway transaction rollback: the CAS never lands.
       throw state.outcomeError;
@@ -344,14 +350,22 @@ export function createGuardianGatewaySim() {
   }
 
   async function expireGuardianRequest(id: string): Promise<void> {
+    // Mirrors the gateway: deliveries expire only when the request CAS
+    // applies, so a decided request's rows are never restamped.
     const row = requests.get(id);
-    if (row?.status === "pending") {
-      row.status = "expired";
-      row.updatedAt = Date.now();
+    if (row?.status !== "pending") {
+      return;
     }
+    row.status = "expired";
+    row.updatedAt = Date.now();
     for (const delivery of deliveries) {
-      if (delivery.requestId === id) {
-        delivery.status = "expired";
+      // A withdrawn row is the daemon's per-surface receipt; the gateway
+      // preserves it through the bulk flip.
+      if (
+        delivery.requestId === id &&
+        delivery.status !== DELIVERY_STATUS.withdrawn
+      ) {
+        delivery.status = DELIVERY_STATUS.expired;
         delivery.updatedAt = Date.now();
       }
     }
@@ -364,9 +378,13 @@ export function createGuardianGatewaySim() {
       if (row.status !== "pending") {
         continue;
       }
+      // Mirrors the gateway contract: only the kinds that die with the
+      // daemon's in-memory pendingInteractions map expire at boot.
+      // Persistent kinds stay pending, whatever their deadline; their
+      // expiry belongs to the sweep, which owns the fan-out.
       const interactionBound =
         row.kind === "tool_approval" || row.kind === "pending_question";
-      if (interactionBound || isGuardianRequestExpired(row, now)) {
+      if (interactionBound) {
         row.status = "expired";
         row.updatedAt = now;
         expired += 1;
@@ -375,19 +393,18 @@ export function createGuardianGatewaySim() {
     return expired;
   }
 
-  async function sweepExpiredGuardianRequests(
-    now?: number,
+  async function listExpiredPendingGuardianRequests(
+    limit = 50,
   ): Promise<SimGuardianRequest[]> {
-    const cutoff = now ?? Date.now();
-    const expired: SimGuardianRequest[] = [];
+    const cutoff = Date.now();
+    const stale: SimGuardianRequest[] = [];
     for (const row of requests.values()) {
       if (row.status === "pending" && isGuardianRequestExpired(row, cutoff)) {
-        row.status = "expired";
-        row.updatedAt = cutoff;
-        expired.push({ ...row });
+        stale.push({ ...row });
       }
     }
-    return expired;
+    stale.sort((a, b) => (a.expiresAt ?? 0) - (b.expiresAt ?? 0));
+    return stale.slice(0, limit);
   }
 
   async function createGuardianRequestDelivery(
@@ -406,7 +423,13 @@ export function createGuardianGatewaySim() {
     if (!row) {
       throw new Error(`sim: delivery ${id} not found`);
     }
-    Object.assign(row, patch, { updatedAt: Date.now() });
+    // Mirrors the gateway store: `withdrawn` is a terminal per-surface
+    // receipt a later status patch never overwrites.
+    const effectivePatch =
+      row.status === "withdrawn" && patch.status !== undefined
+        ? { ...patch, status: row.status }
+        : patch;
+    Object.assign(row, effectivePatch, { updatedAt: Date.now() });
   }
 
   async function listGuardianRequestDeliveries(
@@ -418,6 +441,19 @@ export function createGuardianGatewaySim() {
       .map((d) => ({ ...d }));
   }
 
+  async function listGuardianRequestDeliveriesByChat(
+    channel: string,
+    chatId: string,
+  ): Promise<SimGuardianDelivery[]> {
+    throwIfReadError();
+    return deliveries
+      .filter(
+        (d) =>
+          d.destinationChannel === channel && d.destinationChatId === chatId,
+      )
+      .map((d) => ({ ...d }));
+  }
+
   async function getPendingRequestByDestinationMessage(
     channel: string,
     chatId: string,
@@ -504,7 +540,6 @@ export function createGuardianGatewaySim() {
   async function isGuardianRequestInScope(
     requestId: string,
     conversationId: string,
-    channel?: string,
   ): Promise<boolean> {
     throwIfReadError();
     const request = requests.get(requestId);
@@ -517,8 +552,7 @@ export function createGuardianGatewaySim() {
     return deliveries.some(
       (d) =>
         d.requestId === requestId &&
-        d.destinationConversationId === conversationId &&
-        (!channel || d.destinationChannel === channel),
+        d.destinationConversationId === conversationId,
     );
   }
 
@@ -575,15 +609,17 @@ export function createGuardianGatewaySim() {
     getGuardianRequest,
     getGuardianRequestOrNull: degrade(getGuardianRequest, null),
     getGuardianRequestByCodeOrNull: degrade(getGuardianRequestByCode, null),
+    listGuardianRequests,
     listGuardianRequestsOrEmpty: degrade(listGuardianRequests, []),
     updateGuardianRequest,
     decideGuardianRequest,
     expireGuardianRequest,
     expireInteractionBoundGuardianRequests,
-    sweepExpiredGuardianRequests,
+    listExpiredPendingGuardianRequests,
     createGuardianRequestDelivery,
     updateGuardianRequestDelivery,
     listGuardianRequestDeliveries,
+    listGuardianRequestDeliveriesByChat,
     listGuardianRequestDeliveriesOrEmpty: degrade(
       listGuardianRequestDeliveries,
       [],

package/src/__tests__/guardian-reply-router-answer-mode.test.ts

@@ -34,7 +34,13 @@ mock.module("../approvals/guardian-decision-primitive.js", () => ({
     applyGuardianDecisionMock(params),
 }));
 
+// Spread the actual module so transitive importers of names this
+// factory does not stub keep resolving (a partial factory breaks at
+// import time when the graph gains a new named import).
+const actualGatewayGuardianRequests =
+  await import("../channels/gateway-guardian-requests.js");
 mock.module("../channels/gateway-guardian-requests.js", () => ({
+  ...actualGatewayGuardianRequests,
   getGuardianRequestOrNull: (id: string) =>
     Promise.resolve(requestsById.get(id) ?? null),
   getGuardianRequestByCodeOrNull: () => Promise.resolve(null),

package/src/__tests__/guardian-request-status-sync.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const completeSurfaceAndNotify = mock(() => true);
+const markSurfaceCompleted = mock(() => true);
+mock.module("../daemon/conversation-surfaces.js", () => ({
+  completeSurfaceAndNotify,
+  markSurfaceCompleted,
+}));
+
+const withdrawSlackApprovalCard = mock(
+  async (_params: Record<string, unknown>) => {},
+);
+mock.module("../messaging/providers/slack/withdraw.js", () => ({
+  withdrawSlackApprovalCard,
+}));
+
+const withdrawDiscordApprovalCard = mock(async (_params: unknown) => undefined);
+mock.module("../messaging/providers/discord/withdraw.js", () => ({
+  withdrawDiscordApprovalCard,
+}));
+
+const withdrawTelegramApprovalCard = mock(
+  async (_params: Record<string, unknown>) => ({ complete: true }),
+);
+mock.module("../messaging/providers/telegram-bot/withdraw.js", () => ({
+  withdrawTelegramApprovalCard,
+}));
+
+import {
+  bridgeState,
+  gatewayGuardianRequestsStoreBridge,
+} from "./helpers/gateway-guardian-requests-store-bridge.js";
+
+mock.module(
+  "../channels/gateway-guardian-requests.js",
+  () => gatewayGuardianRequestsStoreBridge,
+);
+
+import { syncTerminalGuardianRequestStatus } from "../approvals/guardian-request-status-sync.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+const PRINCIPAL_ID = "status-sync-test-principal";
+
+function makeRequest(overrides: Record<string, unknown> = {}) {
+  return bridgeState.seedRequest({
+    kind: "tool_approval",
+    sourceType: "channel",
+    sourceChannel: "slack",
+    toolName: "shell",
+    guardianPrincipalId: PRINCIPAL_ID,
+    ...overrides,
+  });
+}
+
+function deliveriesFor(requestId: string) {
+  return bridgeState.deliveries.filter((d) => d.requestId === requestId);
+}
+
+describe("syncTerminalGuardianRequestStatus", () => {
+  beforeEach(() => {
+    bridgeState.reset();
+    completeSurfaceAndNotify.mockClear();
+    markSurfaceCompleted.mockClear();
+    withdrawSlackApprovalCard.mockClear();
+  });
+
+  test("a landed CAS withdraws every delivered projection", async () => {
+    const req = makeRequest();
+    const vellum = bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "vellum",
+      destinationConversationId: "conv-thread",
+    });
+    const slack = bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "slack",
+      destinationChatId: "C1",
+      destinationMessageId: "1.0",
+      destinationConversationId: "conv-dm",
+    });
+
+    await syncTerminalGuardianRequestStatus({
+      requestId: req.id,
+      status: "approved",
+      syncContext: "test",
+    });
+
+    expect(bridgeState.requests.get(req.id)?.status).toBe("approved");
+    // Both in-app projections converge live (no origin channel: the acting
+    // surface was the confirmation prompt, never the card).
+    expect(completeSurfaceAndNotify).toHaveBeenCalledWith(
+      "conv-thread",
+      `tool-approval-${req.id}`,
+      "Approved",
+    );
+    expect(completeSurfaceAndNotify).toHaveBeenCalledWith(
+      "conv-dm",
+      `tool-approval-${req.id}`,
+      "Approved",
+    );
+    expect(withdrawSlackApprovalCard).toHaveBeenCalledTimes(1);
+    const byId = new Map(deliveriesFor(req.id).map((d) => [d.id, d.status]));
+    expect(byId.get(vellum.id)).toBe("withdrawn");
+    expect(byId.get(slack.id)).toBe("withdrawn");
+  });
+
+  test("a denial renders Denied on the withdrawn cards", async () => {
+    const req = makeRequest();
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "vellum",
+      destinationConversationId: "conv-thread",
+    });
+
+    await syncTerminalGuardianRequestStatus({
+      requestId: req.id,
+      status: "denied",
+      syncContext: "test",
+    });
+
+    expect(bridgeState.requests.get(req.id)?.status).toBe("denied");
+    expect(completeSurfaceAndNotify).toHaveBeenCalledWith(
+      "conv-thread",
+      `tool-approval-${req.id}`,
+      "Denied",
+    );
+  });
+
+  test("a CAS miss leaves withdrawal to the path that resolved the request", async () => {
+    const req = makeRequest({ status: "approved" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "vellum",
+      destinationConversationId: "conv-thread",
+    });
+
+    await syncTerminalGuardianRequestStatus({
+      requestId: req.id,
+      status: "approved",
+      syncContext: "test",
+    });
+
+    expect(completeSurfaceAndNotify).not.toHaveBeenCalled();
+    expect(withdrawSlackApprovalCard).not.toHaveBeenCalled();
+  });
+
+  test("never throws when the gateway is unreachable", async () => {
+    const req = makeRequest();
+    bridgeState.state.decideError = new Error("gateway down");
+    await expect(
+      syncTerminalGuardianRequestStatus({
+        requestId: req.id,
+        status: "approved",
+        syncContext: "test",
+      }),
+    ).resolves.toBeUndefined();
+    bridgeState.state.decideError = null;
+    expect(completeSurfaceAndNotify).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/guardian-wait-controller.test.ts

@@ -37,7 +37,13 @@ mock.module("../util/logger.js", () => ({
 
 // Gateway guardian-request client — in-memory map driven by tests.
 const guardianRequests = new Map<string, GuardianRequestWire>();
+// Spread the actual module so transitive importers of names this
+// factory does not stub keep resolving (a partial factory breaks at
+// import time when the graph gains a new named import).
+const actualGatewayGuardianRequests =
+  await import("../channels/gateway-guardian-requests.js");
 mock.module("../channels/gateway-guardian-requests.js", () => ({
+  ...actualGatewayGuardianRequests,
   getGuardianRequestOrNull: async (id: string) =>
     guardianRequests.get(id) ?? null,
 }));

package/src/__tests__/headless-browser-mode.test.ts

@@ -148,6 +148,7 @@ import {
   formatModeSelectionFailure,
   parseBrowserMode,
 } from "../tools/browser/browser-execution.js";
+import { CHROME_WEB_STORE_INSTALL_URL } from "../tools/browser/browser-status-constants.js";
 import type { ToolContext } from "../tools/types.js";
 
 // Restore all module mocks after this file completes so they don't
@@ -305,6 +306,7 @@ describe("formatModeSelectionFailure", () => {
     );
     expect(formatted).toContain("Remediation:");
     expect(formatted).toContain("extension is installed and enabled");
+    expect(formatted).toContain(CHROME_WEB_STORE_INSTALL_URL);
   });
 
   test("renders cdp-inspect transport_error with remediation", () => {
@@ -331,6 +333,29 @@ describe("formatModeSelectionFailure", () => {
     expect(formatted).toContain("Remediation:");
     expect(formatted).toContain("--remote-debugging-port");
   });
+
+  test("includes the Chrome Web Store install URL for host-bridge failures", () => {
+    const diagnostics: AttemptDiagnostic[] = [
+      {
+        candidateKind: "host-bridge",
+        inclusionReason: "auto candidate",
+        stage: "send",
+        errorCode: "transport_error",
+        errorMessage: "desktop client could not reach Chrome",
+      },
+    ];
+
+    const error = new CdpError(
+      "transport_error",
+      "Host bridge unreachable",
+      { attemptDiagnostics: diagnostics },
+    );
+
+    const formatted = formatModeSelectionFailure("auto", error);
+
+    expect(formatted).toContain("Remediation:");
+    expect(formatted).toContain(CHROME_WEB_STORE_INSTALL_URL);
+  });
 });
 
 describe("browser_mode wiring through tool execution", () => {
@@ -398,6 +423,7 @@ describe("browser_mode wiring through tool execution", () => {
     );
     expect(result.content).toContain("Remediation:");
     expect(result.content).toContain("extension is installed and enabled");
+    expect(result.content).toContain(CHROME_WEB_STORE_INSTALL_URL);
     // Factory should not have been called for CDP
     expect(cdpSendCalls).toEqual([]);
   });
@@ -585,6 +611,7 @@ describe("browser_mode wiring through tool execution", () => {
     expect(result.content).toContain("Reason: Host browser not reachable");
     expect(result.content).toContain("Remediation:");
     expect(result.content).toContain("extension is installed and enabled");
+    expect(result.content).toContain(CHROME_WEB_STORE_INSTALL_URL);
   });
 
   test("pinned extension with timeout transport error surfaces failover diagnostics in snapshot", async () => {

package/src/__tests__/helpers/mock-conversation.ts

@@ -36,6 +36,8 @@ export function asConversation<TExtra extends object = object>(
     getTrustContext: () => merged.trustContext,
     getTurnOrRestingTrust: () =>
       merged.currentTurnTrustContext ?? merged.trustContext,
+    isStale: () => false,
+    hasInFlightWork: () => false,
     ...mock,
   };
   return merged as unknown as Conversation & TExtra;

package/src/__tests__/list-messages-system-card.test.ts

@@ -19,6 +19,7 @@ import { ConversationMessageSchema } from "../api/responses/conversation-message
 import {
   addMessage,
   createConversation,
+  NO_RESPONSE_MESSAGE_KIND,
   SYSTEM_CARD_MESSAGE_KIND,
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
@@ -39,6 +40,7 @@ interface ProjectedMessage {
   id: string;
   role: string;
   systemCard?: boolean;
+  noResponse?: boolean;
 }
 
 describe("handleListMessages system-card projection", () => {
@@ -74,6 +76,74 @@ describe("handleListMessages system-card projection", () => {
     expect(cardRow?.systemCard).toBe(true);
   });
 
+  test("projects noResponse from the deliberate-silence marker", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "thanks!" }]),
+    );
+    // Mirror the agent loop's turn-boundary stamp: the row keeps the raw
+    // sentinel as content and carries the marker in metadata.
+    const silent = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "<no_response/>" }]),
+      { metadata: { messageKind: NO_RESPONSE_MESSAGE_KIND } },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: { conversationId: conv.id },
+    })) as { messages: ProjectedMessage[] };
+
+    for (const message of response.messages) {
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+
+    const silentRow = response.messages.find((m) => m.id === silent.id);
+    expect(silentRow?.noResponse).toBe(true);
+  });
+
+  test("projects the reaction fact from a reaction row's envelope", async () => {
+    const conv = createConversation();
+    const row = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "[reaction]" }]),
+      {
+        metadata: {
+          messageKind: "reaction",
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.1",
+              emoji: "🎉",
+              op: "added",
+            },
+          }),
+        },
+      },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: { conversationId: conv.id },
+    })) as {
+      messages: Array<
+        ProjectedMessage & {
+          reaction?: { emoji: string; selfAuthored?: boolean };
+        }
+      >;
+    };
+    for (const message of response.messages) {
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+    const projected = response.messages.find((m) => m.id === row.id);
+    expect(projected?.reaction?.emoji).toBe("🎉");
+    expect(projected?.reaction?.selfAuthored).toBe(true);
+  });
+
   test("omits systemCard on ordinary user and assistant rows", async () => {
     const conv = createConversation();
     await addMessage(

package/src/__tests__/llm-catalog-parity.test.ts

@@ -51,6 +51,7 @@ interface ClientCatalogModel {
   longContextMode?: "native-model" | "provider-request-option" | "unsupported";
   supportsThinking?: boolean;
   adaptiveThinkingOnly?: boolean;
+  thinkingFloor?: "minimal" | "low";
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
@@ -198,6 +199,7 @@ describe("LLM catalog parity: daemon vs client", () => {
         expect(clientModel.adaptiveThinkingOnly).toBe(
           daemonModel.adaptiveThinkingOnly,
         );
+        expect(clientModel.thinkingFloor).toBe(daemonModel.thinkingFloor);
         expect(clientModel.supportsCaching).toBe(daemonModel.supportsCaching);
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);

package/src/__tests__/managed-profile-guard.test.ts

@@ -1118,7 +1118,7 @@ describe("code-owned default profiles — wire view and write normalization", ()
     });
     const response = (await getRoute.handler({})) as Record<string, any>;
     const wireBalanced = response.llm.profiles.balanced;
-    expect(wireBalanced.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(wireBalanced.model).toBe("accounts/fireworks/models/glm-5p3-flash");
     expect(wireBalanced.provider).toBe("vellum");
     expect(wireBalanced.provider_connection).toBeUndefined();
     expect(wireBalanced.status).toBe("disabled");
@@ -1366,7 +1366,7 @@ describe("code-owned default profiles — echoes over stale on-disk bodies", ()
     const response = (await getRoute.handler({})) as Record<string, any>;
     // The wire view serves catalog content, not the stale body.
     expect(response.llm.profiles.balanced.model).toBe(
-      "accounts/fireworks/models/glm-5p2",
+      "accounts/fireworks/models/glm-5p3-flash",
     );
     const result = await patchRoute.handler({
       body: { llm: { profiles: response.llm.profiles } },

package/src/__tests__/media-resolve-image-validation.test.ts

@@ -13,6 +13,7 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import {
   isUnsendableImageSource,
+  mediaSourceDescriptor,
   resolveMediaReferences,
   UNSENDABLE_IMAGE_FORMAT_NOTE,
 } from "../providers/media-resolve.js";
@@ -221,6 +222,111 @@ describe("resolveMediaReferences image validation", () => {
   });
 });
 
+describe("resolveMediaReferences attachment id", () => {
+  beforeEach(resetTables);
+
+  test("carries a file block's attachment id across reference resolution", async () => {
+    // Resolving a reference rebuilds the block around freshly read bytes. The
+    // id is the block's only remaining link to its attachment row, so it has to
+    // survive the rebuild.
+    const conv = createConversation();
+    const stored = await createInlineAttachment(
+      conv.id,
+      conv.createdAt,
+      "notes.txt",
+      "text/plain",
+      Buffer.from("hello").toString("base64"),
+    );
+    const message = userMessage([
+      {
+        type: "file",
+        source: {
+          type: "workspace_ref",
+          media_type: "text/plain",
+          attachmentId: stored.id,
+          sizeBytes: stored.sizeBytes,
+          filename: "notes.txt",
+        },
+        _attachmentId: stored.id,
+      },
+    ]);
+
+    const [resolved] = await resolveMediaReferences([message]);
+
+    const block = resolved.content[0];
+    expect(block.type).toBe("file");
+    expect(block).toMatchObject({
+      source: { type: "base64" },
+      _attachmentId: stored.id,
+    });
+  });
+
+  test("omits the field when the source block carries no id", async () => {
+    const conv = createConversation();
+    const stored = await createInlineAttachment(
+      conv.id,
+      conv.createdAt,
+      "plain.txt",
+      "text/plain",
+      Buffer.from("hi").toString("base64"),
+    );
+    const message = userMessage([
+      {
+        type: "file",
+        source: {
+          type: "workspace_ref",
+          media_type: "text/plain",
+          attachmentId: stored.id,
+          sizeBytes: stored.sizeBytes,
+          filename: "plain.txt",
+        },
+      },
+    ]);
+
+    const [resolved] = await resolveMediaReferences([message]);
+
+    expect("_attachmentId" in resolved.content[0]).toBe(false);
+  });
+});
+
+describe("mediaSourceDescriptor", () => {
+  // The fragment every media stub embeds. Both the retry path's stubs and the
+  // camera-frame stub read it from here, so this pins what they all report.
+  test("describes a reference from its persisted size hint", () => {
+    expect(
+      mediaSourceDescriptor({
+        type: "workspace_ref",
+        media_type: "image/jpeg",
+        attachmentId: "att-1",
+        sizeBytes: 1024,
+      }),
+    ).toBe("image/jpeg, 1024 bytes");
+  });
+
+  test("describes an inline block from its base64 length", () => {
+    // 8 base64 chars decode to 6 bytes.
+    expect(
+      mediaSourceDescriptor({
+        type: "base64",
+        media_type: "image/png",
+        data: "AAAAAAAA",
+      }),
+    ).toBe("image/png, 6 bytes");
+  });
+
+  test("covers non-image media too", () => {
+    expect(
+      mediaSourceDescriptor({
+        type: "workspace_ref",
+        media_type: "application/pdf",
+        attachmentId: "att-2",
+        sizeBytes: 42,
+        filename: "notes.pdf",
+      }),
+    ).toBe("application/pdf, 42 bytes");
+  });
+});
+
 describe("isUnsendableImageSource", () => {
   beforeEach(resetTables);