@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/providers/openai/__tests__/vision-not-supported.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+
+import OpenAI from "openai";
+
+import { detectVisionNotSupported } from "../chat-completions-provider.js";
+
+function buildApiError(
+  status: number,
+  body: unknown,
+): InstanceType<typeof OpenAI.APIError> {
+  return new OpenAI.APIError(
+    status,
+    body as Record<string, unknown>,
+    undefined,
+    new Headers(),
+  );
+}
+
+describe("detectVisionNotSupported", () => {
+  test("detects OpenRouter 'No endpoints found that support image input'", () => {
+    const err = buildApiError(404, {
+      error: {
+        message: "No endpoints found that support image input",
+        code: 404,
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("detects 'does not support image' phrasing", () => {
+    const err = buildApiError(400, {
+      error: {
+        message: "This model does not support image input",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("detects 'image input is not supported'", () => {
+    const err = buildApiError(400, {
+      error: {
+        message: "image input is not supported for this model",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("detects 'vision is not supported'", () => {
+    const err = buildApiError(400, {
+      error: {
+        message: "Vision is not supported by this model",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("returns false for unrelated errors", () => {
+    const err = buildApiError(429, {
+      error: {
+        message: "Rate limit exceeded",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(false);
+  });
+
+  test("returns false for context overflow", () => {
+    const err = buildApiError(400, {
+      error: {
+        code: "context_length_exceeded",
+        message: "This model's maximum context length is 128000 tokens",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(false);
+  });
+});

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

@@ -101,6 +101,22 @@ export function extractApiErrorDetail(
  *  OpenRouter's `error.metadata.raw` strings, which are typically <1KB. */
 const MAX_API_ERROR_DETAIL_CHARS = 2000;
 
+const VISION_NOT_SUPPORTED_PATTERNS = [
+  /no endpoints found that support image input/i,
+  /does not support image/i,
+  /image input is not supported/i,
+  /this model does not support vision/i,
+  /vision is not supported/i,
+  /multi-?modal.*not.*support/i,
+];
+
+export function detectVisionNotSupported(
+  error: InstanceType<typeof OpenAI.APIError>,
+): boolean {
+  const haystack = `${error.message} ${JSON.stringify((error as { error?: unknown }).error ?? "")}`;
+  return VISION_NOT_SUPPORTED_PATTERNS.some((re) => re.test(haystack));
+}
+
 /**
  * Fallback `content` for an assistant turn that has neither visible text nor
  * tool calls (e.g. a reasoning-only turn truncated at the output-token limit).
@@ -293,6 +309,9 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
     const effort = configObj?.effort as string | undefined;
+    const logitBias = configObj?.logit_bias as
+      | Record<string, number>
+      | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
@@ -313,6 +332,12 @@ export class OpenAIChatCompletionsProvider implements Provider {
         params.max_completion_tokens = maxTokens;
       }
 
+      // Profile-scoped token biasing (e.g. the `suppress-cjk` preset). Resolved
+      // and gated to this provider family upstream in `RetryProvider`.
+      if (logitBias) {
+        params.logit_bias = logitBias;
+      }
+
       // Subclasses (OpenRouter) may already have nested effort under
       // `reasoning.effort` via `buildExtraCreateParams`. Skip the flat
       // `reasoning_effort` assignment in that case to avoid sending both forms,
@@ -625,7 +650,16 @@ export class OpenAIChatCompletionsProvider implements Provider {
             : {}),
         },
         stopReason: finishReason,
-        rawRequest: params,
+        // `rawRequest` is persisted to the request-log DB and inspector on every
+        // call. A `logit_bias` preset (e.g. `suppress-cjk`) is ~5.3k deterministic
+        // entries (~68KB); summarize it here so logs don't balloon. The full map
+        // still went out on the wire above.
+        rawRequest: params.logit_bias
+          ? {
+              ...params,
+              logit_bias: `<${Object.keys(params.logit_bias).length} token biases omitted>`,
+            }
+          : params,
         rawResponse,
       };
     } catch (error) {
@@ -649,6 +683,15 @@ export class OpenAIChatCompletionsProvider implements Provider {
             cause: error,
           });
         }
+        if (detectVisionNotSupported(error)) {
+          const model = modelOverride ?? this.model;
+          throw new ProviderError(
+            `This model (${model}) doesn't support image input. Remove the image or switch to a vision-capable model.`,
+            this.name,
+            error.status,
+            abortReason ? { abortReason } : undefined,
+          );
+        }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
           retryAfterMs?: number;

package/src/providers/retry.ts

@@ -13,6 +13,8 @@ import {
   isRetryableNetworkError,
   sleep,
 } from "../util/retry.js";
+import { resolveLogitBiasPreset } from "./inference/logit-bias.js";
+import { isAdaptiveThinkingOnlyModel } from "./model-catalog.js";
 import {
   isThinkingConfigDisabled,
   normalizeThinkingConfigForWire,
@@ -277,6 +279,27 @@ function normalizeSendMessageOptions(
     ) {
       nextConfig.openrouter = { only: resolved.openrouter.only };
     }
+    // Forward a profile's opted-in `logit_bias` preset only on the Fireworks
+    // (OpenAI-compatible) path. `resolved.logitBias` is set by the resolver from
+    // the single winning profile (not the deep-merge), so it can't leak from a
+    // lower-precedence profile into one that didn't opt in.
+    // `resolveLogitBiasPreset` additionally gates on the resolved model's
+    // tokenizer. Strict-schema clients (Anthropic) reject unknown body fields,
+    // hence the provider gate.
+    if (
+      providerName === "fireworks" &&
+      nextConfig.logit_bias === undefined &&
+      resolved.logitBias !== undefined &&
+      typeof nextConfig.model === "string"
+    ) {
+      const biasMap = resolveLogitBiasPreset(
+        resolved.logitBias,
+        nextConfig.model,
+      );
+      if (biasMap !== undefined) {
+        nextConfig.logit_bias = biasMap;
+      }
+    }
     // `contextWindow` and `provider` are server-side concerns, not provider
     // request parameters: effective context is resolved per call site/profile
     // by the agent/conversation path, while `provider` selection is handled by
@@ -302,6 +325,18 @@ function normalizeSendMessageOptions(
     }
   }
 
+  // Claude Fable always reasons with adaptive thinking and rejects an explicit
+  // `thinking: { type: "disabled" }` (Anthropic 400s the request). Drop a
+  // disabled thinking config for these models so they fall back to their
+  // always-on adaptive thinking; effort and other params are unaffected.
+  if (
+    typeof nextConfig.model === "string" &&
+    isAdaptiveThinkingOnlyModel(nextConfig.model) &&
+    isThinkingConfigDisabled(nextConfig.thinking)
+  ) {
+    delete nextConfig.thinking;
+  }
+
   // thinking is Anthropic-specific on the wire; OpenRouter reads it as a
   // signal for its unified reasoning parameter; Gemini reads `level` from it.
   // Strip it for other providers.
@@ -383,15 +418,30 @@ function normalizeSendMessageOptions(
   //   strip `temperature` upstream; non-Anthropic OpenRouter reasoning
   //   models don't have this exact constraint).
   const isThinkingTemperatureConflict = (() => {
-    if (nextConfig.thinking == null) return false;
-    if (isThinkingConfigDisabled(nextConfig.thinking)) return false;
+    const model = typeof nextConfig.model === "string" ? nextConfig.model : "";
+    // Claude Fable always reasons in adaptive mode, so the `temperature: 1`
+    // constraint applies even when no explicit `thinking` config is present
+    // (a disabled config was already dropped above). For every other model
+    // the constraint only applies when thinking is actually enabled.
+    if (!isAdaptiveThinkingOnlyModel(model)) {
+      if (nextConfig.thinking == null) {
+        return false;
+      }
+      if (isThinkingConfigDisabled(nextConfig.thinking)) {
+        return false;
+      }
+    }
     const temp = nextConfig.temperature;
-    if (typeof temp !== "number") return false;
-    if (temp === 1) return false;
-    if (providerName === "anthropic") return true;
+    if (typeof temp !== "number") {
+      return false;
+    }
+    if (temp === 1) {
+      return false;
+    }
+    if (providerName === "anthropic") {
+      return true;
+    }
     if (providerName === "openrouter") {
-      const model =
-        typeof nextConfig.model === "string" ? nextConfig.model : "";
       return model.startsWith("anthropic/");
     }
     return false;

package/src/providers/types.ts

@@ -207,6 +207,12 @@ export interface SendMessageConfig {
   effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
   speed?: "standard" | "fast";
   verbosity?: "low" | "medium" | "high";
+  /**
+   * Wire-format `logit_bias` map (`{ "<tokenId>": bias }`). Set by
+   * `RetryProvider` from a profile's `logitBias` preset and forwarded only on
+   * the OpenAI-compatible (Fireworks) path; other providers ignore it.
+   */
+  logit_bias?: Record<string, number>;
   /**
    * When true, the most recent user message's content varies across
    * otherwise-identical turns (e.g. a per-turn memory block was injected into