@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/providers/model-catalog.ts

@@ -1374,6 +1374,32 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // usage never includes cached tokens. `supportsCaching` therefore stays
       // false; the `cacheReadPer1mTokens` rates below only apply if OpenRouter
       // starts reporting cached tokens in usage.
+      {
+        id: "x-ai/grok-4.6",
+        displayName: "Grok 4.6",
+        contextWindowTokens: 500000,
+        // xAI publishes no completion cap; 30K is the tracker-reported
+        // single-response limit used for sibling Grok 4.x catalog rows.
+        maxOutputTokens: 30000,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: true,
+        supportsToolUse: true,
+        longContextPricingThresholdTokens: 200000,
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 6,
+          cacheReadPer1mTokens: 0.5,
+          tiers: [
+            {
+              inputTokenThreshold: 200000,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 12,
+              cacheReadPer1mTokens: 1,
+            },
+          ],
+        },
+      },
       {
         id: "x-ai/grok-4.5",
         displayName: "Grok 4.5",
@@ -1697,6 +1723,36 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         pricing: { inputPer1mTokens: 0.2, outputPer1mTokens: 1.1 },
       },
       // Z.ai
+      {
+        id: "z-ai/glm-5.3",
+        displayName: "GLM-5.3",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 1.4,
+          outputPer1mTokens: 4.4,
+          cacheReadPer1mTokens: 0.26,
+        },
+      },
+      {
+        id: "z-ai/glm-5.3-flash",
+        displayName: "GLM-5.3 Flash",
+        contextWindowTokens: 1310720,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.075,
+          outputPer1mTokens: 0.25,
+          cacheReadPer1mTokens: 0.015,
+        },
+      },
       {
         id: "z-ai/glm-5.2",
         displayName: "GLM-5.2",
@@ -2038,6 +2094,25 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     models: [],
     defaultModel: "",
   },
+  {
+    id: "opencode",
+    displayName: "OpenCode",
+    subtitle:
+      "OpenCode Zen and OpenCode Go. Models come from the endpoint, not a fixed catalog.",
+    setupMode: "api-key",
+    setupHint:
+      "Enter your OpenCode API key. Leave the base URL empty for Zen, or set it to the Go endpoint.",
+    envVar: "OPENCODE_API_KEY",
+    credentialsGuide: {
+      description:
+        "Create an OpenCode API key, then choose Zen or Go as the endpoint.",
+      url: "https://opencode.ai",
+      linkLabel: "OpenCode",
+    },
+    apiKeyPlaceholder: "sk-...",
+    models: [],
+    defaultModel: "",
+  },
   {
     id: "openai-compatible",
     displayName: "OpenAI-compatible",
@@ -2196,6 +2271,31 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://poolside.ai",
     apiKeyPlaceholder: "Your Poolside API key",
   },
+  {
+    id: "vellum",
+    displayName: "Vellum",
+    subtitle:
+      "Models served on Vellum GPU nodes through the managed connection.",
+    setupMode: "api-key",
+    setupHint:
+      "Uses the assistant API key through the Vellum managed connection. These models cannot use a bring-your-own key.",
+    featureFlag: "settings-developer-nav",
+    models: [
+      {
+        id: "qwen/qwen3-8b",
+        displayName: "Qwen3 8B",
+        contextWindowTokens: 32768,
+        maxOutputTokens: 32768,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 0.3 },
+        featureFlag: "settings-developer-nav",
+      },
+    ],
+    defaultModel: "qwen/qwen3-8b",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/openai/__tests__/api-error-normalization.test.ts

@@ -387,6 +387,28 @@ describe("deriveReason", () => {
     ).toBe("vision_unsupported");
   });
 
+  test("chat-template failure prose on a 400 → request_shape_unsupported", () => {
+    // Together's server-side renderer error for MiniMax M3, verbatim.
+    expect(
+      deriveReason(
+        n({
+          message:
+            "Failed to apply chat template: invalid operation: object is not callable (in chat:22)",
+        }),
+        400,
+      ),
+    ).toBe("request_shape_unsupported");
+  });
+
+  test("chat-template prose on a 5xx stays server-side, not request_shape_unsupported", () => {
+    expect(
+      deriveReason(
+        n({ message: "Failed to apply chat template: renderer crashed" }),
+        500,
+      ),
+    ).not.toBe("request_shape_unsupported");
+  });
+
   test("402 → insufficient_credits", () => {
     expect(deriveReason(n(), 402)).toBe("insufficient_credits");
   });

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

@@ -0,0 +1,198 @@
+import { describe, expect, test } from "bun:test";
+
+import { ProviderError } from "../../../util/errors.js";
+import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
+
+type MockChunk = {
+  choices: Array<{
+    delta: { content?: string | null };
+    finish_reason?: string | null;
+  }>;
+  usage?: { prompt_tokens: number; completion_tokens: number };
+};
+
+function makeStream(chunks: MockChunk[]): AsyncIterable<MockChunk> {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (const c of chunks) {
+        yield c;
+      }
+    },
+  };
+}
+
+const OK_CHUNKS: MockChunk[] = [
+  {
+    choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+    usage: { prompt_tokens: 1, completion_tokens: 1 },
+  },
+];
+
+function stubProviderWithErrors(errors: unknown[]): {
+  provider: OpenAIChatCompletionsProvider;
+  requests: unknown[];
+} {
+  const provider = new OpenAIChatCompletionsProvider("test-key", "test-model");
+  const requests: unknown[] = [];
+  const pending = [...errors];
+  (provider as unknown as { client: unknown }).client = {
+    chat: {
+      completions: {
+        create: async (params: unknown) => {
+          // Snapshot: the fallback mutates `params` between attempts.
+          requests.push(JSON.parse(JSON.stringify(params)));
+          const error = pending.shift();
+          if (error !== undefined) {
+            throw error;
+          }
+          return makeStream(OK_CHUNKS);
+        },
+      },
+    },
+  };
+  return { provider, requests };
+}
+
+// Together's server-side renderer error for MiniMax M3, verbatim.
+const CHAT_TEMPLATE_400 =
+  "Failed to apply chat template: invalid operation: object is not callable (in chat:22)";
+
+function rejection(message: string, status = 400): Error {
+  return Object.assign(new Error(message), { status });
+}
+
+const TINY_PNG =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
+
+describe("chat-template rejection flatten fallback", () => {
+  test("retries once with flattened string content when the chat template rejects a text-only content-parts array", async () => {
+    // GIVEN an endpoint whose chat template 400s on structured message content
+    const { provider, requests } = stubProviderWithErrors([
+      rejection(CHAT_TEMPLATE_400),
+    ]);
+
+    // WHEN a multi-block user message of purely textual parts is sent
+    const response = await provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "first paragraph" },
+          { type: "text", text: "second paragraph" },
+        ],
+      },
+    ]);
+
+    // THEN the first request carried a content-parts array
+    expect(requests).toHaveLength(2);
+    const first = requests[0] as {
+      messages: Array<{ content: unknown }>;
+    };
+    expect(Array.isArray(first.messages[0].content)).toBe(true);
+
+    // AND the retry flattened it to a plain string keeping all the text
+    const second = requests[1] as {
+      messages: Array<{ content: unknown }>;
+    };
+    const flattened = second.messages[0].content;
+    expect(flattened).toBe("first paragraph\n\nsecond paragraph");
+
+    // AND the retry succeeded
+    const text = response.content.find((b) => b.type === "text") as
+      | { type: "text"; text: string }
+      | undefined;
+    expect(text?.text).toBe("ok");
+  });
+
+  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([
+      rejection(CHAT_TEMPLATE_400),
+    ]);
+
+    // WHEN a multi-block user message with an image part is sent
+    const promise = provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "what is in this image?" },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: TINY_PNG,
+            },
+          },
+        ],
+      },
+    ]);
+
+    // THEN the error propagates with no retry, so downstream classification
+    // can surface the capability mismatch instead of answering without the image
+    await expect(promise).rejects.toBeInstanceOf(ProviderError);
+    expect(requests).toHaveLength(1);
+  });
+
+  test("does not retry when the messages are already plain strings", async () => {
+    // GIVEN a chat-template 400 on a request whose content is already a
+    // plain string (flattening would change nothing, so retrying is futile)
+    const { provider, requests } = stubProviderWithErrors([
+      rejection(CHAT_TEMPLATE_400),
+    ]);
+
+    // WHEN a single-text-block user message is sent
+    const promise = provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+
+    // THEN the error propagates as a ProviderError with no retry attempt
+    await expect(promise).rejects.toBeInstanceOf(ProviderError);
+    expect(requests).toHaveLength(1);
+  });
+
+  test("does not retry on 5xx even when the message mentions the chat template", async () => {
+    // GIVEN a 500 whose body happens to mention the chat template (a server
+    // fault, not a request-shape rejection)
+    const { provider, requests } = stubProviderWithErrors([
+      rejection(CHAT_TEMPLATE_400, 500),
+    ]);
+
+    // WHEN a multi-block user message is sent
+    const promise = provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "a" },
+          { type: "text", text: "b" },
+        ],
+      },
+    ]);
+
+    // THEN the error propagates with no retry attempt
+    await expect(promise).rejects.toBeInstanceOf(ProviderError);
+    expect(requests).toHaveLength(1);
+  });
+
+  test("surfaces the retry's error when the flattened request also fails", async () => {
+    // GIVEN an endpoint that rejects both the structured and the flattened shape
+    const { provider, requests } = stubProviderWithErrors([
+      rejection(CHAT_TEMPLATE_400),
+      rejection(CHAT_TEMPLATE_400),
+    ]);
+
+    // WHEN a multi-block user message is sent
+    const promise = provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "a" },
+          { type: "text", text: "b" },
+        ],
+      },
+    ]);
+
+    // THEN the failure propagates after exactly one retry
+    await expect(promise).rejects.toBeInstanceOf(ProviderError);
+    expect(requests).toHaveLength(2);
+  });
+});

package/src/providers/openai/api-error-normalization.ts

@@ -4,6 +4,7 @@ import type { ProviderErrorReason } from "../../util/errors.js";
 import {
   DAILY_LIMIT_PATTERNS,
   INSUFFICIENT_CREDITS_PATTERNS,
+  isChatTemplateFailureError,
   VISION_NOT_SUPPORTED_PATTERNS,
 } from "../../util/provider-error-patterns.js";
 
@@ -81,6 +82,18 @@ export function deriveReason(
     return "vision_unsupported";
   }
 
+  // A 4xx from the endpoint's server-side chat-template renderer: the request
+  // shape (content-parts arrays, tool payloads) is what the template can't
+  // handle, not the credentials or the model.
+  if (
+    status !== undefined &&
+    status >= 400 &&
+    status < 500 &&
+    isChatTemplateFailureError(haystack)
+  ) {
+    return "request_shape_unsupported";
+  }
+
   // The managed proxy's daily-limit 402 shares the status with generic credit
   // exhaustion; match its specific body code first so it isn't swallowed.
   if (DAILY_LIMIT_PATTERNS.some((re) => re.test(haystack))) {

package/src/providers/openai/chat-completions-provider.ts

@@ -4,6 +4,7 @@ import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError, type ProviderErrorReason } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
+import { isChatTemplateFailureError } from "../../util/provider-error-patterns.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { partialTagSuffix as sharedPartialTagSuffix } from "../../util/think-tag-stream.js";
 import { escapeXmlAttr } from "../../util/xml.js";
@@ -529,6 +530,74 @@ function isUnknownAssistantReasoningFieldRejection(
   );
 }
 
+function isTextualContentPart(part: { type: string }): boolean {
+  return part.type === "text" || part.type === "refusal";
+}
+
+function messagesCarryFlattenableContentPartsArrays(params: unknown): boolean {
+  const messages = paramsMessages(params);
+  if (!messages) {
+    return false;
+  }
+  const arrays = messages.filter((msg) => Array.isArray(msg.content));
+  if (arrays.length === 0) {
+    return false;
+  }
+  return arrays.every((msg) =>
+    (msg.content as Array<{ type: string }>).every(isTextualContentPart),
+  );
+}
+
+/**
+ * True when the endpoint's server-side chat-template renderer rejected the
+ * request and every content-parts array in the outbound messages is purely
+ * textual, so flattening to plain strings loses nothing. Some template
+ * engines behind OpenAI-compatible endpoints only render string message
+ * content (Together serving MiniMax M3 400s with `Failed to apply chat
+ * template: invalid operation: object is not callable`); one retry with
+ * flattened content lets the same endpoint succeed instead of surfacing the
+ * raw template error. Requests carrying media parts are never flattened:
+ * silently dropping an image or audio blob would let the model answer
+ * without it, so those rejections propagate to error classification.
+ */
+function isChatTemplateRejection(error: unknown, params: unknown): boolean {
+  if (!isClientErrorStatus(error)) {
+    return false;
+  }
+  if (!isChatTemplateFailureError(openaiCompatErrorHaystack(error))) {
+    return false;
+  }
+  return messagesCarryFlattenableContentPartsArrays(params);
+}
+
+/**
+ * Rewrite every purely-textual content-parts array in `params.messages` into
+ * a plain string. Returns whether any message changed.
+ */
+function flattenContentPartsToStrings(params: unknown): boolean {
+  const messages = paramsMessages(params);
+  if (!messages) {
+    return false;
+  }
+  let flattened = false;
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) {
+      continue;
+    }
+    const parts = msg.content as Array<
+      { type: "text"; text: string } | { type: "refusal"; refusal: string }
+    >;
+    if (!parts.every(isTextualContentPart)) {
+      continue;
+    }
+    msg.content = parts
+      .map((part) => (part.type === "text" ? part.text : part.refusal))
+      .join("\n\n");
+    flattened = true;
+  }
+  return flattened;
+}
+
 /**
  * Translate the neutral (Anthropic-shaped) `tool_choice` carried on the call
  * config into the OpenAI chat-completions wire format. Callers express
@@ -656,6 +725,9 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
+    const perRequestHeaders = configObj?.requestHeaders as
+      | Record<string, string>
+      | undefined;
 
     // Per-tool keys whose object schemas were rewritten to JSON strings for the
     // wire, to be decoded back on the response. Empty unless
@@ -844,6 +916,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
         const requestHeaders = {
           ...this.requestHeaders,
           ...(usageAttributionHeaders ?? {}),
+          ...(perRequestHeaders ?? {}),
         };
         const createStream = () =>
           this.client.chat.completions.create(params, {
@@ -901,6 +974,17 @@ export class OpenAIChatCompletionsProvider implements Provider {
             );
             stripAssistantReasoningFields(params);
             stream = await createStream();
+          } else if (isChatTemplateRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream chat template rejected structured message content; retrying with flattened plain-text content",
+            );
+            flattenContentPartsToStrings(params);
+            stream = await createStream();
           } else {
             throw error;
           }

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

@@ -0,0 +1,150 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  EMPTY_ASSISTANT_TURN_PLACEHOLDER,
+  OpenAIChatCompletionsProvider,
+} from "../openai/chat-completions-provider.js";
+import {
+  buildOpenCodeRequestHeaders,
+  OPENCODE_GO_BASE_URL,
+  OPENCODE_REQUEST_HEADER,
+  OPENCODE_SESSION_HEADER,
+  OPENCODE_ZEN_BASE_URL,
+  OpenCodeProvider,
+  resolveOpenCodeBaseURL,
+} from "./client.js";
+
+describe("resolveOpenCodeBaseURL", () => {
+  test("defaults to OpenCode Zen", () => {
+    expect(resolveOpenCodeBaseURL()).toBe(OPENCODE_ZEN_BASE_URL);
+    expect(resolveOpenCodeBaseURL("")).toBe(OPENCODE_ZEN_BASE_URL);
+    expect(resolveOpenCodeBaseURL("   ")).toBe(OPENCODE_ZEN_BASE_URL);
+  });
+
+  test("keeps a configured origin, including OpenCode Go", () => {
+    expect(resolveOpenCodeBaseURL(OPENCODE_GO_BASE_URL)).toBe(
+      OPENCODE_GO_BASE_URL,
+    );
+    expect(resolveOpenCodeBaseURL(" https://example.com/v1 ")).toBe(
+      "https://example.com/v1",
+    );
+  });
+});
+
+describe("buildOpenCodeRequestHeaders", () => {
+  test("omits headers when ids are missing", () => {
+    expect(buildOpenCodeRequestHeaders({})).toEqual({});
+    expect(buildOpenCodeRequestHeaders({ conversationId: "  " })).toEqual({});
+  });
+
+  test("sets session and request headers without session_id", () => {
+    const headers = buildOpenCodeRequestHeaders({
+      conversationId: "conv-xyz",
+      requestId: "req-123",
+    });
+    expect(headers[OPENCODE_SESSION_HEADER]).toBe("conv-xyz");
+    expect(headers[OPENCODE_REQUEST_HEADER]).toBe("req-123");
+    expect(headers).not.toHaveProperty("session_id");
+  });
+
+  test("sets only the ids that are present", () => {
+    expect(
+      buildOpenCodeRequestHeaders({ conversationId: "conv-xyz" }),
+    ).toEqual({ [OPENCODE_SESSION_HEADER]: "conv-xyz" });
+    expect(buildOpenCodeRequestHeaders({ requestId: "req-123" })).toEqual({
+      [OPENCODE_REQUEST_HEADER]: "req-123",
+    });
+  });
+});
+
+describe("OpenCodeProvider", () => {
+  test("uses OpenAI chat-completions with reasoning-compatible knobs", () => {
+    const provider = new OpenCodeProvider("sk-test", "mimo-v2.5-free");
+    expect(provider).toBeInstanceOf(OpenAIChatCompletionsProvider);
+    expect(provider.name).toBe("opencode");
+    expect(
+      (provider as unknown as { assistantReasoningField?: string })
+        .assistantReasoningField,
+    ).toBe("reasoning_content");
+    expect(
+      (provider as unknown as { omitToolChoiceWhenReasoning: boolean })
+        .omitToolChoiceWhenReasoning,
+    ).toBe(true);
+  });
+
+  test("merges per-request OpenCode headers onto the transport", async () => {
+    const provider = new OpenCodeProvider("sk-test", "mimo-v2.5-free");
+    const seen: Array<{ params: unknown; options: unknown }> = [];
+    (provider as unknown as { client: unknown }).client = {
+      chat: {
+        completions: {
+          create: async (params: unknown, options: unknown) => {
+            seen.push({ params, options });
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield {
+                  choices: [
+                    { delta: { content: "ok" }, finish_reason: "stop" },
+                  ],
+                  usage: { prompt_tokens: 2, completion_tokens: 1 },
+                };
+              },
+            };
+          },
+        },
+      },
+    };
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "question" }] }],
+      {
+        config: {
+          requestHeaders: {
+            [OPENCODE_SESSION_HEADER]: "conv-xyz",
+            [OPENCODE_REQUEST_HEADER]: "req-123",
+          },
+        },
+      },
+    );
+
+    const options = seen[0]!.options as { headers?: Record<string, string> };
+    expect(options.headers?.[OPENCODE_SESSION_HEADER]).toBe("conv-xyz");
+    expect(options.headers?.[OPENCODE_REQUEST_HEADER]).toBe("req-123");
+    expect(options.headers).not.toHaveProperty("session_id");
+  });
+
+  test("backfills placeholder content after an aborted empty assistant turn", async () => {
+    const provider = new OpenCodeProvider("sk-test", "mimo-v2.5-free");
+    const requests: unknown[] = [];
+    (provider as unknown as { client: unknown }).client = {
+      chat: {
+        completions: {
+          create: async (params: unknown) => {
+            requests.push(params);
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield {
+                  choices: [
+                    { delta: { content: "ok" }, finish_reason: "stop" },
+                  ],
+                  usage: { prompt_tokens: 2, completion_tokens: 1 },
+                };
+              },
+            };
+          },
+        },
+      },
+    };
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "question" }] },
+      { role: "assistant", content: [] },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{ role: string; content: string | null }>;
+    };
+    const assistantMsg = params.messages.find((m) => m.role === "assistant")!;
+    expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
+  });
+});