@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/openai-responses-provider.test.ts

@@ -149,6 +149,7 @@ function completedEvent(
   opts?: {
     reasoningTokens?: number;
     cachedTokens?: number;
+    cacheWriteTokens?: number;
     model?: string;
     status?: string;
     output?: unknown[];
@@ -171,8 +172,17 @@ function completedEvent(
         output_tokens_details: {
           reasoning_tokens: opts?.reasoningTokens ?? 0,
         },
-        ...(opts?.cachedTokens
-          ? { input_tokens_details: { cached_tokens: opts.cachedTokens } }
+        ...(opts?.cachedTokens || opts?.cacheWriteTokens
+          ? {
+              input_tokens_details: {
+                ...(opts?.cachedTokens
+                  ? { cached_tokens: opts.cachedTokens }
+                  : {}),
+                ...(opts?.cacheWriteTokens
+                  ? { cache_write_tokens: opts.cacheWriteTokens }
+                  : {}),
+              },
+            }
           : {}),
       },
     },
@@ -576,6 +586,30 @@ describe("OpenAIResponsesProvider", () => {
     });
   });
 
+  test("maps cache write tokens to cacheCreationInputTokens (GPT-5.6+)", async () => {
+    // GPT-5.6+ bills prompt tokens written to the cache at 1.25x input and
+    // reports them in input_tokens_details.cache_write_tokens; input_tokens
+    // includes them, mirroring the cached-read accounting above.
+    fakeStreamEvents = [
+      textDeltaEvent("Cached reply"),
+      completedEvent(50_648, 114, {
+        cachedTokens: 40_000,
+        cacheWriteTokens: 9_536,
+      }),
+    ];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    expect(result.usage).toEqual({
+      inputTokens: 50_648,
+      outputTokens: 114,
+      cacheReadInputTokens: 40_000,
+      cacheCreationInputTokens: 9_536,
+    });
+  });
+
   test("omits cacheReadInputTokens when no cached tokens", async () => {
     fakeStreamEvents = [textDeltaEvent("Fresh reply"), completedEvent(10, 5)];
 
@@ -584,6 +618,7 @@ describe("OpenAIResponsesProvider", () => {
     ]);
 
     expect(result.usage).not.toHaveProperty("cacheReadInputTokens");
+    expect(result.usage).not.toHaveProperty("cacheCreationInputTokens");
   });
 
   // -----------------------------------------------------------------------
@@ -603,7 +638,7 @@ describe("OpenAIResponsesProvider", () => {
   // -----------------------------------------------------------------------
   // Effort → reasoning param
   // -----------------------------------------------------------------------
-  test('effort: "high" maps to reasoning: { effort: "high" }', async () => {
+  test('effort: "high" maps to reasoning: { effort: "high", summary: "auto" }', async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage(
@@ -611,10 +646,13 @@ describe("OpenAIResponsesProvider", () => {
       { config: { effort: "high" } },
     );
 
-    expect(lastStreamParams!.reasoning).toEqual({ effort: "high" });
+    expect(lastStreamParams!.reasoning).toEqual({
+      effort: "high",
+      summary: "auto",
+    });
   });
 
-  test('effort: "max" maps to reasoning: { effort: "xhigh" }', async () => {
+  test('effort: "max" maps to reasoning: { effort: "xhigh", summary: "auto" }', async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage(
@@ -622,10 +660,13 @@ describe("OpenAIResponsesProvider", () => {
       { config: { effort: "max" } },
     );
 
-    expect(lastStreamParams!.reasoning).toEqual({ effort: "xhigh" });
+    expect(lastStreamParams!.reasoning).toEqual({
+      effort: "xhigh",
+      summary: "auto",
+    });
   });
 
-  test('effort: "xhigh" maps to reasoning: { effort: "xhigh" }', async () => {
+  test('effort: "xhigh" maps to reasoning: { effort: "xhigh", summary: "auto" }', async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage(
@@ -633,7 +674,10 @@ describe("OpenAIResponsesProvider", () => {
       { config: { effort: "xhigh" } },
     );
 
-    expect(lastStreamParams!.reasoning).toEqual({ effort: "xhigh" });
+    expect(lastStreamParams!.reasoning).toEqual({
+      effort: "xhigh",
+      summary: "auto",
+    });
   });
 
   test("no effort config means no reasoning in params", async () => {
@@ -650,7 +694,8 @@ describe("OpenAIResponsesProvider", () => {
   test('effort: "none" is sent explicitly as reasoning: { effort: "none" }', async () => {
     // The OpenAI Responses API defaults `reasoning.effort` to "medium" when
     // the field is omitted, so the user's opt-out is only honored when we
-    // send the explicit "none" value on the wire.
+    // send the explicit "none" value on the wire. No summary is requested
+    // for a non-reasoning request.
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage(
@@ -661,6 +706,50 @@ describe("OpenAIResponsesProvider", () => {
     expect(lastStreamParams!.reasoning).toEqual({ effort: "none" });
   });
 
+  // -----------------------------------------------------------------------
+  // Reasoning summaries → visible thinking
+  // -----------------------------------------------------------------------
+  test("reasoning summary deltas become thinking events and a thinking block", async () => {
+    fakeStreamEvents = [
+      { type: "response.reasoning_summary_text.delta", delta: "Consider " },
+      { type: "response.reasoning_summary_text.delta", delta: "the input." },
+      { type: "response.reasoning_summary_part.done" },
+      { type: "response.reasoning_summary_text.delta", delta: "Then answer." },
+      { type: "response.reasoning_summary_part.done" },
+      textDeltaEvent("Hello"),
+      completedEvent(10, 5),
+    ];
+
+    const events: Array<{ type: string; thinking?: string }> = [];
+    const result = await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { effort: "high" }, onEvent: (e) => events.push(e) },
+    );
+
+    expect(
+      events
+        .filter((e) => e.type === "thinking_delta")
+        .map((e) => e.thinking)
+        .join(""),
+    ).toBe("Consider the input.Then answer.");
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Consider the input.\n\nThen answer.",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({ type: "text", text: "Hello" });
+  });
+
+  test("no thinking block when the stream carries no summary events", async () => {
+    fakeStreamEvents = [textDeltaEvent("Hello"), completedEvent(10, 5)];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    expect(result.content.map((b) => b.type)).toEqual(["text"]);
+  });
+
   // -----------------------------------------------------------------------
   // Verbosity → text param
   // -----------------------------------------------------------------------

package/src/__tests__/openrouter-responses-transport.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Routing of OpenRouter `openai/*` models with explicit prompt caching onto
+ * the Responses transport: flagged models hit `/responses` with cache params,
+ * attribution headers, and `provider.only` pass-through; unflagged and
+ * native-web-search traffic stays on chat completions.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mock openai module — must be before importing the provider. Captures both
+// the chat-completions and Responses surfaces so routing is observable.
+// ---------------------------------------------------------------------------
+
+let chatCalls: Array<Record<string, unknown>> = [];
+let responsesCalls: Array<Record<string, unknown>> = [];
+let lastResponsesOptions: Record<string, unknown> | null = null;
+let lastConstructorOptions: Record<string, unknown> | null = null;
+
+mock.module("openai", () => ({
+  default: class MockOpenAI {
+    constructor(opts: Record<string, unknown>) {
+      lastConstructorOptions = opts;
+    }
+    chat = {
+      completions: {
+        create: async (params: Record<string, unknown>) => {
+          chatCalls.push(params);
+          return {
+            [Symbol.asyncIterator]: async function* () {
+              yield {
+                choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+                model: String(params.model),
+                usage: { prompt_tokens: 1, completion_tokens: 1 },
+              };
+            },
+          };
+        },
+      },
+    };
+    responses = {
+      create: async (
+        params: Record<string, unknown>,
+        options?: Record<string, unknown>,
+      ) => {
+        responsesCalls.push(params);
+        lastResponsesOptions = options ?? null;
+        return {
+          [Symbol.asyncIterator]: async function* () {
+            yield { type: "response.output_text.delta", delta: "ok" };
+            yield {
+              type: "response.completed",
+              response: {
+                model: String(params.model),
+                status: "completed",
+                output: [],
+                usage: { input_tokens: 1, output_tokens: 1 },
+              },
+            };
+          },
+        };
+      },
+    };
+  },
+}));
+
+// Import after mocking
+import { OpenRouterProvider } from "../providers/openrouter/client.js";
+import type { Message } from "../providers/types.js";
+
+function userMsg(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+beforeEach(() => {
+  chatCalls = [];
+  responsesCalls = [];
+  lastResponsesOptions = null;
+  lastConstructorOptions = null;
+});
+
+describe("OpenRouter Responses transport routing", () => {
+  test("flagged openai/* model routes to /responses with cache params", async () => {
+    const provider = new OpenRouterProvider("sk-or-test", "openai/gpt-5.6-sol");
+    await provider.sendMessage([userMsg("hi")], {
+      config: { promptCacheKey: "conv-1" },
+    });
+
+    expect(chatCalls).toHaveLength(0);
+    expect(responsesCalls).toHaveLength(1);
+    const params = responsesCalls[0];
+    expect(params.model).toBe("openai/gpt-5.6-sol");
+    expect(params.prompt_cache_options).toEqual({ mode: "explicit" });
+    expect(params.prompt_cache_key).toBe("conv-1");
+    expect(JSON.stringify(params.input)).toContain("prompt_cache_breakpoint");
+    // The delegate targets OpenRouter, not api.openai.com.
+    expect(lastConstructorOptions?.baseURL).toBe(
+      "https://openrouter.ai/api/v1",
+    );
+  });
+
+  test("sends OpenRouter app-attribution headers on /responses requests", async () => {
+    const provider = new OpenRouterProvider(
+      "sk-or-test",
+      "openai/gpt-5.6-luna",
+    );
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(responsesCalls).toHaveLength(1);
+    expect(lastResponsesOptions?.headers).toEqual(
+      expect.objectContaining({
+        "HTTP-Referer": "https://www.vellum.ai",
+        "X-OpenRouter-Title": "Vellum Assistant",
+      }),
+    );
+  });
+
+  test("openrouter.only becomes provider.only on the /responses body", async () => {
+    const provider = new OpenRouterProvider(
+      "sk-or-test",
+      "openai/gpt-5.6-terra",
+    );
+    await provider.sendMessage([userMsg("hi")], {
+      config: { openrouter: { only: ["OpenAI"] } },
+    });
+
+    expect(responsesCalls).toHaveLength(1);
+    expect(responsesCalls[0].provider).toEqual({ only: ["OpenAI"] });
+  });
+
+  test("model override onto a flagged model routes to /responses", async () => {
+    const provider = new OpenRouterProvider("sk-or-test", "x-ai/grok-4.20");
+    await provider.sendMessage([userMsg("hi")], {
+      config: { model: "openai/gpt-5.6-luna" },
+    });
+
+    expect(chatCalls).toHaveLength(0);
+    expect(responsesCalls).toHaveLength(1);
+    expect(responsesCalls[0].model).toBe("openai/gpt-5.6-luna");
+  });
+
+  test("unflagged models stay on chat completions", async () => {
+    const provider = new OpenRouterProvider("sk-or-test", "x-ai/grok-4.20");
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(responsesCalls).toHaveLength(0);
+    expect(chatCalls).toHaveLength(1);
+    expect(chatCalls[0].model).toBe("x-ai/grok-4.20");
+  });
+
+  test("unflagged openai/* models stay on chat completions", async () => {
+    const provider = new OpenRouterProvider("sk-or-test", "openai/gpt-5.5");
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(responsesCalls).toHaveLength(0);
+    expect(chatCalls).toHaveLength(1);
+  });
+
+  test("native web search keeps flagged models on chat completions", async () => {
+    const provider = new OpenRouterProvider(
+      "sk-or-test",
+      "openai/gpt-5.6-sol",
+      { useNativeWebSearch: true },
+    );
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(responsesCalls).toHaveLength(0);
+    expect(chatCalls).toHaveLength(1);
+  });
+});

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -15,43 +15,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Shared mock plumbing (must precede module-under-test imports) ──────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-type TestConfig = {
-  ui: { userTimezone?: string; detectedTimezone?: string };
-  skills: Record<string, unknown>;
-};
-
-const baseConfig: TestConfig = {
-  ui: {},
-  skills: {
-    entries: {},
-    load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
-    install: { nodeManager: "npm" },
-    allowBundled: null,
-    remoteProviders: {
-      skillssh: { enabled: true },
-      clawhub: { enabled: true },
-    },
-    remotePolicy: {
-      blockSuspicious: true,
-      blockMalware: true,
-      maxSkillsShRisk: "medium",
-    },
-  },
-};
-let currentConfig: TestConfig = structuredClone(baseConfig);
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => currentConfig,
-  loadConfig: () => ({}),
-}));
-
 // `addMessage` is the only DB-touching call we need to inspect. We capture
 // its arguments per test invocation so each case can assert on the metadata
 // that was actually persisted.
@@ -119,6 +82,15 @@ mock.module("../persistence/conversation-crud.js", () => ({
     const call = addMessageCalls.find((c) => c.id === messageId);
     if (call) call.content = content;
   },
+  markMessageContentInflight: () => {},
+  finalizeMessageContent: (messageId: string, content: string) => {
+    // The finalize seam writes through `finalizeMessageContent`; mirror it
+    // into the same captures as `updateMessageContent`.
+    const row = persistedRows.find((candidate) => candidate.id === messageId);
+    if (row) row.content = content;
+    const call = addMessageCalls.find((c) => c.id === messageId);
+    if (call) call.content = content;
+  },
   // The handler treats provenance as a flat spread; returning {} keeps the
   // metadata snapshot focused on the fields under test.
   provenanceFromTrustContext: () => ({}),
@@ -194,6 +166,7 @@ import {
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { deliverReplyViaCallback } from "../runtime/channel-reply-delivery.js";
+import { setConfig } from "./helpers/set-config.js";
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
@@ -272,7 +245,7 @@ describe("outbound assistant Slack metadata persistence", () => {
   beforeEach(() => {
     addMessageCalls.length = 0;
     persistedRows.length = 0;
-    currentConfig = structuredClone(baseConfig);
+    setConfig("ui", {});
     nextDeliveryTs = null;
     state = createEventHandlerState();
     state.turnStartedAt = 1_700_000_000_000;
@@ -323,10 +296,7 @@ describe("outbound assistant Slack metadata persistence", () => {
   });
 
   test("stamps assistant Slack rows with effective timestamp timezone and no speaker suffix", async () => {
-    currentConfig = {
-      ...structuredClone(baseConfig),
-      ui: { userTimezone: "America/Denver" },
-    };
+    setConfig("ui", { userTimezone: "America/Denver" });
     state.turnStartedAt = Date.parse("2026-03-05T03:38:00Z");
     const conversationId = "conv-slack-timezone";
     const channelId = "C999TIMEZONE";
@@ -382,10 +352,7 @@ describe("outbound assistant Slack metadata persistence", () => {
   });
 
   test("post-send reconciliation preserves assistant Slack timezone metadata", async () => {
-    currentConfig = {
-      ...structuredClone(baseConfig),
-      ui: { userTimezone: "America/Denver" },
-    };
+    setConfig("ui", { userTimezone: "America/Denver" });
     const conversationId = "conv-slack-reconcile-timezone";
     const channelId = "C999RECONCILE";
 

package/src/__tests__/outlook-email-watcher.test.ts

@@ -46,15 +46,6 @@ mock.module("../oauth/connection-resolver.js", () => ({
   resolveOAuthConnection: mockResolveOAuthConnection,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-}));
-
 // Import module under test after mocks
 const { outlookProvider, DeltaSyncExpiredError } =
   await import("../watcher/providers/outlook.js");

package/src/__tests__/outlook-messaging-provider.test.ts

@@ -473,6 +473,7 @@ describe("Outlook messaging provider", () => {
         conn,
         "original-msg-id",
         "Reply text",
+        undefined,
       );
       expect(mockSendMessage).not.toHaveBeenCalled();
       expect(result).toMatchObject({
@@ -481,6 +482,76 @@ describe("Outlook messaging provider", () => {
       });
     });
 
+    test("attaches files to a new message as Graph file attachments", async () => {
+      const conn = createMockConnection();
+      await outlookMessagingProvider.sendMessage(
+        conn,
+        "recipient@example.com",
+        "See attached",
+        {
+          subject: "Docs",
+          attachments: [
+            {
+              filename: "report.pdf",
+              mimeType: "application/pdf",
+              data: Buffer.from("pdf-bytes"),
+            },
+          ],
+        },
+      );
+
+      expect(mockSendMessage).toHaveBeenCalledWith(conn, {
+        message: {
+          subject: "Docs",
+          body: { contentType: "text", content: "See attached" },
+          toRecipients: [
+            { emailAddress: { address: "recipient@example.com" } },
+          ],
+          attachments: [
+            {
+              "@odata.type": "#microsoft.graph.fileAttachment",
+              name: "report.pdf",
+              contentType: "application/pdf",
+              contentBytes: Buffer.from("pdf-bytes").toString("base64"),
+            },
+          ],
+        },
+      });
+    });
+
+    test("forwards attachments to replyToMessage when replying", async () => {
+      const conn = createMockConnection();
+      await outlookMessagingProvider.sendMessage(
+        conn,
+        "conv-id",
+        "Reply body",
+        {
+          inReplyTo: "original-msg-id",
+          attachments: [
+            {
+              filename: "report.pdf",
+              mimeType: "application/pdf",
+              data: Buffer.from("pdf-bytes"),
+            },
+          ],
+        },
+      );
+
+      expect(mockReplyToMessage).toHaveBeenCalledWith(
+        conn,
+        "original-msg-id",
+        "Reply body",
+        [
+          {
+            "@odata.type": "#microsoft.graph.fileAttachment",
+            name: "report.pdf",
+            contentType: "application/pdf",
+            contentBytes: Buffer.from("pdf-bytes").toString("base64"),
+          },
+        ],
+      );
+    });
+
     test("throws when connection is undefined", async () => {
       await expect(
         outlookMessagingProvider.sendMessage(

package/src/__tests__/path-policy.test.ts

@@ -30,13 +30,6 @@ mock.module("../config/skills.js", () => ({
   getBundledSkillsDir: () => MOCK_BUNDLED_DIR,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const {
   isSkillSourcePath,
   normalizeDirPath,

package/src/__tests__/persist-media-references.test.ts

@@ -1,9 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { referenceMediaBlocksForPersist } from "../daemon/persist-media-references.js";
 import { getAttachmentsForMessage } from "../persistence/attachments-store.js";

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -24,6 +24,11 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // caps before calling this, so in-limit images never reach the mock.
 const SHRUNK_DATA = "c2hydW5r"; // base64 for "shrunk"
 mock.module("../agent/image-optimize.js", () => ({
+  // The gate helper must stay real-shaped: every image in this file is
+  // oversized (never undersized), so the min-dimension gate never matches
+  // and the rejection-path upscale is never reached.
+  isBelowMinDimension: () => false,
+  upscaleImageToMinimum: () => null,
   optimizeImageForTransport: () => ({
     data: SHRUNK_DATA,
     mediaType: "image/jpeg",
@@ -107,9 +112,7 @@ function toolResultWithImage(data: string): ContentBlock {
 }
 
 function storedContent(conversationId: string): ContentBlock[][] {
-  return getMessages(conversationId).map(
-    (row) => JSON.parse(row.content) as ContentBlock[],
-  );
+  return getMessages(conversationId).map((row) => row.content);
 }
 
 describe("persistUnsendableImageDowngrades (downscalable host)", () => {

package/src/__tests__/persist-unsendable-image.test.ts

@@ -22,8 +22,8 @@ import {
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import {
-  oversizedImageReplacement,
   persistUnsendableImageDowngrades,
+  unsendableImageReplacement,
 } from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
@@ -105,9 +105,7 @@ function toolResultWithImage(data: string): ContentBlock {
 }
 
 function storedContent(conversationId: string): ContentBlock[][] {
-  return getMessages(conversationId).map(
-    (row) => JSON.parse(row.content) as ContentBlock[],
-  );
+  return getMessages(conversationId).map((row) => row.content);
 }
 
 const PROVIDER_MAX_IMAGE_DIMENSION = 8000;
@@ -211,6 +209,28 @@ describe("persistUnsendableImageDowngrades", () => {
     expect(content.some((b) => b.type === "image")).toBe(false);
   });
 
+  /** The minimum-size floor is enforced alongside the oversized caps: an
+   *  image the provider rejects with "Could not process image" (e.g. a
+   *  16×14 px upload) must not rehydrate and re-reject on later turns. */
+  test("removes an image below the minimum-size floor", async () => {
+    // GIVEN a message holding a tiny image below the provider minimum
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(16, 14))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the undersized image is removed (upscale is a no-op on this host)
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+  });
+
   /** JARVIS-1041: the oversized image is nested inside a tool_result (e.g. a
    *  browser screenshot), not a top-level block. The downgrade must descend
    *  into tool_result.contentBlocks and swap the nested image for a note, while
@@ -286,7 +306,7 @@ describe("persistUnsendableImageDowngrades", () => {
   });
 });
 
-describe("oversizedImageReplacement", () => {
+describe("unsendableImageReplacement", () => {
   /** A still-sendable image must be left alone — never replaced with a note.
    *  This is the gate that keeps the in-memory recovery from discarding valid
    *  screenshots when only one image in the turn was actually oversized. */
@@ -295,7 +315,7 @@ describe("oversizedImageReplacement", () => {
       ContentBlock,
       { type: "image" }
     >;
-    expect(oversizedImageReplacement(sendable)).toBeNull();
+    expect(unsendableImageReplacement(sendable)).toBeNull();
   });
 
   /** An image past the provider caps that cannot be shrunk on this host (fake
@@ -305,7 +325,19 @@ describe("oversizedImageReplacement", () => {
       ContentBlock,
       { type: "image" }
     >;
-    const replacement = oversizedImageReplacement(oversized);
+    const replacement = unsendableImageReplacement(oversized);
+    expect(replacement?.type).toBe("text");
+  });
+
+  /** An image below the provider's minimum-size floor (rejected with "Could
+   *  not process image") that cannot be upscaled on this host collapses to
+   *  the unsendable note, same as the oversized direction. */
+  test("returns the unsendable note when an undersized image cannot be upscaled", () => {
+    const undersized = imageBlock(makePngBase64(16, 14)) as Extract<
+      ContentBlock,
+      { type: "image" }
+    >;
+    const replacement = unsendableImageReplacement(undersized);
     expect(replacement?.type).toBe("text");
   });
 });