@vellumai/assistant 0.11.6 → 0.11.7-staging.1

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);
+  });
+});

package/src/providers/opencode/client.ts

@@ -0,0 +1,61 @@
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+export const OPENCODE_ZEN_BASE_URL = "https://opencode.ai/zen/v1";
+export const OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+export const OPENCODE_SESSION_HEADER = "x-opencode-session";
+export const OPENCODE_REQUEST_HEADER = "x-opencode-request";
+
+export interface OpenCodeProviderOptions {
+  baseURL?: string;
+  streamTimeoutMs?: number;
+}
+
+/**
+ * Resolve the OpenCode chat-completions origin. A stored connection URL
+ * wins; otherwise the request goes to OpenCode Zen.
+ */
+export function resolveOpenCodeBaseURL(configuredBaseURL?: string): string {
+  const trimmed = configuredBaseURL?.trim();
+  if (trimmed) {
+    return trimmed;
+  }
+  return OPENCODE_ZEN_BASE_URL;
+}
+
+/**
+ * OpenCode-owned request headers for support lookup. Sends session and
+ * request ids only when they exist. Never sets `session_id` (zen/go
+ * returns 500 when that header is present).
+ */
+export function buildOpenCodeRequestHeaders(opts: {
+  conversationId?: string;
+  requestId?: string;
+}): Record<string, string> {
+  const headers: Record<string, string> = {};
+  const session = opts.conversationId?.trim();
+  if (session) {
+    headers[OPENCODE_SESSION_HEADER] = session;
+  }
+  const requestId = opts.requestId?.trim();
+  if (requestId) {
+    headers[OPENCODE_REQUEST_HEADER] = requestId;
+  }
+  return headers;
+}
+
+export class OpenCodeProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: OpenCodeProviderOptions = {},
+  ) {
+    super(apiKey, model, {
+      baseURL: resolveOpenCodeBaseURL(options.baseURL),
+      providerName: "opencode",
+      providerLabel: "OpenCode",
+      streamTimeoutMs: options.streamTimeoutMs,
+      assistantReasoningField: "reasoning_content",
+      omitToolChoiceWhenReasoning: true,
+    });
+  }
+}

package/src/providers/provider-resolvability.ts

@@ -0,0 +1,20 @@
+import { getDb } from "../persistence/db-connection.js";
+import { VALID_CONNECTION_PROVIDERS } from "./inference/auth.js";
+import { getConnection } from "./inference/connections.js";
+
+/**
+ * Selection-time predicate for `ResolveCallSiteOpts.isResolvableProvider`:
+ * a provider value dispatches when it is a known vendor/identity or names a
+ * connection entry row. Permissive on DB unavailability so a transient blip
+ * never heals away a valid entry profile; dispatch soft-fails on its own.
+ */
+export function dispatchProviderResolvable(provider: string): boolean {
+  if (VALID_CONNECTION_PROVIDERS.includes(provider)) {
+    return true;
+  }
+  try {
+    return getConnection(getDb(), provider) != null;
+  } catch {
+    return true;
+  }
+}