@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

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

@@ -425,6 +425,62 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.temperature).toBe(0.5);
   });
 
+  test("forwards resolved topP to wire `top_p` (non-thinking provider)", async () => {
+    // `topP` (schema, camelCase) renames to `top_p` on the wire, mirroring
+    // `maxTokens`→`max_tokens`. Fireworks has no thinking constraint, so the
+    // value passes straight through.
+    setLlmConfig({
+      default: {
+        provider: "fireworks",
+        model: "fireworks-model",
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("fireworks", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.top_p).toBe(0.95);
+  });
+
+  test("does NOT forward top_p when resolved topP is null (schema default)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "fireworks",
+        model: "fireworks-model",
+        // `topP` defaults to null — "let provider pick".
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("fireworks", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    // Must NOT be set — `top_p: null` would either be a wire error or override
+    // sensible provider defaults, mirroring the `temperature` handling.
+    expect(config.top_p).toBeUndefined();
+    expect("top_p" in config).toBe(false);
+  });
+
   test("strips effort/speed for providers that don't support them (e.g. fireworks)", async () => {
     setLlmConfig({
       default: {
@@ -773,6 +829,126 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
   });
 });
 
+// ── RetryProvider — Anthropic thinking + top_p conflict guard ───────────────
+//
+// Anthropic rejects *any* `top_p` modification when extended thinking is
+// enabled (same constraint family as `temperature` ≠ 1, but with no
+// "=== 1 is fine" exception). This guard drops the offending `top_p` so the
+// request goes through with Anthropic's default instead of 400ing at the wire.
+
+describe("RetryProvider — thinking/top_p conflict guard", () => {
+  test("drops top_p when thinking is enabled (Anthropic)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "adaptive" });
+    expect(config.top_p).toBeUndefined();
+    expect("top_p" in config).toBe(false);
+  });
+
+  test("drops top_p for OpenRouter when fronting an `anthropic/*` model", async () => {
+    setLlmConfig({
+      default: {
+        provider: "openrouter",
+        model: "anthropic/claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+        topP: 0.9,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("openrouter", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.model).toBe("anthropic/claude-opus-4-7");
+    expect(config.top_p).toBeUndefined();
+  });
+
+  test("preserves top_p when thinking is enabled on a non-Anthropic provider (fireworks)", async () => {
+    // Fireworks (and other non-Anthropic providers) don't share Anthropic's
+    // top_p-with-thinking constraint — the guard must not over-reach. Note
+    // that fireworks strips `thinking` itself, but `top_p` stays.
+    setLlmConfig({
+      default: {
+        provider: "fireworks",
+        model: "fireworks-model",
+        thinking: { enabled: true, streamThinking: true },
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("fireworks", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.top_p).toBe(0.95);
+  });
+
+  test("preserves top_p when thinking is disabled (Anthropic)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: false, streamThinking: false },
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "disabled" });
+    expect(config.top_p).toBe(0.95);
+  });
+});
+
 // ── RetryProvider — pre-resolved model fast-path ────────────────────────────
 
 describe("RetryProvider — no callSite (pre-resolved config passes through)", () => {

package/src/providers/atlascloud/client.ts

@@ -0,0 +1,85 @@
+import OpenAI from "openai";
+
+import { getLogger } from "../../util/logger.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+const log = getLogger("atlascloud-client");
+
+/** Validation-specific timeout (10s) so a stalled network doesn't block key submission. */
+const VALIDATION_TIMEOUT_MS = 10_000;
+
+export interface AtlasCloudProviderOptions {
+  apiKey?: string;
+  streamTimeoutMs?: number;
+}
+
+/**
+ * Atlas Cloud exposes a single OpenAI-compatible endpoint. Unlike MiniMax it
+ * has no regional fallback host, so validation targets this URL only.
+ */
+const DEFAULT_ATLASCLOUD_BASE_URL = "https://api.atlascloud.ai/v1";
+
+/**
+ * Validate an Atlas Cloud API key by listing models against the OpenAI-compatible
+ * endpoint. Definitive auth failures (401/403) reject the key; transient errors
+ * (429, 5xx, network) allow the key to be stored so a flaky network doesn't
+ * block setup.
+ */
+export async function validateAtlasCloudApiKey(
+  apiKey: string,
+): Promise<{ valid: true } | { valid: false; reason: string }> {
+  try {
+    const client = new OpenAI({
+      apiKey,
+      baseURL: DEFAULT_ATLASCLOUD_BASE_URL,
+      timeout: VALIDATION_TIMEOUT_MS,
+      maxRetries: 0,
+    });
+    await client.models.list();
+    return { valid: true };
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      if (error.status === 401) {
+        return { valid: false, reason: "API key is invalid or expired." };
+      }
+      if (error.status === 403) {
+        return {
+          valid: false,
+          reason: `Atlas Cloud API error (${error.status}): ${error.message}`,
+        };
+      }
+      // Transient errors (429, 5xx, etc.) — allow the key to be stored.
+      log.warn(
+        { status: error.status },
+        "Atlas Cloud API returned a transient error during key validation — allowing key",
+      );
+      return { valid: true };
+    }
+    // Network errors — allow the key to be stored.
+    log.warn(
+      { error: error instanceof Error ? error.message : String(error) },
+      "Network error during Atlas Cloud key validation — allowing key",
+    );
+    return { valid: true };
+  }
+}
+
+export class AtlasCloudProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: AtlasCloudProviderOptions = {},
+  ) {
+    super(apiKey, model, {
+      baseURL: DEFAULT_ATLASCLOUD_BASE_URL,
+      providerName: "atlascloud",
+      providerLabel: "Atlas Cloud",
+      streamTimeoutMs: options.streamTimeoutMs,
+      // Atlas Cloud hosts reasoning models (e.g. DeepSeek) that emit chain of
+      // thought via `reasoning_content` rather than inline `<think>` tags. The
+      // base provider parses this field into thinking blocks and replays it on
+      // multi-turn requests.
+      assistantReasoningField: "reasoning_content",
+    });
+  }
+}

package/src/providers/fetch-provider-catalog.ts

@@ -0,0 +1,85 @@
+/**
+ * Canonical catalog of built-in web-fetch providers.
+ *
+ * This is the single source of truth that drives the config-schema enum
+ * (`VALID_WEB_FETCH_PROVIDERS` in `assistant/src/config/schemas/services.ts`)
+ * and the client picker mirror in
+ * `clients/web/src/assistant/generated/web-fetch-provider-catalog.gen.ts`.
+ *
+ * Mirrors `search-provider-catalog.ts`. Where web-search distinguishes
+ * `managed` (platform proxy) from `byok` (user key), web-fetch has no managed
+ * proxy yet, so the two kinds are:
+ *
+ *   - `builtin` — the daemon's own HTTP fetch + extract path (`default`). No
+ *     key, always available, the default.
+ *   - `byok`    — an external provider that needs a user-supplied key (e.g.
+ *     `firecrawl`, which scrapes via its hosted API and returns clean
+ *     markdown, including for JavaScript-rendered pages the builtin fetcher
+ *     can't see).
+ *
+ * BYOK fetch providers intentionally reuse the SAME bare-name credential as
+ * their search counterpart (e.g. `firecrawl` → `FIRECRAWL_API_KEY`), so a
+ * single stored key powers both `web_search` and `web_fetch`. The key is
+ * already registered in `API_KEY_PROVIDERS` via `SEARCH_PROVIDER_CATALOG`;
+ * this catalog deliberately does NOT re-register it.
+ */
+
+export type FetchProviderKind = "builtin" | "byok";
+
+export interface FetchProviderCatalogEntry {
+  /** Stable provider identifier. Matches config values. */
+  readonly id: string;
+  /** Short display name used by picker UIs. */
+  readonly displayName: string;
+  /** Optional long display name for prose contexts. */
+  readonly displayNameLong?: string;
+  /** `builtin` (no key) or `byok` (user-supplied key). */
+  readonly kind: FetchProviderKind;
+  /** Placeholder shown in the API-key input. BYOK providers only. */
+  readonly apiKeyPrefix?: string;
+  /** Environment variable name carrying the API key. BYOK providers only. */
+  readonly envVar?: string;
+  /** Secret-catalog key (the bare provider name accepted by
+   *  `getProviderKeyAsync`). BYOK providers only. */
+  readonly secretKey?: string;
+  /** Privacy-policy URL surfaced in marketing data-sharing docs.
+   *  BYOK providers only. */
+  readonly privacyPolicyUrl?: string;
+}
+
+export const FETCH_PROVIDER_CATALOG: readonly FetchProviderCatalogEntry[] = [
+  {
+    id: "default",
+    displayName: "Built-in",
+    displayNameLong: "Built-in fetcher",
+    kind: "builtin",
+  },
+  {
+    id: "firecrawl",
+    displayName: "Firecrawl",
+    kind: "byok",
+    apiKeyPrefix: "fc-...",
+    envVar: "FIRECRAWL_API_KEY",
+    secretKey: "firecrawl",
+    privacyPolicyUrl: "https://www.firecrawl.dev/privacy-policy",
+  },
+];
+
+/** Provider ids accepted by the web-fetch config schema. */
+export const FETCH_PROVIDER_IDS: readonly string[] =
+  FETCH_PROVIDER_CATALOG.map((p) => p.id);
+
+/** Catalog entries that require a user-supplied API key. */
+export const BYOK_FETCH_PROVIDERS: readonly FetchProviderCatalogEntry[] =
+  FETCH_PROVIDER_CATALOG.filter((p) => p.kind === "byok");
+
+/** BYOK fetch-provider ids. */
+export const BYOK_FETCH_PROVIDER_IDS: readonly string[] =
+  BYOK_FETCH_PROVIDERS.map((p) => p.id);
+
+/** Look up a single catalog entry by id. Returns `undefined` if unknown. */
+export function getFetchProvider(
+  id: string,
+): FetchProviderCatalogEntry | undefined {
+  return FETCH_PROVIDER_CATALOG.find((p) => p.id === id);
+}

package/src/providers/inference/adapter-factory.ts

@@ -19,6 +19,7 @@
  */
 
 import { AnthropicProvider } from "../anthropic/client.js";
+import { AtlasCloudProvider } from "../atlascloud/client.js";
 import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
 import { MinimaxProvider } from "../minimax/client.js";
@@ -114,6 +115,8 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
     }),
   minimax: ({ apiKey, model, streamTimeoutMs }) =>
     new MinimaxProvider(apiKey, model, { streamTimeoutMs }),
+  atlascloud: ({ apiKey, model, streamTimeoutMs }) =>
+    new AtlasCloudProvider(apiKey, model, { streamTimeoutMs }),
 };
 
 /**

package/src/providers/model-catalog.ts

@@ -677,6 +677,23 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.16,
         },
       },
+      {
+        id: "accounts/fireworks/models/glm-5p2",
+        displayName: "GLM 5.2",
+        // Fireworks serves GLM 5.2 with a 1,040K input window.
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        pricing: {
+          inputPer1mTokens: 1.4,
+          outputPer1mTokens: 4.4,
+          cacheReadPer1mTokens: 0.26,
+        },
+      },
       {
         id: "accounts/fireworks/models/kimi-k2p5",
         displayName: "Kimi K2.5",
@@ -1148,6 +1165,18 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: false,
         pricing: { inputPer1mTokens: 0.2, outputPer1mTokens: 1.1 },
       },
+      // Z.ai
+      {
+        id: "z-ai/glm-5.2",
+        displayName: "GLM-5.2",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 1.4, outputPer1mTokens: 4.4 },
+      },
       // Mistral
       {
         id: "mistralai/mistral-medium-3",
@@ -1284,6 +1313,35 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://platform.minimax.io/",
     apiKeyPlaceholder: "sk-cp-...",
   },
+  {
+    id: "atlascloud",
+    displayName: "Atlas Cloud",
+    subtitle:
+      "Atlas Cloud AI models (OpenAI-compatible). Requires an Atlas Cloud API key.",
+    setupMode: "api-key",
+    setupHint: "Enter your Atlas Cloud API key to enable Atlas Cloud models.",
+    envVar: "ATLASCLOUD_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to the Atlas Cloud console and create an API key.",
+      url: "https://www.atlascloud.ai/console",
+      linkLabel: "Open Atlas Cloud Console",
+    },
+    models: [
+      {
+        id: "deepseek-ai/deepseek-v4-pro",
+        displayName: "DeepSeek V4 Pro",
+        contextWindowTokens: 128000,
+        maxOutputTokens: 8192,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "deepseek-ai/deepseek-v4-pro",
+    apiKeyUrl: "https://www.atlascloud.ai/console",
+    apiKeyPlaceholder: "apikey-...",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/openai/__tests__/chat-completions-provider-reasoning.test.ts

@@ -460,6 +460,39 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     expect(params.messages[0].content).toBeNull();
   });
 
+  test("forwards config.top_p onto the request body", async () => {
+    const { provider, requests } = stubProvider([
+      {
+        choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 2, completion_tokens: 1 },
+      },
+    ]);
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      { config: { top_p: 0.95 } },
+    );
+
+    const params = requests[0] as { top_p?: number };
+    expect(params.top_p).toBe(0.95);
+  });
+
+  test("omits top_p from the request body when not configured", async () => {
+    const { provider, requests } = stubProvider([
+      {
+        choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 2, completion_tokens: 1 },
+      },
+    ]);
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+
+    const params = requests[0] as { top_p?: number };
+    expect(params.top_p).toBeUndefined();
+  });
+
   test("skips Anthropic-originated thinking blocks (with signatures)", async () => {
     const { provider, requests } = stubProvider(
       [

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

@@ -367,6 +367,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const logitBias = configObj?.logit_bias as
       | Record<string, number>
       | undefined;
+    const topP = configObj?.top_p as number | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
@@ -398,6 +399,12 @@ export class OpenAIChatCompletionsProvider implements Provider {
         params.logit_bias = logitBias;
       }
 
+      // `top_p` (nucleus sampling). Forwarded explicitly because this client
+      // builds `params` field-by-field rather than spreading the config object.
+      if (typeof topP === "number") {
+        params.top_p = topP;
+      }
+
       // 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,

package/src/providers/openai/responses-provider.ts

@@ -243,6 +243,16 @@ export class OpenAIResponsesProvider implements Provider {
         params.text = { verbosity };
       }
 
+      // Sampling params (`top_p`/`temperature`) are intentionally NOT forwarded
+      // on the Responses path. OpenAI reasoning models (o-series, GPT-5
+      // reasoning) reject them with HTTP 400 when reasoning is active, and the
+      // resolved `effort` defaults to a reasoning effort, so `reasoning` is set
+      // on essentially every Responses request. The profile editor therefore
+      // doesn't surface `topP` for the native `openai` provider (mirroring
+      // `temperature`, which is also never offered/forwarded here); OpenAI-
+      // compatible connections, which use the chat-completions client, honor
+      // `top_p` normally.
+
       if (tools && tools.length > 0) {
         if (
           this.useNativeWebSearch &&

package/src/providers/provider-send-message.ts

@@ -48,6 +48,7 @@ export class CallSiteConfiguredProvider implements Provider {
     private readonly inner: Provider,
     private readonly callSite: LLMCallSite,
     private readonly overrideProfile?: string,
+    private readonly forceOverrideProfile?: boolean,
   ) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
@@ -71,6 +72,10 @@ export class CallSiteConfiguredProvider implements Provider {
         this.overrideProfile !== undefined
           ? { overrideProfile: this.overrideProfile }
           : {}),
+        ...(config?.forceOverrideProfile === undefined &&
+        this.forceOverrideProfile !== undefined
+          ? { forceOverrideProfile: this.forceOverrideProfile }
+          : {}),
       },
     });
   }
@@ -88,13 +93,15 @@ export class CallSiteConfiguredProvider implements Provider {
  * matching call-site identifier from `LLMCallSiteEnum` when adding a new
  * caller. Pass `opts.overrideProfile` to apply a per-call ad-hoc profile
  * override (e.g. a per-conversation pinned profile) on top of any workspace
- * `activeProfile`.
+ * `activeProfile`. Pass `opts.forceOverrideProfile` to float that override
+ * above the call-site layers (named site profile + call-site override) for
+ * non-main-agent call sites — see `ResolveCallSiteOpts.forceOverrideProfile`.
  *
  * Returns `null` when no providers are available at all.
  */
 export async function resolveConfiguredProvider(
   callSite: LLMCallSite,
-  opts: { overrideProfile?: string } = {},
+  opts: { overrideProfile?: string; forceOverrideProfile?: boolean } = {},
 ): Promise<ConfiguredProviderResult | null> {
   const config = getConfig();
 
@@ -174,6 +181,7 @@ export async function resolveConfiguredProvider(
       connectionProvider,
       callSite,
       opts.overrideProfile,
+      opts.forceOverrideProfile,
     ),
     configuredProviderName: inferenceProvider,
   };
@@ -189,7 +197,7 @@ export async function resolveConfiguredProvider(
  */
 export async function getConfiguredProvider(
   callSite: LLMCallSite,
-  opts: { overrideProfile?: string } = {},
+  opts: { overrideProfile?: string; forceOverrideProfile?: boolean } = {},
 ): Promise<Provider | null> {
   const result = await resolveConfiguredProvider(callSite, opts);
   return result?.provider ?? null;

package/src/providers/retry.ts

@@ -268,6 +268,16 @@ function normalizeSendMessageOptions(
     ) {
       nextConfig.temperature = resolved.temperature;
     }
+    // `topP` (schema, camelCase) maps to the provider wire field `top_p`.
+    // Defaults to `null` ("no opinion"); only forward an actual number so we
+    // never send `top_p: null`, mirroring the `temperature` handling above.
+    if (
+      nextConfig.top_p === undefined &&
+      resolved.topP !== null &&
+      resolved.topP !== undefined
+    ) {
+      nextConfig.top_p = resolved.topP;
+    }
     if (nextConfig.thinking === undefined && resolved.thinking !== undefined) {
       nextConfig.thinking = resolved.thinking;
     }
@@ -428,12 +438,16 @@ function normalizeSendMessageOptions(
   // - 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 = (() => {
+  //
+  // Anthropic applies the same constraint family to `top_p` (see the `top_p`
+  // guard below), so the "thinking is enabled on the Anthropic wire" predicate
+  // is shared between the two guards.
+  const isThinkingEnabledOnAnthropicWire = (() => {
     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.
+    // Claude Fable always reasons in adaptive mode, so the 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;
@@ -442,13 +456,6 @@ function normalizeSendMessageOptions(
         return false;
       }
     }
-    const temp = nextConfig.temperature;
-    if (typeof temp !== "number") {
-      return false;
-    }
-    if (temp === 1) {
-      return false;
-    }
     if (providerName === "anthropic") {
       return true;
     }
@@ -457,6 +464,18 @@ function normalizeSendMessageOptions(
     }
     return false;
   })();
+  const isThinkingTemperatureConflict = (() => {
+    if (!isThinkingEnabledOnAnthropicWire) {
+      return false;
+    }
+    const temp = nextConfig.temperature;
+    if (typeof temp !== "number") {
+      return false;
+    }
+    // Unlike `top_p`, `temperature: 1` is explicitly accepted alongside
+    // thinking, so it's the one value that doesn't conflict.
+    return temp !== 1;
+  })();
   if (isThinkingTemperatureConflict) {
     log.warn(
       {
@@ -472,6 +491,28 @@ function normalizeSendMessageOptions(
     delete nextConfig.temperature;
   }
 
+  // Anthropic (and OpenRouter fronting Anthropic) also rejects requests that
+  // combine extended thinking with *any* `top_p` modification. Unlike
+  // `temperature` there is no "=== 1 is fine" exception — when thinking is
+  // enabled the request must not set `top_p` at all. Drop it with a warn log
+  // so the request goes through with Anthropic's default, keeping `thinking`
+  // (the more deliberate, profile-level choice) for the same reasons as the
+  // temperature guard above.
+  if (isThinkingEnabledOnAnthropicWire && nextConfig.top_p !== undefined) {
+    log.warn(
+      {
+        providerName,
+        callSite: config.callSite,
+        droppedTopP: nextConfig.top_p,
+      },
+      "Dropping `top_p` because thinking is enabled — Anthropic does not " +
+        "accept `top_p` modifications when thinking/adaptive mode is on. Set " +
+        "`thinking: { type: 'disabled' }` on the call site if you need a " +
+        "specific top_p.",
+    );
+    delete nextConfig.top_p;
+  }
+
   // effort is supported by Anthropic, OpenAI, and OpenAI-compatible providers; strip for others
   if (
     !EFFORT_SUPPORTED_PROVIDERS.has(providerName) &&