@vellumai/assistant 0.11.8 → 0.11.9-staging.1

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";
@@ -429,8 +434,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 +766,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 +779,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 +805,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;
         }

package/src/providers/inference/auth.ts

@@ -144,12 +144,12 @@ export type ConnectionProvider = string;
 export const CHATGPT_SUBSCRIPTION_CONNECTION_NAME = "chatgpt-subscription";
 
 /**
- * Provider values that are routing identities rather than adapters: the
- * value names HOW a request routes (vellum = the platform-managed route,
- * chatgpt = the subscription route), and dispatch translates it to a real
- * upstream + connection row per-request (resolveRoutingIdentity). Identity
- * profiles carry no provider_connection; backfill and materialization must
- * not stamp one.
+ * Provider values that name a routing identity. Dispatch translates them
+ * to a connection row and an upstream factory id via
+ * `resolveRoutingIdentity`. `chatgpt` has no adapter factory (upstream is
+ * always openai). `vellum` is also a catalog factory id when the derived
+ * upstream is vellum. Identity profiles carry no provider_connection;
+ * backfill and materialization must not stamp one.
  */
 export const ROUTING_IDENTITY_PROVIDERS: ReadonlySet<string> = new Set([
   "vellum",

package/src/providers/media-resolve.ts

@@ -28,6 +28,7 @@ import {
   sniffImageMimeType,
 } from "../util/image-conversion.js";
 import { getLogger } from "../util/logger.js";
+import { keepFileAsWorkspaceRef } from "./content-block-size.js";
 import {
   attachmentIdFragment,
   type Base64MediaSource,
@@ -265,6 +266,16 @@ async function resolveImageBlock(
 }
 
 function resolveFileBlock(block: FileContent): ContentBlock {
+  // Video and over-cap text stay a workspace file. Do not load bytes or
+  // carry extracted_text into the provider prompt: serializers name the
+  // file and stop there.
+  if (keepFileAsWorkspaceRef(block.source)) {
+    if (block.extracted_text === undefined) {
+      return block;
+    }
+    const { extracted_text: _extracted, ...rest } = block;
+    return rest;
+  }
   if (block.source.type === "base64") {
     return block;
   }
@@ -356,6 +367,9 @@ function contentNeedsResolution(
         : base64ImageNeedsRewrite(block.source, options);
     }
     if (block.type === "file") {
+      if (keepFileAsWorkspaceRef(block.source)) {
+        return block.extracted_text !== undefined;
+      }
       return block.source.type === "workspace_ref";
     }
     if (block.type === "tool_result" && block.contentBlocks?.length) {

package/src/providers/model-catalog.ts

@@ -928,23 +928,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.16,
         },
       },
-      {
-        id: "accounts/fireworks/models/glm-5p2",
-        displayName: "GLM 5.2",
-        // Fireworks serves GLM 5.2 with a 1,040K input window.
-        contextWindowTokens: 1040000,
-        maxOutputTokens: 131072,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        maxEffort: "max",
-        pricing: {
-          inputPer1mTokens: 1.4,
-          outputPer1mTokens: 4.4,
-          cacheReadPer1mTokens: 0.26,
-        },
-      },
       {
         id: "accounts/fireworks/models/glm-5p3",
         displayName: "GLM 5.3",
@@ -984,6 +967,23 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.029,
         },
       },
+      {
+        id: "accounts/fireworks/models/glm-5p2",
+        displayName: "GLM 5.2",
+        // Fireworks serves GLM 5.2 with a 1,040K input window.
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        pricing: {
+          inputPer1mTokens: 1.4,
+          outputPer1mTokens: 4.4,
+          cacheReadPer1mTokens: 0.26,
+        },
+      },
       // Kimi K2.5 (accounts/fireworks/models/kimi-k2p5) is intentionally
       // absent: Fireworks serves it on-demand/dedicated only, so serverless
       // chat/completions calls 404 ("not found, inaccessible, and/or not
@@ -1006,28 +1006,25 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.06,
         },
       },
+      // MiniMax M2.7 (accounts/fireworks/models/minimax-m2p7) is
+      // intentionally absent: Fireworks has no serverless deployment for
+      // it (the model page claims serverless support, but the serving API
+      // returns 404).
       {
-        id: "accounts/fireworks/models/minimax-m2p7",
-        displayName: "MiniMax M2.7",
-        contextWindowTokens: 196608,
-        maxOutputTokens: 25000,
-        supportsThinking: false,
-        supportsCaching: false,
-        supportsVision: false,
-        supportsToolUse: true,
-        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 1.2 },
-      },
-      {
-        id: "accounts/fireworks/models/deepseek-v4-pro",
+        id: "accounts/fireworks/models/deepseek-v4-pro-0813",
         displayName: "DeepSeek V4 Pro",
         contextWindowTokens: 1040000,
         maxOutputTokens: 131072,
         supportsThinking: true,
-        supportsCaching: false,
+        supportsCaching: true,
         supportsVision: false,
         supportsToolUse: true,
         maxEffort: "max",
-        pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
+        pricing: {
+          inputPer1mTokens: 1.32,
+          outputPer1mTokens: 3.96,
+          cacheReadPer1mTokens: 0.044,
+        },
       },
       {
         id: "accounts/fireworks/models/deepseek-v4-flash-0731",
@@ -1834,7 +1831,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // Z.ai
       {
         id: "z-ai/glm-5.3",
-        displayName: "GLM-5.3",
+        displayName: "GLM 5.3",
         contextWindowTokens: 1048576,
         maxOutputTokens: 131072,
         supportsThinking: true,
@@ -1849,7 +1846,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       },
       {
         id: "z-ai/glm-5.3-flash",
-        displayName: "GLM-5.3 Flash",
+        displayName: "GLM 5.3 Flash",
         contextWindowTokens: 1310720,
         maxOutputTokens: 131072,
         supportsThinking: true,
@@ -1864,7 +1861,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       },
       {
         id: "z-ai/glm-5.2",
-        displayName: "GLM-5.2",
+        displayName: "GLM 5.2",
         contextWindowTokens: 1048576,
         maxOutputTokens: 131072,
         supportsThinking: true,