fix(inference): keep Windows Ollama requests in Docker

src/lib/actions/sandbox/agent/ollama-restart-recovery.test.ts

@@ -63,9 +63,11 @@ describe("maybeWarmOllamaAfterDaemonRestart", () => {
     expect(getCommandUrl(runCaptureImpl.mock.calls[0][0])).toBe(
       `http://host.docker.internal:${OLLAMA_PORT}/api/ps`,
     );
+    expect(runCaptureImpl.mock.calls[0][0][0]).toBe("docker");
     expect(getCommandUrl(runCaptureExImpl.mock.calls[0][0])).toBe(
       `http://host.docker.internal:${OLLAMA_PORT}/api/generate`,
     );
+    expect(runCaptureExImpl.mock.calls[0][0][0]).toBe("docker");
     expect(getCommandBody(runCaptureExImpl.mock.calls[0][0])).toMatchObject({
       model: "qwen3.6:35b",
       stream: false,
@@ -89,9 +91,11 @@ describe("maybeWarmOllamaAfterDaemonRestart", () => {
     expect(getCommandUrl(runCaptureImpl.mock.calls[0][0])).toBe(
       `http://127.0.0.1:${OLLAMA_PORT}/api/ps`,
     );
+    expect(runCaptureImpl.mock.calls[0][0][0]).toBe("curl");
     expect(getCommandUrl(runCaptureExImpl.mock.calls[0][0])).toBe(
       `http://127.0.0.1:${OLLAMA_PORT}/api/generate`,
     );
+    expect(runCaptureExImpl.mock.calls[0][0][0]).toBe("curl");
   });
 
   it("falls back to an allowlisted host instead of probing an arbitrary registry URL", () => {
@@ -228,7 +232,7 @@ describe("maybeWarmOllamaAfterDaemonRestart", () => {
       endpoint: `http://host.docker.internal:${OLLAMA_PORT}`,
       inventoryLabel: "llama3.2:1b",
     });
-    expect(probeModelInventory).toHaveBeenCalledWith("host.docker.internal", undefined);
+    expect(probeModelInventory).toHaveBeenCalledWith("host.docker.internal", expect.any(Function));
   });
 
   it("keeps the warm failure when the daemon does hold the model (#9455)", () => {

src/lib/actions/sandbox/agent/ollama-restart-recovery.ts

@@ -18,6 +18,7 @@ import { buildValidatedCurlCommandArgs } from "../../../adapters/http/curl-args"
 import { OLLAMA_PORT, OLLAMA_PROXY_PORT } from "../../../core/ports";
 import {
   describeModelInventory,
+  getOllamaApiCommand,
   getResolvedOllamaHost,
   ollamaInventoryContainsModel,
   OLLAMA_HOST_DOCKER_INTERNAL,
@@ -30,7 +31,7 @@ import {
   type OllamaRuntimeRunCaptureFn,
   probeOllamaRuntimeModelStatus,
 } from "../../../inference/ollama-runtime-context";
-import { runCaptureEx } from "../../../runner";
+import { runCapture, runCaptureEx } from "../../../runner";
 
 export interface OllamaRestartRecoveryRoute {
   provider?: string | null;
@@ -150,9 +151,8 @@ function buildWarmCommand(model: string, hostname: string): string[] {
     keep_alive: "15m",
     options: { num_predict: 16 },
   });
-  return [
-    "curl",
-    ...buildValidatedCurlCommandArgs([
+  return getOllamaApiCommand(
+    buildValidatedCurlCommandArgs([
       "-sS",
       "--connect-timeout",
       "3",
@@ -164,7 +164,18 @@ function buildWarmCommand(model: string, hostname: string): string[] {
       body,
       `http://${hostname}:${OLLAMA_PORT}/api/generate`,
     ]),
-  ];
+    hostname,
+  );
+}
+
+function createRawOllamaCapture(
+  hostname: string,
+  capture: OllamaRuntimeRunCaptureFn,
+): OllamaRuntimeRunCaptureFn {
+  return (command, options) => {
+    const [executable, ...args] = command;
+    return capture(executable === "curl" ? getOllamaApiCommand(args, hostname) : command, options);
+  };
 }
 
 function validateWarmResponse(stdout: string): "ok" | "ollama-error" | "invalid-response" {
@@ -209,9 +220,10 @@ export function maybeWarmOllamaAfterDaemonRestart(
   const getOllamaHost = deps.getOllamaHost ?? getResolvedOllamaHost;
   const rawHost = resolveRawOllamaHost(route.endpointUrl, getOllamaHost);
   const probe = deps.probeRuntimeModelStatus ?? probeOllamaRuntimeModelStatus;
+  const rawCapture = createRawOllamaCapture(rawHost, deps.runCaptureImpl ?? runCapture);
   let status: OllamaRuntimeModelStatus;
   try {
-    status = probe(model, () => rawHost, deps.runCaptureImpl);
+    status = probe(model, () => rawHost, rawCapture);
   } catch {
     return { kind: "skipped", reason: "unreachable" };
   }
@@ -239,7 +251,7 @@ export function maybeWarmOllamaAfterDaemonRestart(
     // an unreadable inventory keeps the original warm-failure reason.
     if (response === "ollama-error") {
       const probeInventory = deps.probeModelInventory ?? probeOllamaEndpointInventory;
-      const inventory = probeInventory(rawHost, deps.runCaptureImpl);
+      const inventory = probeInventory(rawHost, rawCapture);
       if (inventory && !ollamaInventoryContainsModel(inventory, model)) {
         return {
           kind: "skipped",

src/lib/actions/sandbox/destroy.ts

@@ -22,6 +22,7 @@ import {
   revokeHttpsPinRuntimeAdapterRoute,
 } from "../../inference/https-pin-runtime-adapter";
 import { prepareManagedLlamaCppRuntimeCleanupForSandbox } from "../../inference/local-model-profile/cleanup";
+import type { OllamaUnloadResult } from "../../inference/ollama/proxy";
 import {
   CURRENT_RUNTIME_PROVIDER_BUNDLES,
   normalizeRuntimeProviderIdentity,
@@ -165,8 +166,8 @@ type RunOpenshell = (args: string[], opts?: Record<string, unknown>) => { status
 
 export type CleanupSandboxServicesDeps = {
   getSandbox?: typeof registry.getSandbox;
-  stopAll?: (opts: { sandboxName: string }) => void;
-  unloadOllamaModels?: () => void;
+  stopAll?: (opts: { sandboxName: string }) => OllamaUnloadResult | void;
+  unloadOllamaModels?: () => OllamaUnloadResult | void;
   runOpenshell?: RunOpenshell;
   rmSync?: typeof fs.rmSync;
   stopGooglechatWebhookTunnel?: (sandboxName: string) => string;
@@ -227,17 +228,17 @@ export function cleanupSandboxServices(
     deps.stopAll ??
     ((opts: { sandboxName: string }) => {
       const services = require("../../tunnel/services") as {
-        stopAll: (opts: { sandboxName: string }) => void;
+        stopAll: (opts: { sandboxName: string }) => OllamaUnloadResult | void;
       };
-      services.stopAll(opts);
+      return services.stopAll(opts);
     });
   const unloadOllamaModels =
     deps.unloadOllamaModels ??
     (() => {
       const { unloadOllamaModels: unload } = require("../../inference/ollama/proxy") as {
-        unloadOllamaModels: () => void;
+        unloadOllamaModels: () => OllamaUnloadResult;
       };
-      unload();
+      return unload();
     });
   const runOpenshell =
     deps.runOpenshell ??
@@ -289,14 +290,28 @@ export function cleanupSandboxServices(
   if (stopHostServices) {
     // `stopAll()` already runs `unloadOllamaModels()` unconditionally —
     // see src/lib/tunnel/services.ts. Don't double-call here.
-    stopAll({ sandboxName: validatedSandboxName });
+    const cleanup = stopAll({ sandboxName: validatedSandboxName });
+    if (cleanup && !cleanup.ok) {
+      throw new Error(
+        `Sandbox host services stopped, but Ollama model cleanup failed at ${cleanup.endpoint} ` +
+          `(${cleanup.outcome}: ${cleanup.message ?? "no detail"}). The saved local route was ` +
+          "retained; repair Ollama and retry destroy.",
+      );
+    }
   } else {
     // No global stop, so `stopAll()` did not run; explicitly free Ollama
     // models for this sandbox if its provider used Ollama. Without this
     // branch a single-sandbox destroy would leave models loaded on the GPU.
     const sb = getSandbox(validatedSandboxName);
     if (sb?.provider?.includes("ollama")) {
-      unloadOllamaModels();
+      const cleanup = unloadOllamaModels();
+      if (cleanup && !cleanup.ok) {
+        throw new Error(
+          `Sandbox resources were removed, but Ollama model cleanup failed at ${cleanup.endpoint} ` +
+            `(${cleanup.outcome}: ${cleanup.message ?? "no detail"}). The saved local route was ` +
+            "retained; repair Ollama and retry destroy.",
+        );
+      }
     }
   }
 

src/lib/inference/local-windows-ollama-transport.test.ts

@@ -0,0 +1,214 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  applyOllamaRuntimeContextWindow,
+  CONTAINER_REACHABILITY_IMAGE,
+  getLocalProviderHealthCheck,
+  getOllamaHostForCleanup,
+  getOllamaModelOptions,
+  getOllamaProbeCommand,
+  getOllamaWarmupRequestCommand,
+  OLLAMA_HOST_DOCKER_INTERNAL,
+  loadPersistedOllamaHost,
+  persistResolvedOllamaHost,
+  probeOllamaModelCapabilities,
+  resetOllamaHostCache,
+  resetOllamaRuntimeContextWindowAutoState,
+  setResolvedOllamaHost,
+  validateLocalProvider,
+} from "./local";
+
+describe("Windows-host Ollama transport", () => {
+  afterEach(() => {
+    resetOllamaHostCache();
+    resetOllamaRuntimeContextWindowAutoState();
+  });
+
+  it("restores the accepted route for cleanup in a fresh process", () => {
+    const stateRoot = mkdtempSync(join(tmpdir(), "nemoclaw-ollama-host-receipt-"));
+    try {
+      setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+      persistResolvedOllamaHost(undefined, stateRoot);
+      resetOllamaHostCache();
+
+      expect(loadPersistedOllamaHost(stateRoot)).toBe(OLLAMA_HOST_DOCKER_INTERNAL);
+      expect(getOllamaHostForCleanup(stateRoot)).toBe(OLLAMA_HOST_DOCKER_INTERNAL);
+    } finally {
+      rmSync(stateRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("reads the model inventory through Docker Desktop (#10553)", () => {
+    setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+    const capture = vi.fn(() => JSON.stringify({ models: [{ name: "qwen3.5:9b" }] }));
+
+    expect(getOllamaModelOptions(capture)).toEqual(["qwen3.5:9b"]);
+    expect(capture).toHaveBeenCalledWith(
+      [
+        "docker",
+        "run",
+        "--rm",
+        CONTAINER_REACHABILITY_IMAGE,
+        "-sf",
+        "--connect-timeout",
+        "3",
+        "--max-time",
+        "5",
+        "http://host.docker.internal:11434/api/tags",
+      ],
+      { ignoreError: true },
+    );
+  });
+
+  it("builds warm-up and validation requests for Docker Desktop (#10553)", () => {
+    setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+
+    expect(getOllamaWarmupRequestCommand("qwen3.5:9b")).toEqual([
+      "docker",
+      "run",
+      "--rm",
+      CONTAINER_REACHABILITY_IMAGE,
+      "-s",
+      "--connect-timeout",
+      "10",
+      "--max-time",
+      "120",
+      "http://host.docker.internal:11434/api/generate",
+      "-H",
+      "Content-Type: application/json",
+      "-d",
+      expect.stringContaining('"model":"qwen3.5:9b"'),
+    ]);
+
+    expect(getOllamaProbeCommand("qwen3.5:9b")).toEqual([
+      "docker",
+      "run",
+      "--rm",
+      CONTAINER_REACHABILITY_IMAGE,
+      "-sS",
+      "--max-time",
+      "120",
+      "http://host.docker.internal:11434/api/generate",
+      "-H",
+      "Content-Type: application/json",
+      "-d",
+      expect.stringContaining('"model":"qwen3.5:9b"'),
+    ]);
+  });
+
+  it("validates health and container reachability through Docker Desktop (#10553)", () => {
+    setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+    const capture = vi.fn((_command: readonly string[]) => JSON.stringify({ models: [] }));
+
+    expect(getLocalProviderHealthCheck("ollama-local")).toEqual([
+      "docker",
+      "run",
+      "--rm",
+      CONTAINER_REACHABILITY_IMAGE,
+      "-sf",
+      "http://host.docker.internal:11434/api/tags",
+    ]);
+    expect(
+      validateLocalProvider(
+        "ollama-local",
+        capture,
+        () => {},
+        () => ({
+          env: {},
+          isolatedCredentialConfig: false,
+          cleanup: () => ({ ok: true }),
+        }),
+      ),
+    ).toEqual({ ok: true });
+
+    expect(capture).toHaveBeenCalledTimes(2);
+    expect(capture.mock.calls[0]?.[0]).toEqual(
+      expect.arrayContaining([
+        "docker",
+        "run",
+        "--rm",
+        CONTAINER_REACHABILITY_IMAGE,
+        "http://host.docker.internal:11434/api/tags",
+      ]),
+    );
+    expect(capture.mock.calls[1]?.[0]).toEqual(
+      expect.arrayContaining([
+        "docker",
+        "run",
+        "--rm",
+        "--add-host",
+        "host.openshell.internal:host-gateway",
+      ]),
+    );
+  });
+
+  it("checks the Hermes context window through Docker Desktop (#10553)", () => {
+    setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+    const capture = vi.fn((command: readonly string[]) =>
+      String(command.at(-1)).endsWith("/api/ps")
+        ? JSON.stringify({
+            models: [{ name: "qwen3.5:9b", context_length: 65_536, processor: "100% GPU" }],
+          })
+        : "",
+    );
+    const env: NodeJS.ProcessEnv = {};
+
+    expect(
+      applyOllamaRuntimeContextWindow("qwen3.5:9b", {
+        contextWindowFloor: 64_000,
+        env,
+        logger: { log: vi.fn(), warn: vi.fn() },
+        runCaptureImpl: capture,
+      }),
+    ).toEqual({ ok: true });
+    expect(env.NEMOCLAW_CONTEXT_WINDOW).toBe("65536");
+    expect(capture).toHaveBeenCalledOnce();
+    expect(capture.mock.calls[0]?.[0]).toEqual(
+      expect.arrayContaining(["docker", "run", "--rm", CONTAINER_REACHABILITY_IMAGE]),
+    );
+  });
+
+  it("checks model capability metadata through Docker Desktop (#10553)", () => {
+    setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+    const capture = vi.fn((_command: readonly string[]) =>
+      JSON.stringify({ capabilities: ["tools"] }),
+    );
+
+    expect(probeOllamaModelCapabilities("qwen3.5:9b", capture)).toMatchObject({
+      source: "api",
+      supportsTools: true,
+    });
+    expect(capture).toHaveBeenCalledOnce();
+    expect(capture.mock.calls[0]?.[0]).toEqual(
+      expect.arrayContaining(["docker", "run", "--rm", CONTAINER_REACHABILITY_IMAGE]),
+    );
+  });
+
+  it("keeps the Hermes context-window check fail-closed on an invalid Docker response (#10553)", () => {
+    setResolvedOllamaHost(OLLAMA_HOST_DOCKER_INTERNAL);
+    const capture = vi.fn((_command: readonly string[]) =>
+      JSON.stringify({ models: [{ name: "qwen3.5:9b", context_length: "invalid" }] }),
+    );
+
+    const result = applyOllamaRuntimeContextWindow("qwen3.5:9b", {
+      contextWindowFloor: 64_000,
+      env: {},
+      logger: { log: vi.fn(), warn: vi.fn() },
+      runCaptureImpl: capture,
+    });
+
+    expect(result).toMatchObject({
+      ok: false,
+      message: expect.stringContaining("cannot verify the required 64000-token window"),
+    });
+    expect(capture.mock.calls[0]?.[0]).toEqual(
+      expect.arrayContaining(["docker", "run", "--rm", CONTAINER_REACHABILITY_IMAGE]),
+    );
+  });
+});

src/lib/inference/local.test.ts

@@ -1212,7 +1212,8 @@ describe("local inference helpers", () => {
   it("builds a background warmup command for ollama models", () => {
     const command = getOllamaWarmupCommand("nemotron-3-nano:30b");
     expect(command).toEqual(expect.arrayContaining(["bash", "-c"]));
-    expect(command[2]).toMatch(/^nohup curl -s http:\/\/127.0.0.1:11434\/api\/generate /);
+    expect(command[2]).toContain("'--connect-timeout' '10' '--max-time' '120'");
+    expect(command[2]).toContain("http://127.0.0.1:11434/api/generate");
     expect(command[2]).toMatch(/"model":"nemotron-3-nano:30b"/);
     expect(command[2]).toMatch(/"keep_alive":"15m"/);
   });