@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/providers/__tests__/dispatch-connection-routing.test.ts

@@ -321,6 +321,26 @@ describe("routing identities", () => {
     expect(resolveProviderOpts[0]?.providerOverride).toBe("anthropic");
   });
 
+  test("a stored vellum GPU profile dispatches through the vellum adapter", async () => {
+    registerConnection(
+      { name: "vellum", provider: "vellum", auth: { type: "platform" } },
+      { name: "vellum", tag: "gpu-stub" },
+    );
+    setLlmConfig({
+      profiles: {
+        gpu: { provider: "vellum", model: "qwen/qwen3-8b" },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "gpu",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls[0]?.name).toBe("vellum");
+    expect(resolveProviderOpts[0]?.providerOverride).toBe("vellum");
+  });
+
   test("a stored chatgpt profile dispatches end-to-end through the real config loader", async () => {
     registerConnection(
       {
@@ -356,6 +376,10 @@ describe("routing identities", () => {
     expect(
       resolveRoutingIdentity("vellum", "accounts/fireworks/models/glm-5p2"),
     ).toEqual({ connectionName: "vellum", expectedProvider: "fireworks" });
+    expect(resolveRoutingIdentity("vellum", "qwen/qwen3-8b")).toEqual({
+      connectionName: "vellum",
+      expectedProvider: "vellum",
+    });
   });
 
   test("resolveRoutingIdentity throws loudly for an unroutable vellum model", () => {
@@ -423,6 +447,32 @@ describe("routing identities", () => {
     expect(resolveProviderOpts[0]?.providerOverride).toBe("anthropic");
   });
 
+  test("vellum identity + GPU model threads vellum as the upstream override", async () => {
+    fakeConnections.set("vellum", {
+      name: "vellum",
+      provider: "vellum",
+      auth: { type: "platform" },
+    });
+    fakeProviders.set("conn:vellum", { name: "vellum", tag: "gpu" });
+
+    const provider = await tryResolveProviderForConnectionName(
+      "ignored-stale-name",
+      { llm: {} } as never,
+      "vellum",
+      "qwen/qwen3-8b",
+    );
+
+    expect(provider).toEqual({
+      name: "vellum",
+      tag: "gpu",
+      routeAttribution: {
+        connectionName: "vellum",
+        isManagedRoute: true,
+      },
+    } as never);
+    expect(resolveProviderOpts[0]?.providerOverride).toBe("vellum");
+  });
+
   test("chatgpt identity resolves the subscription row by name with an openai override", async () => {
     fakeConnections.set("chatgpt-subscription", {
       name: "chatgpt-subscription",

package/src/providers/__tests__/registry-native-web-search.test.ts

@@ -14,7 +14,7 @@ import type { ProvidersConfig } from "../registry.js";
 
 const adapterCalls: Array<{
   connection: ProviderConnection;
-  opts: { model: string; useNativeWebSearch?: boolean };
+  opts: { model: string; useNativeWebSearch?: boolean; provider?: string };
 }> = [];
 
 mock.module("../inference/resolve-auth.js", () => ({
@@ -32,7 +32,7 @@ mock.module("../inference/adapter-factory.js", () => ({
   createAdapterFromConnection: (
     connection: ProviderConnection,
     _resolvedAuth: unknown,
-    opts: { model: string; useNativeWebSearch?: boolean },
+    opts: { model: string; useNativeWebSearch?: boolean; provider?: string },
   ) => {
     adapterCalls.push({ connection, opts });
     return {
@@ -83,6 +83,18 @@ const openRouterConnection: ProviderConnection = {
   isManaged: false,
 };
 
+const vellumConnection: ProviderConnection = {
+  name: "vellum",
+  provider: "vellum",
+  auth: { type: "platform" },
+  label: "Vellum",
+  baseUrl: null,
+  models: null,
+  createdAt: 1,
+  updatedAt: 1,
+  isManaged: true,
+};
+
 describe("resolveProviderFromConnection native web search selection", () => {
   beforeEach(() => {
     adapterCalls.length = 0;
@@ -160,6 +172,41 @@ describe("resolveProviderFromConnection connection cache TTL", () => {
   });
 });
 
+describe("resolveProviderFromConnection vellum GPU upstream", () => {
+  beforeEach(() => {
+    adapterCalls.length = 0;
+    clearConnectionProviderCache();
+  });
+
+  test("a GPU model with providerOverride vellum builds an adapter", async () => {
+    const adapter = await resolveProviderFromConnection(
+      vellumConnection,
+      makeConfig(),
+      { model: "qwen/qwen3-8b", providerOverride: "vellum" },
+    );
+    expect(adapter).not.toBeNull();
+    expect(adapterCalls).toHaveLength(1);
+    expect(adapterCalls[0].opts).toMatchObject({
+      model: "qwen/qwen3-8b",
+      provider: "vellum",
+    });
+  });
+
+  test("providerOverride vellum is a factory id, not an unresolved identity", async () => {
+    const adapter = await resolveProviderFromConnection(
+      vellumConnection,
+      makeConfig(),
+      { model: "claude-opus-4-8", providerOverride: "vellum" },
+    );
+    expect(adapter).not.toBeNull();
+    expect(adapterCalls).toHaveLength(1);
+    expect(adapterCalls[0].opts).toMatchObject({
+      model: "claude-opus-4-8",
+      provider: "vellum",
+    });
+  });
+});
+
 describe("isNativeWebSearchCapableProvider gateway anthropic routing", () => {
   test("vercel-ai-gateway anthropic/* models are capable", () => {
     expect(

package/src/providers/anthropic/client.ts

@@ -10,6 +10,12 @@ import {
 } from "../../util/provider-error-patterns.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { stripOrphanedSurrogatesDeep } from "../../util/unicode.js";
+import {
+  clampProviderString,
+  isDecodableTextMimeType,
+  keepFileAsWorkspaceRef,
+} from "../content-block-size.js";
+import { fileBlockToProviderText } from "../file-block-text.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import {
   couldBePlaceholderSentinelPrefix,
@@ -106,8 +112,7 @@ function readAnthropicErrorType(
   error: InstanceType<typeof Anthropic.APIError>,
 ): string | undefined {
   const body = error.error as
-    | { type?: string; error?: { type?: string; code?: string } }
-    | undefined;
+    { type?: string; error?: { type?: string; code?: string } } | undefined;
   return body?.error?.type ?? body?.type;
 }
 
@@ -127,8 +132,7 @@ function readAnthropicMessage(
   error: InstanceType<typeof Anthropic.APIError>,
 ): string | undefined {
   const body = error.error as
-    | { message?: string; error?: { message?: string } }
-    | undefined;
+    { message?: string; error?: { message?: string } } | undefined;
   const inner = body?.error?.message ?? body?.message;
   return typeof inner === "string" && inner.length > 0 ? inner : undefined;
 }
@@ -283,15 +287,6 @@ const ANTHROPIC_SUPPORTED_IMAGE_TYPES = new Set([
   "image/webp",
 ]);
 
-function isTextBasedMimeType(mediaType: string): boolean {
-  return (
-    mediaType.startsWith("text/") ||
-    mediaType === "application/json" ||
-    mediaType === "application/xml" ||
-    mediaType === "application/javascript"
-  );
-}
-
 /** Anthropic requires tool_use IDs to match ^[a-zA-Z0-9_-]+$ */
 function sanitizeToolId(id: string): string {
   if (!id) {
@@ -968,8 +963,7 @@ export class AnthropicProvider implements Provider {
     const { tools, systemPrompt, config, onEvent, signal } = options ?? {};
     const cacheTtl: "5m" | "1h" =
       ((config as Record<string, unknown> | undefined)?.cacheTtl as
-        | "5m"
-        | "1h") ?? "1h";
+        "5m" | "1h") ?? "1h";
     // Opt-out for callers (e.g. the memory router) that send a single
     // user message per call with content that changes every time. The
     // turn-start cache breakpoint below is only useful when the same
@@ -2148,9 +2142,10 @@ export class AnthropicProvider implements Provider {
         const cacheControl = (
           block as { cache_control?: Anthropic.CacheControlEphemeral }
         ).cache_control;
+        const text = clampProviderString(block.text);
         return cacheControl
-          ? { type: "text", text: block.text, cache_control: cacheControl }
-          : { type: "text", text: block.text };
+          ? { type: "text", text, cache_control: cacheControl }
+          : { type: "text", text };
       }
       case "thinking":
         if (!block.signature) {
@@ -2183,6 +2178,9 @@ export class AnthropicProvider implements Provider {
           },
         };
       case "file": {
+        if (keepFileAsWorkspaceRef(block.source)) {
+          return { type: "text", text: fileBlockToProviderText(block) };
+        }
         const { media_type, data, filename } = base64Source(block.source);
         if (media_type === "application/pdf") {
           // Only valid base64 document source for Anthropic
@@ -2192,9 +2190,11 @@ export class AnthropicProvider implements Provider {
             ...(filename ? { title: filename } : {}),
           } as unknown as Anthropic.ContentBlockParam;
         }
-        if (isTextBasedMimeType(media_type)) {
+        if (isDecodableTextMimeType(media_type)) {
           // Decode base64 to UTF-8 text and send as PlainTextSource
-          const decodedText = Buffer.from(data, "base64").toString("utf-8");
+          const decodedText = clampProviderString(
+            Buffer.from(data, "base64").toString("utf-8"),
+          );
           return {
             type: "document",
             source: {
@@ -2205,14 +2205,11 @@ export class AnthropicProvider implements Provider {
             ...(filename ? { title: filename } : {}),
           } as unknown as Anthropic.ContentBlockParam;
         }
-        // Binary non-text file: use extracted_text if available, otherwise a placeholder
+        // Binary non-text file: name the workspace file, never dump bytes.
         log.warn(
           `Binary file type not natively supported by Anthropic: ${media_type}; falling back to text`,
         );
-        const fallbackText = block.extracted_text?.trim()
-          ? block.extracted_text
-          : `[File: ${filename ?? "unknown"} (${media_type}) — binary file]`;
-        return { type: "text", text: fallbackText };
+        return { type: "text", text: fileBlockToProviderText(block) };
       }
       case "tool_use":
         return {

package/src/providers/call-site-routing.ts

@@ -358,17 +358,18 @@ export class CallSiteRoutingProvider implements Provider {
       }
       // Soft credential failure: the routed connection yielded no usable
       // adapter and dispatch is landing on the default transport, which may
-      // be the platform-billed route — keep every such degradation
-      // observable.
+      // be the platform-billed route. Keep every such degradation
+      // observable. The reason is "no adapter", not a proven credential miss:
+      // adapter construction can also fail for dispatch bugs.
       log.warn(
         {
           callSite,
           connectionName,
           provider: resolved.provider,
           model: resolved.model,
-          reason: "credential_unavailable",
+          reason: "adapter_unavailable",
         },
-        "Routed connection yielded no adapter — falling back to the default transport",
+        "Routed connection yielded no adapter: falling back to the default transport",
       );
       return this.defaultRoute(profileName);
     }

package/src/providers/connection-resolution.ts

@@ -387,9 +387,23 @@ export async function tryResolveProviderForConnectionName(
     });
     return attachProviderRoute(provider, connection);
   } catch (err) {
+    if (err instanceof ConnectionResolutionError) {
+      throw err;
+    }
+    if (
+      err instanceof Error &&
+      /unresolved routing identity/.test(err.message)
+    ) {
+      throw new ConnectionResolutionError(
+        connectionName,
+        "adapter_unavailable",
+        err.message,
+        { cause: err, model },
+      );
+    }
     log.warn(
       { err, connectionName },
-      "provider_connection auth resolution failed transiently — returning null",
+      "provider_connection auth resolution failed transiently: returning null",
     );
     return null;
   }
@@ -457,6 +471,20 @@ async function resolveThroughPlatform(
       { model, providerOverride: upstream },
     );
   } catch (err) {
+    if (err instanceof ConnectionResolutionError) {
+      throw err;
+    }
+    if (
+      err instanceof Error &&
+      /unresolved routing identity/.test(err.message)
+    ) {
+      throw new ConnectionResolutionError(
+        VELLUM_MANAGED_CONNECTION_NAME,
+        "adapter_unavailable",
+        err.message,
+        { cause: err, model },
+      );
+    }
     log.warn({ err }, "Platform fallback auth resolution failed transiently");
     return null;
   }

package/src/providers/content-block-size.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  clampProviderString,
+  exceedsProviderStringCap,
+  extractedTextForFileBlock,
+  isDecodableTextMimeType,
+  isVideoMimeType,
+  keepFileAsWorkspaceRef,
+  MAX_PROVIDER_STRING_BYTES,
+  PROVIDER_STRING_OMITTED_NOTE,
+  utf8ByteLength,
+} from "./content-block-size.js";
+
+describe("content-block-size", () => {
+  test("counts UTF-8 bytes, not JS string length", () => {
+    expect(utf8ByteLength("é")).toBe(2);
+    expect(exceedsProviderStringCap("é".repeat(4), 7)).toBe(true);
+    expect(exceedsProviderStringCap("é".repeat(3), 7)).toBe(false);
+  });
+
+  test("default cap is under OpenAI's 10 MiB per-part limit", () => {
+    expect(MAX_PROVIDER_STRING_BYTES).toBe(8_000_000);
+    expect(MAX_PROVIDER_STRING_BYTES).toBeLessThan(10_485_760);
+  });
+
+  test("treats video MIME types, including parameters, as video", () => {
+    expect(isVideoMimeType("video/mp4")).toBe(true);
+    expect(isVideoMimeType("VIDEO/WEBM; codecs=vp9")).toBe(true);
+    expect(isVideoMimeType("application/pdf")).toBe(false);
+  });
+
+  test("drops extracted_text for video and for over-cap extracts", () => {
+    expect(
+      extractedTextForFileBlock("video/mp4", "anything at all"),
+    ).toBeUndefined();
+    expect(extractedTextForFileBlock("application/pdf", "hello")).toBe("hello");
+    expect(
+      extractedTextForFileBlock("text/plain", "abcdef", 4),
+    ).toBeUndefined();
+  });
+
+  test("clampProviderString replaces an over-cap string", () => {
+    expect(clampProviderString("ok")).toBe("ok");
+    expect(clampProviderString("abcdef", 4)).toBe(PROVIDER_STRING_OMITTED_NOTE);
+  });
+
+  test("keepFileAsWorkspaceRef covers video and over-cap text refs", () => {
+    expect(isDecodableTextMimeType("text/plain")).toBe(true);
+    expect(isDecodableTextMimeType("application/json")).toBe(true);
+    expect(isDecodableTextMimeType("application/pdf")).toBe(false);
+
+    expect(
+      keepFileAsWorkspaceRef({
+        type: "workspace_ref",
+        media_type: "video/mp4",
+        sizeBytes: 12,
+      }),
+    ).toBe(true);
+    expect(
+      keepFileAsWorkspaceRef({
+        type: "workspace_ref",
+        media_type: "text/plain",
+        sizeBytes: MAX_PROVIDER_STRING_BYTES + 1,
+      }),
+    ).toBe(true);
+    expect(
+      keepFileAsWorkspaceRef({
+        type: "workspace_ref",
+        media_type: "text/plain",
+        sizeBytes: 20,
+      }),
+    ).toBe(false);
+    expect(
+      keepFileAsWorkspaceRef({
+        type: "workspace_ref",
+        media_type: "application/pdf",
+        sizeBytes: MAX_PROVIDER_STRING_BYTES + 1,
+      }),
+    ).toBe(false);
+  });
+});

package/src/providers/content-block-size.ts

@@ -0,0 +1,99 @@
+/**
+ * Provider per-string size cap and helpers for content that would be
+ * serialized as a single text part.
+ *
+ * OpenAI rejects a request when any `content[].text` / `input[].content[].text`
+ * exceeds 10_485_760 bytes (`string_above_max_length`). Stay under that so a
+ * single block cannot brick every later turn. Extra SQLite-only columns and
+ * attachment bytes are out of scope: this is the wire-string budget.
+ */
+
+/** Bytes. Under OpenAI's 10 MiB per-part string limit (10_485_760). */
+export const MAX_PROVIDER_STRING_BYTES = 8_000_000;
+
+export function utf8ByteLength(text: string): number {
+  return Buffer.byteLength(text, "utf8");
+}
+
+export function exceedsProviderStringCap(
+  text: string,
+  maxBytes: number = MAX_PROVIDER_STRING_BYTES,
+): boolean {
+  return utf8ByteLength(text) > maxBytes;
+}
+
+export function isVideoMimeType(mimeType: string): boolean {
+  const normalised = mimeType.toLowerCase().trim().split(";")[0]?.trim() ?? "";
+  return normalised.startsWith("video/");
+}
+
+/**
+ * MIME types a serializer would decode into a provider text/document string.
+ * Binary types (PDF, images, audio) stay out of this set: they are not the
+ * OpenAI `string_above_max_length` failure mode.
+ */
+export function isDecodableTextMimeType(mimeType: string): boolean {
+  const normalised = mimeType.toLowerCase().trim().split(";")[0]?.trim() ?? "";
+  return (
+    normalised.startsWith("text/") ||
+    normalised === "application/json" ||
+    normalised === "application/xml" ||
+    normalised === "application/javascript"
+  );
+}
+
+/**
+ * Video and over-cap text files stay on disk. Serializers name the workspace
+ * file; they must not load bytes or emit a decoded dump.
+ */
+export function keepFileAsWorkspaceRef(source: {
+  type: string;
+  media_type: string;
+  sizeBytes?: number;
+}): boolean {
+  if (isVideoMimeType(source.media_type)) {
+    return true;
+  }
+  return (
+    source.type === "workspace_ref" &&
+    source.sizeBytes !== undefined &&
+    source.sizeBytes > MAX_PROVIDER_STRING_BYTES &&
+    isDecodableTextMimeType(source.media_type)
+  );
+}
+
+/**
+ * Drop `extracted_text` that must not ride a file block into the provider
+ * prompt: video is a workspace file, not a transcript dump, and any extract
+ * over the cap belongs in the attachment store rather than the request.
+ */
+export function extractedTextForFileBlock(
+  mimeType: string,
+  extractedText: string | undefined,
+  maxBytes: number = MAX_PROVIDER_STRING_BYTES,
+): string | undefined {
+  if (extractedText === undefined || extractedText.length === 0) {
+    return undefined;
+  }
+  if (isVideoMimeType(mimeType)) {
+    return undefined;
+  }
+  if (exceedsProviderStringCap(extractedText, maxBytes)) {
+    return undefined;
+  }
+  return extractedText;
+}
+
+/** Fallback copy when a serializer still sees a string over the cap. */
+export const PROVIDER_STRING_OMITTED_NOTE =
+  "Content exceeded the provider size limit and was omitted from this prompt.";
+
+export function clampProviderString(
+  text: string,
+  maxBytes: number = MAX_PROVIDER_STRING_BYTES,
+): string {
+  if (!exceedsProviderStringCap(text, maxBytes)) {
+    return text;
+  }
+  return PROVIDER_STRING_OMITTED_NOTE;
+}

package/src/providers/file-block-text.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+
+import { PROVIDER_STRING_OMITTED_NOTE } from "./content-block-size.js";
+import { fileBlockToProviderText } from "./file-block-text.js";
+import type { ContentBlock } from "./types.js";
+
+function fileBlock(
+  mediaType: string,
+  extractedText?: string,
+): Extract<ContentBlock, { type: "file" }> {
+  return {
+    type: "file",
+    source: {
+      type: "workspace_ref",
+      media_type: mediaType,
+      attachmentId: "att-1",
+      sizeBytes: 12,
+      filename: "clip.mp4",
+    },
+    ...(extractedText !== undefined ? { extracted_text: extractedText } : {}),
+  };
+}
+
+describe("fileBlockToProviderText", () => {
+  test("names a video without dumping extracted_text", () => {
+    const text = fileBlockToProviderText(
+      fileBlock("video/mp4", "a".repeat(1000)),
+    );
+    expect(text).toContain("video/mp4");
+    expect(text).toContain("workspace file");
+    expect(text).not.toContain("aaa");
+  });
+
+  test("includes extracted_text for a non-video file under the cap", () => {
+    const text = fileBlockToProviderText({
+      type: "file",
+      source: {
+        type: "workspace_ref",
+        media_type: "application/pdf",
+        attachmentId: "att-2",
+        sizeBytes: 20,
+        filename: "notes.pdf",
+      },
+      extracted_text: "quarterly summary",
+    });
+    expect(text).toContain("quarterly summary");
+  });
+
+  test("omits an over-cap extracted_text dump", () => {
+    const text = fileBlockToProviderText({
+      type: "file",
+      source: {
+        type: "workspace_ref",
+        media_type: "text/plain",
+        attachmentId: "att-3",
+        sizeBytes: 20,
+        filename: "huge.txt",
+      },
+      extracted_text: "x".repeat(8_000_001),
+    });
+    expect(text).toBe(PROVIDER_STRING_OMITTED_NOTE);
+    expect(text.length).toBeLessThan(200);
+  });
+});

package/src/providers/file-block-text.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared file-block → provider text. OpenAI, Anthropic, and Gemini all fold
+ * non-native files into a text part. Video is never inlined: it stays a
+ * workspace file and the prompt only names it.
+ */
+
+import { escapeXmlAttr } from "../util/xml.js";
+import { clampProviderString, isVideoMimeType } from "./content-block-size.js";
+import type { ContentBlock } from "./types.js";
+
+const VIDEO_FILE_NOTE =
+  "Video is stored as a workspace file. It is not inlined in this prompt.";
+
+export function fileBlockToProviderText(
+  block: Extract<ContentBlock, { type: "file" }>,
+): string {
+  const header = `<attached_file name="${escapeXmlAttr(
+    block.source.filename ?? "",
+  )}" type="${escapeXmlAttr(block.source.media_type)}" />`;
+  if (isVideoMimeType(block.source.media_type)) {
+    return `${header}\n${VIDEO_FILE_NOTE}`;
+  }
+  const extracted = block.extracted_text?.trim() ?? "";
+  if (extracted.length > 0) {
+    return clampProviderString(`${header}\n${extracted}`);
+  }
+  return `${header}\nNo extracted text available.`;
+}

package/src/providers/gemini/client.ts

@@ -10,6 +10,11 @@ import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError, type ProviderErrorReason } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { DAILY_LIMIT_PATTERNS } from "../../util/provider-error-patterns.js";
+import {
+  clampProviderString,
+  keepFileAsWorkspaceRef,
+} from "../content-block-size.js";
+import { fileBlockToProviderText } from "../file-block-text.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
@@ -116,8 +121,9 @@ function clampThinkingLevelToFloor(
  * dynamic medium-level thinking).
  *
  * - `enabled: false` maps to the model's floor (the most "off" state it
- *   allows): `"minimal"` for most models, `"low"` for Pro and Gemini 3.7
- *   Flash, which reject `"minimal"`.
+ *   allows): `"minimal"` for most models, `"low"` for models whose catalog
+ *   `thinkingFloor` is `"low"` (Pro and recent Flash IDs that reject
+ *   `"minimal"`).
  * - An explicit `level` below the floor is raised to the floor.
  * - When no `level` is pinned, Pro models get the documented default (`"high"`)
  *   because an absent level resolves to the unsupported `"minimal"` upstream;
@@ -429,8 +435,7 @@ export class GeminiProvider implements Provider {
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
     const activeModel = modelOverride ?? this.model;
     const thinkingConfig = geminiModelSupportsThinking(activeModel)
       ? buildThinkingConfig(
@@ -762,7 +767,7 @@ export class GeminiProvider implements Provider {
     for (const block of blocks) {
       switch (block.type) {
         case "text":
-          parts.push({ text: block.text });
+          parts.push({ text: clampProviderString(block.text) });
           break;
         case "image": {
           const imageSrc = base64Source(block.source);
@@ -775,6 +780,10 @@ export class GeminiProvider implements Provider {
           break;
         }
         case "file": {
+          if (keepFileAsWorkspaceRef(block.source)) {
+            parts.push({ text: fileBlockToProviderText(block) });
+            break;
+          }
           const fileSrc = base64Source(block.source);
           if (this.supportsGeminiInlineFile(fileSrc.media_type)) {
             // Normalize audio MIME onto Gemini's spelling (e.g. audio/mpeg →
@@ -797,10 +806,7 @@ export class GeminiProvider implements Provider {
               });
             }
           } else {
-            const fallback = block.extracted_text?.trim()
-              ? `[Attached file: ${fileSrc.filename} (${fileSrc.media_type})]\n${block.extracted_text}`
-              : `[Attached file: ${fileSrc.filename} (${fileSrc.media_type})]\nNo extracted text available.`;
-            parts.push({ text: fallback });
+            parts.push({ text: fileBlockToProviderText(block) });
           }
           break;
         }