fix(provider): compose custom reasoning and sampling settings

Author: TheGreatAxios

src/config.test.ts

@@ -1344,6 +1344,51 @@ describe("buildOpenAISource", () => {
     });
   });
 
+  test("overrides maxTokens and adds temperature to providerOptions", () => {
+    const source = buildOpenAISource({
+      id: "fp",
+      baseURL: "https://fp/v1",
+      apiKey: "k",
+      model: "m",
+      maxTokens: 8192,
+      temperature: 0.7,
+    });
+    expect(source.defaults).toEqual({
+      maxTokens: 8192,
+      providerOptions: { temperature: 0.7 },
+    });
+  });
+
+  test("adds top_p to providerOptions when topP is present", () => {
+    const source = buildOpenAISource({
+      id: "fp",
+      baseURL: "https://fp/v1",
+      apiKey: "k",
+      model: "m",
+      topP: 0.9,
+    });
+    expect(source.defaults).toEqual({
+      maxTokens: SOURCE_MAX_TOKENS,
+      providerOptions: { top_p: 0.9 },
+    });
+  });
+
+  test("coexists temperature with reasoning_effort in one providerOptions", () => {
+    const source = buildOpenAISource({
+      id: "fp",
+      baseURL: "https://fp/v1",
+      apiKey: "k",
+      model: "gpt-5.1",
+      reasoningEffort: "medium",
+      temperature: 1.0,
+      maxTokens: 4096,
+    });
+    expect(source.defaults).toEqual({
+      maxTokens: 4096,
+      providerOptions: { reasoning_effort: "medium", temperature: 1.0 },
+    });
+  });
+
   test("projects an Ollama root URL to the OpenAI-compatible /v1 endpoint", () => {
     const source = buildOpenAISource({
       id: "ollama/default",

src/config/custom-provider-options.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  buildProviderCatalog,
+  refreshProviderContextWindows,
+} from "./index.js";
+import { buildMainSessionSources } from "./inference-sources.js";
+import { loadSettings } from "./settings.js";
+import { clearSourceCredentials } from "./source-credentials.js";
+import {
+  contextWindowFor,
+  setProviderContextWindowOverrides,
+} from "../provider/context-window.js";
+import { createOpenAICompatibleAdapter } from "../provider/openai-compatible-adapter.js";
+import { buildProviderSubmitHandler } from "../tui/provider/submit.js";
+import type { ProviderFormValues } from "../tui/provider/types.js";
+
+afterEach(() => {
+  clearSourceCredentials();
+  setProviderContextWindowOverrides(undefined);
+});
+
+test("edited custom reasoning and sampling options persist and reach the request together", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "custom-provider-options-"));
+  try {
+    const path = join(dir, "settings.json");
+    const values: ProviderFormValues = {
+      name: "combined",
+      baseURL: "https://combined.example/v1",
+      apiKey: "",
+      model: "custom-only",
+      oauthProfile: "",
+      reasoningEfforts: ["medium", "high"],
+      defaultReasoningEffort: "high",
+      contextWindow: "32000",
+      maxTokens: "4096",
+      temperature: "",
+      topP: "0.9",
+    };
+    await buildProviderSubmitHandler(path, null, null)(
+      values,
+      () => undefined,
+      { skipValidation: true },
+    );
+    const original = await loadSettings(path);
+    if (original === null) throw new Error("missing original settings");
+    const catalog = buildProviderCatalog(original, {
+      providerName: values.name,
+      baseURL: values.baseURL,
+      apiKey: "",
+      keyless: true,
+      model: values.model,
+    });
+
+    await buildProviderSubmitHandler(path, original, null)(
+      {
+        ...values,
+        reasoningEfforts: ["low", "max"],
+        defaultReasoningEffort: "max",
+        contextWindow: "64000",
+        maxTokens: "8192",
+        temperature: "0",
+        topP: "",
+      },
+      () => undefined,
+      { skipValidation: true },
+    );
+    const settings = await loadSettings(path);
+    if (settings === null) throw new Error("missing edited settings");
+    expect(Object.keys(settings.providers)).toEqual(["combined"]);
+    expect(settings.providers["combined"]).toMatchObject({
+      models: ["custom-only"],
+      reasoningEfforts: ["low", "max"],
+      defaultReasoningEffort: "max",
+      contextWindow: 64_000,
+      maxTokens: 8192,
+      temperature: 0,
+    });
+    expect(settings.providers["combined"]?.topP).toBeUndefined();
+    refreshProviderContextWindows(settings, catalog, values.name, values.model);
+    expect(contextWindowFor("combined:custom-only")).toBe(64_000);
+
+    // Discovery can still hold the old declaration when an edited row is used.
+    for (const reasoningEffort of [undefined, "medium"] as const) {
+      const source = buildMainSessionSources({
+        settings,
+        catalog,
+        activeProvider: values.name,
+        activeModel: values.model,
+        sessionId: "combined-session",
+        ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+      }).sources[0];
+      if (source === undefined) throw new Error("missing source");
+      const adapter = createOpenAICompatibleAdapter({
+        sourceId: source.id,
+        provider: source.provider,
+        model: source.model,
+      });
+      const body = JSON.parse(
+        adapter.buildRequest([], source.model, source.defaults ?? {}).body,
+      ) as Record<string, unknown>;
+      expect(body.reasoning_effort).toBe("max");
+      expect(body.max_tokens).toBe(8192);
+      expect(body.temperature).toBe(0);
+      expect(body).not.toHaveProperty("top_p");
+    }
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

src/config/index.ts

@@ -273,12 +273,17 @@ export function buildOpenAISource(fields: {
   apiKey?: string;
   model: string;
   reasoningEffort?: ReasoningEffort;
+  maxTokens?: number;
+  temperature?: number;
+  topP?: number;
   quirks?: Record<string, unknown>;
 }): InferenceSource {
-  const overrides =
-    fields.reasoningEffort !== undefined
-      ? { providerOptions: { reasoning_effort: fields.reasoningEffort } }
-      : {};
+  const providerOptions: Record<string, unknown> = {};
+  if (fields.reasoningEffort !== undefined)
+    providerOptions["reasoning_effort"] = fields.reasoningEffort;
+  if (fields.temperature !== undefined)
+    providerOptions["temperature"] = fields.temperature;
+  if (fields.topP !== undefined) providerOptions["top_p"] = fields.topP;
   registerSourceSecret(fields.id, fields.apiKey);
   return {
     id: fields.id,
@@ -288,7 +293,10 @@ export function buildOpenAISource(fields: {
       : normalizeOpenAICompatibleBaseURL(fields.baseURL),
     credentialId: fields.id,
     model: fields.model,
-    defaults: { maxTokens: SOURCE_MAX_TOKENS, ...overrides },
+    defaults: {
+      maxTokens: fields.maxTokens ?? SOURCE_MAX_TOKENS,
+      ...(Object.keys(providerOptions).length > 0 ? { providerOptions } : {}),
+    },
     ...(fields.quirks !== undefined ? { quirks: fields.quirks } : {}),
   };
 }
@@ -1382,12 +1390,55 @@ export function mergeOAuthCatalog(
 export async function refreshLiveProviderCatalog(
   settings: Settings | null,
   resolved: ResolvedProvider,
+  liveSelection?: () => Pick<ResolvedProvider, "providerName" | "model">,
 ): Promise<ProviderCatalogEntry[]> {
   const [codexProfiles, xaiProfiles] = await Promise.all([
     listCodexProfiles(),
     listXaiProfiles(),
   ]);
-  return mergeOAuthCatalog(settings, resolved, codexProfiles, xaiProfiles);
+  const catalog = mergeOAuthCatalog(
+    settings,
+    resolved,
+    codexProfiles,
+    xaiProfiles,
+  );
+  // Discovery can finish after a model switch; never restore its old bare-model slot.
+  const active = liveSelection?.() ?? resolved;
+  refreshProviderContextWindows(
+    settings ?? undefined,
+    catalog,
+    active.providerName,
+    active.model,
+  );
+  return catalog;
+}
+
+export function refreshProviderContextWindows(
+  settings: Settings | undefined,
+  catalog: readonly ProviderCatalogEntry[],
+  activeProvider: string,
+  activeModel: string,
+): void {
+  // Catalog models can expand during discovery. OAuth projections deliberately
+  // omit settings-only window overrides, just as startup resolution does.
+  const providers = Object.fromEntries(
+    catalog.map((entry) => {
+      const window =
+        entry.codexProfile === undefined && entry.xaiProfile === undefined
+          ? settings?.providers[entry.name]?.contextWindow
+          : undefined;
+      return [
+        entry.name,
+        {
+          models: entry.models,
+          ...(window !== undefined ? { contextWindow: window } : {}),
+        },
+      ];
+    }),
+  );
+  setProviderContextWindowOverrides(
+    buildProviderContextWindowOverrides(providers, activeProvider, activeModel),
+  );
 }
 
 export function catalogEntryAsProviderSettings(
@@ -1413,6 +1464,11 @@ export function catalogEntryAsProviderSettings(
       ? { defaultModel: entry.defaultModel }
       : {}),
     ...(entry.free !== undefined ? { free: entry.free } : {}),
+    ...(entry.maxTokens !== undefined ? { maxTokens: entry.maxTokens } : {}),
+    ...(entry.temperature !== undefined
+      ? { temperature: entry.temperature }
+      : {}),
+    ...(entry.topP !== undefined ? { topP: entry.topP } : {}),
     ...(entry.bifrostVirtualKey === true ? { bifrostVirtualKey: true } : {}),
     ...(entry.anthropic === true ? { anthropic: true } : {}),
     ...(go ? { opencodeGo: true } : {}),
@@ -1497,6 +1553,11 @@ export function buildProviderCatalog(
             ? { defaultModel: p.defaultModel }
             : {}),
           ...(p.free !== undefined ? { free: p.free } : {}),
+          ...(p.maxTokens !== undefined ? { maxTokens: p.maxTokens } : {}),
+          ...(p.temperature !== undefined
+            ? { temperature: p.temperature }
+            : {}),
+          ...(p.topP !== undefined ? { topP: p.topP } : {}),
           ...(p.bifrostVirtualKey === true ? { bifrostVirtualKey: true } : {}),
           ...(p.anthropic === true ? { anthropic: true } : {}),
           ...(go ? { opencodeGo: true } : {}),

src/config/inference-sources.test.ts

@@ -205,6 +205,67 @@ describe("contextWindow / maxTokens split (CL-7784)", () => {
   });
 });
 
+describe("custom provider token/sampling knobs flow into the source", () => {
+  test("maxTokens/temperature/topP from provider settings reach defaults", () => {
+    const entryCatalog: ProviderCatalogEntry[] = [
+      {
+        name: "custom",
+        baseURL: "https://api.example.com/v1",
+        apiKey: "sk-key",
+        models: ["m"],
+      },
+    ];
+    const settings: Settings = {
+      providers: {
+        custom: {
+          baseURL: "https://api.example.com/v1",
+          apiKey: "sk-key",
+          models: ["m"],
+          maxTokens: 4096,
+          temperature: 0.7,
+        },
+      },
+    };
+    const source = buildInferenceSourceForRef(
+      { provider: "custom", model: "m" },
+      { sessionId: "sess-1", catalog: entryCatalog },
+      settings,
+    );
+    expect(source).not.toBeNull();
+    expect(source?.defaults?.maxTokens).toBe(4096);
+    expect(source?.defaults?.providerOptions).toEqual({ temperature: 0.7 });
+  });
+
+  test("topP flows as top_p and overrides nothing else", () => {
+    const entryCatalog: ProviderCatalogEntry[] = [
+      {
+        name: "custom",
+        baseURL: "https://api.example.com/v1",
+        apiKey: "sk-key",
+        models: ["m"],
+        topP: 0.9,
+      },
+    ];
+    const source = buildInferenceSourceForRef(
+      { provider: "custom", model: "m" },
+      { sessionId: "sess-1", catalog: entryCatalog },
+      undefined,
+    );
+    expect(source?.defaults?.maxTokens).toBe(SOURCE_MAX_TOKENS);
+    expect(source?.defaults?.providerOptions).toEqual({ top_p: 0.9 });
+  });
+
+  test("unset knobs leave the default maxTokens and no providerOptions", () => {
+    const source = buildInferenceSourceForRef(
+      { provider: "fp", model: "fp-large" },
+      ctx(),
+      undefined,
+    );
+    expect(source?.defaults?.maxTokens).toBe(SOURCE_MAX_TOKENS);
+    expect(source?.defaults?.providerOptions).toBeUndefined();
+  });
+});
+
 describe("OpenAI reasoning max_completion_tokens quirk (CL-7785)", () => {
   const openaiApi = firstClassProviderById("openai")?.paths?.find(
     (p) => p.id === "api",

src/config/inference-sources.ts

@@ -204,6 +204,11 @@ export function buildInferenceSourceForRef(
           reasoning?.defaultReasoningEffort,
         )
       : undefined;
+  // A cleared sampling field must not revive its stale catalog value.
+  const inferenceOptions = providerSettings ?? entry;
+  const maxTokens = inferenceOptions?.maxTokens;
+  const temperature = inferenceOptions?.temperature;
+  const topP = inferenceOptions?.topP;
   return buildOpenAISource({
     id: ref.provider,
     baseURL,
@@ -214,6 +219,9 @@ export function buildInferenceSourceForRef(
         : {}),
     model: ref.model,
     ...(customEffort !== undefined ? { reasoningEffort: customEffort } : {}),
+    ...(maxTokens !== undefined ? { maxTokens } : {}),
+    ...(temperature !== undefined ? { temperature } : {}),
+    ...(topP !== undefined ? { topP } : {}),
     ...(quirks !== undefined ? { quirks } : {}),
   });
 }