fix(status): keep the recorded API family when only the model drifts

Sandbox status probes the live shared route with one real inference
request, and that request's result decides `status --json`'s exit code.
The probe dropped the sandbox's recorded API family whenever the live
route was not exactly aligned, including when the shared route drifted
by model alone and the provider was unchanged.

For a compatible endpoint the recorded family is the only signal that
the route speaks openai-responses or anthropic-messages, so dropping it
fell back to openai-completions and sent the request to an endpoint the
provider does not serve. A healthy route was then reported unhealthy and
the command exited nonzero, which is what automation reading the route
drift fields observes.

Keep the recorded family while the live provider matches the recorded
provider, and drop it only when the provider itself changed, so one
provider's family is still never carried onto another.

Refs #9302

Signed-off-by: Yanyun Liao <yanyunl@nvidia.com>

Author: yanyunl1991

src/lib/actions/sandbox/status-snapshot-route-drift.test.ts

@@ -183,3 +183,87 @@ describe("collectSandboxStatusSnapshot route drift", () => {
     expect(snapshot.routeDrift).toMatchObject({ canConnect: false });
   });
 });
+
+describe("collectSandboxStatusSnapshot inference invocation route (#9302)", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  /**
+   * Capture the route the in-sandbox invocation probe is asked to exercise.
+   * The probe reports the health that decides `status --json`'s exit code.
+   */
+  async function captureInvocationRoute(
+    entry: Partial<SandboxEntry>,
+  ): Promise<Record<string, unknown> | null> {
+    let seen: Record<string, unknown> | null = null;
+    const sandbox = {
+      name: "alpha",
+      agent: "openclaw",
+      policies: [],
+      gatewayName: "nemoclaw",
+      ...entry,
+    } as SandboxEntry;
+    await collectSandboxStatusSnapshot("alpha", {
+      deps: {
+        getSandbox: () => sandbox,
+        listSandboxes: () => ({ sandboxes: [sandbox], defaultSandbox: "alpha" }),
+        reconcile: async () => ({ state: "present", output: "Phase: Ready" }),
+        probeProviderHealthImpl: () => null,
+        probeSandboxInferenceGatewayHealthImpl: async () => ({
+          ok: true,
+          endpoint: "https://inference.local/v1/models",
+          detail: "reachable",
+          httpStatus: 200,
+        }),
+        probeSandboxInferenceInvocationImpl: (input: Record<string, unknown>) => {
+          seen = input;
+          return { ok: true };
+        },
+      },
+    } as never);
+    return seen;
+  }
+
+  const recorded = {
+    provider: "compatible-endpoint",
+    model: "recorded/model",
+    endpointUrl: "https://target.example/v1",
+    credentialEnv: "TARGET_KEY",
+    preferredInferenceApi: "openai-responses",
+  } satisfies Partial<SandboxEntry>;
+
+  it("keeps the recorded API family when only the model drifted", async () => {
+    // The recorded family describes the provider, which has not changed, so
+    // dropping it would probe /v1/chat/completions against a responses-only
+    // endpoint and report a healthy route as unhealthy.
+    liveGatewayInference("compatible-endpoint", "live/model");
+
+    expect(await captureInvocationRoute(recorded)).toMatchObject({
+      provider: "compatible-endpoint",
+      model: "live/model",
+      preferredInferenceApi: "openai-responses",
+    });
+  });
+
+  it("keeps the recorded API family when the route is aligned", async () => {
+    liveGatewayInference("compatible-endpoint", "recorded/model");
+
+    expect(await captureInvocationRoute(recorded)).toMatchObject({
+      model: "recorded/model",
+      preferredInferenceApi: "openai-responses",
+    });
+  });
+
+  it("drops the recorded API family when the provider itself drifted", async () => {
+    // Regression lock: one provider's family must never be carried onto
+    // another that may have no such endpoint.
+    liveGatewayInference("nvidia-prod", "nvidia/nemotron");
+
+    expect(await captureInvocationRoute(recorded)).toMatchObject({
+      provider: "nvidia-prod",
+      model: "nvidia/nemotron",
+      preferredInferenceApi: null,
+    });
+  });
+});

src/lib/actions/sandbox/status-snapshot.ts

@@ -589,11 +589,14 @@ export async function collectSandboxStatusSnapshot(
         ? {
             provider: live.provider,
             model: live.model,
-            // The live gateway RPC does not expose a stored API override. Do
-            // not carry an API family across route drift. When the live pair
-            // is unchanged, the recorded family still describes that route.
+            // The live gateway RPC does not expose a stored API override. The
+            // recorded family describes the recorded *provider*, so it keeps
+            // describing the live route while that provider is unchanged —
+            // including when only the model drifted. Drop it only when the
+            // provider itself changed, so one provider's family cannot be
+            // carried onto another that has no such endpoint (#9302).
             preferredInferenceApi:
-              routeDriftPlan?.kind === "aligned" ? (sb?.preferredInferenceApi ?? null) : null,
+              live.provider === sb?.provider ? (sb?.preferredInferenceApi ?? null) : null,
           }
         : {
             provider: currentProvider,