feat(inference): map Pi model tuning through the managed startup profile

The startup profile declares each agent's capabilities in one table whose
contract is that an unadvertised field is rejected rather than silently
dropped, but tuning fields, the upstream endpoint, the messaging plan, and
the agent-specific input check each enforced that contract with a hardcoded
agent name. Pi matched none of them, so it accepted an effort value it has
no surface for, accepted an upstream endpoint its mapper discards, bypassed
the messaging null rule, and could not be built at all through the shared
onboarding builder, which demanded approval state that belongs to Deep
Agents Code. Each check now reads the capability table.

Pi's context window, output limit, and reasoning support now travel from
the environment through the profile to the sandbox model catalog. The
generator writes only the fields the pinned Pi release documents for a
catalog entry, and omits each one the host leaves unset so the release
default applies.

Signed-off-by: Tinson Lai <tinsonl@nvidia.com>

Author: laitingsheng

agents/pi/Dockerfile

@@ -176,6 +176,10 @@ ARG NEMOCLAW_INFERENCE_PROVIDER_ID=inference
 ARG NEMOCLAW_UPSTREAM_PROVIDER=nvidia
 ARG NEMOCLAW_INFERENCE_BASE_URL=https://inference.local/v1
 ARG NEMOCLAW_INFERENCE_API=openai-completions
+ARG NEMOCLAW_CONTEXT_WINDOW=
+# hadolint ignore=DL3064
+ARG NEMOCLAW_MAX_TOKENS=
+ARG NEMOCLAW_REASONING=
 # Pi installs no optional package. The Pi image still declares the managed-image
 # capability contract used by OpenClaw, Hermes, and Deep Agents Code.
 ARG NEMOCLAW_MANAGED_IMAGE_CAPABILITY_UNION=0
@@ -197,13 +201,17 @@ RUN install -d -m 0755 /usr/local/share/nemoclaw \
     && chown root:root /usr/local/share/nemoclaw/pi-proxy-host /usr/local/share/nemoclaw/pi-proxy-port \
     && chmod 0444 /usr/local/share/nemoclaw/pi-proxy-host /usr/local/share/nemoclaw/pi-proxy-port
 
+# hadolint ignore=DL3064
 ENV HOME=/sandbox \
     PATH="/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin" \
     NEMOCLAW_MODEL=${NEMOCLAW_MODEL} \
     NEMOCLAW_INFERENCE_PROVIDER_ID=${NEMOCLAW_INFERENCE_PROVIDER_ID} \
     NEMOCLAW_UPSTREAM_PROVIDER=${NEMOCLAW_UPSTREAM_PROVIDER} \
     NEMOCLAW_INFERENCE_BASE_URL=${NEMOCLAW_INFERENCE_BASE_URL} \
     NEMOCLAW_INFERENCE_API=${NEMOCLAW_INFERENCE_API} \
+    NEMOCLAW_CONTEXT_WINDOW=${NEMOCLAW_CONTEXT_WINDOW} \
+    NEMOCLAW_MAX_TOKENS=${NEMOCLAW_MAX_TOKENS} \
+    NEMOCLAW_REASONING=${NEMOCLAW_REASONING} \
     NEMOCLAW_MANAGED_IMAGE_CAPABILITY_UNION=${NEMOCLAW_MANAGED_IMAGE_CAPABILITY_UNION} \
     NEMOCLAW_BUILD_ID=${NEMOCLAW_BUILD_ID} \
     PI_OFFLINE=1 \

agents/pi/generate-config.ts

@@ -21,6 +21,9 @@ type Settings = {
   providerKey: string;
   upstreamProvider: string;
   inferenceApi: string;
+  contextWindow: number | null;
+  maxTokens: number | null;
+  reasoning: boolean | null;
 };
 
 type ManagedPiConfig = {
@@ -75,6 +78,27 @@ function normalizeInferenceBaseUrl(value: string): string {
   return text;
 }
 
+function normalizePositiveInteger(value: string | undefined, name: string): number | null {
+  const text = (value ?? "").trim();
+  if (!text) return null;
+  if (!/^\d+$/u.test(text)) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+  const parsed = Number(text);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+  return parsed;
+}
+
+function normalizeReasoning(value: string | undefined): boolean | null {
+  const text = (value ?? "").trim();
+  if (!text) return null;
+  if (text === "true") return true;
+  if (text === "false") return false;
+  throw new Error('NEMOCLAW_REASONING must be "true" or "false".');
+}
+
 function readSettings(env: NodeJS.ProcessEnv): Settings {
   const providerKey = normalizeMetadata(
     env.NEMOCLAW_INFERENCE_PROVIDER_ID || env.NEMOCLAW_PROVIDER_KEY || "inference",
@@ -91,9 +115,20 @@ function readSettings(env: NodeJS.ProcessEnv): Settings {
       "NEMOCLAW_UPSTREAM_PROVIDER",
     ),
     inferenceApi: normalizeInferenceApi(env.NEMOCLAW_INFERENCE_API),
+    contextWindow: normalizePositiveInteger(env.NEMOCLAW_CONTEXT_WINDOW, "NEMOCLAW_CONTEXT_WINDOW"),
+    maxTokens: normalizePositiveInteger(env.NEMOCLAW_MAX_TOKENS, "NEMOCLAW_MAX_TOKENS"),
+    reasoning: normalizeReasoning(env.NEMOCLAW_REASONING),
   };
 }
 
+function buildModel(settings: Settings): Record<string, unknown> {
+  const model: Record<string, unknown> = { id: settings.model };
+  if (settings.contextWindow !== null) model.contextWindow = settings.contextWindow;
+  if (settings.maxTokens !== null) model.maxTokens = settings.maxTokens;
+  if (settings.reasoning !== null) model.reasoning = settings.reasoning;
+  return model;
+}
+
 function buildConfig(settings: Settings): ManagedPiConfig {
   const config = {
     $comment: `Generated by NemoClaw. This file contains no provider secrets. NemoClaw provider route: ${settings.providerKey}; upstream provider: ${settings.upstreamProvider}; API: ${settings.inferenceApi}.`,
@@ -103,7 +138,7 @@ function buildConfig(settings: Settings): ManagedPiConfig {
         api: settings.inferenceApi,
         apiKey: MANAGED_PROVIDER_API_KEY,
         baseUrl: settings.baseUrl,
-        models: [{ id: settings.model }],
+        models: [buildModel(settings)],
       },
     },
   };

src/lib/onboard/managed-startup-agent-environment.test.ts

@@ -687,6 +687,140 @@ describe("managed startup agent environment", () => {
     ]);
   });
 
+  it("keeps the Pi managed route credential-free and confined to root-owned proxy files (#7930)", () => {
+    const result = mapManagedStartupProfileToAgentEnvironment(piProfile());
+
+    expect(result.configurationEnvironment).toEqual({
+      HTTP_PROXY: "",
+      HTTPS_PROXY: "",
+      NEMOCLAW_CONTEXT_WINDOW: "",
+      NEMOCLAW_INFERENCE_API: "openai-completions",
+      NEMOCLAW_INFERENCE_BASE_URL: "https://inference.local/v1",
+      NEMOCLAW_INFERENCE_PROVIDER_ID: "inference",
+      NEMOCLAW_MAX_TOKENS: "",
+      NEMOCLAW_MODEL: "nvidia/nemotron-3-super-120b-a12b",
+      NEMOCLAW_REASONING: "",
+      NEMOCLAW_TOOL_DISCLOSURE: "progressive",
+      NEMOCLAW_UPSTREAM_PROVIDER: "nvidia",
+      NO_PROXY: "",
+      http_proxy: "",
+      https_proxy: "",
+      no_proxy: "",
+    });
+    const expectedPiRuntime = { ...result.configurationEnvironment };
+    delete expectedPiRuntime.NEMOCLAW_INFERENCE_BASE_URL;
+    delete expectedPiRuntime.NEMOCLAW_CONTEXT_WINDOW;
+    delete expectedPiRuntime.NEMOCLAW_MAX_TOKENS;
+    delete expectedPiRuntime.NEMOCLAW_REASONING;
+    for (const name of [
+      "HTTP_PROXY",
+      "HTTPS_PROXY",
+      "NO_PROXY",
+      "http_proxy",
+      "https_proxy",
+      "no_proxy",
+    ]) {
+      delete expectedPiRuntime[name];
+    }
+    expect(result.runtimeEnvironment).toEqual(expectedPiRuntime);
+    expect(result.materials).toEqual([
+      {
+        kind: "corporate-ca-handoff",
+        legacyInput: "NEMOCLAW_CORPORATE_CA_B64",
+        expectedSha256: CA_SHA256,
+      },
+      {
+        kind: "root-owned-file",
+        legacyInput: "NEMOCLAW_PROXY_HOST",
+        path: "/usr/local/share/nemoclaw/pi-proxy-host",
+        contents: "10.200.0.1\n",
+        owner: "root",
+        group: "root",
+        mode: 0o444,
+      },
+      {
+        kind: "root-owned-file",
+        legacyInput: "NEMOCLAW_PROXY_PORT",
+        path: "/usr/local/share/nemoclaw/pi-proxy-port",
+        contents: "3128\n",
+        owner: "root",
+        group: "root",
+        mode: 0o444,
+      },
+    ]);
+    expect(result.actions).toEqual([
+      { kind: "generate-agent-config", agent: "pi", runAs: "sandbox" },
+      { kind: "configure-dashboard", dashboard: { agent: "pi", mode: "disabled" } },
+    ]);
+
+    const serialized = JSON.stringify(result);
+    expect(serialized).not.toContain("nvapi-");
+    expect(serialized).not.toContain("NVIDIA_API_KEY");
+    expect(serialized).not.toContain("BEGIN CERTIFICATE");
+    expect(serialized).toContain(CA_SHA256);
+  });
+
+  it("hands Pi model tuning to its config generator and keeps it out of the long-running runtime (#7930)", () => {
+    const base = piProfile();
+    const result = mapManagedStartupProfileToAgentEnvironment({
+      ...base,
+      tuning: { contextWindow: 262_144, maxTokens: 32_000, reasoning: true, reasoningEffort: null },
+    });
+
+    expect(result.configurationEnvironment).toMatchObject({
+      NEMOCLAW_CONTEXT_WINDOW: "262144",
+      NEMOCLAW_MAX_TOKENS: "32000",
+      NEMOCLAW_REASONING: "1",
+    });
+    for (const name of ["NEMOCLAW_CONTEXT_WINDOW", "NEMOCLAW_MAX_TOKENS", "NEMOCLAW_REASONING"]) {
+      expect(result.runtimeEnvironment).not.toHaveProperty(name);
+    }
+    expect(
+      mapManagedStartupProfileToAgentEnvironment({
+        ...base,
+        tuning: { ...base.tuning, reasoning: false },
+      }).configurationEnvironment.NEMOCLAW_REASONING,
+    ).toBe("0");
+  });
+
+  it("rebuilds the Pi generator inputs from the current route without retaining the previous one (#7930)", () => {
+    const base = piProfile();
+    const before = mapManagedStartupProfileToAgentEnvironment(base);
+    const after = mapManagedStartupProfileToAgentEnvironment({
+      ...base,
+      inference: {
+        ...base.inference,
+        routeProvider: "rebuilt-inference",
+        upstreamProvider: "openrouter",
+        model: "openai/gpt-5.4",
+        routedBaseUrl: "https://rebuilt.inference.local/v1",
+      },
+      proxy: { ...base.proxy, managedHost: "10.200.0.9", managedPort: 3129 },
+    });
+
+    expect(after.configurationEnvironment).toMatchObject({
+      NEMOCLAW_INFERENCE_BASE_URL: "https://rebuilt.inference.local/v1",
+      NEMOCLAW_INFERENCE_PROVIDER_ID: "rebuilt-inference",
+      NEMOCLAW_MODEL: "openai/gpt-5.4",
+      NEMOCLAW_UPSTREAM_PROVIDER: "openrouter",
+    });
+    expect(after.materials).toEqual([
+      before.materials[0],
+      { ...before.materials[1], contents: "10.200.0.9\n" },
+      { ...before.materials[2], contents: "3129\n" },
+    ]);
+    const serialized = JSON.stringify(after);
+    for (const stale of [
+      "https://inference.local/v1",
+      "nvidia/nemotron-3-super-120b-a12b",
+      "10.200.0.1",
+      "3128",
+    ]) {
+      expect(serialized).not.toContain(stale);
+    }
+    expect(after.actions).toEqual(before.actions);
+  });
+
   it("feeds the existing OpenClaw and Hermes config consumers without translation", () => {
     const openclaw = mapManagedStartupProfileToAgentEnvironment(openClawProfile());
     const openclawConfig = buildOpenClawConfig({

src/lib/onboard/managed-startup-onboard-profile.test.ts

@@ -136,7 +136,85 @@ function dcodeInput(
   };
 }
 
+function piInput(
+  overrides: Partial<ManagedStartupOnboardProfileInput> = {},
+): ManagedStartupOnboardProfileInput {
+  return {
+    agentName: "pi",
+    inference: {
+      routeProvider: "inference",
+      upstreamProvider: "nvidia",
+      model: "nvidia/nemotron-3-super-120b-a12b",
+      routedBaseUrl: "https://inference.local/v1",
+      upstreamEndpointUrl: null,
+      api: "openai-completions",
+      primaryModelRef: null,
+      compatibility: null,
+    },
+    chatUiUrl: "",
+    effectiveDashboardPort: 0,
+    manageDashboard: false,
+    dashboardBindAddress: undefined,
+    wslExposure: false,
+    hermesDashboardState: { config: null, enabled: false },
+    webSearch: null,
+    toolDisclosure: "progressive",
+    hermesToolGateways: [],
+    messagingPlan: null,
+    dcodeAutoApprovalMode: "disabled",
+    observabilityEnabled: false,
+    environment: EMPTY_ENVIRONMENT,
+    corporateCa: null,
+    ...overrides,
+  };
+}
+
 describe("buildManagedStartupOnboardProfile", () => {
+  it("builds Pi without requiring state another agent owns (#7930)", () => {
+    const built = buildManagedStartupOnboardProfile(
+      piInput({
+        environment: {
+          NEMOCLAW_CONTEXT_WINDOW: "262144",
+          NEMOCLAW_MAX_TOKENS: "32000",
+          NEMOCLAW_REASONING: "true",
+        },
+      }),
+    );
+
+    expect(built.profile).toMatchObject({
+      agent: "pi",
+      agentConfig: { agent: "pi" },
+      dashboard: { agent: "pi", mode: "disabled" },
+      messaging: { plan: null },
+      tuning: {
+        contextWindow: 262_144,
+        maxTokens: 32_000,
+        reasoning: true,
+        reasoningEffort: null,
+      },
+    });
+  });
+
+  it("rejects Pi web-search intent instead of carrying it into the profile (#7930)", () => {
+    expect(
+      buildManagedStartupOnboardProfile(
+        piInput({ webSearch: { fetchEnabled: true, provider: "tavily" } }),
+      ).profile.agentConfig,
+    ).toEqual({ agent: "pi" });
+  });
+
+  it("rejects Pi messaging intent instead of silently discarding it (#7930)", () => {
+    expect(() =>
+      buildManagedStartupOnboardProfile(piInput({ messagingPlan: messagingPlan("openclaw") })),
+    ).toThrow(/pi does not support messaging/);
+  });
+
+  it("rejects a Pi dashboard request (#7930)", () => {
+    expect(() =>
+      buildManagedStartupOnboardProfile(piInput({ manageDashboard: true })),
+    ).toThrow(/Pi must not enable a dashboard/);
+  });
+
   it("maps a remote OpenClaw dashboard and its complete agent-owned state", () => {
     const plan = messagingPlan("openclaw");
     const built = buildManagedStartupOnboardProfile(