@full-self-developing/fsd 1.0.0

package/extensions/moonshot/src/kimi-web-search-provider.test.ts

@@ -0,0 +1,297 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/provider-onboard";
+import { withEnvAsync } from "openclaw/plugin-sdk/test-env";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { testing } from "../test-api.js";
+import { createKimiWebSearchProvider } from "./kimi-web-search-provider.js";
+
+const kimiApiKeyEnv = ["KIMI_API", "KEY"].join("_");
+
+function withEnv(overrides: Record<string, string>, run: () => void): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(overrides)) {
+    previous.set(key, process.env[key]);
+    process.env[key] = value;
+  }
+  try {
+    run();
+  } finally {
+    for (const [key, value] of previous) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+async function executeKimiSearch(query: string): Promise<Record<string, unknown>> {
+  const provider = createKimiWebSearchProvider();
+  const tool = provider.createTool({ config: {}, searchConfig: {} });
+  if (!tool) {
+    throw new Error("Expected tool definition");
+  }
+  return await tool.execute({ query });
+}
+
+function expectStringFieldContains(result: Record<string, unknown>, field: string, text: string) {
+  const value = result[field];
+  expect(typeof value).toBe("string");
+  expect(value).toContain(text);
+}
+
+describe("kimi web search provider", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("points missing-key users to fetch/browser alternatives", async () => {
+    await withEnvAsync({ KIMI_API_KEY: undefined, MOONSHOT_API_KEY: undefined }, async () => {
+      const provider = createKimiWebSearchProvider();
+      const tool = provider.createTool({ config: {}, searchConfig: {} });
+      if (!tool) {
+        throw new Error("Expected tool definition");
+      }
+
+      const result = await tool.execute({ query: "OpenClaw docs" });
+
+      expect(result.error).toBe("missing_kimi_api_key");
+      expectStringFieldContains(
+        result,
+        "message",
+        "use web_fetch for a specific URL or the browser tool",
+      );
+    });
+  });
+
+  it("uses configured model and base url overrides with sane defaults", () => {
+    expect(testing.resolveKimiModel()).toBe("kimi-k2.6");
+    expect(testing.resolveKimiModel({ model: "kimi-k2" })).toBe("kimi-k2");
+    expect(testing.resolveKimiBaseUrl()).toBe("https://api.moonshot.ai/v1");
+    expect(testing.resolveKimiBaseUrl({ baseUrl: "https://kimi.example/v1" })).toBe(
+      "https://kimi.example/v1",
+    );
+  });
+
+  it("inherits native Moonshot chat baseUrl when kimi baseUrl is unset", () => {
+    const cnConfig = {
+      models: { providers: { moonshot: { baseUrl: "https://api.moonshot.cn/v1" } } },
+    } as unknown as OpenClawConfig;
+    const cnConfigWithTrailingSlash = {
+      models: { providers: { moonshot: { baseUrl: "https://api.moonshot.cn/v1/" } } },
+    } as unknown as OpenClawConfig;
+
+    expect(testing.resolveKimiBaseUrl(undefined, cnConfig)).toBe("https://api.moonshot.cn/v1");
+    expect(testing.resolveKimiBaseUrl(undefined, cnConfigWithTrailingSlash)).toBe(
+      "https://api.moonshot.cn/v1",
+    );
+  });
+
+  it("does not inherit non-native Moonshot baseUrl for web search", () => {
+    const proxyConfig = {
+      models: { providers: { moonshot: { baseUrl: "https://proxy.example/v1" } } },
+    } as unknown as OpenClawConfig;
+
+    expect(testing.resolveKimiBaseUrl(undefined, proxyConfig)).toBe("https://api.moonshot.ai/v1");
+  });
+
+  it("keeps explicit kimi baseUrl over models.providers.moonshot.baseUrl", () => {
+    const moonshotConfig = {
+      models: { providers: { moonshot: { baseUrl: "https://api.moonshot.cn/v1" } } },
+    } as unknown as OpenClawConfig;
+
+    expect(
+      testing.resolveKimiBaseUrl({ baseUrl: "https://api.moonshot.ai/v1" }, moonshotConfig),
+    ).toBe("https://api.moonshot.ai/v1");
+  });
+
+  it("extracts unique citations from search results and tool call arguments", () => {
+    expect(
+      testing.extractKimiCitations({
+        search_results: [{ url: "https://a.test" }, { url: "https://b.test" }],
+        choices: [
+          {
+            message: {
+              tool_calls: [
+                {
+                  function: {
+                    arguments: JSON.stringify({
+                      url: "https://a.test",
+                      search_results: [{ url: "https://c.test" }],
+                    }),
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      }),
+    ).toEqual(["https://a.test", "https://b.test", "https://c.test"]);
+  });
+
+  it("returns a structured failure for ungrounded chat-only responses", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      jsonResponse({
+        choices: [
+          {
+            finish_reason: "stop",
+            message: { content: "I cannot browse the internet." },
+          },
+        ],
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {
+      const result = await executeKimiSearch("kimi ungrounded chat fallback");
+
+      expect(result.error).toBe("kimi_web_search_ungrounded");
+      expect(result.provider).toBe("kimi");
+      expectStringFieldContains(result, "message", "without native web-search grounding");
+    });
+  });
+
+  it("reports malformed Kimi API JSON with a stable provider error", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response("{ nope"));
+    vi.stubGlobal("fetch", fetchMock);
+
+    await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {
+      await expect(executeKimiSearch("kimi malformed response")).rejects.toThrow(
+        "Kimi API error: malformed JSON response",
+      );
+    });
+  });
+
+  it("rejects wrong-root Kimi success JSON with a stable provider error", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse([]));
+    vi.stubGlobal("fetch", fetchMock);
+
+    await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {
+      await expect(executeKimiSearch("kimi wrong root response")).rejects.toThrow(
+        "Kimi API error: malformed JSON response",
+      );
+    });
+  });
+
+  it("rejects Kimi success JSON without a final message", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ choices: [] }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {
+      await expect(executeKimiSearch("kimi missing final message")).rejects.toThrow(
+        "Kimi API error: malformed JSON response",
+      );
+    });
+  });
+
+  it("accepts final responses backed by Kimi web search tool replay", async () => {
+    const toolArguments = JSON.stringify({
+      query: "OpenClaw GitHub repository",
+      usage: { total_tokens: 1200 },
+    });
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        jsonResponse({
+          choices: [
+            {
+              finish_reason: "tool_calls",
+              message: {
+                content: "",
+                tool_calls: [
+                  {
+                    id: "call-1",
+                    function: {
+                      name: "$web_search",
+                      arguments: toolArguments,
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          choices: [
+            {
+              finish_reason: "stop",
+              message: { content: "OpenClaw is available on GitHub." },
+            },
+          ],
+        }),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {
+      const result = await executeKimiSearch("kimi grounded tool replay");
+
+      expect(result.provider).toBe("kimi");
+      expectStringFieldContains(result, "content", "OpenClaw is available on GitHub.");
+      expect(result.citations).toEqual([]);
+      expect(result).not.toHaveProperty("error");
+    });
+  });
+
+  it("accepts final responses with search result citations", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      jsonResponse({
+        search_results: [{ title: "OpenClaw", url: "https://github.com/openclaw/openclaw" }],
+        choices: [
+          {
+            finish_reason: "stop",
+            message: { content: "OpenClaw is on GitHub." },
+          },
+        ],
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {
+      const result = await executeKimiSearch("kimi grounded citation");
+
+      expect(result.provider).toBe("kimi");
+      expectStringFieldContains(result, "content", "OpenClaw is on GitHub.");
+      expect(result.citations).toEqual(["https://github.com/openclaw/openclaw"]);
+      expect(result).not.toHaveProperty("error");
+    });
+  });
+
+  it("returns original tool arguments as tool content", () => {
+    const rawArguments = '  {"query":"MacBook Neo","usage":{"total_tokens":123}}  ';
+
+    expect(
+      testing.extractKimiToolResultContent({
+        function: {
+          arguments: rawArguments,
+        },
+      }),
+    ).toBe(rawArguments);
+
+    expect(
+      testing.extractKimiToolResultContent({
+        function: {
+          arguments: "   ",
+        },
+      }),
+    ).toBeUndefined();
+  });
+
+  it("uses config apiKey when provided", () => {
+    expect(testing.resolveKimiApiKey({ apiKey: "kimi-test-key" })).toBe("kimi-test-key");
+  });
+
+  it("falls back to env apiKey", () => {
+    withEnv({ [kimiApiKeyEnv]: "kimi-env-key" }, () => {
+      expect(testing.resolveKimiApiKey({})).toBe("kimi-env-key");
+    });
+  });
+});

package/extensions/moonshot/src/kimi-web-search-provider.ts

@@ -0,0 +1,71 @@
+import {
+  createWebSearchProviderContractFields,
+  type WebSearchProviderPlugin,
+  type WebSearchProviderSetupContext,
+} from "openclaw/plugin-sdk/provider-web-search-config-contract";
+
+const KIMI_CREDENTIAL_PATH = "plugins.entries.moonshot.config.webSearch.apiKey";
+type KimiWebSearchProviderRuntime = typeof import("./kimi-web-search-provider.runtime.js");
+
+let kimiWebSearchProviderRuntimePromise: Promise<KimiWebSearchProviderRuntime> | undefined;
+
+function loadKimiWebSearchProviderRuntime(): Promise<KimiWebSearchProviderRuntime> {
+  kimiWebSearchProviderRuntimePromise ??= import("./kimi-web-search-provider.runtime.js");
+  return kimiWebSearchProviderRuntimePromise;
+}
+
+const KimiSearchSchema = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Search query string." },
+    count: {
+      type: "number",
+      description: "Number of results to return (1-10).",
+      minimum: 1,
+      maximum: 10,
+    },
+    country: { type: "string", description: "Not supported by Kimi." },
+    language: { type: "string", description: "Not supported by Kimi." },
+    freshness: { type: "string", description: "Not supported by Kimi." },
+    date_after: { type: "string", description: "Not supported by Kimi." },
+    date_before: { type: "string", description: "Not supported by Kimi." },
+  },
+} satisfies Record<string, unknown>;
+
+async function runKimiSearchProviderSetup(
+  ctx: WebSearchProviderSetupContext,
+): Promise<WebSearchProviderSetupContext["config"]> {
+  const runtime = await loadKimiWebSearchProviderRuntime();
+  return await runtime.runKimiSearchProviderSetup(ctx);
+}
+
+export function createKimiWebSearchProvider(): WebSearchProviderPlugin {
+  return {
+    id: "kimi",
+    label: "Kimi (Moonshot)",
+    hint: "Requires Moonshot / Kimi API key · Moonshot web search",
+    onboardingScopes: ["text-inference"],
+    credentialLabel: "Moonshot / Kimi API key",
+    envVars: ["KIMI_API_KEY", "MOONSHOT_API_KEY"],
+    placeholder: "sk-...",
+    signupUrl: "https://platform.moonshot.cn/",
+    docsUrl: "https://docs.openclaw.ai/tools/web",
+    autoDetectOrder: 40,
+    credentialPath: KIMI_CREDENTIAL_PATH,
+    ...createWebSearchProviderContractFields({
+      credentialPath: KIMI_CREDENTIAL_PATH,
+      searchCredential: { type: "scoped", scopeId: "kimi" },
+      configuredCredential: { pluginId: "moonshot" },
+    }),
+    runSetup: runKimiSearchProviderSetup,
+    createTool: (ctx) => ({
+      description:
+        "Search the web using Kimi by Moonshot. Returns AI-synthesized answers with citations from native $web_search.",
+      parameters: KimiSearchSchema,
+      execute: async (args) => {
+        const { executeKimiWebSearchProviderTool } = await loadKimiWebSearchProviderRuntime();
+        return await executeKimiWebSearchProviderTool(ctx, args);
+      },
+    }),
+  };
+}

package/extensions/moonshot/test-api.ts

@@ -0,0 +1,2 @@
+export { testing, testing as __testing } from "./src/kimi-web-search-provider.runtime.js";
+export { moonshotMediaUnderstandingProvider } from "./media-understanding-provider.js";

package/extensions/moonshot/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}

package/extensions/moonshot/web-search-contract-api.ts

@@ -0,0 +1,28 @@
+import {
+  createWebSearchProviderContractFields,
+  type WebSearchProviderPlugin,
+} from "openclaw/plugin-sdk/provider-web-search-config-contract";
+
+export function createKimiWebSearchProvider(): WebSearchProviderPlugin {
+  const credentialPath = "plugins.entries.moonshot.config.webSearch.apiKey";
+
+  return {
+    id: "kimi",
+    label: "Kimi (Moonshot)",
+    hint: "Requires Moonshot / Kimi API key · Moonshot web search",
+    onboardingScopes: ["text-inference"],
+    credentialLabel: "Moonshot / Kimi API key",
+    envVars: ["KIMI_API_KEY", "MOONSHOT_API_KEY"],
+    placeholder: "sk-...",
+    signupUrl: "https://platform.moonshot.cn/",
+    docsUrl: "https://docs.openclaw.ai/tools/web",
+    autoDetectOrder: 40,
+    credentialPath,
+    ...createWebSearchProviderContractFields({
+      credentialPath,
+      searchCredential: { type: "scoped", scopeId: "kimi" },
+      configuredCredential: { pluginId: "moonshot" },
+    }),
+    createTool: () => null,
+  };
+}

package/extensions/moonshot/web-search-provider.ts

@@ -0,0 +1 @@
+export { createKimiWebSearchProvider } from "./src/kimi-web-search-provider.js";

package/extensions/nvidia/api.ts

@@ -0,0 +1,6 @@
+export { buildNvidiaProvider, NVIDIA_DEFAULT_MODEL_ID } from "./provider-catalog.js";
+export {
+  applyNvidiaConfig,
+  applyNvidiaProviderConfig,
+  NVIDIA_DEFAULT_MODEL_REF,
+} from "./onboard.js";

package/extensions/nvidia/index.test.ts

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import { createTestPluginApi } from "openclaw/plugin-sdk/plugin-test-api";
+import {
+  registerSingleProviderPlugin,
+  resolveProviderPluginChoice,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+
+type NvidiaManifest = {
+  providerAuthChoices?: Array<Record<string, unknown>>;
+};
+type RegisteredModelCatalogProvider = Parameters<
+  ReturnType<typeof createTestPluginApi>["registerModelCatalogProvider"]
+>[0];
+
+function readManifest(): NvidiaManifest {
+  return JSON.parse(
+    fs.readFileSync(new URL("./openclaw.plugin.json", import.meta.url), "utf8"),
+  ) as NvidiaManifest;
+}
+
+async function registerNvidiaProvider() {
+  return registerSingleProviderPlugin(plugin);
+}
+
+describe("nvidia provider hooks", () => {
+  it("registers the nvidia provider with correct metadata", async () => {
+    const provider = await registerNvidiaProvider();
+
+    expect(provider.id).toBe("nvidia");
+    expect(provider.label).toBe("NVIDIA");
+    expect(provider.docsPath).toBe("/providers/nvidia");
+    expect(provider.envVars).toEqual(["NVIDIA_API_KEY"]);
+  });
+
+  it("registers API-key auth choice metadata", async () => {
+    const provider = await registerNvidiaProvider();
+
+    expect(provider.auth?.map((method) => method.id)).toEqual(["api-key"]);
+
+    const choice = resolveProviderPluginChoice({
+      providers: [provider],
+      choice: "nvidia-api-key",
+    });
+    expect(choice?.provider.id).toBe("nvidia");
+    expect(choice?.method.id).toBe("api-key");
+    expect(readManifest().providerAuthChoices).toStrictEqual([
+      {
+        provider: "nvidia",
+        method: "api-key",
+        choiceId: "nvidia-api-key",
+        choiceLabel: "NVIDIA API key",
+        groupId: "nvidia",
+        groupLabel: "NVIDIA",
+        groupHint: "Direct API key",
+        optionKey: "nvidiaApiKey",
+        cliFlag: "--nvidia-api-key",
+        cliOption: "--nvidia-api-key <key>",
+        cliDescription: "NVIDIA API key",
+      },
+    ]);
+  });
+
+  it("keeps nvidia auth setup metadata aligned", async () => {
+    const provider = await registerNvidiaProvider();
+
+    expect(
+      provider.auth.map((method) => ({
+        id: method.id,
+        label: method.label,
+        hint: method.hint,
+        choiceId: method.wizard?.choiceId,
+        groupId: method.wizard?.groupId,
+        groupLabel: method.wizard?.groupLabel,
+        groupHint: method.wizard?.groupHint,
+      })),
+    ).toEqual([
+      {
+        id: "api-key",
+        label: "NVIDIA API key",
+        hint: "Direct API key",
+        choiceId: "nvidia-api-key",
+        groupId: "nvidia",
+        groupLabel: "NVIDIA",
+        groupHint: "Direct API key",
+      },
+    ]);
+  });
+
+  it("keeps nvidia wizard setup metadata aligned", async () => {
+    const provider = await registerNvidiaProvider();
+
+    expect(provider.wizard?.setup).toStrictEqual({
+      choiceId: "nvidia-api-key",
+      choiceLabel: "NVIDIA API key",
+      groupId: "nvidia",
+      groupLabel: "NVIDIA",
+      groupHint: "Direct API key",
+      methodId: "api-key",
+      modelSelection: {
+        promptWhenAuthChoiceProvided: true,
+        allowKeepCurrent: false,
+      },
+    });
+  });
+
+  it("keeps nvidia model picker metadata aligned", async () => {
+    const provider = await registerNvidiaProvider();
+
+    expect(provider.wizard?.modelPicker).toStrictEqual({
+      label: "NVIDIA (custom)",
+      hint: "Use NVIDIA-hosted open models",
+      methodId: "api-key",
+    });
+  });
+
+  it("does not override replay policy for standard openai-compatible transport", async () => {
+    const provider = await registerNvidiaProvider();
+
+    // NVIDIA uses standard OpenAI-compatible API without custom replay logic
+    expect(provider.buildReplayPolicy).toBeUndefined();
+  });
+
+  it("does not override stream wrapper for standard models", async () => {
+    const provider = await registerNvidiaProvider();
+
+    // NVIDIA uses standard streaming without custom wrappers
+    expect(provider.wrapStreamFn).toBeUndefined();
+  });
+
+  it("surfaces the bundled NVIDIA models via augmentModelCatalog", async () => {
+    const provider = await registerNvidiaProvider();
+
+    const entries = await provider.augmentModelCatalog?.({
+      env: process.env,
+      entries: [],
+    });
+
+    expect(entries?.map((entry) => entry.id)).toEqual([
+      "nvidia/nemotron-3-super-120b-a12b",
+      "moonshotai/kimi-k2.5",
+      "minimaxai/minimax-m2.5",
+      "z-ai/glm5",
+    ]);
+    expect(entries?.every((entry) => entry.provider === "nvidia")).toBe(true);
+  });
+
+  it("opts into literal provider-prefix preservation", async () => {
+    const provider = await registerNvidiaProvider();
+
+    // NVIDIA's ids like nvidia/nemotron-... sit alongside moonshotai/...,
+    // minimaxai/..., z-ai/... in the same catalog, so the leading nvidia/
+    // is a vendor namespace rather than a redundant provider prefix. The
+    // flag keeps the canonical ref as nvidia/nvidia/nemotron-... instead
+    // of letting the default string-based dedupe collapse it.
+    expect(provider.preserveLiteralProviderPrefix).toBe(true);
+  });
+
+  it("registers nvidia provider through the plugin api", () => {
+    const registeredProviders: string[] = [];
+    const registeredModelCatalogProviders: RegisteredModelCatalogProvider[] = [];
+
+    plugin.register(
+      createTestPluginApi({
+        registerProvider(provider: { id: string }) {
+          registeredProviders.push(provider.id);
+        },
+        registerModelCatalogProvider(provider) {
+          registeredModelCatalogProviders.push(provider);
+        },
+      }),
+    );
+
+    expect(registeredProviders).toStrictEqual(["nvidia"]);
+    expect(registeredModelCatalogProviders.map((provider) => provider.provider)).toStrictEqual([
+      "nvidia",
+    ]);
+  });
+});

package/extensions/nvidia/index.ts

@@ -0,0 +1,64 @@
+import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
+import { applyNvidiaConfig, NVIDIA_DEFAULT_MODEL_REF } from "./onboard.js";
+import { buildNvidiaProvider } from "./provider-catalog.js";
+
+const PROVIDER_ID = "nvidia";
+
+function buildNvidiaCatalogModels() {
+  return buildNvidiaProvider().models.map((model) => ({
+    provider: PROVIDER_ID,
+    id: model.id,
+    name: model.name ?? model.id,
+    contextWindow: model.contextWindow,
+    reasoning: model.reasoning,
+    input: model.input,
+  }));
+}
+
+export default defineSingleProviderPluginEntry({
+  id: PROVIDER_ID,
+  name: "NVIDIA Provider",
+  description: "Bundled NVIDIA provider plugin",
+  provider: {
+    label: "NVIDIA",
+    docsPath: "/providers/nvidia",
+    envVars: ["NVIDIA_API_KEY"],
+    preserveLiteralProviderPrefix: true,
+    auth: [
+      {
+        methodId: "api-key",
+        label: "NVIDIA API key",
+        hint: "Direct API key",
+        optionKey: "nvidiaApiKey",
+        flagName: "--nvidia-api-key",
+        envVar: "NVIDIA_API_KEY",
+        promptMessage: "Enter NVIDIA API key",
+        defaultModel: NVIDIA_DEFAULT_MODEL_REF,
+        applyConfig: applyNvidiaConfig,
+      },
+    ],
+    catalog: {
+      buildProvider: buildNvidiaProvider,
+    },
+    augmentModelCatalog: buildNvidiaCatalogModels,
+    wizard: {
+      setup: {
+        choiceId: "nvidia-api-key",
+        choiceLabel: "NVIDIA API key",
+        groupId: "nvidia",
+        groupLabel: "NVIDIA",
+        groupHint: "Direct API key",
+        methodId: "api-key",
+        modelSelection: {
+          promptWhenAuthChoiceProvided: true,
+          allowKeepCurrent: false,
+        },
+      },
+      modelPicker: {
+        label: "NVIDIA (custom)",
+        hint: "Use NVIDIA-hosted open models",
+        methodId: "api-key",
+      },
+    },
+  },
+});