@vellumai/assistant 0.8.9 → 0.8.10-staging.1

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.8.9
+  version: 0.8.10
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.9",
+  "version": "0.8.10-staging.1",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/sync-llm-catalog.ts

@@ -74,6 +74,8 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
     projected.longContextMode = model.longContextMode;
   if (model.supportsThinking !== undefined)
     projected.supportsThinking = model.supportsThinking;
+  if (model.adaptiveThinkingOnly !== undefined)
+    projected.adaptiveThinkingOnly = model.adaptiveThinkingOnly;
   if (model.supportsCaching !== undefined)
     projected.supportsCaching = model.supportsCaching;
   if (model.supportsVision !== undefined)

package/src/__tests__/llm-catalog-parity.test.ts

@@ -53,6 +53,7 @@ interface ClientCatalogModel {
   longContextPricingThresholdTokens?: number;
   longContextMode?: "native-model" | "provider-request-option" | "unsupported";
   supportsThinking?: boolean;
+  adaptiveThinkingOnly?: boolean;
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
@@ -194,6 +195,9 @@ describe("LLM catalog parity: daemon vs client", () => {
         );
         expect(clientModel.longContextMode).toBe(daemonModel.longContextMode);
         expect(clientModel.supportsThinking).toBe(daemonModel.supportsThinking);
+        expect(clientModel.adaptiveThinkingOnly).toBe(
+          daemonModel.adaptiveThinkingOnly,
+        );
         expect(clientModel.supportsCaching).toBe(daemonModel.supportsCaching);
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);

package/src/__tests__/retry-thinking-adaptive-only.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Verifies that `RetryProvider.normalizeSendMessageOptions` drops a disabled
+ * thinking config for adaptive-thinking-only models (Claude Fable), preventing
+ * an Anthropic 400: Fable always reasons with always-on adaptive thinking and
+ * rejects `thinking: { type: "disabled" }`.
+ *
+ * Effort and other parameters are unaffected, and models that genuinely support
+ * disabling thinking (e.g. Opus) keep their disabled config.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let mockLlmConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ llm: mockLlmConfig }),
+}));
+
+import { LLMSchema } from "../config/schemas/llm.js";
+import { RetryProvider } from "../providers/retry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+
+function setLlmConfig(raw: unknown): void {
+  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+});
+
+function makePipeline(providerName: string): {
+  provider: Provider;
+  lastConfig: () => Record<string, unknown> | undefined;
+} {
+  let captured: Record<string, unknown> | undefined;
+  const inner: Provider = {
+    name: providerName,
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      captured = options?.config as Record<string, unknown> | undefined;
+      return {
+        content: [],
+        model: "test",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "stop",
+      };
+    },
+  };
+  return {
+    provider: new RetryProvider(inner),
+    lastConfig: () => captured,
+  };
+}
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "hi" }],
+};
+
+describe("retry normalization: adaptive-only thinking models", () => {
+  test("drops resolved thinking: disabled for Claude Fable", async () => {
+    // GIVEN a profile that disables thinking for an adaptive-only Fable model
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-fable-5",
+        thinking: { enabled: false },
+        effort: "high",
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking config is dropped so Fable falls back to its
+    // always-on adaptive thinking instead of 400-ing
+    expect(lastConfig()?.thinking).toBeUndefined();
+    // AND effort is still forwarded
+    expect(lastConfig()?.effort).toBe("high");
+  });
+
+  test("drops explicit thinking: disabled from pass-through callers for Fable", async () => {
+    // GIVEN a pass-through caller supplying the wire-shape disabled config
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN sending against a Fable model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "claude-fable-5",
+        thinking: { type: "disabled" },
+      },
+    });
+
+    // THEN the disabled thinking config is dropped
+    expect(lastConfig()?.thinking).toBeUndefined();
+  });
+
+  test("drops disabled thinking for OpenRouter-proxied Fable", async () => {
+    // GIVEN a profile disabling thinking on the OpenRouter-proxied Fable id
+    setLlmConfig({
+      default: {
+        provider: "openrouter",
+        model: "anthropic/claude-fable-5",
+        thinking: { enabled: false },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("openrouter");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking config is dropped
+    expect(lastConfig()?.thinking).toBeUndefined();
+  });
+
+  test("preserves adaptive thinking for Fable", async () => {
+    // GIVEN a profile that enables thinking for a Fable model
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-fable-5",
+        thinking: { enabled: true },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN adaptive thinking is preserved (only disabled is dropped)
+    expect(lastConfig()?.thinking).toEqual({ type: "adaptive" });
+  });
+
+  test("preserves disabled thinking for models that support disabling it", async () => {
+    // GIVEN a profile disabling thinking for a non-adaptive-only model
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: false },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking config is preserved for Opus
+    expect(lastConfig()?.thinking).toEqual({ type: "disabled" });
+  });
+
+  test("drops non-1 temperature for Fable when thinking is disabled", async () => {
+    // GIVEN a Fable profile that disables thinking and sets a non-1 temperature
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-fable-5",
+        thinking: { enabled: false },
+        temperature: 0.7,
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking is dropped (Fable falls back to adaptive) AND
+    // the non-1 temperature is dropped, since adaptive mode requires
+    // temperature: 1 — leaving it would 400 the request
+    expect(lastConfig()?.thinking).toBeUndefined();
+    expect(lastConfig()?.temperature).toBeUndefined();
+  });
+
+  test("drops non-1 temperature for Fable with no explicit thinking config", async () => {
+    // GIVEN a pass-through caller that sets a non-1 temperature and no thinking
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN sending against a Fable model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "claude-fable-5",
+        temperature: 0.5,
+      },
+    });
+
+    // THEN the temperature is dropped: Fable is always in adaptive mode, so the
+    // temperature: 1 constraint applies even without an explicit thinking config
+    expect(lastConfig()?.temperature).toBeUndefined();
+  });
+
+  test("drops non-1 temperature for OpenRouter-proxied Fable", async () => {
+    // GIVEN a pass-through caller on the OpenRouter-proxied Fable id
+    const { provider, lastConfig } = makePipeline("openrouter");
+
+    // WHEN sending with a non-1 temperature and no explicit thinking config
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "anthropic/claude-fable-5",
+        temperature: 0.2,
+      },
+    });
+
+    // THEN the temperature is dropped for the Anthropic-fronted Fable model
+    expect(lastConfig()?.temperature).toBeUndefined();
+  });
+
+  test("preserves temperature: 1 for Fable", async () => {
+    // GIVEN a Fable profile with the only adaptive-mode-valid temperature
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN sending against a Fable model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "claude-fable-5",
+        temperature: 1,
+      },
+    });
+
+    // THEN temperature: 1 is preserved (it is valid in adaptive mode)
+    expect(lastConfig()?.temperature).toBe(1);
+  });
+});

package/src/providers/model-catalog.ts

@@ -41,6 +41,15 @@ export interface CatalogModel {
   longContextPricingThresholdTokens?: number;
   longContextMode?: LongContextMode;
   supportsThinking?: boolean;
+  /**
+   * When true, the model always reasons with adaptive (always-on) thinking and
+   * rejects an explicit `thinking: { type: "disabled" }` request (Anthropic
+   * 400s such calls). Clients hide the enable/disable thinking toggle for these
+   * models — effort stays adjustable — and the daemon drops a disabled thinking
+   * config (and any non-1 `temperature`, which adaptive mode also rejects)
+   * before dispatching. Implies `supportsThinking`.
+   */
+  adaptiveThinkingOnly?: boolean;
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
@@ -144,6 +153,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Anthropic Console",
     },
     models: [
+      {
+        id: "claude-fable-5",
+        displayName: "Claude Fable 5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 10,
+          outputPer1mTokens: 50,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 1,
+        },
+      },
       {
         id: "claude-opus-4-8",
         displayName: "Claude Opus 4.8",
@@ -720,6 +747,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // OpenRouter proxies anthropic/* through Anthropic's Messages API, so
       // prompt caching and cache TTL metadata pass through unchanged and
       // billing matches Anthropic's direct rates.
+      {
+        id: "anthropic/claude-fable-5",
+        displayName: "Claude Fable 5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 10,
+          outputPer1mTokens: 50,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 1,
+        },
+      },
       {
         id: "anthropic/claude-opus-4.8",
         displayName: "Claude Opus 4.8",
@@ -1227,3 +1272,15 @@ export function getCatalogProviderForModel(
   );
   return matches.length === 1 ? matches[0]?.id : undefined;
 }
+
+/**
+ * Whether the given model only supports adaptive (always-on) thinking, driven
+ * by the `adaptiveThinkingOnly` capability in the catalog. Matches the model ID
+ * across every provider (a model carries the same id under each provider it is
+ * offered by, e.g. `claude-fable-5` and OpenRouter's `anthropic/claude-fable-5`).
+ */
+export function isAdaptiveThinkingOnlyModel(modelId: string): boolean {
+  return PROVIDER_CATALOG.some((p) =>
+    p.models.some((m) => m.id === modelId && m.adaptiveThinkingOnly === true),
+  );
+}

package/src/providers/retry.ts

@@ -14,6 +14,7 @@ import {
   sleep,
 } from "../util/retry.js";
 import { resolveLogitBiasPreset } from "./inference/logit-bias.js";
+import { isAdaptiveThinkingOnlyModel } from "./model-catalog.js";
 import {
   isThinkingConfigDisabled,
   normalizeThinkingConfigForWire,
@@ -324,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.
@@ -405,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;