feat(config): warn on ignored provider fields

Author: TheGreatAxios

src/config/settings.test.ts

@@ -13,6 +13,7 @@ import { loadConfig } from "./index.js";
 import { resetPricingMetadataRefreshForTests } from "../cost/pricing-metadata.js";
 import { setProviderContextWindowOverrides } from "../provider/context-window.js";
 import { withMockedHomedir } from "../../testkit/mock-module.js";
+import { captureStderr } from "../../testkit/capture-stderr.js";
 import { isSettings, loadSettings, saveGlobalSettings } from "./settings.js";
 
 test.each([
@@ -680,3 +681,107 @@ test("--config composes with OAuth profile auth instead of suppressing it", asyn
     await rm(cwd, { recursive: true, force: true });
   }
 });
+
+// CL-10226 (Part 1): some external tools' provider blocks carry fields Corbits
+// does not honor. They pass ProviderSettingsSchema (which stays fail-open on
+// unknown keys) and are silently dropped. The settings load path must warn on
+// stderr while still loading successfully.
+test("settings load warns and still loads when a provider carries ignored fields", async () => {
+  const cwd = await mkdtemp(join(tmpdir(), "ic-unit-config-ignored-fields-"));
+  const path = join(cwd, "settings.json");
+  const stderr = captureStderr();
+  try {
+    await writeFile(
+      path,
+      JSON.stringify({
+        providers: {
+          external: {
+            baseURL: "https://external.example/v1",
+            keyless: true,
+            models: ["test-model"],
+            supportsThinkingTokenBudget: true,
+            thinkingLevelMap: { low: 1 },
+            samplingParams: { temperature: 0.5 },
+            compat: { supportsReasoningEffort: true },
+          },
+        },
+      }),
+    );
+    const loaded = await loadSettings(path);
+    expect(loaded).not.toBeNull();
+    expect(loaded?.providers.external).toBeDefined();
+    expect(stderr.output()).toContain(
+      '"external" sets fields that are not honored by Corbits and are ignored',
+    );
+    expect(stderr.output()).toContain("supportsThinkingTokenBudget");
+    expect(stderr.output()).toContain("thinkingLevelMap");
+    expect(stderr.output()).toContain("samplingParams");
+    expect(stderr.output()).toContain("compat.supportsReasoningEffort");
+  } finally {
+    stderr.restore();
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("settings load does not warn for a normal provider block", async () => {
+  const cwd = await mkdtemp(join(tmpdir(), "ic-unit-config-no-ignored-"));
+  const path = join(cwd, "settings.json");
+  const stderr = captureStderr();
+  try {
+    await writeFile(
+      path,
+      JSON.stringify({
+        providers: {
+          external: {
+            baseURL: "https://external.example/v1",
+            keyless: true,
+            models: ["test-model"],
+          },
+        },
+      }),
+    );
+    const loaded = await loadSettings(path);
+    expect(loaded).not.toBeNull();
+    expect(stderr.output()).not.toContain("not honored by Corbits");
+    expect(stderr.output()).not.toContain("supportsThinkingTokenBudget");
+  } finally {
+    stderr.restore();
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+// CL-10226 (Part 1): the same warn must surface on the config path (--config /
+// global settings), which routes through loadSettings... → normalizeParsedSettings.
+test("loadConfig warns and still loads when a provider carries ignored fields", async () => {
+  const cwd = await mkdtemp(join(tmpdir(), "ic-unit-config-ignored-config-"));
+  const globalSettingsPath = join(cwd, "global.json");
+  const stderr = captureStderr();
+  try {
+    await writeFile(
+      globalSettingsPath,
+      JSON.stringify({
+        defaultProvider: "external",
+        providers: {
+          external: {
+            baseURL: "https://external.example/v1",
+            apiKey: "test-key",
+            models: ["test-model"],
+            samplingParams: { temperature: 0.5 },
+          },
+        },
+      }),
+    );
+    const { impl } = offlineFetch();
+    const config = await loadConfig(["--cwd", cwd, "do something"], {
+      globalSettingsPath,
+      pricing: { fetchImpl: impl },
+    });
+    expect(config.configured).toBe(true);
+    if (config.configured) expect(config.providerName).toBe("external");
+    expect(stderr.output()).toContain("not honored by Corbits");
+    expect(stderr.output()).toContain("samplingParams");
+  } finally {
+    stderr.restore();
+    await rm(cwd, { recursive: true, force: true });
+  }
+});

src/config/settings.ts

@@ -1036,11 +1036,64 @@ function settingsSchemaError(path: string): Error {
   );
 }
 
+// Provider blocks from some external tools carry fields Corbits does not
+// honor: compat.supportsReasoningEffort, supportsThinkingTokenBudget,
+// thinkingLevelMap, samplingParams. ProviderSettingsSchema does not reject
+// unknown keys, so they pass validation and are silently dropped. Warn when
+// any are present so the ignore is never silent. CL-10226 (Part 1): the field
+// mappings themselves are separate follow-ups — this only surfaces the warn.
+const IGNORED_PROVIDER_FIELDS: {
+  key: string;
+  path: (p: Record<string, unknown>) => unknown;
+}[] = [
+  {
+    key: "supportsThinkingTokenBudget",
+    path: (p) => p.supportsThinkingTokenBudget,
+  },
+  { key: "thinkingLevelMap", path: (p) => p.thinkingLevelMap },
+  { key: "samplingParams", path: (p) => p.samplingParams },
+  {
+    key: "compat.supportsReasoningEffort",
+    path: (p) =>
+      typeof p.compat === "object" &&
+      p.compat !== null &&
+      (p.compat as Record<string, unknown>).supportsReasoningEffort !==
+        undefined
+        ? (p.compat as Record<string, unknown>).supportsReasoningEffort
+        : undefined,
+  },
+];
+
+function warnOnIgnoredProviderFields(providers: unknown): void {
+  if (
+    providers === undefined ||
+    typeof providers !== "object" ||
+    providers === null
+  ) {
+    return;
+  }
+  for (const [name, provider] of Object.entries(
+    providers as Record<string, unknown>,
+  )) {
+    if (typeof provider !== "object" || provider === null) continue;
+    const p = provider as Record<string, unknown>;
+    const present = IGNORED_PROVIDER_FIELDS.filter(
+      (field) => field.path(p) !== undefined,
+    ).map((field) => field.key);
+    if (present.length > 0) {
+      process.stderr.write(
+        `settings: provider "${name}" sets fields that are not honored by Corbits and are ignored: ${present.join(", ")}. These will not be applied.\n`,
+      );
+    }
+  }
+}
+
 function normalizeParsedSettings(path: string, parsed: unknown): Settings {
   if (!isSettings(parsed)) {
     throw settingsSchemaError(path);
   }
   const s = parsed as unknown as Record<string, unknown>;
+  warnOnIgnoredProviderFields(s.providers);
   // These keys were removed when plugins moved to discovery; they are now
   // silently dropped on the next save. Warn so a user who relied on them knows
   // to re-enable the equivalent plugins in /plugins instead of losing the