test(onboard): split helper coverage

src/lib/adapters/http/probe.test.ts

@@ -27,6 +27,8 @@ describe("http-probe helpers", () => {
     expect(summarizeCurlFailure(7, "", " connection refused ")).toBe(
       "curl failed (exit 7): connection refused",
     );
+    expect(summarizeCurlFailure(28, "", "")).toBe("curl failed (exit 28)");
+    expect(summarizeCurlFailure(0, "", "")).toBe("curl failed (exit 0)");
   });
 
   it("summarizes JSON and text HTTP probe failures", () => {
@@ -36,6 +38,14 @@ describe("http-probe helpers", () => {
     ).toBe('HTTP 401: {"reason":"bad key","retry":false}');
     expect(summarizeProbeError(" plain  text   body ", 500)).toBe("HTTP 500: plain text body");
     expect(summarizeProbeFailure("", 0, 28, "timeout")).toBe("curl failed (exit 28): timeout");
+    expect(summarizeProbeFailure("body", 500, 7, "Connection refused")).toBe(
+      "curl failed (exit 7): Connection refused",
+    );
+    expect(summarizeProbeFailure("Not Found", 404, 0, "")).toBe("HTTP 404: Not Found");
+    expect(summarizeProbeFailure("", 0, 0, "")).toBe("HTTP 0 with no response body");
+    expect(summarizeProbeFailure("  Service  Unavailable  ", 503, 0, "")).toBe(
+      "HTTP 503: Service Unavailable",
+    );
   });
 
   it("captures successful curl output and cleans up the temp file", () => {

src/lib/build-context.test.ts

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { printSandboxCreateRecoveryHints, shouldIncludeBuildContextPath } from "../../dist/lib/build-context";
+
+type ConsoleErrorSpy = ReturnType<typeof vi.spyOn>;
+
+describe("build context filtering", () => {
+  it("filters local-only artifacts out of the sandbox build context", () => {
+    expect(
+      shouldIncludeBuildContextPath(
+        "/repo/nemoclaw-blueprint",
+        "/repo/nemoclaw-blueprint/orchestrator/main.py",
+      ),
+    ).toBe(true);
+    expect(
+      shouldIncludeBuildContextPath(
+        "/repo/nemoclaw-blueprint",
+        "/repo/nemoclaw-blueprint/.venv/bin/python",
+      ),
+    ).toBe(false);
+    expect(
+      shouldIncludeBuildContextPath(
+        "/repo/nemoclaw-blueprint",
+        "/repo/nemoclaw-blueprint/.ruff_cache/cache",
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("printSandboxCreateRecoveryHints", () => {
+  let errorSpy: ConsoleErrorSpy;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+  });
+
+  function stderr(): string {
+    return errorSpy.mock.calls.map((call: unknown[]) => String(call[0])).join("\n");
+  }
+
+  it("prints resume guidance when sandbox image upload times out", () => {
+    printSandboxCreateRecoveryHints("failed to read image export stream");
+
+    expect(stderr()).toContain("image upload into the OpenShell gateway timed out");
+    expect(stderr()).toContain("onboard --resume");
+    expect(stderr()).toContain("Docker memory");
+  });
+
+  it("prints progress-specific resume guidance when upload reached the gateway", () => {
+    printSandboxCreateRecoveryHints(
+      [
+        "[progress] Uploaded to gateway",
+        "failed to read image export stream",
+      ].join("\n"),
+    );
+
+    expect(stderr()).toContain("reuse existing gateway state");
+  });
+
+  it("prints resume guidance when sandbox image upload resets after transfer progress", () => {
+    printSandboxCreateRecoveryHints(
+      [
+        "Image openshell/sandbox-from:123 is available in the gateway.",
+        "Connection reset by peer",
+      ].join("\n"),
+    );
+
+    expect(stderr()).toContain("image push/import stream was interrupted");
+    expect(stderr()).toContain("onboard --resume");
+    expect(stderr()).toContain("reached the gateway");
+  });
+});

src/lib/core/url-utils.test.ts

@@ -47,6 +47,12 @@ describe("normalizeProviderBaseUrl", () => {
     expect(normalizeProviderBaseUrl("https://api.anthropic.com/v1/messages", "anthropic")).toBe(
       "https://api.anthropic.com",
     );
+    expect(normalizeProviderBaseUrl("https://proxy.example.com/v1", "anthropic")).toBe(
+      "https://proxy.example.com",
+    );
+    expect(normalizeProviderBaseUrl("https://proxy.example.com/v1/messages", "anthropic")).toBe(
+      "https://proxy.example.com",
+    );
   });
 
   it("strips trailing slashes", () => {

src/lib/inference/config.test.ts

@@ -17,6 +17,7 @@ import {
   VLLM_LOCAL_CREDENTIAL_ENV,
   getOpenClawPrimaryModel,
   getProviderSelectionConfig,
+  getSandboxInferenceConfig,
   parseGatewayInference,
 } from "../../../dist/lib/inference/config";
 
@@ -221,6 +222,77 @@ describe("inference selection config", () => {
   });
 });
 
+describe("getSandboxInferenceConfig", () => {
+  it("maps NVIDIA Endpoints to the routed inference provider", () => {
+    expect(
+      getSandboxInferenceConfig("qwen/qwen3.5-397b-a17b", "nvidia-prod", "openai-completions"),
+    ).toEqual({
+      providerKey: MANAGED_PROVIDER_ID,
+      primaryModelRef: `${MANAGED_PROVIDER_ID}/qwen/qwen3.5-397b-a17b`,
+      inferenceBaseUrl: INFERENCE_ROUTE_URL,
+      inferenceApi: "openai-completions",
+      inferenceCompat: null,
+    });
+  });
+
+  it("maps Model Router sandboxes through managed inference.local", () => {
+    expect(getSandboxInferenceConfig("nvidia-routed", "nvidia-router")).toEqual({
+      providerKey: MANAGED_PROVIDER_ID,
+      primaryModelRef: `${MANAGED_PROVIDER_ID}/nvidia-routed`,
+      inferenceBaseUrl: INFERENCE_ROUTE_URL,
+      inferenceApi: "openai-completions",
+      inferenceCompat: null,
+    });
+  });
+
+  it("leaves Kimi K2.6 compat to the model-specific setup registry", () => {
+    expect(
+      getSandboxInferenceConfig("moonshotai/kimi-k2.6", "nvidia-prod", "openai-completions"),
+    ).toEqual({
+      providerKey: MANAGED_PROVIDER_ID,
+      primaryModelRef: `${MANAGED_PROVIDER_ID}/moonshotai/kimi-k2.6`,
+      inferenceBaseUrl: INFERENCE_ROUTE_URL,
+      inferenceApi: "openai-completions",
+      inferenceCompat: null,
+    });
+  });
+
+  it("maps OpenAI-compatible endpoints to the managed inference provider", () => {
+    expect(getSandboxInferenceConfig("deepseek-ai/DeepSeek-V4-Flash", "compatible-endpoint"))
+      .toEqual({
+        providerKey: MANAGED_PROVIDER_ID,
+        primaryModelRef: `${MANAGED_PROVIDER_ID}/deepseek-ai/DeepSeek-V4-Flash`,
+        inferenceBaseUrl: INFERENCE_ROUTE_URL,
+        inferenceApi: "openai-completions",
+        inferenceCompat: {
+          supportsStore: false,
+        },
+      });
+  });
+
+  it("maps Gemini to the routed inference provider with supportsStore disabled", () => {
+    expect(getSandboxInferenceConfig("gemini-2.5-flash", "gemini-api")).toEqual({
+      providerKey: MANAGED_PROVIDER_ID,
+      primaryModelRef: `${MANAGED_PROVIDER_ID}/gemini-2.5-flash`,
+      inferenceBaseUrl: INFERENCE_ROUTE_URL,
+      inferenceApi: "openai-completions",
+      inferenceCompat: {
+        supportsStore: false,
+      },
+    });
+  });
+
+  it("uses a probed Responses API override when one is available", () => {
+    expect(getSandboxInferenceConfig("gpt-5.4", "openai-api", "openai-responses")).toEqual({
+      providerKey: "openai",
+      primaryModelRef: "openai/gpt-5.4",
+      inferenceBaseUrl: INFERENCE_ROUTE_URL,
+      inferenceApi: "openai-responses",
+      inferenceCompat: null,
+    });
+  });
+});
+
 describe("parseGatewayInference", () => {
   it("parses provider and model from openshell inference get output", () => {
     const output = [