@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/plugins/defaults/task-progress/src/format-task-progress-context.ts

@@ -0,0 +1,67 @@
+import type { ConversationSurfaceSnapshot } from "../../../../daemon/conversation-surface-snapshots.js";
+import { getTaskProgressDataFromSurfaceData } from "../../../../runtime/task-progress.js";
+
+export const ACTIVE_TASK_PROGRESS_OPEN = "<active_task_progress>";
+export const ACTIVE_TASK_PROGRESS_CLOSE = "</active_task_progress>";
+
+export const ACTIVE_TASK_PROGRESS_BLOCK =
+  /<active_task_progress\b[\s\S]*?<\/active_task_progress>/gi;
+
+const STEP_INSTRUCTION =
+  "Update this card with ui_update as the steps change.";
+
+function normalizeField(value: string): string {
+  return value
+    .replace(/[<>]/g, "")
+    .replace(/[\r\n\u2028\u2029]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function isActiveTaskProgressSurface(
+  snapshot: ConversationSurfaceSnapshot,
+): boolean {
+  if (snapshot.surfaceType !== "card" || snapshot.completed) {
+    return false;
+  }
+  const plan = getTaskProgressDataFromSurfaceData(snapshot.data);
+  if (!plan) {
+    return false;
+  }
+  return plan.steps.some(
+    (step) => step.status === "pending" || step.status === "in_progress",
+  );
+}
+
+export function formatActiveTaskProgressSnapshot(
+  snapshots: ConversationSurfaceSnapshot[],
+): string {
+  const cards = snapshots.filter(isActiveTaskProgressSurface);
+  if (cards.length === 0) {
+    return "";
+  }
+  return cards
+    .map((snapshot) => {
+      const plan = getTaskProgressDataFromSurfaceData(snapshot.data);
+      if (!plan) {
+        return "";
+      }
+      const lines = [
+        ACTIVE_TASK_PROGRESS_OPEN,
+        `surface_id: ${normalizeField(snapshot.surfaceId)}`,
+      ];
+      const title = plan.title ? normalizeField(plan.title) : "";
+      if (title.length > 0) {
+        lines.push(`title: ${title}`);
+      }
+      lines.push("steps:");
+      for (const step of plan.steps) {
+        lines.push(`- [${step.status}] ${normalizeField(step.label)}`);
+      }
+      lines.push(STEP_INSTRUCTION);
+      lines.push(ACTIVE_TASK_PROGRESS_CLOSE);
+      return lines.join("\n");
+    })
+    .filter((block) => block.length > 0)
+    .join("\n");
+}

package/src/providers/__tests__/context-overflow-error.test.ts

@@ -47,6 +47,16 @@ describe("ContextOverflowError", () => {
     expect((err as Error & { cause?: unknown }).cause).toBe(cause);
   });
 
+  test("forwards rawRequest onto the ProviderError", () => {
+    const rawRequest = { model: "claude-opus-4.6", messages: [] };
+    const err = new ContextOverflowError("m", "anthropic", {
+      actualTokens: 10,
+      maxTokens: 5,
+      rawRequest,
+    });
+    expect(err.rawRequest).toEqual(rawRequest);
+  });
+
   test("omits optional fields when unset", () => {
     const err = new ContextOverflowError("m", "gemini");
     expect(err.actualTokens).toBeUndefined();

package/src/providers/__tests__/search-provider-catalog.test.ts

@@ -86,4 +86,22 @@ describe("search-provider-catalog", () => {
     expect(getSearchProvider("brave")?.displayName).toBe("Brave");
     expect(getSearchProvider("unknown-xyz")).toBeUndefined();
   });
+
+  test("SearXNG is a keyless BYOK provider that requires an instance URL", () => {
+    const searxng = getSearchProvider("searxng");
+    expect(searxng?.kind).toBe("byok");
+    expect(searxng?.keyless).toBe(true);
+    expect(searxng?.supportsApiBase).toBe(true);
+    expect(searxng?.defaultApiBase).toBeUndefined();
+    expect(searxng?.envVar).toBe("SEARXNG_API_KEY");
+  });
+
+  test("TinyFish is a keyed BYOK provider with a cloud API base", () => {
+    const tinyfish = getSearchProvider("tinyfish");
+    expect(tinyfish?.kind).toBe("byok");
+    expect(tinyfish?.keyless).toBeUndefined();
+    expect(tinyfish?.supportsApiBase).toBe(true);
+    expect(tinyfish?.defaultApiBase).toBe("https://api.search.tinyfish.ai");
+    expect(tinyfish?.envVar).toBe("TINYFISH_API_KEY");
+  });
 });

package/src/providers/anthropic/client.ts

@@ -958,6 +958,7 @@ export class AnthropicProvider implements Provider {
     // (30 min default) from an external transport abort (bun fetch deadline,
     // edge LB, NAT idle) — only the latter should be retried.
     let innerTimeoutSignal: AbortSignal | undefined;
+    let inspectableRequest: unknown | undefined;
     try {
       sentMessages = await this.buildSentMessages(messages);
       const {
@@ -1344,6 +1345,7 @@ export class AnthropicProvider implements Provider {
         const streamOnce = async (
           streamParams: Anthropic.MessageStreamParams,
         ): Promise<Anthropic.Message> => {
+          inspectableRequest = streamParams;
           const stream: UnifiedStream = useFastMode
             ? (this.client.beta.messages.stream(
                 {
@@ -1768,6 +1770,7 @@ export class AnthropicProvider implements Provider {
               statusCode: error.status,
               reason: "context_overflow",
               cause: error,
+              rawRequest: inspectableRequest,
             },
           );
         }
@@ -1779,7 +1782,11 @@ export class AnthropicProvider implements Provider {
           reason?: ProviderErrorReason;
           apiErrorType?: string;
           apiErrorCode?: string;
+          rawRequest?: unknown;
         } = {};
+        if (inspectableRequest !== undefined) {
+          errorOptions.rawRequest = inspectableRequest;
+        }
         if (retryAfterMs !== undefined) {
           errorOptions.retryAfterMs = retryAfterMs;
         }
@@ -1832,7 +1839,9 @@ export class AnthropicProvider implements Provider {
         }`,
         "anthropic",
         undefined,
-        abortReason ? { cause: error, abortReason } : { cause: error },
+        abortReason
+          ? { cause: error, abortReason, rawRequest: inspectableRequest }
+          : { cause: error, rawRequest: inspectableRequest },
       );
     }
   }

package/src/providers/anthropic-gateway-shared.ts

@@ -45,6 +45,9 @@ export function retagDelegateError(
       maxTokens: error.maxTokens,
       statusCode: error.statusCode,
       cause: error,
+      ...(error.rawRequest !== undefined
+        ? { rawRequest: error.rawRequest }
+        : {}),
     });
   }
   if (error instanceof ProviderError && error.provider !== providerName) {
@@ -57,6 +60,9 @@ export function retagDelegateError(
       apiErrorCode: error.apiErrorCode,
       apiErrorParam: error.apiErrorParam,
       rawBody: error.rawBody,
+      ...(error.rawRequest !== undefined
+        ? { rawRequest: error.rawRequest }
+        : {}),
     });
   }
   throw error;

package/src/providers/fetch-provider-catalog.ts

@@ -84,6 +84,17 @@ export const FETCH_PROVIDER_CATALOG: readonly FetchProviderCatalogEntry[] = [
     supportsApiBase: true,
     defaultApiBase: "https://api.fastcrw.com",
   },
+  {
+    id: "tinyfish",
+    displayName: "TinyFish",
+    kind: "byok",
+    apiKeyPrefix: "TinyFish API key...",
+    envVar: "TINYFISH_API_KEY",
+    secretKey: "tinyfish",
+    privacyPolicyUrl: "https://www.tinyfish.ai/privacy-policy",
+    supportsApiBase: true,
+    defaultApiBase: "https://api.fetch.tinyfish.ai",
+  },
 ];
 
 /** Provider ids accepted by the web-fetch config schema. */

package/src/providers/gemini/client.ts

@@ -439,6 +439,14 @@ export class GeminiProvider implements Provider {
         )
       : undefined;
 
+    let inspectableRequest:
+      | {
+          model: string;
+          contents: unknown;
+          config: genai.GenerateContentConfig;
+        }
+      | undefined;
+
     try {
       recordProviderRequestDiagnostics({ model_id: activeModel });
       const geminiContents = await this.toGeminiContents(messages, activeModel);
@@ -476,6 +484,12 @@ export class GeminiProvider implements Provider {
         geminiConfig.httpOptions = { headers: usageAttributionHeaders };
       }
 
+      inspectableRequest = {
+        model: activeModel,
+        contents: geminiContents,
+        config: stripGeminiHttpOptions(geminiConfig),
+      };
+
       // Accumulate from streaming chunks
       let fullText = "";
       const functionCalls: Array<{
@@ -583,11 +597,6 @@ export class GeminiProvider implements Provider {
         content.push(block);
       }
 
-      const rawRequest = {
-        model: activeModel,
-        contents: geminiContents,
-        config: stripGeminiHttpOptions(geminiConfig),
-      };
       const rawResponse = {
         model: responseModel,
         text: fullText || null,
@@ -609,7 +618,7 @@ export class GeminiProvider implements Provider {
           ...(cachedTokens > 0 ? { cacheReadInputTokens: cachedTokens } : {}),
         },
         stopReason: finishReason,
-        rawRequest,
+        rawRequest: inspectableRequest,
         rawResponse,
       };
     } catch (error) {
@@ -630,6 +639,7 @@ export class GeminiProvider implements Provider {
               maxTokens: overflow.maxTokens,
               statusCode: error.status,
               cause: error,
+              rawRequest: inspectableRequest,
             },
           );
         }
@@ -639,7 +649,12 @@ export class GeminiProvider implements Provider {
           error.status,
           // Skip reason on caller-abort: abortReason already carries the intent
           // and short-circuits classification/retry (mirrors the Anthropic client).
-          abortReason ? { abortReason } : { reason: deriveGeminiReason(error) },
+        abortReason
+            ? { abortReason, rawRequest: inspectableRequest }
+            : {
+                reason: deriveGeminiReason(error),
+                rawRequest: inspectableRequest,
+              },
         );
       }
       throw new ProviderError(
@@ -648,7 +663,9 @@ export class GeminiProvider implements Provider {
         }`,
         "gemini",
         undefined,
-        abortReason ? { cause: error, abortReason } : { cause: error },
+        abortReason
+          ? { cause: error, abortReason, rawRequest: inspectableRequest }
+          : { cause: error, rawRequest: inspectableRequest },
       );
     }
   }

package/src/providers/inference/adapter-factory.ts

@@ -206,7 +206,7 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
-  jev: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+  typesafe: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new JevProvider(apiKey, model, {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),

package/src/providers/jev/client.test.ts

@@ -5,6 +5,7 @@ import {
   conversationToState,
   DEFAULT_JEV_MODEL,
   JevProvider,
+  noulFromAnswer,
   parseSystemOneOverride,
   validateJevApiKey,
 } from "./client.js";
@@ -66,6 +67,15 @@ describe("parseSystemOneOverride", () => {
   });
 });
 
+describe("noulFromAnswer", () => {
+  test("reads a typed noul object or a bare number", () => {
+    expect(noulFromAnswer({ type: "noul", noul: 0.91 })).toBe(0.91);
+    expect(noulFromAnswer(0.4)).toBe(0.4);
+    expect(noulFromAnswer({ type: "choice", choice: "keep" })).toBeUndefined();
+    expect(noulFromAnswer(null)).toBeUndefined();
+  });
+});
+
 describe("conversationToState", () => {
   test("flattens system prompt and turns into a string", () => {
     const state = conversationToState(

package/src/providers/jev/client.ts

@@ -15,7 +15,7 @@ import type {
 
 const log = getLogger("jev-client");
 
-export const JEV_PROVIDER_ID = "jev";
+export const JEV_PROVIDER_ID = "typesafe";
 export const DEFAULT_JEV_BASE_URL = "https://api.typesafe.ai";
 export const DEFAULT_JEV_MODEL = "jev-latest";
 
@@ -115,6 +115,21 @@ function isJevQuestions(value: unknown): value is JevQuestions {
   return entries.every(([, question]) => isJevQuestion(question));
 }
 
+/** Calibrated P(yes) from a System One noul answer, or undefined when absent. */
+export function noulFromAnswer(answer: unknown): number | undefined {
+  if (typeof answer === "number" && Number.isFinite(answer)) {
+    return answer;
+  }
+  if (
+    isRecord(answer) &&
+    typeof answer.noul === "number" &&
+    Number.isFinite(answer.noul)
+  ) {
+    return answer.noul;
+  }
+  return undefined;
+}
+
 /**
  * If the last user message is a TypeSafe System One payload, use it as the
  * evaluation request. `state` is optional; callers fall back to the
@@ -411,7 +426,7 @@ export class JevProvider implements Provider {
           extractErrorMessage(bodyText, response.status),
           JEV_PROVIDER_ID,
           response.status,
-          { reason, rawBody: bodyText },
+          { reason, rawBody: bodyText, rawRequest: request },
         );
       }
       let parsed: unknown;
@@ -422,7 +437,7 @@ export class JevProvider implements Provider {
           "TypeSafe returned a non-JSON response.",
           JEV_PROVIDER_ID,
           response.status,
-          { reason: "bad_request", rawBody: bodyText },
+          { reason: "bad_request", rawBody: bodyText, rawRequest: request },
         );
       }
       if (!isRecord(parsed) || !isRecord(parsed.answers)) {
@@ -430,7 +445,7 @@ export class JevProvider implements Provider {
           "TypeSafe returned a response without answers.",
           JEV_PROVIDER_ID,
           response.status,
-          { reason: "bad_request", rawBody: bodyText },
+          { reason: "bad_request", rawBody: bodyText, rawRequest: request },
         );
       }
       const usage = isRecord(parsed.usage) ? parsed.usage : undefined;
@@ -471,6 +486,7 @@ export class JevProvider implements Provider {
           cause: error,
           abortReason,
           reason: abortReason ? undefined : "network_error",
+          rawRequest: request,
         },
       );
     } finally {

package/src/providers/model-catalog.ts

@@ -77,7 +77,8 @@ export interface CatalogModel {
    * Whether the model produces free-form chat text. Omit (or true) for
    * ordinary chat models. False for structured-decision models that return
    * answers rather than generated text; those stay out of conversation
-   * pickers and cannot be the conversation model.
+   * pickers and cannot be the conversation model. They can still back a
+   * saved profile and a call-site pin.
    */
   supportsText?: boolean;
   supportsEffort?: boolean;
@@ -2532,8 +2533,8 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyPlaceholder: "Your Poolside API key",
   },
   {
-    id: "jev",
-    displayName: "Jev",
+    id: "typesafe",
+    displayName: "TypeSafe",
     subtitle:
       "TypeSafe System One decision model. Returns structured answers, not generated text. Requires a TypeSafe API key.",
     setupMode: "api-key",

package/src/providers/openai/__tests__/chat-completions-extra-body.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import type { SendMessageOptions } from "../../types.js";
+import OpenAI from "openai";
+
+import { ProviderError } from "../../../util/errors.js";
+import { ContextOverflowError, type SendMessageOptions } from "../../types.js";
 import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
 
 class ExtraBodyProvider extends OpenAIChatCompletionsProvider {
@@ -48,4 +51,94 @@ describe("chat-completions extraBody", () => {
     expect(seenParams?.directions).toEqual({ companion: 0.4 });
     expect(seenOptions?.extraBody).toBeUndefined();
   });
+
+  test("attaches the SDK create params as ProviderError.rawRequest on 4xx", async () => {
+    const provider = new ExtraBodyProvider("test-key", "qwen/qwen3-8b", {
+      providerName: "vellum",
+      providerLabel: "Vellum",
+    });
+    (
+      provider as unknown as {
+        client: {
+          chat: {
+            completions: {
+              create: () => Promise<AsyncIterable<unknown>>;
+            };
+          };
+        };
+      }
+    ).client.chat.completions.create = async () => {
+      throw new OpenAI.APIError(
+        400,
+        { detail: "directions are not loaded" },
+        undefined,
+        new Headers(),
+      );
+    };
+
+    try {
+      await provider.sendMessage([
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ]);
+      throw new Error("expected ProviderError");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      const rejected = error as ProviderError;
+      expect(rejected.provider).toBe("vellum");
+      expect(rejected.statusCode).toBe(400);
+      expect(rejected.rawRequest).toEqual(
+        expect.objectContaining({
+          model: "qwen/qwen3-8b",
+          directions: { companion: 0.4 },
+        }),
+      );
+    }
+  });
+
+  test("attaches the SDK create params as ContextOverflowError.rawRequest", async () => {
+    const provider = new ExtraBodyProvider("test-key", "qwen/qwen3-8b", {
+      providerName: "vellum",
+      providerLabel: "Vellum",
+    });
+    (
+      provider as unknown as {
+        client: {
+          chat: {
+            completions: {
+              create: () => Promise<AsyncIterable<unknown>>;
+            };
+          };
+        };
+      }
+    ).client.chat.completions.create = async () => {
+      throw new OpenAI.APIError(
+        400,
+        {
+          message:
+            "This model's maximum context length is 128000 tokens. However, your messages resulted in 150000 tokens.",
+          type: "invalid_request_error",
+          code: "context_length_exceeded",
+        },
+        undefined,
+        new Headers(),
+      );
+    };
+
+    try {
+      await provider.sendMessage([
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ]);
+      throw new Error("expected ContextOverflowError");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ContextOverflowError);
+      const rejected = error as ContextOverflowError;
+      expect(rejected.provider).toBe("vellum");
+      expect(rejected.rawRequest).toEqual(
+        expect.objectContaining({
+          model: "qwen/qwen3-8b",
+          directions: { companion: 0.4 },
+        }),
+      );
+    }
+  });
 });

package/src/providers/openai/__tests__/chat-completions-provider-reasoning.test.ts

@@ -1,12 +1,14 @@
-import { describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import OpenAI from "openai";
 
+import { ProviderError } from "../../../util/errors.js";
 import { isPlaceholderSentinelText } from "../../placeholder-sentinels.js";
 import {
   EMPTY_ASSISTANT_TURN_PLACEHOLDER,
   OpenAIChatCompletionsProvider,
   type OpenAIChatCompletionsProviderOptions,
+  resetReasoningOptOutRejectersForTests,
 } from "../chat-completions-provider.js";
 
 type ReasoningDetail = {
@@ -777,6 +779,65 @@ function rejection(message: string, status = 400): Error {
 }
 
 describe("reasoning opt-out rejection fallback", () => {
+  beforeEach(() => {
+    resetReasoningOptOutRejectersForTests();
+  });
+
+  test("remembers a rejecting model and skips the opt-out on later requests", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [rejection("reasoning_effort 'none' is not supported for this model")],
+      OK_CHUNKS,
+    );
+    const send = () =>
+      provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+        { config: { effort: "none" } },
+      );
+
+    await send();
+    await send();
+
+    expect(requests).toHaveLength(3);
+    expect(
+      (requests[2] as { reasoning_effort?: string }).reasoning_effort,
+    ).toBeUndefined();
+  });
+
+  test("does not remember when success needed a further compat retry", async () => {
+    // The broad /reasoning/ match misreads the reasoning_content round-trip
+    // error as an opt-out rejection; the request only succeeds after the
+    // backfill retry, so the opt-out itself was never proven unsupported.
+    const { provider, requests } = stubProviderWithErrors(
+      [
+        rejection("reasoning_content must be passed back to the API"),
+        rejection("reasoning_content must be passed back to the API"),
+      ],
+      OK_CHUNKS,
+    );
+    const messages = [
+      {
+        role: "user" as const,
+        content: [{ type: "text" as const, text: "hi" }],
+      },
+      {
+        role: "assistant" as const,
+        content: [{ type: "text" as const, text: "hello" }],
+      },
+      {
+        role: "user" as const,
+        content: [{ type: "text" as const, text: "again" }],
+      },
+    ];
+
+    await provider.sendMessage(messages, { config: { effort: "none" } });
+    await provider.sendMessage(messages, { config: { effort: "none" } });
+
+    expect(requests).toHaveLength(4);
+    expect(
+      (requests[3] as { reasoning_effort?: string }).reasoning_effort,
+    ).toBe("none");
+  });
+
   test("retries once without reasoning params when a model rejects the explicit opt-out", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [rejection("reasoning_effort 'none' is not supported for this model")],
@@ -928,12 +989,56 @@ describe("thinking-mode tool_choice rejection fallback", () => {
     expect(first.reasoning_effort).toBe("high");
     expect(second.tool_choice).toBeUndefined();
     expect(second.reasoning_effort).toBe("high");
+    expect(
+      (response.rawRequest as { tool_choice?: unknown }).tool_choice,
+    ).toBeUndefined();
     const text = response.content.find((b) => b.type === "text") as
       | { type: "text"; text: string }
       | undefined;
     expect(text?.text).toBe("ok");
   });
 
+  test("ProviderError.rawRequest is the post-retry params when the retried call fails", async () => {
+    const { provider } = stubProviderWithErrors(
+      [
+        rejection("Thinking mode does not support this tool_choice"),
+        Object.assign(
+          new Error("Thinking mode does not support this tool_choice"),
+          { status: 400 },
+        ),
+      ],
+      OK_CHUNKS,
+    );
+
+    try {
+      await provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+        {
+          tools: [
+            {
+              name: "bash",
+              description: "Run a shell command",
+              input_schema: { type: "object", properties: {} },
+            },
+          ],
+          config: { tool_choice: { type: "none" }, effort: "high" },
+        },
+      );
+      throw new Error("expected ProviderError");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      const rejected = error as ProviderError;
+      expect(
+        (rejected.rawRequest as { tool_choice?: unknown } | undefined)
+          ?.tool_choice,
+      ).toBeUndefined();
+      expect(
+        (rejected.rawRequest as { reasoning_effort?: string } | undefined)
+          ?.reasoning_effort,
+      ).toBe("high");
+    }
+  });
+
   test("retries once when Kimi rejects a specified tool_choice in thinking mode", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [

package/src/providers/openai/__tests__/chat-template-flatten.test.ts

@@ -57,6 +57,10 @@ function stubProviderWithErrors(errors: unknown[]): {
 const CHAT_TEMPLATE_400 =
   "Failed to apply chat template: invalid operation: object is not callable (in chat:22)";
 
+// Fireworks' renderer error for DeepSeek, verbatim.
+const FIREWORKS_STR_JOIN_400 =
+  "sequence item 0: expected str instance, list found";
+
 function rejection(message: string, status = 400): Error {
   return Object.assign(new Error(message), { status });
 }
@@ -103,6 +107,26 @@ describe("chat-template rejection flatten fallback", () => {
     expect(text?.text).toBe("ok");
   });
 
+  test("retries with flattened content on Fireworks' str-join template error", async () => {
+    const { provider, requests } = stubProviderWithErrors([
+      rejection(FIREWORKS_STR_JOIN_400),
+    ]);
+
+    await provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "[Image: a cat]" },
+          { type: "text", text: "what is this?" },
+        ],
+      },
+    ]);
+
+    expect(requests).toHaveLength(2);
+    const retry = requests[1] as { messages: Array<{ content: unknown }> };
+    expect(retry.messages[0].content).toBe("[Image: a cat]\n\nwhat is this?");
+  });
+
   test("does not retry when a content-parts array carries media (never silently drop an image)", async () => {
     // GIVEN an endpoint whose chat template 400s on structured message content
     const { provider, requests } = stubProviderWithErrors([