feat(nvidia): add NVIDIA provider with onboarding flow (#71204)

* feat(nvidia): add NVIDIA provider with onboarding flow

Add the NVIDIA build.nvidia.com API as a bundled provider. Default model
is nvidia/nvidia/nemotron-3-super-120b-a12b: first segment is the provider
id, remaining "nvidia/nemotron-3-super-120b-a12b" is the literal upstream
model id (which happens to start with "nvidia/" because NVIDIA is also the
model maker).

Supporting core change: introduce a provider capability flag
nativeIdsIncludeProviderPrefix so providers whose native catalog ids
intentionally include their provider prefix (OpenRouter) opt into self-prefix
dedupe in modelKey, without hardcoding provider names in core. Providers
whose ids merely happen to start with their own name (NVIDIA) leave the flag
unset and get the full <provider>/<model-id> concatenation.

- extensions/nvidia/*: new plugin, catalog, onboarding, tests, docs
- extensions/openrouter/index.ts: declare nativeIdsIncludeProviderPrefix
- src/plugins/types.ts: add field to ProviderPlugin
- src/plugins/registry.ts: populate self-prefix set on registration
- src/agents/provider-self-prefix.ts: sync accessor used by modelKey
- src/agents/model-ref-shared.ts: modelKey consults the flag
- test updates for affected surfaces

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(model-picker): simplify literal-prefix display to label-only

* fix(model-picker): pass workspaceDir/env to allowlist literal-prefix resolution

* chore: untrack generated baseline JSON artifacts (gitignored)

* fix(nvidia): show literal model ref in picker and onboarding notes

* fix(nvidia): show hint whenever display label differs from stored config

* fix(nvidia): drop redundant hint from Keep current label

* fix(nvidia): restore literal double-prefix display labels

* fix(picker): handle literal-prefix fast path

* fix(picker): show literal keep label

* fix(docs): update nvidia provider docs

* fix(nvidia): update test helper imports

* fix(changelog): add nvidia provider entry

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

extensions/nvidia/api.ts

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

extensions/nvidia/index.test.ts

@@ -16,12 +16,23 @@ function readManifest(): NvidiaManifest {
   ) as NvidiaManifest;
 }
 
-describe("nvidia provider plugin", () => {
-  it("registers API-key auth metadata", async () => {
-    const provider = await registerSingleProviderPlugin(plugin);
+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({
@@ -40,4 +51,107 @@ describe("nvidia provider plugin", () => {
       ]),
     );
   });
+
+  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).toMatchObject({
+      choiceId: "nvidia-api-key",
+      choiceLabel: "NVIDIA API key",
+      groupId: "nvidia",
+      groupLabel: "NVIDIA",
+      groupHint: "Direct API key",
+      methodId: "api-key",
+    });
+  });
+
+  it("keeps nvidia model picker metadata aligned", async () => {
+    const provider = await registerNvidiaProvider();
+
+    expect(provider.wizard?.modelPicker).toMatchObject({
+      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[] = [];
+
+    plugin.register({
+      registerProvider(provider: { id: string }) {
+        registeredProviders.push(provider.id);
+      },
+    } as any);
+
+    expect(registeredProviders).toContain("nvidia");
+  });
 });

extensions/nvidia/index.ts

@@ -1,8 +1,20 @@
 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",
@@ -11,26 +23,42 @@ export default defineSingleProviderPluginEntry({
     label: "NVIDIA",
     docsPath: "/providers/nvidia",
     envVars: ["NVIDIA_API_KEY"],
+    preserveLiteralProviderPrefix: true,
     auth: [
       {
         methodId: "api-key",
         label: "NVIDIA API key",
-        hint: "API key",
+        hint: "Direct API key",
         optionKey: "nvidiaApiKey",
         flagName: "--nvidia-api-key",
         envVar: "NVIDIA_API_KEY",
         promptMessage: "Enter NVIDIA API key",
-        wizard: {
-          choiceId: "nvidia-api-key",
-          choiceLabel: "NVIDIA API key",
-          groupId: "nvidia",
-          groupLabel: "NVIDIA",
-          groupHint: "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",
+      },
+    },
   },
 });

extensions/nvidia/onboard.test.ts

@@ -0,0 +1,47 @@
+import {
+  expectProviderOnboardMergedLegacyConfig,
+  expectProviderOnboardPrimaryModel,
+} from "openclaw/plugin-sdk/provider-test-contracts";
+import { describe, expect, it } from "vitest";
+import { applyNvidiaConfig, applyNvidiaProviderConfig } from "./onboard.js";
+
+describe("nvidia onboard", () => {
+  it("adds NVIDIA provider with correct settings", () => {
+    const cfg = applyNvidiaConfig({});
+    expect(cfg.models?.providers?.nvidia).toMatchObject({
+      baseUrl: "https://integrate.api.nvidia.com/v1",
+      api: "openai-completions",
+    });
+    expect(cfg.models?.providers?.nvidia?.models.map((model) => model.id)).toEqual([
+      "nvidia/nemotron-3-super-120b-a12b",
+      "moonshotai/kimi-k2.5",
+      "minimaxai/minimax-m2.5",
+      "z-ai/glm5",
+    ]);
+    // Config stores the canonical form; the picker label shows the literal
+    // form via preserveLiteralProviderPrefix.
+    expectProviderOnboardPrimaryModel({
+      applyConfig: applyNvidiaConfig,
+      modelRef: "nvidia/nemotron-3-super-120b-a12b",
+    });
+  });
+
+  it("merges NVIDIA models and keeps existing provider overrides", () => {
+    const provider = expectProviderOnboardMergedLegacyConfig({
+      applyProviderConfig: applyNvidiaProviderConfig,
+      providerId: "nvidia",
+      providerApi: "openai-completions",
+      baseUrl: "https://integrate.api.nvidia.com/v1",
+      legacyApi: "openai-completions",
+      legacyModelId: "custom-model",
+      legacyModelName: "Custom",
+    });
+    expect(provider?.models.map((model) => model.id)).toEqual([
+      "custom-model",
+      "nvidia/nemotron-3-super-120b-a12b",
+      "moonshotai/kimi-k2.5",
+      "minimaxai/minimax-m2.5",
+      "z-ai/glm5",
+    ]);
+  });
+});

extensions/nvidia/onboard.ts

@@ -0,0 +1,30 @@
+import {
+  createDefaultModelsPresetAppliers,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/provider-onboard";
+import { buildNvidiaProvider, NVIDIA_DEFAULT_MODEL_ID } from "./provider-catalog.js";
+
+export const NVIDIA_DEFAULT_MODEL_REF = NVIDIA_DEFAULT_MODEL_ID;
+
+const nvidiaPresetAppliers = createDefaultModelsPresetAppliers({
+  primaryModelRef: NVIDIA_DEFAULT_MODEL_REF,
+  resolveParams: (_cfg: OpenClawConfig) => {
+    const defaultProvider = buildNvidiaProvider();
+    return {
+      providerId: "nvidia",
+      api: defaultProvider.api ?? "openai-completions",
+      baseUrl: defaultProvider.baseUrl,
+      defaultModels: defaultProvider.models ?? [],
+      defaultModelId: NVIDIA_DEFAULT_MODEL_ID,
+      aliases: [{ modelRef: NVIDIA_DEFAULT_MODEL_REF, alias: "NVIDIA" }],
+    };
+  },
+});
+
+export function applyNvidiaProviderConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return nvidiaPresetAppliers.applyProviderConfig(cfg);
+}
+
+export function applyNvidiaConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return nvidiaPresetAppliers.applyConfig(cfg);
+}

extensions/nvidia/openclaw.plugin.json

@@ -100,7 +100,7 @@
       "choiceLabel": "NVIDIA API key",
       "groupId": "nvidia",
       "groupLabel": "NVIDIA",
-      "groupHint": "API key",
+      "groupHint": "Direct API key",
       "optionKey": "nvidiaApiKey",
       "cliFlag": "--nvidia-api-key",
       "cliOption": "--nvidia-api-key <key>",

extensions/nvidia/plugin-registration.contract.test.ts

@@ -0,0 +1,14 @@
+import { describePluginRegistrationContract } from "openclaw/plugin-sdk/plugin-test-contracts";
+
+describePluginRegistrationContract({
+  pluginId: "nvidia",
+  providerIds: ["nvidia"],
+  manifestAuthChoice: {
+    pluginId: "nvidia",
+    choiceId: "nvidia-api-key",
+    choiceLabel: "NVIDIA API key",
+    groupId: "nvidia",
+    groupLabel: "NVIDIA",
+    groupHint: "Direct API key",
+  },
+});

extensions/nvidia/provider-catalog.ts

@@ -2,6 +2,8 @@ import { buildManifestModelProviderConfig } from "openclaw/plugin-sdk/provider-c
 import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-shared";
 import manifest from "./openclaw.plugin.json" with { type: "json" };
 
+export const NVIDIA_DEFAULT_MODEL_ID = "nvidia/nemotron-3-super-120b-a12b";
+
 export function buildNvidiaProvider(): ModelProviderConfig {
   return {
     ...buildManifestModelProviderConfig({