@vellumai/assistant 0.7.2 → 0.8.0

package/src/providers/__tests__/retry-callsite.test.ts

@@ -391,7 +391,14 @@ describe("RetryProvider — callSite resolution", () => {
 
   test("propagates temperature when explicitly set in resolved config", async () => {
     setLlmConfig({
-      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        // Thinking defaults to enabled in the schema. Disable here so the
+        // thinking/temperature conflict guard doesn't fire — that guard
+        // (Anthropic 400 backstop) has dedicated coverage further down.
+        thinking: { enabled: false },
+      },
       callSites: {
         mainAgent: { temperature: 0.5 },
       },
@@ -466,6 +473,220 @@ describe("RetryProvider — callSite resolution", () => {
   });
 });
 
+// ── RetryProvider — Anthropic thinking + temperature conflict guard ─────────
+//
+// Anthropic 400s with "temperature may only be set to 1 when thinking is
+// enabled or in adaptive mode" if a request combines extended thinking with
+// `temperature` ≠ 1. We had three call sites ship with hardcoded
+// per-call temperatures that exploded for Opus 4.x effort=high/xhigh
+// profiles (PR #29560 fixed the call sites). This guard is a backstop: if a
+// future call site reintroduces the same pattern, retry.ts drops the
+// offending temperature instead of letting the request fail at the wire.
+
+describe("RetryProvider — thinking/temperature conflict guard", () => {
+  test("drops explicit non-1 temperature when thinking is enabled (Anthropic)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      // Hardcoded per-call temperature — the pattern that caused the PR
+      // #29560 bug class. Without the guard this would forward to Anthropic
+      // and 400.
+      config: { callSite: "mainAgent", temperature: 0.7 },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "adaptive" });
+    expect(config.temperature).toBeUndefined();
+    expect("temperature" in config).toBe(false);
+  });
+
+  test("drops explicit temperature: 0 when thinking is enabled (Anthropic)", async () => {
+    // Mirrors the recall-agent / retriever shape: `temperature: 0` for
+    // determinism on a thinking-enabled profile. Same 400 risk, same fix.
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { recall: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "recall", temperature: 0 },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "adaptive" });
+    expect(config.temperature).toBeUndefined();
+  });
+
+  test("preserves temperature: 1 when thinking is enabled (Anthropic accepts it)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent", temperature: 1 },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "adaptive" });
+    expect(config.temperature).toBe(1);
+  });
+
+  test("preserves explicit temperature when thinking is disabled (Anthropic)", async () => {
+    // The bug class only exists when thinking resolves enabled. With
+    // thinking disabled, every temperature value is valid — the guard must
+    // not fire.
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: false, streamThinking: false },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent", temperature: 0.7 },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "disabled" });
+    expect(config.temperature).toBe(0.7);
+  });
+
+  test("drops temperature for OpenRouter when fronting an `anthropic/*` model", async () => {
+    setLlmConfig({
+      default: {
+        provider: "openrouter",
+        model: "anthropic/claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("openrouter", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent", temperature: 0.7 },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.model).toBe("anthropic/claude-opus-4-7");
+    expect(config.temperature).toBeUndefined();
+  });
+
+  test("preserves temperature for OpenRouter when fronting a non-Anthropic reasoning model", async () => {
+    // OpenRouter's other reasoning models (xAI Grok, etc.) translate
+    // `thinking` into the `reasoning` parameter via `buildExtraCreateParams`
+    // and don't share Anthropic's temperature-must-be-1 constraint. The
+    // guard must not over-reach.
+    setLlmConfig({
+      default: {
+        provider: "openrouter",
+        model: "x-ai/grok-4",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("openrouter", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent", temperature: 0.7 },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.model).toBe("x-ai/grok-4");
+    expect(config.temperature).toBe(0.7);
+  });
+
+  test("guard does not fire when thinking has already been stripped by forced tool_choice", async () => {
+    // `retry.ts` strips `thinking` when forced `tool_choice: { type: "tool" }`
+    // is set on Anthropic — the guard runs after that step, so by the time
+    // we check, `thinking` is gone and the temperature can stay.
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { trustRuleSuggestion: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: {
+        callSite: "trustRuleSuggestion",
+        temperature: 0.7,
+        tool_choice: { type: "tool", name: "suggest_trust_rule" },
+      },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toBeUndefined();
+    expect(config.temperature).toBe(0.7);
+  });
+});
+
 // ── RetryProvider — pre-resolved model fast-path ────────────────────────────
 
 describe("RetryProvider — no callSite (pre-resolved config passes through)", () => {

package/src/providers/model-intents.ts

@@ -11,31 +11,37 @@ const PROVIDER_DEFAULT_MODELS: Record<string, string> = Object.fromEntries(
 
 const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
+    balanced: "claude-sonnet-4-6",
     "latency-optimized": "claude-haiku-4-5-20251001",
     "quality-optimized": "claude-opus-4-7",
     "vision-optimized": "claude-opus-4-6",
   },
   openai: {
+    balanced: "gpt-5.4-mini",
     "latency-optimized": "gpt-5.4-nano",
     "quality-optimized": "gpt-5.4",
     "vision-optimized": "gpt-5.4",
   },
   gemini: {
+    balanced: "gemini-3-flash-preview",
     "latency-optimized": "gemini-3.1-flash-lite-preview",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",
   },
   ollama: {
+    balanced: "llama3.2",
     "latency-optimized": "llama3.2",
     "quality-optimized": "llama3.2",
     "vision-optimized": "llama3.2",
   },
   fireworks: {
+    balanced: "accounts/fireworks/models/kimi-k2p5",
     "latency-optimized": "accounts/fireworks/models/kimi-k2p5",
     "quality-optimized": "accounts/fireworks/models/kimi-k2p5",
     "vision-optimized": "accounts/fireworks/models/kimi-k2p5",
   },
   openrouter: {
+    balanced: "anthropic/claude-sonnet-4.6",
     "latency-optimized": "anthropic/claude-haiku-4.5",
     "quality-optimized": "anthropic/claude-opus-4.7",
     "vision-optimized": "anthropic/claude-opus-4.6",
@@ -45,6 +51,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
 const FALLBACK_DEFAULT_MODEL = "claude-opus-4-7";
 
 const MODEL_INTENTS = new Set<ModelIntent>([
+  "balanced",
   "latency-optimized",
   "quality-optimized",
   "vision-optimized",

package/src/providers/openrouter/client.ts

@@ -1,3 +1,4 @@
+import { ProviderError } from "../../util/errors.js";
 import { AnthropicProvider } from "../anthropic/client.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
 import { isThinkingConfigEnabled } from "../thinking-config.js";
@@ -139,6 +140,13 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
           cause: error,
         });
       }
+      if (error instanceof ProviderError && error.provider !== this.name) {
+        throw new ProviderError(error.message, this.name, error.statusCode, {
+          cause: error.cause ?? error,
+          retryAfterMs: error.retryAfterMs,
+          abortReason: error.abortReason,
+        });
+      }
       throw error;
     }
   }

package/src/providers/retry.ts

@@ -273,6 +273,56 @@ function normalizeSendMessageOptions(
     delete nextConfig.thinking;
   }
 
+  // Anthropic (and OpenRouter fronting Anthropic) rejects requests that
+  // combine extended thinking with `temperature` ≠ 1. From the API:
+  //   "`temperature` may only be set to 1 when thinking is enabled or in
+  //   adaptive mode."
+  //
+  // Defense-in-depth: callers that hardcode a non-default temperature in
+  // their per-call config are easy to miss when reviewing — we already had
+  // this bug ship in three places (reply suggestions, recall agent
+  // round, recall fallback finalize). Drop the offending temperature with
+  // a warn log so the request goes through with Anthropic's default
+  // (which is 1 in thinking mode anyway). We keep `thinking` rather than
+  // `temperature` because thinking is the more deliberate, profile-level
+  // choice — silently downgrading reasoning capacity for an unrelated
+  // per-call hint would be the worse failure mode.
+  //
+  // Scope:
+  // - Anthropic: always.
+  // - OpenRouter fronting `anthropic/*`: same wire constraint applies.
+  // - Other providers: not our problem here (e.g. OpenAI reasoning models
+  //   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 temp = nextConfig.temperature;
+    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;
+  })();
+  if (isThinkingTemperatureConflict) {
+    log.warn(
+      {
+        providerName,
+        callSite: config.callSite,
+        droppedTemperature: nextConfig.temperature,
+      },
+      "Dropping `temperature` because thinking is enabled — Anthropic only " +
+        "accepts `temperature: 1` (or unset) when thinking/adaptive mode is " +
+        "on. Set `thinking: { type: 'disabled' }` on the call site if you " +
+        "need a specific temperature.",
+    );
+    delete nextConfig.temperature;
+  }
+
   // effort is supported by Anthropic, OpenAI, and OpenAI-compatible providers; strip for others
   if (
     !EFFORT_SUPPORTED_PROVIDERS.has(providerName) &&

package/src/providers/types.ts

@@ -91,6 +91,7 @@ export interface Message {
 }
 
 export type ModelIntent =
+  | "balanced"
   | "latency-optimized"
   | "quality-optimized"
   | "vision-optimized";