some more menu options...

.dockerignore

@@ -3,9 +3,7 @@ ollama
 app
 macapp
 dist
-build
+llm/llama.cpp
 .env
 .cache
 test_data
-.git
-

.gitattributes

@@ -1,28 +1 @@
-llama/**/*.cpp linguist-vendored
-llama/**/*.hpp linguist-vendored
-llama/**/*.h linguist-vendored
-llama/**/*.c linguist-vendored
-llama/**/*.cu linguist-vendored
-llama/**/*.cuh linguist-vendored
-llama/**/*.m linguist-vendored
-llama/**/*.metal linguist-vendored
-
-ml/backend/**/*.c linguist-vendored
-ml/backend/**/*.h linguist-vendored
-ml/backend/**/*.cpp linguist-vendored
-ml/backend/**/*.hpp linguist-vendored
-ml/backend/**/*.cu linguist-vendored
-ml/backend/**/*.cuh linguist-vendored
-ml/backend/**/*.m linguist-vendored
-ml/backend/**/*.metal linguist-vendored
-ml/backend/**/*.comp linguist-vendored
-ml/backend/**/*.glsl linguist-vendored
-ml/backend/**/CMakeLists.txt linguist-vendored
-
-app/webview linguist-vendored
-
-llama/build-info.cpp linguist-generated
-ml/backend/ggml/ggml/src/ggml-metal/ggml-metal-embed.s linguist-generated
-
-* text=auto
-*.go text eol=lf
+llm/ext_server/* linguist-vendored

.github/ISSUE_TEMPLATE/10_bug_report.yml

@@ -9,14 +9,6 @@ body:
       description: What happened? What did you expect to happen?
     validations:
       required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant log output
-      description: Please copy and paste any relevant log output. See [Troubleshooting Guide](https://github.com/ollama/ollama/blob/main/docs/troubleshooting.mdx#how-to-troubleshoot-issues) for details.
-      render: shell
-    validations:
-      required: false
   - type: dropdown
     id: os
     attributes:

.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

@@ -21,9 +21,9 @@ jobs:
   changes:
     runs-on: ubuntu-latest
     outputs:
-      changed: ${{ steps.changes.outputs.changed }}
-      app_changed: ${{ steps.changes.outputs.app_changed }}
-      enginehash: ${{ steps.changes.outputs.enginehash }}
+      GENERATE: ${{ steps.changes.outputs.GENERATE }}
+      GENERATE_CUDA: ${{ steps.changes.outputs.GENERATE_CUDA }}
+      GENERATE_ROCM: ${{ steps.changes.outputs.GENERATE_ROCM }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -31,388 +31,289 @@ jobs:
       - id: changes
         run: |
           changed() {
-            local BASE=${{ github.event.pull_request.base.sha }}
-            local HEAD=${{ github.event.pull_request.head.sha }}
-            local MERGE_BASE=$(git merge-base $BASE $HEAD)
-            git diff-tree -r --no-commit-id --name-only "$MERGE_BASE" "$HEAD" \
-              | 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(' ')))"
+            git diff-tree -r --no-commit-id --name-only \
+              $(git merge-base ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}) \
+              ${{ github.event.pull_request.head.sha }} \
+              | xargs python3 -c "import sys; print(any([x.startswith('$1') for x in sys.argv[1:]]))"
           }
 
-          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
+          {
+            echo GENERATE=$(changed llm/)
+            echo GENERATE_CUDA=$(changed llm/)
+            echo GENERATE_ROCM=$(changed llm/)
+          } >>$GITHUB_OUTPUT
 
-  patches:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Verify patches apply cleanly
-        shell: bash
-        run: |
-          cmake -S llama/server -B "$RUNNER_TEMP/llama-server-patch-check" \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DBUILD_SHARED_LIBS=ON \
-            -DGGML_BACKEND_DL=ON \
-            -DGGML_NATIVE=OFF \
-            -DGGML_OPENMP=OFF \
-            -DGGML_CPU_ALL_VARIANTS=ON \
-            -DOLLAMA_RUNNER_DIR=
-
-  linux:
+  generate:
     needs: [changes]
-    if: needs.changes.outputs.changed == 'True'
+    if: ${{ needs.changes.outputs.GENERATE == 'True' }}
     strategy:
       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
-          - preset: ROCm
-            container: rocm/dev-ubuntu-22.04:7.2.1
-            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
-          - 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
-    runs-on: linux
-    container: ${{ matrix.container }}
-    steps:
-      - uses: actions/checkout@v4
-      - run: |
-          [ -n "${{ matrix.container }}" ] || sudo=sudo
-          $sudo apt-get update
-          # Add LunarG Vulkan SDK apt repo for Ubuntu 22.04
-          if [ "${{ matrix.preset }}" = "Vulkan" ]; then
-            $sudo apt-get install -y --no-install-recommends wget gnupg ca-certificates software-properties-common
-            wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | $sudo gpg --dearmor -o /usr/share/keyrings/lunarg-archive-keyring.gpg
-            # Use signed-by to bind the repo to the installed keyring to avoid NO_PUBKEY
-            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
-          # 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"
-  windows:
-    needs: [changes]
-    if: needs.changes.outputs.changed == 'True'
-    strategy:
-      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
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"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
-          - 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'
-        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
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'MLX CUDA 13'
-        name: Install CUDA ${{ matrix.cuda-version }}
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            $subpackages = @(${{ join(matrix.cuda-components, ', ') }}) | Foreach-Object {"${_}_${{ matrix.cuda-version }}"}
-            Start-Process -FilePath .\install.exe -ArgumentList (@("-s") + $subpackages) -NoNewWindow -Wait
-          }
-
-          $cudaPath = (Resolve-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\*").path
-          echo "$cudaPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-      - if: 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 ${{ 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 "-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:
-          path: |
-            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 }}
-      - 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"
-          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 }}"
-          }
-        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:
-      - uses: actions/checkout@v4
-      - name: check that 'go mod tidy' is clean
-        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]
+        os: [ubuntu-latest, macos-latest, windows-2019]
+        arch: [amd64, arm64]
+        exclude:
+          - os: ubuntu-latest
+            arch: arm64
+          - os: windows-2019
+            arch: arm64
     runs-on: ${{ matrix.os }}
     env:
-      CGO_ENABLED: '1'
+      GOARCH: ${{ matrix.arch }}
     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/setup-node@v4
+          go-version-file: go.mod
+          cache: true
+      - run: go get ./...
+      - run: |
+          $gopath=(get-command go).source | split-path -parent
+          $gccpath=(get-command gcc).source | split-path -parent
+          & "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Launch-VsDevShell.ps1"
+          cd $env:GITHUB_WORKSPACE
+          $env:CMAKE_SYSTEM_VERSION="10.0.22621.0"
+          $env:PATH="$gopath;$gccpath;$env:PATH"
+          echo $env:PATH
+          go generate -x ./...
+        if: ${{ startsWith(matrix.os, 'windows-') }}
+        name: 'Windows Go Generate'
+      - run: go generate -x ./...
+        if: ${{ ! startsWith(matrix.os, 'windows-') }}
+        name: 'Unix Go Generate'
+      - uses: actions/upload-artifact@v4
         with:
-          node-version: '20'
-      - name: Install UI dependencies
-        working-directory: ./app/ui/app
-        run: npm ci
-      - name: Install tscriptify
+          name: ${{ matrix.os }}-${{ matrix.arch }}-libraries
+          path: |
+            llm/build/**/bin/*
+            llm/build/**/*.a
+  generate-cuda:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.GENERATE_CUDA == 'True' }}
+    strategy:
+      matrix:
+        cuda-version:
+          - '11.8.0'
+    runs-on: linux
+    container: nvidia/cuda:${{ matrix.cuda-version }}-devel-ubuntu20.04
+    steps:
+      - run: |
+          apt-get update && apt-get install -y git build-essential curl
+          curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.28.1/cmake-3.28.1-linux-x86_64.tar.gz \
+            | tar -zx -C /usr --strip-components 1
+        env:
+          DEBIAN_FRONTEND: noninteractive
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v4
+        with:
+          go-version-file: go.mod
+          cache: true
+      - run: go get ./...
+      - run: |
+          git config --global --add safe.directory /__w/ollama/ollama
+          go generate -x ./...
+        env:
+          OLLAMA_SKIP_CPU_GENERATE: '1'
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cuda-${{ matrix.cuda-version }}-libraries
+          path: |
+            llm/build/**/bin/*
+            dist/windows-amd64/**
+  generate-rocm:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.GENERATE_ROCM == 'True' }}
+    strategy:
+      matrix:
+        rocm-version:
+          - '6.0.2'
+    runs-on: linux
+    container: rocm/dev-ubuntu-20.04:${{ matrix.rocm-version }}
+    steps:
+      - run: |
+          apt-get update && apt-get install -y git build-essential curl rocm-libs
+          curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.28.1/cmake-3.28.1-linux-x86_64.tar.gz \
+            | tar -zx -C /usr --strip-components 1
+        env:
+          DEBIAN_FRONTEND: noninteractive
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v4
+        with:
+          go-version-file: go.mod
+          cache: true
+      - run: go get ./...
+      - run: |
+          git config --global --add safe.directory /__w/ollama/ollama
+          go generate -x ./...
+        env:
+          OLLAMA_SKIP_CPU_GENERATE: '1'
+      - uses: actions/upload-artifact@v4
+        with:
+          name: rocm-${{ matrix.rocm-version }}-libraries
+          path: |
+            llm/build/**/bin/*
+            dist/windows-amd64/**
+
+  # ROCm generation step
+  generate-windows-rocm:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.GENERATE_ROCM == 'True' }}
+    runs-on: windows
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+      - name: 'Install ROCm'
         run: |
-          go install github.com/tkrajina/typescriptify-golang-structs/tscriptify@latest
-      - name: Run UI tests
-        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') }}
+          $ErrorActionPreference = "Stop"
+          write-host "downloading AMD HIP Installer"
+          Invoke-WebRequest -Uri "https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-23.Q4-WinSvr2022-For-HIP.exe" -OutFile "${env:RUNNER_TEMP}\rocm-install.exe"
+          write-host "Installing AMD HIP"
+          Start-Process "${env:RUNNER_TEMP}\rocm-install.exe" -ArgumentList '-install' -NoNewWindow -Wait
+          write-host "Completed AMD HIP"
+      - name: 'Verify ROCm'
         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 ./...
+          & 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' --version
+      - run: go get ./...
+      - run: |
+          $gopath=(get-command go).source | split-path -parent
+          & "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Launch-VsDevShell.ps1"
+          cd $env:GITHUB_WORKSPACE
+          $env:CMAKE_SYSTEM_VERSION="10.0.22621.0"
+          $env:PATH="$gopath;$env:PATH"
+          $env:OLLAMA_SKIP_CPU_GENERATE="1"
+          $env:HIP_PATH=$(Resolve-Path 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' | split-path | split-path)
+          go generate -x ./...
+        name: go generate
+        env:
+          OLLAMA_SKIP_CPU_GENERATE: '1'
+      # TODO - do we need any artifacts?
 
-      - name: go test
-        if: always()
-        run: go test -count=1 -benchtime=1x ./...
+  # CUDA generation step
+  generate-windows-cuda:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.GENERATE_CUDA == 'True' }}
+    runs-on: windows
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+      - name: 'Install CUDA'
+        run: |
+          $ErrorActionPreference = "Stop"
+          write-host "downloading CUDA Installer"
+          Invoke-WebRequest -Uri "https://developer.download.nvidia.com/compute/cuda/11.3.1/local_installers/cuda_11.3.1_465.89_win10.exe" -OutFile "${env:RUNNER_TEMP}\cuda-install.exe"
+          write-host "Installing CUDA"
+          Start-Process "${env:RUNNER_TEMP}\cuda-install.exe" -ArgumentList '-s' -NoNewWindow -Wait
+          write-host "Completed CUDA"
+          $cudaPath=((resolve-path "c:\Program Files\NVIDIA*\CUDA\v*\bin\nvcc.exe")[0].path | split-path | split-path)
+          $cudaVer=($cudaPath | split-path -leaf ) -replace 'v(\d+).(\d+)', '$1_$2' 
+          echo "$cudaPath\bin" >> $env:GITHUB_PATH
+          echo "CUDA_PATH=$cudaPath" >> $env:GITHUB_ENV
+          echo "CUDA_PATH_V${cudaVer}=$cudaPath" >> $env:GITHUB_ENV
+          echo "CUDA_PATH_VX_Y=CUDA_PATH_V${cudaVer}" >> $env:GITHUB_ENV
+      - name: 'Verify CUDA'
+        run: nvcc -V
+      - run: go get ./...
+      - name: go generate
+        run: |
+          $gopath=(get-command go).source | split-path -parent
+          $cudabin=(get-command nvcc).source | split-path
+          & "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Launch-VsDevShell.ps1"
+          cd $env:GITHUB_WORKSPACE
+          $env:CMAKE_SYSTEM_VERSION="10.0.22621.0"
+          $env:PATH="$gopath;$cudabin;$env:PATH"
+          $env:OLLAMA_SKIP_CPU_GENERATE="1"
+          go generate -x ./...
+        env:
+          OLLAMA_SKIP_CPU_GENERATE: '1'
+      # TODO - do we need any artifacts?
 
-      - 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
+  lint:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-2019]
+        arch: [amd64, arm64]
+        exclude:
+          - os: ubuntu-latest
+            arch: arm64
+          - os: windows-2019
+            arch: arm64
+          - os: macos-latest
+            arch: amd64
+    runs-on: ${{ matrix.os }}
+    env:
+      GOARCH: ${{ matrix.arch }}
+      CGO_ENABLED: '1'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: false
+      - run: |
+          case ${{ matrix.arch }} in
+            amd64) echo ARCH=x86_64 ;;
+            arm64) echo ARCH=arm64 ;;
+          esac >>$GITHUB_ENV
+        shell: bash
+      - run: |
+          mkdir -p llm/build/linux/$ARCH/stub/bin
+          touch llm/build/linux/$ARCH/stub/bin/ollama_llama_server
+        if: ${{ startsWith(matrix.os, 'ubuntu-') }}
+      - run: |
+          mkdir -p llm/build/darwin/$ARCH/stub/bin
+          touch llm/build/darwin/$ARCH/stub/bin/ollama_llama_server
+        if: ${{ startsWith(matrix.os, 'macos-') }}
+      - uses: golangci/golangci-lint-action@v4
+        with:
+          args: --timeout 8m0s -v
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-2019]
+        arch: [amd64]
+        exclude:
+          - os: ubuntu-latest
+            arch: arm64
+          - os: windows-2019
+            arch: arm64
+    runs-on: ${{ matrix.os }}
+    env:
+      GOARCH: ${{ matrix.arch }}
+      CGO_ENABLED: '1'
+      OLLAMA_CPU_TARGET: 'static'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+      - run: |
+          case ${{ matrix.arch }} in
+            amd64) echo ARCH=x86_64 ;;
+            arm64) echo ARCH=arm64 ;;
+          esac >>$GITHUB_ENV
+        shell: bash
+      - run: |
+          mkdir -p llm/build/linux/$ARCH/stub/bin
+          touch llm/build/linux/$ARCH/stub/bin/ollama_llama_server
+        if: ${{ startsWith(matrix.os, 'ubuntu-') }}
+      - run: |
+          mkdir -p llm/build/darwin/$ARCH/stub/bin
+          touch llm/build/darwin/$ARCH/stub/bin/ollama_llama_server
+        if: ${{ startsWith(matrix.os, 'macos-') }}
+        shell: bash
+      - run: go generate ./...
+      - run: go build
+      - run: go test -v ./...
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.os }}-binaries
+          path: ollama

.gitignore

@@ -4,15 +4,11 @@
 .venv
 .swp
 dist
-build
+ollama
+ggml-metal.metal
 .cache
-.gocache
 *.exe
 .idea
 test_data
 *.crt
-__debug_bin*
-llama/build
-llama/vendor
-/ollama
-integration/testdata/models/
+llm/build

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "llama.cpp"]
+	path = llm/llama.cpp
+	url = https://github.com/ggerganov/llama.cpp.git
+	shallow = true

.golangci.yaml

@@ -1,51 +1,17 @@
-version: "2"
+run:
+  timeout: 5m
 linters:
   enable:
     - asasalint
     - bidichk
     - bodyclose
     - containedctx
+    - contextcheck
+    - exportloopref
     - gocheckcompilerdirectives
-    - intrange
-    - makezero
+    # FIXME: for some reason this errors on windows
+    # - gofmt
+    # - goimports
     - misspell
     - nilerr
-    - nolintlint
-    - nosprintfhostport
-    - unconvert
-    - usetesting
-    - wastedassign
-    - whitespace
-  disable:
-    - errcheck
-    - usestdlibvars
-  settings:
-    govet:
-      disable:
-        - unusedresult
-    staticcheck:
-      checks:
-        - all
-        - -QF* # disable quick fix suggestions
-        - -SA1019
-        - -ST1000 # package comment format
-        - -ST1003 # underscores in package names
-        - -ST1005 # error strings should not be capitalized
-        - -ST1012 # error var naming (ErrFoo)
-        - -ST1016 # receiver name consistency
-        - -ST1020 # comment on exported function format
-        - -ST1021 # comment on exported type format
-        - -ST1022 # comment on exported var format
-        - -ST1023 # omit type from declaration
-severity:
-  default: error
-  rules:
-    - linters:
-        - gofmt
-        - goimports
-        - intrange
-      severity: info
-formatters:
-  enable:
-    - gofmt
-    - gofumpt
+    - unused

.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "singleQuote": true,
+  "jsxSingleQuote": true,
+  "printWidth": 120,
+  "arrowParens": "avoid"
+}

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,70 +0,0 @@
-cmake_minimum_required(VERSION 3.24)
-
-project(Ollama C CXX)
-
-# Handle cross-compilation on macOS: when CMAKE_OSX_ARCHITECTURES is set to a
-# single architecture different from the host, override CMAKE_SYSTEM_PROCESSOR
-# to match. This is necessary because CMAKE_SYSTEM_PROCESSOR defaults to the
-# host architecture, but downstream projects (like MLX) use it to detect the
-# target architecture.
-if(CMAKE_OSX_ARCHITECTURES AND NOT CMAKE_OSX_ARCHITECTURES MATCHES ";")
-    # Single architecture specified
-    if(CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" AND NOT CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-        message(STATUS "Cross-compiling for x86_64: overriding CMAKE_SYSTEM_PROCESSOR from ${CMAKE_SYSTEM_PROCESSOR} to x86_64")
-        set(CMAKE_SYSTEM_PROCESSOR "x86_64")
-    elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "arm64" AND NOT CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
-        message(STATUS "Cross-compiling for arm64: overriding CMAKE_SYSTEM_PROCESSOR from ${CMAKE_SYSTEM_PROCESSOR} to arm64")
-        set(CMAKE_SYSTEM_PROCESSOR "arm64")
-    endif()
-endif()
-
-include(CheckLanguage)
-include(GNUInstallDirs)
-
-find_package(Threads REQUIRED)
-
-if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
-endif()
-
-# These defaults can be overridden by presets (e.g., for static macOS llama-server builds)
-if(NOT DEFINED BUILD_SHARED_LIBS)
-    set(BUILD_SHARED_LIBS ON)
-endif()
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS ON) # Recent versions of MLX require 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/.
-
-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(CMAKE_RUNTIME_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})
-
-if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/llama/server/CMakeLists.txt")
-    set(OLLAMA_HAVE_LLAMA_SERVER TRUE)
-else()
-    set(OLLAMA_HAVE_LLAMA_SERVER FALSE)
-endif()
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/local.cmake)

CMakePresets.json

@@ -1,33 +0,0 @@
-{
-  "version": 3,
-  "configurePresets": [
-    {
-      "name": "Default",
-      "binaryDir": "${sourceDir}/build",
-      "installDir": "${sourceDir}/dist",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_MSVC_RUNTIME_LIBRARY": "MultiThreaded"
-      }
-    },
-    {
-      "name": "MLX Metal",
-      "inherits": [ "Default" ],
-      "cacheVariables": {
-        "OLLAMA_MLX_BACKENDS": "metal_v3;metal_v4"
-      }
-    }
-  ],
-  "buildPresets": [
-    {
-      "name": "Default",
-      "configurePreset": "Default",
-      "configuration": "Release"
-    },
-    {
-      "name": "MLX Metal",
-      "targets": [ "ollama-mlx-backends" ],
-      "configurePreset": "MLX Metal"
-    }
-  ]
-}

CONTRIBUTING.md

@@ -1,88 +0,0 @@
-# Contributing to Ollama
-
-Thank you for your interest in contributing to Ollama! Here are a few guidelines to help get you started.
-
-## Set up
-
-See the [development documentation](./docs/development.md) for instructions on how to build and run Ollama locally.
-
-### Ideal issues
-
-* [Bugs](https://github.com/ollama/ollama/issues?q=is%3Aissue+is%3Aopen+label%3Abug): issues where Ollama stops working or where it results in an unexpected error.
-* [Performance](https://github.com/ollama/ollama/issues?q=is%3Aissue+is%3Aopen+label%3Aperformance): issues to make Ollama faster at model inference, downloading or uploading.
-* [Security](https://github.com/ollama/ollama/blob/main/SECURITY.md): issues that could lead to a security vulnerability. As mentioned in [SECURITY.md](https://github.com/ollama/ollama/blob/main/SECURITY.md), please do not disclose security vulnerabilities publicly.
-
-### Issues that are harder to review
-
-* New features: new features (e.g. API fields, environment variables) add surface area to Ollama and make it harder to maintain in the long run as they cannot be removed without potentially breaking users in the future.
-* Refactoring: large code improvements are important, but can be harder or take longer to review and merge.
-* Documentation: small updates to fill in or correct missing documentation are helpful, however large documentation additions can be hard to maintain over time.
-
-### Issues that may not be accepted
-
-* Changes that break backwards compatibility in Ollama's API (including the OpenAI-compatible API)
-* Changes that add significant friction to the user experience
-* Changes that create a large future maintenance burden for maintainers and contributors
-
-## Proposing a (non-trivial) change
-
-> By "non-trivial", we mean a change that is not a bug fix or small
-> documentation update. If you are unsure, please ask us on our [Discord
-> server](https://discord.gg/ollama).
-
-Before opening a non-trivial Pull Request, please open an issue to discuss the change and
-get feedback from the maintainers. This helps us understand the context of the
-change and how it fits into Ollama's roadmap and prevents us from duplicating
-work or you from spending time on a change that we may not be able to accept.
-
-Tips for proposals:
-
-* Explain the problem you are trying to solve, not what you are trying to do.
-* Explain why the change is important.
-* Explain how the change will be used.
-* Explain how the change will be tested.
-
-Additionally, for bonus points: Provide draft documentation you would expect to
-see if the changes were accepted.
-
-## Pull requests
-
-**Commit messages**
-
-The title should look like:
-
-    <package>: <short description>
-
-The package is the most affected Go package. If the change does not affect Go
-code, then use the directory name instead. Changes to a single well-known
-file in the root directory may use the file name.
-
-The short description should start with a lowercase letter and be a
-continuation of the sentence:
-
-      "This changes Ollama to..."
-
-Examples:
-
-      llm/backend/mlx: support the llama architecture
-      CONTRIBUTING: provide clarity on good commit messages, and bad
-
-Bad Examples:
-
-      feat: add more emoji
-      fix: was not using famous web framework
-      chore: generify code
-
-**Tests**
-
-Please include tests. Strive to test behavior, not implementation.
-
-**New dependencies**
-
-Dependencies should be added sparingly. If you are adding a new dependency,
-please explain why it is necessary and what other ways you attempted that
-did not work without it.
-
-## Need help?
-
-If you need help with anything, feel free to reach out to us on our [Discord server](https://discord.gg/ollama).

Dockerfile

@@ -1,320 +1,144 @@
-# vim: filetype=dockerfile
+ARG GOLANG_VERSION=1.22.1
+ARG CMAKE_VERSION=3.22.1
+# this CUDA_VERSION corresponds with the one specified in docs/gpu.md
+ARG CUDA_VERSION=11.3.1
+ARG ROCM_VERSION=6.0.2
 
-ARG FLAVOR=${TARGETARCH}
+# Copy the minimal context we need to run the generate scripts
+FROM scratch AS llm-code
+COPY .git .git
+COPY .gitmodules .gitmodules
+COPY llm llm
 
-ARG ROCMVERSION=7.2.1
-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
-
-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 \
-    && 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
-
-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 \
-    && 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-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-12-deps
-ARG CUDA12VERSION=12.8
-RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
-ENV PATH=/usr/local/cuda-12/bin:$PATH
-
-FROM base AS cuda-13-deps
-ARG CUDA13VERSION=13.0
-RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
-ENV PATH=/usr/local/cuda-13/bin:$PATH
-
-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
-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
-
-FROM scratch AS publish-llama-server-cpu
-COPY --from=llama-server-cpu dist/lib/ollama /lib/ollama/
-
-FROM cuda-12-deps AS llama-server-cuda_v12
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_v12_linux \
-        && cmake --build build/llama-server-cuda_v12 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_v12 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_v12
-COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
-
-FROM cuda-13-deps AS llama-server-cuda_v13
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_v13_linux \
-        && cmake --build build/llama-server-cuda_v13 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_v13 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_v13
-COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
-
-FROM rocm-7-deps AS llama-server-rocm_v7_2
-ENV CC=clang CXX=clang++ 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
-#
-
-FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK5VERSION} AS jetpack-5
-ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache git unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_jetpack5 \
-        && cmake --build build/llama-server-cuda_jetpack5 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_jetpack5 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_jetpack5
-COPY --from=jetpack-5 dist/lib/ollama /lib/ollama/
-
-FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK6VERSION} AS jetpack-6
-ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache git unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_jetpack6 \
-        && cmake --build build/llama-server-cuda_jetpack6 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_jetpack6 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_jetpack6
-COPY --from=jetpack-6 dist/lib/ollama /lib/ollama/
-
-#
-# MLX stage
-#
-
-FROM base AS mlx
-ARG CUDA13VERSION=13.0
-ARG OLLAMA_MLX_BUILD_JOBS=
-ARG OLLAMA_MLX_NVCC_THREADS=2
-ARG MLX_CUDA_RAM_MB=
-RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-} \
-    && dnf install -y openblas-devel lapack-devel \
-    && dnf install -y libcudnn9-cuda-13 libcudnn9-devel-cuda-13 \
-    && dnf install -y libnccl libnccl-devel
-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"
-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 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
-#
-
-FROM base AS build
-WORKDIR /go/src/github.com/ollama/ollama
-COPY go.mod go.sum .
-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
-COPY . .
-ARG GOFLAGS="'-ldflags=-w -s'"
-ENV CGO_ENABLED=1
+FROM --platform=linux/amd64 nvidia/cuda:$CUDA_VERSION-devel-centos7 AS cuda-build-amd64
+ARG CMAKE_VERSION
+COPY ./scripts/rh_linux_deps.sh /
+RUN CMAKE_VERSION=${CMAKE_VERSION} sh /rh_linux_deps.sh
+ENV PATH /opt/rh/devtoolset-10/root/usr/bin:$PATH
+COPY --from=llm-code / /go/src/github.com/ollama/ollama/
+WORKDIR /go/src/github.com/ollama/ollama/llm/generate
 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 .
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_SKIP_CPU_GENERATE=1 sh gen_linux.sh
 
-FROM scratch AS publish-go
-COPY --from=build /bin/ollama /bin/ollama
+FROM --platform=linux/arm64 nvidia/cuda:$CUDA_VERSION-devel-rockylinux8 AS cuda-build-arm64
+ARG CMAKE_VERSION
+COPY ./scripts/rh_linux_deps.sh /
+RUN CMAKE_VERSION=${CMAKE_VERSION} sh /rh_linux_deps.sh
+ENV PATH /opt/rh/gcc-toolset-10/root/usr/bin:$PATH
+COPY --from=llm-code / /go/src/github.com/ollama/ollama/
+WORKDIR /go/src/github.com/ollama/ollama/llm/generate
+ARG CGO_CFLAGS
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_SKIP_CPU_GENERATE=1 sh gen_linux.sh
 
-#
-# Assembly stages — combine llama-server variants + GPU runtime libs
-#
+FROM --platform=linux/amd64 rocm/dev-centos-7:${ROCM_VERSION}-complete AS rocm-build-amd64
+ARG CMAKE_VERSION
+COPY ./scripts/rh_linux_deps.sh /
+RUN CMAKE_VERSION=${CMAKE_VERSION} sh /rh_linux_deps.sh
+ENV PATH /opt/rh/devtoolset-10/root/usr/bin:$PATH
+ENV LIBRARY_PATH /opt/amdgpu/lib64
+COPY --from=llm-code / /go/src/github.com/ollama/ollama/
+WORKDIR /go/src/github.com/ollama/ollama/llm/generate
+ARG CGO_CFLAGS
+ARG AMDGPU_TARGETS
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_SKIP_CPU_GENERATE=1 sh gen_linux.sh
+RUN mkdir /tmp/scratch && \
+    for dep in $(zcat /go/src/github.com/ollama/ollama/llm/build/linux/x86_64/rocm*/bin/deps.txt.gz) ; do \
+        cp ${dep} /tmp/scratch/ || exit 1 ; \
+    done && \
+    (cd /opt/rocm/lib && tar cf - rocblas/library) | (cd /tmp/scratch/ && tar xf - ) && \
+    mkdir -p /go/src/github.com/ollama/ollama/dist/deps/ && \
+    (cd /tmp/scratch/ && tar czvf /go/src/github.com/ollama/ollama/dist/deps/ollama-linux-amd64-rocm.tgz . )
 
-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=mlx     /go/src/github.com/ollama/ollama/dist/lib/ollama /lib/ollama/
 
-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=jetpack-5 dist/lib/ollama/ /lib/ollama/
-COPY --from=jetpack-6 dist/lib/ollama/ /lib/ollama/
+FROM --platform=linux/amd64 centos:7 AS cpu-builder-amd64
+ARG CMAKE_VERSION
+ARG GOLANG_VERSION
+COPY ./scripts/rh_linux_deps.sh /
+RUN CMAKE_VERSION=${CMAKE_VERSION} GOLANG_VERSION=${GOLANG_VERSION} sh /rh_linux_deps.sh
+ENV PATH /opt/rh/devtoolset-10/root/usr/bin:$PATH
+COPY --from=llm-code / /go/src/github.com/ollama/ollama/
+ARG OLLAMA_CUSTOM_CPU_DEFS
+ARG CGO_CFLAGS
+WORKDIR /go/src/github.com/ollama/ollama/llm/generate
 
-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
+FROM --platform=linux/amd64 cpu-builder-amd64 AS static-build-amd64
+RUN OLLAMA_CPU_TARGET="static" sh gen_linux.sh
+FROM --platform=linux/amd64 cpu-builder-amd64 AS cpu-build-amd64
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_CPU_TARGET="cpu" sh gen_linux.sh
+FROM --platform=linux/amd64 cpu-builder-amd64 AS cpu_avx-build-amd64
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_CPU_TARGET="cpu_avx" sh gen_linux.sh
+FROM --platform=linux/amd64 cpu-builder-amd64 AS cpu_avx2-build-amd64
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_CPU_TARGET="cpu_avx2" sh gen_linux.sh
 
-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 centos:7 AS cpu-builder-arm64
+ARG CMAKE_VERSION
+ARG GOLANG_VERSION
+COPY ./scripts/rh_linux_deps.sh /
+RUN CMAKE_VERSION=${CMAKE_VERSION} GOLANG_VERSION=${GOLANG_VERSION} sh /rh_linux_deps.sh
+ENV PATH /opt/rh/devtoolset-10/root/usr/bin:$PATH
+COPY --from=llm-code / /go/src/github.com/ollama/ollama/
+ARG OLLAMA_CUSTOM_CPU_DEFS
+ARG CGO_CFLAGS
+WORKDIR /go/src/github.com/ollama/ollama/llm/generate
 
-FROM --platform=linux/arm64 scratch AS arm64-archive
-COPY --from=arm64 /lib/ollama /lib/ollama/
+FROM --platform=linux/arm64 cpu-builder-arm64 AS static-build-arm64
+RUN OLLAMA_CPU_TARGET="static" sh gen_linux.sh
+FROM --platform=linux/arm64 cpu-builder-arm64 AS cpu-build-arm64
+RUN OLLAMA_SKIP_STATIC_GENERATE=1 OLLAMA_CPU_TARGET="cpu" sh gen_linux.sh
 
-FROM ${TARGETARCH}-archive AS archive
-COPY --from=build /bin/ollama /bin/ollama
 
-FROM ${FLAVOR} AS image-archive
-COPY --from=build /bin/ollama /bin/ollama
+# Intermediate stage used for ./scripts/build_linux.sh
+FROM --platform=linux/amd64 cpu-build-amd64 AS build-amd64
+ENV CGO_ENABLED 1
+WORKDIR /go/src/github.com/ollama/ollama
+COPY . .
+COPY --from=static-build-amd64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+COPY --from=cpu_avx-build-amd64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+COPY --from=cpu_avx2-build-amd64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+COPY --from=cuda-build-amd64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+COPY --from=rocm-build-amd64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+COPY --from=rocm-build-amd64 /go/src/github.com/ollama/ollama/dist/deps/ ./dist/deps/
+ARG GOFLAGS
+ARG CGO_CFLAGS
+RUN go build -trimpath .
 
-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 \
-    && 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
+# Intermediate stage used for ./scripts/build_linux.sh
+FROM --platform=linux/arm64 cpu-build-arm64 AS build-arm64
+ENV CGO_ENABLED 1
+ARG GOLANG_VERSION
+WORKDIR /go/src/github.com/ollama/ollama
+COPY . .
+COPY --from=static-build-arm64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+COPY --from=cuda-build-arm64 /go/src/github.com/ollama/ollama/llm/build/linux/ llm/build/linux/
+ARG GOFLAGS
+ARG CGO_CFLAGS
+RUN go build -trimpath .
+
+# Runtime stages
+FROM --platform=linux/amd64 ubuntu:22.04 as runtime-amd64
+RUN apt-get update && apt-get install -y ca-certificates
+COPY --from=build-amd64 /go/src/github.com/ollama/ollama/ollama /bin/ollama
+FROM --platform=linux/arm64 ubuntu:22.04 as runtime-arm64
+RUN apt-get update && apt-get install -y ca-certificates
+COPY --from=build-arm64 /go/src/github.com/ollama/ollama/ollama /bin/ollama
+
+# Radeon images are much larger so we keep it distinct from the CPU/CUDA image
+FROM --platform=linux/amd64 rocm/dev-centos-7:${ROCM_VERSION}-complete as runtime-rocm
+RUN update-pciids
+COPY --from=build-amd64 /go/src/github.com/ollama/ollama/ollama /bin/ollama
+EXPOSE 11434
+ENV OLLAMA_HOST 0.0.0.0
+
+ENTRYPOINT ["/bin/ollama"]
+CMD ["serve"]
+
+FROM runtime-$TARGETARCH
+EXPOSE 11434
+ENV OLLAMA_HOST 0.0.0.0
 ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-COPY --from=image-archive /lib/ollama /usr/lib/ollama
 ENV LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64
 ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility
 ENV NVIDIA_VISIBLE_DEVICES=all
-ENV OLLAMA_HOST=0.0.0.0:11434
-EXPOSE 11434
+
 ENTRYPOINT ["/bin/ollama"]
 CMD ["serve"]

LLAMA_CPP_VERSION

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

MLX_C_VERSION

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

MLX_VERSION

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

README.md

@@ -1,38 +1,28 @@
-<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"/>
-  </a>
-</p>
+<div align="center">
+  <img alt="ollama" height="200px" src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7">
+</div>
 
 # Ollama
 
-Start building with open models.
+[![Discord](https://dcbadge.vercel.app/api/server/ollama?style=flat&compact=true)](https://discord.gg/ollama)
 
-## Download
+Get up and running with large language models locally.
 
 ### macOS
 
-```shell
-curl -fsSL https://ollama.com/install.sh | sh
-```
+[Download](https://ollama.com/download/Ollama-darwin.zip)
 
-or [download manually](https://ollama.com/download/Ollama.dmg)
+### Windows preview
 
-### 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
 
-```shell
+```
 curl -fsSL https://ollama.com/install.sh | sh
 ```
 
-[Manual install instructions](https://docs.ollama.com/linux#manual-install)
+[Manual install instructions](https://github.com/ollama/ollama/blob/main/docs/linux.md)
 
 ### Docker
 
@@ -43,314 +33,355 @@ The official [Ollama Docker image](https://hub.docker.com/r/ollama/ollama) `olla
 - [ollama-python](https://github.com/ollama/ollama-python)
 - [ollama-js](https://github.com/ollama/ollama-js)
 
-### Community
+## Quickstart
 
-- [Discord](https://discord.gg/ollama)
-- [𝕏 (Twitter)](https://x.com/ollama)
-- [Reddit](https://reddit.com/r/ollama)
-
-## Get started
+To run and chat with [Llama 3](https://ollama.com/library/llama3):
 
 ```
-ollama
+ollama run llama3
 ```
 
-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:
+
+| Model              | Parameters | Size  | Download                       |
+| ------------------ | ---------- | ----- | ------------------------------ |
+| Llama 3            | 8B         | 4.7GB | `ollama run llama3`            |
+| Llama 3            | 70B        | 40GB  | `ollama run llama3:70b`        |
+| Phi-3              | 3,8B       | 2.3GB | `ollama run phi3`              |
+| Mistral            | 7B         | 4.1GB | `ollama run mistral`           |
+| 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`             |
+| Gemma              | 2B         | 1.4GB | `ollama run gemma:2b`          |
+| Gemma              | 7B         | 4.8GB | `ollama run gemma:7b`          |
+| Solar              | 10.7B      | 6.1GB | `ollama run solar`             |
+
+> 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
+
+   ```
+   ollama create example -f Modelfile
+   ```
+
+3. Run the model
+
+   ```
+   ollama run example
+   ```
+
+### Import from PyTorch or Safetensors
+
+See the [guide](docs/import.md) 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` model:
 
 ```
-ollama launch claude
+ollama pull llama3
 ```
 
-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
+
+# 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 examples, see the [examples](examples) directory. For more information on working with a Modelfile, see the [Modelfile](docs/modelfile.md) 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.
+
+```
+ollama create mymodel -f ./Modelfile
+```
+
+### Pull a model
+
+```
+ollama pull llama3
+```
+
+> This command can also be used to update a local model. Only the diff will be pulled.
+
+### Remove a model
+
+```
+ollama rm llama3
+```
+
+### Copy a model
+
+```
+ollama cp llama3 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
+
+```
+>>> What's in this image? /Users/jmorgan/Desktop/smile.png
+The image features a yellow smiley face, which is likely the central focus of the picture.
+```
+
+### Pass in prompt as arguments
+
+```
+$ ollama run llama3 "Summarize this file: $(cat README.md)"
+ 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.
+```
+
+### List models on your computer
+
+```
+ollama list
+```
+
+### Start Ollama
+
+`ollama serve` is used when you want to start ollama without running the desktop application.
+
+## Building
+
+Install `cmake` and `go`:
+
+```
+brew install cmake go
+```
+
+Then generate dependencies:
+
+```
+go generate ./...
+```
+
+Then build the binary:
+
+```
+go build .
+```
+
+More detailed instructions can be found in the [developer guide](https://github.com/ollama/ollama/blob/main/docs/development.md)
+
+### Running local builds
+
+Next, start the server:
+
+```
+./ollama serve
+```
+
+Finally, in a separate shell, run a model:
+
+```
+./ollama run llama3
+```
 
 ## REST API
 
 Ollama has a REST API for running and managing models.
 
+### Generate a response
+
 ```
-curl http://localhost:11434/api/chat -d '{
-  "model": "gemma4",
-  "messages": [{
-    "role": "user",
-    "content": "Why is the sky blue?"
-  }],
-  "stream": false
+curl http://localhost:11434/api/generate -d '{
+  "model": "llama3",
+  "prompt":"Why is the sky blue?"
 }'
 ```
 
-See the [API documentation](https://docs.ollama.com/api) for all endpoints.
-
-### Python
+### Chat with a model
 
 ```
-pip install ollama
+curl http://localhost:11434/api/chat -d '{
+  "model": "llama3",
+  "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)
+- [Enchanted (macOS native)](https://github.com/AugustDev/enchanted)
+- [Lollms-Webui](https://github.com/ParisNeo/lollms-webui)
+- [LibreChat](https://github.com/danny-avila/LibreChat)
+- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt)
+- [HTML UI](https://github.com/rtcfirefly/ollama-ui)
+- [Saddle](https://github.com/jikkuatwork/saddle)
+- [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/blob/main/docs/config-local-ollama.md)
+- [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: Progressive Web App](https://github.com/mrdjohnson/llm-x)
+- [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)
+- [QA-Pilot: Chat with Code Repository](https://github.com/reid41/QA-Pilot)
+- [ChatOllama: Open Source Chatbot based on Ollama with Knowledge Bases](https://github.com/sugarforever/chat-ollama)
+- [CRAG Ollama Chat: Simple Web Search with Corrective RAG](https://github.com/Nagi-ovo/CRAG-Ollama-Chat)
+- [RAGFlow: Open-source Retrieval-Augmented Generation engine based on deep document understanding](https://github.com/infiniflow/ragflow)
+- [chat: chat web app for teams](https://github.com/swuecho/chat)
+- [Lobe Chat](https://github.com/lobehub/lobe-chat) with [Integrating Doc](https://lobehub.com/docs/self-hosting/examples/ollama)
+- [Ollama RAG Chatbot: Local Chat with multiples PDFs using Ollama and RAG.](https://github.com/datvodinh/rag-chatbot.git)
 
-#### Web
+### Terminal
 
-- [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
+- [oterm](https://github.com/ggozad/oterm)
+- [Ellama Emacs client](https://github.com/s-kostyaev/ellama)
+- [Emacs client](https://github.com/zweifisch/ollama)
+- [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)
+- [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)
 
-#### Desktop
+### Database
 
-- [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
+- [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)
 
-#### 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
-
-- [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
+### 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)
-- [Guix channel](https://codeberg.org/tusharhero/ollama-guix)
+
+### Libraries
+
+- [LangChain](https://python.langchain.com/docs/integrations/llms/ollama) and [LangChain.js](https://js.langchain.com/docs/modules/model_io/models/llms/integrations/ollama) with [example](https://js.langchain.com/docs/use_cases/question_answering/local_retrieval_qa)
+- [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)
+- [LlamaIndex](https://gpt-index.readthedocs.io/en/stable/examples/llm/ollama.html)
+- [LiteLLM](https://github.com/BerriAI/litellm)
+- [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)
+- [Ollama4j for Java](https://github.com/amithkoujalgi/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-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/)
+
+### Mobile
+
+- [Enchanted](https://github.com/AugustDev/enchanted)
+- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid)
+
+### 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)
+- [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)
+- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using 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)
+- [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 HuggingFace)
+- [Page Assist](https://github.com/n4ze3m/page-assist) (Chrome Extension)
+- [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)
+
+### Supported backends 
+- [llama.cpp](https://github.com/ggerganov/llama.cpp) project founded by Georgi Gerganov. 

SECURITY.md

@@ -1,25 +0,0 @@
-# Security
-
-The Ollama maintainer team takes security seriously and will actively work to resolve security issues.
-
-## Reporting a vulnerability
-
-If you discover a security vulnerability, please do not open a public issue. Instead, please report it by emailing hello@ollama.com. We ask that you give us sufficient time to investigate and address the vulnerability before disclosing it publicly.
-
-Please include the following details in your report:
-- A description of the vulnerability
-- Steps to reproduce the issue
-- Your assessment of the potential impact
-- Any possible mitigations
-
-## Security best practices
-
-While the maintainer team does its best to secure Ollama, users are encouraged to implement their own security best practices, such as:
-
-- Regularly updating to the latest version of Ollama
-- Securing access to hosted instances of Ollama
-- Monitoring systems for unusual activity
-
-## Contact
-
-For any other questions or concerns related to security, please contact us at hello@ollama.com

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

@@ -1,16 +1,9 @@
 // Package api implements the client-side API for code wishing to interact
 // with the ollama service. The methods of the [Client] type correspond to
-// the ollama REST API as described in [the API documentation].
+// the ollama REST API as described in https://github.com/ollama/ollama/blob/main/docs/api.md
+//
 // The ollama command-line client itself uses this package to interact with
 // the backend service.
-//
-// # Examples
-//
-// Several examples of using this package are available [in the GitHub
-// repository].
-//
-// [the API documentation]: https://github.com/ollama/ollama/blob/main/docs/api.md
-// [in the GitHub repository]: https://github.com/ollama/ollama/tree/main/api/examples
 package api
 
 import (
@@ -18,17 +11,15 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"net/url"
+	"os"
 	"runtime"
-	"strconv"
-	"time"
+	"strings"
 
-	"github.com/ollama/ollama/auth"
-	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/format"
 	"github.com/ollama/ollama/version"
 )
@@ -45,12 +36,6 @@ func checkError(resp *http.Response, body []byte) error {
 		return nil
 	}
 
-	if resp.StatusCode == http.StatusUnauthorized {
-		authError := AuthorizationError{StatusCode: resp.StatusCode}
-		json.Unmarshal(body, &authError)
-		return authError
-	}
-
 	apiError := StatusError{StatusCode: resp.StatusCode}
 
 	err := json.Unmarshal(body, &apiError)
@@ -64,7 +49,7 @@ func checkError(resp *http.Response, body []byte) error {
 
 // ClientFromEnvironment creates a new [Client] using configuration from the
 // environment variable OLLAMA_HOST, which points to the network host and
-// port on which the ollama service is listening. The format of this variable
+// port on which the ollama service is listenting. The format of this variable
 // is:
 //
 //	<scheme>://<host>:<port>
@@ -72,8 +57,36 @@ func checkError(resp *http.Response, body []byte) error {
 // If the variable is not specified, a default ollama host and port will be
 // used.
 func ClientFromEnvironment() (*Client, error) {
+	defaultPort := "11434"
+
+	scheme, hostport, ok := strings.Cut(os.Getenv("OLLAMA_HOST"), "://")
+	switch {
+	case !ok:
+		scheme, hostport = "http", os.Getenv("OLLAMA_HOST")
+	case scheme == "http":
+		defaultPort = "80"
+	case scheme == "https":
+		defaultPort = "443"
+	}
+
+	// trim trailing slashes
+	hostport = strings.TrimRight(hostport, "/")
+
+	host, port, err := net.SplitHostPort(hostport)
+	if err != nil {
+		host, port = "127.0.0.1", defaultPort
+		if ip := net.ParseIP(strings.Trim(hostport, "[]")); ip != nil {
+			host = ip.String()
+		} else if hostport != "" {
+			host = hostport
+		}
+	}
+
 	return &Client{
-		base: envconfig.Host(),
+		base: &url.URL{
+			Scheme: scheme,
+			Host:   net.JoinHostPort(host, port),
+		},
 		http: http.DefaultClient,
 	}, nil
 }
@@ -85,14 +98,6 @@ func NewClient(base *url.URL, http *http.Client) *Client {
 	}
 }
 
-func getAuthorizationToken(ctx context.Context, challenge string) (string, error) {
-	token, err := auth.Sign(ctx, []byte(challenge))
-	if err != nil {
-		return "", err
-	}
-	return token, nil
-}
-
 func (c *Client) do(ctx context.Context, method, path string, reqData, respData any) error {
 	var reqBody io.Reader
 	var data []byte
@@ -114,21 +119,6 @@ func (c *Client) do(ctx context.Context, method, path string, reqData, respData
 	}
 
 	requestURL := c.base.JoinPath(path)
-
-	var token string
-	if envconfig.UseAuth() || c.base.Hostname() == "ollama.com" {
-		now := strconv.FormatInt(time.Now().Unix(), 10)
-		chal := fmt.Sprintf("%s,%s?ts=%s", method, path, now)
-		token, err = getAuthorizationToken(ctx, chal)
-		if err != nil {
-			return err
-		}
-
-		q := requestURL.Query()
-		q.Set("ts", now)
-		requestURL.RawQuery = q.Encode()
-	}
-
 	request, err := http.NewRequestWithContext(ctx, method, requestURL.String(), reqBody)
 	if err != nil {
 		return err
@@ -138,10 +128,6 @@ func (c *Client) do(ctx context.Context, method, path string, reqData, respData
 	request.Header.Set("Accept", "application/json")
 	request.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))
 
-	if token != "" {
-		request.Header.Set("Authorization", token)
-	}
-
 	respObj, err := c.http.Do(request)
 	if err != nil {
 		return err
@@ -165,10 +151,10 @@ func (c *Client) do(ctx context.Context, method, path string, reqData, respData
 	return nil
 }
 
-const maxBufferSize = 8 * format.MegaByte
+const maxBufferSize = 512 * format.KiloByte
 
 func (c *Client) stream(ctx context.Context, method, path string, data any, fn func([]byte) error) error {
-	var buf io.Reader
+	var buf *bytes.Buffer
 	if data != nil {
 		bts, err := json.Marshal(data)
 		if err != nil {
@@ -179,22 +165,6 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 	}
 
 	requestURL := c.base.JoinPath(path)
-
-	var token string
-	if envconfig.UseAuth() || c.base.Hostname() == "ollama.com" {
-		var err error
-		now := strconv.FormatInt(time.Now().Unix(), 10)
-		chal := fmt.Sprintf("%s,%s?ts=%s", method, path, now)
-		token, err = getAuthorizationToken(ctx, chal)
-		if err != nil {
-			return err
-		}
-
-		q := requestURL.Query()
-		q.Set("ts", now)
-		requestURL.RawQuery = q.Encode()
-	}
-
 	request, err := http.NewRequestWithContext(ctx, method, requestURL.String(), buf)
 	if err != nil {
 		return err
@@ -204,10 +174,6 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 	request.Header.Set("Accept", "application/x-ndjson")
 	request.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))
 
-	if token != "" {
-		request.Header.Set("Authorization", token)
-	}
-
 	response, err := c.http.Do(request)
 	if err != nil {
 		return err
@@ -220,29 +186,19 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 	scanner.Buffer(scanBuf, maxBufferSize)
 	for scanner.Scan() {
 		var errorResponse struct {
-			Error     string `json:"error,omitempty"`
-			SigninURL string `json:"signin_url,omitempty"`
+			Error string `json:"error,omitempty"`
 		}
 
 		bts := scanner.Bytes()
 		if err := json.Unmarshal(bts, &errorResponse); err != nil {
-			if response.StatusCode >= http.StatusBadRequest {
-				return StatusError{
-					StatusCode:   response.StatusCode,
-					Status:       response.Status,
-					ErrorMessage: string(bts),
-				}
-			}
-			return errors.New(string(bts))
+			return fmt.Errorf("unmarshal: %w", err)
 		}
 
-		if response.StatusCode == http.StatusUnauthorized {
-			return AuthorizationError{
-				StatusCode: response.StatusCode,
-				Status:     response.Status,
-				SigninURL:  errorResponse.SigninURL,
-			}
-		} else if response.StatusCode >= http.StatusBadRequest {
+		if errorResponse.Error != "" {
+			return fmt.Errorf(errorResponse.Error)
+		}
+
+		if response.StatusCode >= http.StatusBadRequest {
 			return StatusError{
 				StatusCode:   response.StatusCode,
 				Status:       response.Status,
@@ -250,19 +206,11 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 			}
 		}
 
-		if errorResponse.Error != "" {
-			return errors.New(errorResponse.Error)
-		}
-
 		if err := fn(bts); err != nil {
 			return err
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-
 	return nil
 }
 
@@ -324,14 +272,8 @@ func (c *Client) Pull(ctx context.Context, req *PullRequest, fn PullProgressFunc
 	})
 }
 
-// PushProgressFunc is a function that [Client.Push] invokes when progress is
-// made.
-// It's similar to other progress function types like [PullProgressFunc].
 type PushProgressFunc func(ProgressResponse) error
 
-// Push uploads a model to the model library; requires registering for ollama.ai
-// and adding a public key first. fn is called each time progress is made on
-// the request and can be used to display a progress bar, etc.
 func (c *Client) Push(ctx context.Context, req *PushRequest, fn PushProgressFunc) error {
 	return c.stream(ctx, http.MethodPost, "/api/push", req, func(bts []byte) error {
 		var resp ProgressResponse
@@ -343,15 +285,8 @@ func (c *Client) Push(ctx context.Context, req *PushRequest, fn PushProgressFunc
 	})
 }
 
-// CreateProgressFunc is a function that [Client.Create] invokes when progress
-// is made.
-// It's similar to other progress function types like [PullProgressFunc].
 type CreateProgressFunc func(ProgressResponse) error
 
-// Create creates a model from a [Modelfile]. fn is a progress function that
-// behaves similarly to other methods (see [Client.Pull]).
-//
-// [Modelfile]: https://github.com/ollama/ollama/blob/main/docs/modelfile.mdx
 func (c *Client) Create(ctx context.Context, req *CreateRequest, fn CreateProgressFunc) error {
 	return c.stream(ctx, http.MethodPost, "/api/create", req, func(bts []byte) error {
 		var resp ProgressResponse
@@ -363,7 +298,6 @@ func (c *Client) Create(ctx context.Context, req *CreateRequest, fn CreateProgre
 	})
 }
 
-// List lists models that are available locally.
 func (c *Client) List(ctx context.Context) (*ListResponse, error) {
 	var lr ListResponse
 	if err := c.do(ctx, http.MethodGet, "/api/tags", nil, &lr); err != nil {
@@ -372,27 +306,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
-	if err := c.do(ctx, http.MethodGet, "/api/ps", nil, &lr); err != nil {
-		return nil, err
-	}
-	return &lr, nil
-}
-
-// Copy copies a model - creating a model with another name from an existing
-// model.
 func (c *Client) Copy(ctx context.Context, req *CopyRequest) error {
 	if err := c.do(ctx, http.MethodPost, "/api/copy", req, nil); err != nil {
 		return err
@@ -400,7 +313,6 @@ func (c *Client) Copy(ctx context.Context, req *CopyRequest) error {
 	return nil
 }
 
-// Delete deletes a model and its data.
 func (c *Client) Delete(ctx context.Context, req *DeleteRequest) error {
 	if err := c.do(ctx, http.MethodDelete, "/api/delete", req, nil); err != nil {
 		return err
@@ -408,7 +320,6 @@ func (c *Client) Delete(ctx context.Context, req *DeleteRequest) error {
 	return nil
 }
 
-// Show obtains model information, including details, modelfile, license etc.
 func (c *Client) Show(ctx context.Context, req *ShowRequest) (*ShowResponse, error) {
 	var resp ShowResponse
 	if err := c.do(ctx, http.MethodPost, "/api/show", req, &resp); err != nil {
@@ -417,25 +328,12 @@ func (c *Client) Show(ctx context.Context, req *ShowRequest) (*ShowResponse, err
 	return &resp, nil
 }
 
-// Heartbeat checks if the server has started and is responsive; if yes, it
-// returns nil, otherwise an error.
 func (c *Client) Heartbeat(ctx context.Context) error {
 	if err := c.do(ctx, http.MethodHead, "/", nil, nil); err != nil {
 		return err
 	}
 	return nil
 }
-
-// Embed generates embeddings from a model.
-func (c *Client) Embed(ctx context.Context, req *EmbedRequest) (*EmbedResponse, error) {
-	var resp EmbedResponse
-	if err := c.do(ctx, http.MethodPost, "/api/embed", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-// Embeddings generates an embedding from a model.
 func (c *Client) Embeddings(ctx context.Context, req *EmbeddingRequest) (*EmbeddingResponse, error) {
 	var resp EmbeddingResponse
 	if err := c.do(ctx, http.MethodPost, "/api/embeddings", req, &resp); err != nil {
@@ -444,13 +342,10 @@ func (c *Client) Embeddings(ctx context.Context, req *EmbeddingRequest) (*Embedd
 	return &resp, nil
 }
 
-// CreateBlob creates a blob from a file on the server. digest is the
-// expected SHA256 digest of the file, and r represents the file.
 func (c *Client) CreateBlob(ctx context.Context, digest string, r io.Reader) error {
 	return c.do(ctx, http.MethodPost, fmt.Sprintf("/api/blobs/%s", digest), r, nil)
 }
 
-// Version returns the Ollama server version as a string.
 func (c *Client) Version(ctx context.Context) (string, error) {
 	var version struct {
 		Version string `json:"version"`
@@ -462,51 +357,3 @@ 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)
-}
-
-// Disconnect will disconnect an ollama instance from ollama.com.
-func (c *Client) Disconnect(ctx context.Context, encodedKey string) error {
-	return c.do(ctx, http.MethodDelete, fmt.Sprintf("/api/user/keys/%s", encodedKey), nil, nil)
-}
-
-func (c *Client) Whoami(ctx context.Context) (*UserResponse, error) {
-	var resp UserResponse
-	if err := c.do(ctx, http.MethodPost, "/api/me", nil, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}

api/client_test.go

@@ -1,16 +1,6 @@
 package api
 
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-)
+import "testing"
 
 func TestClientFromEnvironment(t *testing.T) {
 	type testCase struct {
@@ -51,457 +41,3 @@ func TestClientFromEnvironment(t *testing.T) {
 		})
 	}
 }
-
-// testError represents an internal error type with status code and message
-// this is used since the error response from the server is not a standard error struct
-type testError struct {
-	message    string
-	statusCode int
-	raw        bool // if true, write message as-is instead of JSON encoding
-}
-
-func (e testError) Error() string {
-	return e.message
-}
-
-func TestClientStream(t *testing.T) {
-	testCases := []struct {
-		name      string
-		responses []any
-		wantErr   string
-	}{
-		{
-			name: "immediate error response",
-			responses: []any{
-				testError{
-					message:    "test error message",
-					statusCode: http.StatusBadRequest,
-				},
-			},
-			wantErr: "test error message",
-		},
-		{
-			name: "error after successful chunks, ok response",
-			responses: []any{
-				ChatResponse{Message: Message{Content: "partial response 1"}},
-				ChatResponse{Message: Message{Content: "partial response 2"}},
-				testError{
-					message:    "mid-stream error",
-					statusCode: http.StatusOK,
-				},
-			},
-			wantErr: "mid-stream error",
-		},
-		{
-			name: "http status error takes precedence over general error",
-			responses: []any{
-				testError{
-					message:    "custom error message",
-					statusCode: http.StatusInternalServerError,
-				},
-			},
-			wantErr: "500",
-		},
-		{
-			name: "successful stream completion",
-			responses: []any{
-				ChatResponse{Message: Message{Content: "chunk 1"}},
-				ChatResponse{Message: Message{Content: "chunk 2"}},
-				ChatResponse{
-					Message:    Message{Content: "final chunk"},
-					Done:       true,
-					DoneReason: "stop",
-				},
-			},
-		},
-		{
-			name: "plain text error response",
-			responses: []any{
-				"internal server error",
-			},
-			wantErr: "internal server error",
-		},
-		{
-			name: "HTML error page",
-			responses: []any{
-				"<html><body>404 Not Found</body></html>",
-			},
-			wantErr: "404 Not Found",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				flusher, ok := w.(http.Flusher)
-				if !ok {
-					t.Fatal("expected http.Flusher")
-				}
-
-				w.Header().Set("Content-Type", "application/x-ndjson")
-
-				for _, resp := range tc.responses {
-					if errResp, ok := resp.(testError); ok {
-						w.WriteHeader(errResp.statusCode)
-						err := json.NewEncoder(w).Encode(map[string]string{
-							"error": errResp.message,
-						})
-						if err != nil {
-							t.Fatal("failed to encode error response:", err)
-						}
-						return
-					}
-
-					if str, ok := resp.(string); ok {
-						fmt.Fprintln(w, str)
-						flusher.Flush()
-						continue
-					}
-
-					if err := json.NewEncoder(w).Encode(resp); err != nil {
-						t.Fatalf("failed to encode response: %v", err)
-					}
-					flusher.Flush()
-				}
-			}))
-			defer ts.Close()
-
-			client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
-
-			var receivedChunks []ChatResponse
-			err := client.stream(t.Context(), http.MethodPost, "/v1/chat", nil, func(chunk []byte) error {
-				var resp ChatResponse
-				if err := json.Unmarshal(chunk, &resp); err != nil {
-					return fmt.Errorf("failed to unmarshal chunk: %w", err)
-				}
-				receivedChunks = append(receivedChunks, resp)
-				return nil
-			})
-
-			if tc.wantErr != "" {
-				if err == nil {
-					t.Fatal("expected error but got nil")
-				}
-				if !strings.Contains(err.Error(), tc.wantErr) {
-					t.Errorf("expected error containing %q, got %v", tc.wantErr, err)
-				}
-				return
-			}
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-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
-		response       any
-		wantErr        string
-		wantStatusCode int
-	}{
-		{
-			name: "immediate error response",
-			response: testError{
-				message:    "test error message",
-				statusCode: http.StatusBadRequest,
-			},
-			wantErr:        "test error message",
-			wantStatusCode: http.StatusBadRequest,
-		},
-		{
-			name: "server error response",
-			response: testError{
-				message:    "internal error",
-				statusCode: http.StatusInternalServerError,
-			},
-			wantErr:        "internal error",
-			wantStatusCode: http.StatusInternalServerError,
-		},
-		{
-			name: "successful response",
-			response: struct {
-				ID      string `json:"id"`
-				Success bool   `json:"success"`
-			}{
-				ID:      "msg_123",
-				Success: true,
-			},
-		},
-		{
-			name: "plain text error response",
-			response: testError{
-				message:    "internal server error",
-				statusCode: http.StatusInternalServerError,
-				raw:        true,
-			},
-			wantErr:        "internal server error",
-			wantStatusCode: http.StatusInternalServerError,
-		},
-		{
-			name: "HTML error page",
-			response: testError{
-				message:    "<html><body>404 Not Found</body></html>",
-				statusCode: http.StatusNotFound,
-				raw:        true,
-			},
-			wantErr:        "<html><body>404 Not Found</body></html>",
-			wantStatusCode: http.StatusNotFound,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if errResp, ok := tc.response.(testError); ok {
-					w.WriteHeader(errResp.statusCode)
-					if !errResp.raw {
-						err := json.NewEncoder(w).Encode(map[string]string{
-							"error": errResp.message,
-						})
-						if err != nil {
-							t.Fatal("failed to encode error response:", err)
-						}
-					} else {
-						// Write raw message (simulates non-JSON error responses)
-						fmt.Fprint(w, errResp.message)
-					}
-					return
-				}
-
-				w.Header().Set("Content-Type", "application/json")
-				if err := json.NewEncoder(w).Encode(tc.response); err != nil {
-					t.Fatalf("failed to encode response: %v", err)
-				}
-			}))
-			defer ts.Close()
-
-			client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
-
-			var resp struct {
-				ID      string `json:"id"`
-				Success bool   `json:"success"`
-			}
-			err := client.do(t.Context(), http.MethodPost, "/v1/messages", nil, &resp)
-
-			if tc.wantErr != "" {
-				if err == nil {
-					t.Fatalf("got nil, want error %q", tc.wantErr)
-				}
-				if err.Error() != tc.wantErr {
-					t.Errorf("error message mismatch: got %q, want %q", err.Error(), tc.wantErr)
-				}
-				if tc.wantStatusCode != 0 {
-					if statusErr, ok := err.(StatusError); ok {
-						if statusErr.StatusCode != tc.wantStatusCode {
-							t.Errorf("status code mismatch: got %d, want %d", statusErr.StatusCode, tc.wantStatusCode)
-						}
-					} else {
-						t.Errorf("expected StatusError, got %T", err)
-					}
-				}
-				return
-			}
-
-			if err != nil {
-				t.Fatalf("got error %q, want nil", err)
-			}
-
-			if expectedResp, ok := tc.response.(struct {
-				ID      string `json:"id"`
-				Success bool   `json:"success"`
-			}); ok {
-				if resp.ID != expectedResp.ID {
-					t.Errorf("response ID mismatch: got %q, want %q", resp.ID, expectedResp.ID)
-				}
-				if resp.Success != expectedResp.Success {
-					t.Errorf("response Success mismatch: got %v, want %v", resp.Success, expectedResp.Success)
-				}
-			}
-		})
-	}
-}
-
-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/examples/README.md

@@ -1,18 +0,0 @@
-# Ollama API Examples
-
-Run the examples in this directory with:
-
-```shell
-go run example_name/main.go
-```
-
-## Chat - Chat with a model
-- [chat/main.go](chat/main.go)
-
-## Generate - Generate text from a model
-- [generate/main.go](generate/main.go)
-- [generate-streaming/main.go](generate-streaming/main.go)
-
-## Pull - Pull a model
-- [pull-progress/main.go](pull-progress/main.go)
-

api/types_test.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"encoding/json"
-	"errors"
 	"math"
 	"testing"
 	"time"
@@ -11,49 +10,17 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests, order not preserved)
-func testPropsMap(m map[string]ToolProperty) *ToolPropertiesMap {
-	props := NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	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()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
 func TestKeepAliveParsingFromJSON(t *testing.T) {
 	tests := []struct {
 		name string
 		req  string
 		exp  *Duration
 	}{
-		{
-			name: "Unset",
-			req:  `{ }`,
-			exp:  nil,
-		},
 		{
 			name: "Positive Integer",
 			req:  `{ "keep_alive": 42 }`,
 			exp:  &Duration{42 * time.Second},
 		},
-		{
-			name: "Positive Float",
-			req:  `{ "keep_alive": 42.5 }`,
-			exp:  &Duration{42500 * time.Millisecond},
-		},
 		{
 			name: "Positive Integer String",
 			req:  `{ "keep_alive": "42m" }`,
@@ -64,11 +31,6 @@ func TestKeepAliveParsingFromJSON(t *testing.T) {
 			req:  `{ "keep_alive": -1 }`,
 			exp:  &Duration{math.MaxInt64},
 		},
-		{
-			name: "Negative Float",
-			req:  `{ "keep_alive": -3.14 }`,
-			exp:  &Duration{math.MaxInt64},
-		},
 		{
 			name: "Negative Integer String",
 			req:  `{ "keep_alive": "-1m" }`,
@@ -86,883 +48,3 @@ func TestKeepAliveParsingFromJSON(t *testing.T) {
 		})
 	}
 }
-
-func TestDurationMarshalUnmarshal(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    time.Duration
-		expected time.Duration
-	}{
-		{
-			"negative duration",
-			time.Duration(-1),
-			time.Duration(math.MaxInt64),
-		},
-		{
-			"positive duration",
-			42 * time.Second,
-			42 * time.Second,
-		},
-		{
-			"another positive duration",
-			42 * time.Minute,
-			42 * time.Minute,
-		},
-		{
-			"zero duration",
-			time.Duration(0),
-			time.Duration(0),
-		},
-		{
-			"max duration",
-			time.Duration(math.MaxInt64),
-			time.Duration(math.MaxInt64),
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			b, err := json.Marshal(Duration{test.input})
-			require.NoError(t, err)
-
-			var d Duration
-			err = json.Unmarshal(b, &d)
-			require.NoError(t, err)
-
-			assert.Equal(t, test.expected, d.Duration, "input %v, marshalled %v, got %v", test.input, string(b), d.Duration)
-		})
-	}
-}
-
-func TestUseMmapParsingFromJSON(t *testing.T) {
-	tr := true
-	fa := false
-	tests := []struct {
-		name string
-		req  string
-		exp  *bool
-	}{
-		{
-			name: "Undefined",
-			req:  `{ }`,
-			exp:  nil,
-		},
-		{
-			name: "True",
-			req:  `{ "use_mmap": true }`,
-			exp:  &tr,
-		},
-		{
-			name: "False",
-			req:  `{ "use_mmap": false }`,
-			exp:  &fa,
-		},
-	}
-
-	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)
-			assert.Equal(t, test.exp, opts.UseMMap)
-		})
-	}
-}
-
-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
-	tests := []struct {
-		name string
-		req  map[string][]string
-		exp  *bool
-		err  error
-	}{
-		{
-			name: "True",
-			req: map[string][]string{
-				"use_mmap": {"true"},
-			},
-			exp: &tr,
-			err: nil,
-		},
-		{
-			name: "False",
-			req: map[string][]string{
-				"use_mmap": {"false"},
-			},
-			exp: &fa,
-			err: nil,
-		},
-		{
-			name: "Numeric True",
-			req: map[string][]string{
-				"use_mmap": {"1"},
-			},
-			exp: &tr,
-			err: nil,
-		},
-		{
-			name: "Numeric False",
-			req: map[string][]string{
-				"use_mmap": {"0"},
-			},
-			exp: &fa,
-			err: nil,
-		},
-		{
-			name: "invalid string",
-			req: map[string][]string{
-				"use_mmap": {"foo"},
-			},
-			exp: nil,
-			err: errors.New("invalid bool value [foo]"),
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			resp, err := FormatParams(test.req)
-			require.Equal(t, test.err, err)
-			respVal, ok := resp["use_mmap"]
-			if test.exp != nil {
-				assert.True(t, ok, "resp: %v", resp)
-				assert.Equal(t, *test.exp, *respVal.(*bool))
-			}
-		})
-	}
-}
-
-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
-		expected string
-	}{
-		{`{"role": "USER", "content": "Hello!"}`, "user"},
-		{`{"role": "System", "content": "Initialization complete."}`, "system"},
-		{`{"role": "assistant", "content": "How can I help you?"}`, "assistant"},
-		{`{"role": "TOOl", "content": "Access granted."}`, "tool"},
-	}
-
-	for _, test := range tests {
-		var msg Message
-		if err := json.Unmarshal([]byte(test.input), &msg); err != nil {
-			t.Errorf("Unexpected error: %v", err)
-		}
-
-		if msg.Role != test.expected {
-			t.Errorf("role not lowercased: got %v, expected %v", msg.Role, test.expected)
-		}
-	}
-}
-
-func TestToolFunction_UnmarshalJSON(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		wantErr string
-	}{
-		{
-			name: "valid enum with same types",
-			input: `{
-				"name": "test",
-				"description": "test function",
-				"parameters": {
-					"type": "object",
-					"required": ["test"],
-					"properties": {
-						"test": {
-							"type": "string",
-							"description": "test prop",
-							"enum": ["a", "b", "c"]
-						}
-					}
-				}
-			}`,
-			wantErr: "",
-		},
-		{
-			name: "empty enum array",
-			input: `{
-				"name": "test",
-				"description": "test function",
-				"parameters": {
-					"type": "object",
-					"required": ["test"],
-					"properties": {
-						"test": {
-							"type": "string",
-							"description": "test prop",
-							"enum": []
-						}
-					}
-				}
-			}`,
-			wantErr: "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var tf ToolFunction
-			err := json.Unmarshal([]byte(tt.input), &tf)
-
-			if tt.wantErr != "" {
-				require.Error(t, err)
-				assert.Contains(t, err.Error(), tt.wantErr)
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}
-
-func TestToolFunctionParameters_MarshalJSON(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    ToolFunctionParameters
-		expected string
-	}{
-		{
-			name: "simple object with string property",
-			input: ToolFunctionParameters{
-				Type:     "object",
-				Required: []string{"name"},
-				Properties: testPropsMap(map[string]ToolProperty{
-					"name": {Type: PropertyType{"string"}},
-				}),
-			},
-			expected: `{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}`,
-		},
-		{
-			name: "no required",
-			input: ToolFunctionParameters{
-				Type: "object",
-				Properties: testPropsMap(map[string]ToolProperty{
-					"name": {Type: PropertyType{"string"}},
-				}),
-			},
-			expected: `{"type":"object","properties":{"name":{"type":"string"}}}`,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			data, err := json.Marshal(test.input)
-			require.NoError(t, err)
-			assert.Equal(t, test.expected, string(data))
-		})
-	}
-}
-
-func TestToolCallFunction_IndexAlwaysMarshals(t *testing.T) {
-	fn := ToolCallFunction{
-		Name:      "echo",
-		Arguments: testArgs(map[string]any{"message": "hi"}),
-	}
-
-	data, err := json.Marshal(fn)
-	require.NoError(t, err)
-
-	raw := map[string]any{}
-	require.NoError(t, json.Unmarshal(data, &raw))
-	require.Contains(t, raw, "index")
-	assert.Equal(t, float64(0), raw["index"])
-
-	fn.Index = 3
-	data, err = json.Marshal(fn)
-	require.NoError(t, err)
-
-	raw = map[string]any{}
-	require.NoError(t, json.Unmarshal(data, &raw))
-	require.Contains(t, raw, "index")
-	assert.Equal(t, float64(3), raw["index"])
-}
-
-func TestPropertyType_UnmarshalJSON(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected PropertyType
-	}{
-		{
-			name:     "string type",
-			input:    `"string"`,
-			expected: PropertyType{"string"},
-		},
-		{
-			name:     "array of types",
-			input:    `["string", "number"]`,
-			expected: PropertyType{"string", "number"},
-		},
-		{
-			name:     "array with single type",
-			input:    `["string"]`,
-			expected: PropertyType{"string"},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			var pt PropertyType
-			if err := json.Unmarshal([]byte(test.input), &pt); err != nil {
-				t.Errorf("Unexpected error: %v", err)
-			}
-
-			if len(pt) != len(test.expected) {
-				t.Errorf("Length mismatch: got %v, expected %v", len(pt), len(test.expected))
-			}
-
-			for i, v := range pt {
-				if v != test.expected[i] {
-					t.Errorf("Value mismatch at index %d: got %v, expected %v", i, v, test.expected[i])
-				}
-			}
-		})
-	}
-}
-
-func TestPropertyType_MarshalJSON(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    PropertyType
-		expected string
-	}{
-		{
-			name:     "single type",
-			input:    PropertyType{"string"},
-			expected: `"string"`,
-		},
-		{
-			name:     "multiple types",
-			input:    PropertyType{"string", "number"},
-			expected: `["string","number"]`,
-		},
-		{
-			name:     "empty type",
-			input:    PropertyType{},
-			expected: `[]`,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			data, err := json.Marshal(test.input)
-			if err != nil {
-				t.Errorf("Unexpected error: %v", err)
-			}
-
-			if string(data) != test.expected {
-				t.Errorf("Marshaled data mismatch: got %v, expected %v", string(data), test.expected)
-			}
-		})
-	}
-}
-
-func TestThinking_UnmarshalJSON(t *testing.T) {
-	tests := []struct {
-		name             string
-		input            string
-		expectedThinking *ThinkValue
-		expectedError    bool
-	}{
-		{
-			name:             "true",
-			input:            `{ "think": true }`,
-			expectedThinking: &ThinkValue{Value: true},
-		},
-		{
-			name:             "false",
-			input:            `{ "think": false }`,
-			expectedThinking: &ThinkValue{Value: false},
-		},
-		{
-			name:             "unset",
-			input:            `{ }`,
-			expectedThinking: nil,
-		},
-		{
-			name:             "string_high",
-			input:            `{ "think": "high" }`,
-			expectedThinking: &ThinkValue{Value: "high"},
-		},
-		{
-			name:             "string_medium",
-			input:            `{ "think": "medium" }`,
-			expectedThinking: &ThinkValue{Value: "medium"},
-		},
-		{
-			name:             "string_low",
-			input:            `{ "think": "low" }`,
-			expectedThinking: &ThinkValue{Value: "low"},
-		},
-		{
-			name:             "string_max",
-			input:            `{ "think": "max" }`,
-			expectedThinking: &ThinkValue{Value: "max"},
-		},
-		{
-			name:             "invalid_string",
-			input:            `{ "think": "invalid" }`,
-			expectedThinking: nil,
-			expectedError:    true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			var req GenerateRequest
-			err := json.Unmarshal([]byte(test.input), &req)
-			if test.expectedError {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				if test.expectedThinking == nil {
-					assert.Nil(t, req.Think)
-				} else {
-					require.NotNil(t, req.Think)
-					assert.Equal(t, test.expectedThinking.Value, req.Think.Value)
-				}
-			}
-		})
-	}
-}
-
-func TestToolPropertyNestedProperties(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected ToolProperty
-	}{
-		{
-			name: "nested object properties",
-			input: `{
-				"type": "object",
-				"description": "Location details",
-				"properties": {
-					"address": {
-						"type": "string",
-						"description": "Street address"
-					},
-					"city": {
-						"type": "string",
-						"description": "City name"
-					}
-				}
-			}`,
-			expected: ToolProperty{
-				Type:        PropertyType{"object"},
-				Description: "Location details",
-				Properties: testPropsMap(map[string]ToolProperty{
-					"address": {
-						Type:        PropertyType{"string"},
-						Description: "Street address",
-					},
-					"city": {
-						Type:        PropertyType{"string"},
-						Description: "City name",
-					},
-				}),
-			},
-		},
-		{
-			name: "deeply nested properties",
-			input: `{
-				"type": "object",
-				"description": "Event",
-				"properties": {
-					"location": {
-						"type": "object",
-						"description": "Location",
-						"properties": {
-							"coordinates": {
-								"type": "object",
-								"description": "GPS coordinates",
-								"properties": {
-									"lat": {"type": "number", "description": "Latitude"},
-									"lng": {"type": "number", "description": "Longitude"}
-								}
-							}
-						}
-					}
-				}
-			}`,
-			expected: ToolProperty{
-				Type:        PropertyType{"object"},
-				Description: "Event",
-				Properties: testPropsMap(map[string]ToolProperty{
-					"location": {
-						Type:        PropertyType{"object"},
-						Description: "Location",
-						Properties: testPropsMap(map[string]ToolProperty{
-							"coordinates": {
-								Type:        PropertyType{"object"},
-								Description: "GPS coordinates",
-								Properties: testPropsMap(map[string]ToolProperty{
-									"lat": {Type: PropertyType{"number"}, Description: "Latitude"},
-									"lng": {Type: PropertyType{"number"}, Description: "Longitude"},
-								}),
-							},
-						}),
-					},
-				}),
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var prop ToolProperty
-			err := json.Unmarshal([]byte(tt.input), &prop)
-			require.NoError(t, err)
-
-			// Compare JSON representations since pointer comparison doesn't work
-			expectedJSON, err := json.Marshal(tt.expected)
-			require.NoError(t, err)
-			actualJSON, err := json.Marshal(prop)
-			require.NoError(t, err)
-			assert.JSONEq(t, string(expectedJSON), string(actualJSON))
-
-			// Round-trip test: marshal and unmarshal again
-			data, err := json.Marshal(prop)
-			require.NoError(t, err)
-
-			var prop2 ToolProperty
-			err = json.Unmarshal(data, &prop2)
-			require.NoError(t, err)
-
-			prop2JSON, err := json.Marshal(prop2)
-			require.NoError(t, err)
-			assert.JSONEq(t, string(expectedJSON), string(prop2JSON))
-		})
-	}
-}
-
-func TestToolFunctionParameters_String(t *testing.T) {
-	tests := []struct {
-		name     string
-		params   ToolFunctionParameters
-		expected string
-	}{
-		{
-			name: "simple object with string property",
-			params: ToolFunctionParameters{
-				Type:     "object",
-				Required: []string{"name"},
-				Properties: testPropsMap(map[string]ToolProperty{
-					"name": {
-						Type:        PropertyType{"string"},
-						Description: "The name of the person",
-					},
-				}),
-			},
-			expected: `{"type":"object","required":["name"],"properties":{"name":{"type":"string","description":"The name of the person"}}}`,
-		},
-		{
-			name: "marshal failure returns empty string",
-			params: ToolFunctionParameters{
-				Type: "object",
-				Defs: func() any {
-					// Create a cycle that will cause json.Marshal to fail
-					type selfRef struct {
-						Self *selfRef
-					}
-					s := &selfRef{}
-					s.Self = s
-					return s
-				}(),
-				Properties: testPropsMap(map[string]ToolProperty{}),
-			},
-			expected: "",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			result := test.params.String()
-			assert.Equal(t, test.expected, result)
-		})
-	}
-}
-
-func TestToolCallFunctionArguments_OrderPreservation(t *testing.T) {
-	t.Run("marshal preserves insertion order", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("zebra", "z")
-		args.Set("apple", "a")
-		args.Set("mango", "m")
-
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-
-		// Should preserve insertion order, not alphabetical
-		assert.Equal(t, `{"zebra":"z","apple":"a","mango":"m"}`, string(data))
-	})
-
-	t.Run("unmarshal preserves JSON order", func(t *testing.T) {
-		jsonData := `{"zebra":"z","apple":"a","mango":"m"}`
-
-		var args ToolCallFunctionArguments
-		err := json.Unmarshal([]byte(jsonData), &args)
-		require.NoError(t, err)
-
-		// Verify iteration order matches JSON order
-		var keys []string
-		for k := range args.All() {
-			keys = append(keys, k)
-		}
-		assert.Equal(t, []string{"zebra", "apple", "mango"}, keys)
-	})
-
-	t.Run("round trip preserves order", func(t *testing.T) {
-		original := `{"z":1,"a":2,"m":3,"b":4}`
-
-		var args ToolCallFunctionArguments
-		err := json.Unmarshal([]byte(original), &args)
-		require.NoError(t, err)
-
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-
-		assert.Equal(t, original, string(data))
-	})
-
-	t.Run("String method returns ordered JSON", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("c", 3)
-		args.Set("a", 1)
-		args.Set("b", 2)
-
-		assert.Equal(t, `{"c":3,"a":1,"b":2}`, args.String())
-	})
-
-	t.Run("Get retrieves correct values", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("key1", "value1")
-		args.Set("key2", 42)
-
-		v, ok := args.Get("key1")
-		assert.True(t, ok)
-		assert.Equal(t, "value1", v)
-
-		v, ok = args.Get("key2")
-		assert.True(t, ok)
-		assert.Equal(t, 42, v)
-
-		_, ok = args.Get("nonexistent")
-		assert.False(t, ok)
-	})
-
-	t.Run("Len returns correct count", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		assert.Equal(t, 0, args.Len())
-
-		args.Set("a", 1)
-		assert.Equal(t, 1, args.Len())
-
-		args.Set("b", 2)
-		assert.Equal(t, 2, args.Len())
-	})
-
-	t.Run("empty args marshal to empty object", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-		assert.Equal(t, `{}`, string(data))
-	})
-
-	t.Run("zero value args marshal to empty object", func(t *testing.T) {
-		var args ToolCallFunctionArguments
-		assert.Equal(t, "{}", args.String())
-	})
-}
-
-func TestToolPropertiesMap_OrderPreservation(t *testing.T) {
-	t.Run("marshal preserves insertion order", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		props.Set("zebra", ToolProperty{Type: PropertyType{"string"}})
-		props.Set("apple", ToolProperty{Type: PropertyType{"number"}})
-		props.Set("mango", ToolProperty{Type: PropertyType{"boolean"}})
-
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-
-		// Should preserve insertion order, not alphabetical
-		expected := `{"zebra":{"type":"string"},"apple":{"type":"number"},"mango":{"type":"boolean"}}`
-		assert.Equal(t, expected, string(data))
-	})
-
-	t.Run("unmarshal preserves JSON order", func(t *testing.T) {
-		jsonData := `{"zebra":{"type":"string"},"apple":{"type":"number"},"mango":{"type":"boolean"}}`
-
-		var props ToolPropertiesMap
-		err := json.Unmarshal([]byte(jsonData), &props)
-		require.NoError(t, err)
-
-		// Verify iteration order matches JSON order
-		var keys []string
-		for k := range props.All() {
-			keys = append(keys, k)
-		}
-		assert.Equal(t, []string{"zebra", "apple", "mango"}, keys)
-	})
-
-	t.Run("round trip preserves order", func(t *testing.T) {
-		original := `{"z":{"type":"string"},"a":{"type":"number"},"m":{"type":"boolean"}}`
-
-		var props ToolPropertiesMap
-		err := json.Unmarshal([]byte(original), &props)
-		require.NoError(t, err)
-
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-
-		assert.Equal(t, original, string(data))
-	})
-
-	t.Run("Get retrieves correct values", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		props.Set("name", ToolProperty{Type: PropertyType{"string"}, Description: "The name"})
-		props.Set("age", ToolProperty{Type: PropertyType{"integer"}, Description: "The age"})
-
-		v, ok := props.Get("name")
-		assert.True(t, ok)
-		assert.Equal(t, "The name", v.Description)
-
-		v, ok = props.Get("age")
-		assert.True(t, ok)
-		assert.Equal(t, "The age", v.Description)
-
-		_, ok = props.Get("nonexistent")
-		assert.False(t, ok)
-	})
-
-	t.Run("Len returns correct count", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		assert.Equal(t, 0, props.Len())
-
-		props.Set("a", ToolProperty{})
-		assert.Equal(t, 1, props.Len())
-
-		props.Set("b", ToolProperty{})
-		assert.Equal(t, 2, props.Len())
-	})
-
-	t.Run("nil props marshal to null", func(t *testing.T) {
-		var props *ToolPropertiesMap
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-		assert.Equal(t, `null`, string(data))
-	})
-
-	t.Run("ToMap returns regular map", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		props.Set("a", ToolProperty{Type: PropertyType{"string"}})
-		props.Set("b", ToolProperty{Type: PropertyType{"number"}})
-
-		m := props.ToMap()
-		assert.Equal(t, 2, len(m))
-		assert.Equal(t, PropertyType{"string"}, m["a"].Type)
-		assert.Equal(t, PropertyType{"number"}, m["b"].Type)
-	})
-}
-
-func TestToolCallFunctionArguments_ComplexValues(t *testing.T) {
-	t.Run("nested objects preserve order", func(t *testing.T) {
-		jsonData := `{"outer":{"z":1,"a":2},"simple":"value"}`
-
-		var args ToolCallFunctionArguments
-		err := json.Unmarshal([]byte(jsonData), &args)
-		require.NoError(t, err)
-
-		// Outer keys should be in order
-		var keys []string
-		for k := range args.All() {
-			keys = append(keys, k)
-		}
-		assert.Equal(t, []string{"outer", "simple"}, keys)
-	})
-
-	t.Run("arrays as values", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("items", []string{"a", "b", "c"})
-		args.Set("numbers", []int{1, 2, 3})
-
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-
-		assert.Equal(t, `{"items":["a","b","c"],"numbers":[1,2,3]}`, string(data))
-	})
-}
-
-func TestToolPropertiesMap_NestedProperties(t *testing.T) {
-	t.Run("nested properties preserve order", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-
-		nestedProps := NewToolPropertiesMap()
-		nestedProps.Set("z_field", ToolProperty{Type: PropertyType{"string"}})
-		nestedProps.Set("a_field", ToolProperty{Type: PropertyType{"number"}})
-
-		props.Set("outer", ToolProperty{
-			Type:       PropertyType{"object"},
-			Properties: nestedProps,
-		})
-
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-
-		// Both outer and inner should preserve order
-		expected := `{"outer":{"type":"object","properties":{"z_field":{"type":"string"},"a_field":{"type":"number"}}}}`
-		assert.Equal(t, expected, string(data))
-	})
-}

api/types_typescript_test.go

@@ -1,142 +0,0 @@
-package api
-
-import (
-	"testing"
-)
-
-func TestToolParameterToTypeScriptType(t *testing.T) {
-	tests := []struct {
-		name     string
-		param    ToolProperty
-		expected string
-	}{
-		{
-			name: "single string type",
-			param: ToolProperty{
-				Type: PropertyType{"string"},
-			},
-			expected: "string",
-		},
-		{
-			name: "single number type",
-			param: ToolProperty{
-				Type: PropertyType{"number"},
-			},
-			expected: "number",
-		},
-		{
-			name: "integer maps to number",
-			param: ToolProperty{
-				Type: PropertyType{"integer"},
-			},
-			expected: "number",
-		},
-		{
-			name: "boolean type",
-			param: ToolProperty{
-				Type: PropertyType{"boolean"},
-			},
-			expected: "boolean",
-		},
-		{
-			name: "array type",
-			param: ToolProperty{
-				Type: PropertyType{"array"},
-			},
-			expected: "any[]",
-		},
-		{
-			name: "object type",
-			param: ToolProperty{
-				Type: PropertyType{"object"},
-			},
-			expected: "Record<string, any>",
-		},
-		{
-			name: "null type",
-			param: ToolProperty{
-				Type: PropertyType{"null"},
-			},
-			expected: "null",
-		},
-		{
-			name: "multiple types as union",
-			param: ToolProperty{
-				Type: PropertyType{"string", "number"},
-			},
-			expected: "string | number",
-		},
-		{
-			name: "string or null union",
-			param: ToolProperty{
-				Type: PropertyType{"string", "null"},
-			},
-			expected: "string | null",
-		},
-		{
-			name: "anyOf with single types",
-			param: ToolProperty{
-				AnyOf: []ToolProperty{
-					{Type: PropertyType{"string"}},
-					{Type: PropertyType{"number"}},
-				},
-			},
-			expected: "string | number",
-		},
-		{
-			name: "anyOf with multiple types in each branch",
-			param: ToolProperty{
-				AnyOf: []ToolProperty{
-					{Type: PropertyType{"string", "null"}},
-					{Type: PropertyType{"number"}},
-				},
-			},
-			expected: "string | null | number",
-		},
-		{
-			name: "nested anyOf",
-			param: ToolProperty{
-				AnyOf: []ToolProperty{
-					{Type: PropertyType{"boolean"}},
-					{
-						AnyOf: []ToolProperty{
-							{Type: PropertyType{"string"}},
-							{Type: PropertyType{"number"}},
-						},
-					},
-				},
-			},
-			expected: "boolean | string | number",
-		},
-		{
-			name: "empty type returns any",
-			param: ToolProperty{
-				Type: PropertyType{},
-			},
-			expected: "any",
-		},
-		{
-			name: "unknown type maps to any",
-			param: ToolProperty{
-				Type: PropertyType{"unknown_type"},
-			},
-			expected: "any",
-		},
-		{
-			name: "multiple types including array",
-			param: ToolProperty{
-				Type: PropertyType{"string", "array", "null"},
-			},
-			expected: "string | any[] | null",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := tt.param.ToTypeScriptType()
-			if result != tt.expected {
-				t.Errorf("ToTypeScriptType() = %q, want %q", result, tt.expected)
-			}
-		})
-	}
-}

app/.gitignore

@@ -1,11 +1,2 @@
 ollama.syso
-*.crt
-*.exe
-/app/app
-/app/squirrel
-ollama
-*cover*
-.vscode
-.env
-.DS_Store
-.claude
+app

app/README.md

@@ -1,97 +1,18 @@
-# Ollama for macOS and Windows
+# Ollama App
 
-## Download
+## macOS
 
-- [macOS](https://github.com/ollama/app/releases/download/latest/Ollama.dmg)
-- [Windows](https://github.com/ollama/app/releases/download/latest/OllamaSetup.exe)
+TODO
 
-## Development
-
-### Desktop App
-
-```bash
-go generate ./... &&
-go run ./cmd/app
-```
-
-### UI Development
-
-#### Setup
-
-Install required tools:
-
-```bash
-go install github.com/tkrajina/typescriptify-golang-structs/tscriptify@latest
-```
-
-#### Develop UI (Development Mode)
-
-1. Start the React development server (with hot-reload):
-
-```bash
-cd ui/app
-npm install
-npm run dev
-```
-
-2. In a separate terminal, run the Ollama app with the `-dev` flag:
-
-```bash
-go generate ./... &&
-OLLAMA_DEBUG=1 go run ./cmd/app -dev
-```
-
-The `-dev` flag enables:
-
-- Loading the UI from the Vite dev server at http://localhost:5173
-- Fixed UI server port at http://127.0.0.1:3001 for API requests
-- CORS headers for cross-origin requests
-- Hot-reload support for UI development
-
-## Build
-
-
-### Windows
+## Windows
 
+If you want to build the installer, youll need to install
 - https://jrsoftware.org/isinfo.php
 
 
-**Dependencies** - either build a local copy of ollama, or use a github release
-```powershell
-# Local dependencies
-.\scripts\deps_local.ps1
-
-# Release dependencies
-.\scripts\deps_release.ps1 0.6.8
-```
-
-**Build**
-```powershell
-.\scripts\build_windows.ps1
-```
-
-### macOS
-
-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:
+In the top directory of this repo, run the following powershell script
+to build the ollama CLI, ollama app, and ollama installer.
 
 ```
-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 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
-```
-
-**Dependencies** - either build a local copy of Ollama, or use a GitHub release:
-```sh
-# Local dependencies
-./scripts/deps_local.sh
-
-# Release dependencies
-./scripts/deps_release.sh 0.6.8
-```
-
-**Build**
-```sh
-./scripts/build_darwin.sh
+powershell -ExecutionPolicy Bypass -File .\scripts\build_windows.ps1
 ```

app/app_darwin.go

@@ -0,0 +1,76 @@
+package main
+
+// #cgo CFLAGS: -x objective-c
+// #cgo LDFLAGS: -framework Cocoa -framework LocalAuthentication -framework ServiceManagement
+// #include "app_darwin.h"
+import "C"
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"syscall"
+)
+
+func init() {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		panic(err)
+	}
+
+	ServerLogFile = filepath.Join(home, ".ollama", "logs", "server.log")
+}
+
+func run() {
+	initLogging()
+	slog.Info("ollama macOS app started")
+
+	// Ask to move to applications directory
+	moving := C.askToMoveToApplications()
+	if moving {
+		return
+	}
+
+	C.killOtherInstances()
+
+	code := C.installSymlink()
+	if code != 0 {
+		slog.Error("Failed to install symlink")
+	}
+
+	exe, err := os.Executable()
+	if err != nil {
+		panic(err)
+	}
+
+	var options ServerOptions
+
+	ctx, cancel := context.WithCancel(context.Background())
+	var done chan int
+
+	done, err = SpawnServer(ctx, filepath.Join(filepath.Dir(exe), "..", "Resources", "ollama"), options)
+	if err != nil {
+		slog.Error(fmt.Sprintf("Failed to spawn ollama server %s", err))
+		done = make(chan int, 1)
+		done <- 1
+	}
+
+	// Run the native macOS app
+	// Note: this will block until the app is closed
+	C.run()
+
+	slog.Info("ollama macOS app closed")
+
+	cancel()
+	slog.Info("Waiting for ollama server to shutdown...")
+	if done != nil {
+		<-done
+	}
+	slog.Info("Ollama app exiting")
+}
+
+//export Quit
+func Quit() {
+	syscall.Kill(os.Getpid(), syscall.SIGTERM)
+}

app/app_darwin.h

@@ -0,0 +1,13 @@
+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+@end
+
+void run();
+void killOtherInstances();
+bool askToMoveToApplications();
+int createSymlinkWithAuthorization();
+int installSymlink();
+extern void Restart();
+extern void Quit();

app/app_darwin.m

@@ -0,0 +1,282 @@
+#import <AppKit/AppKit.h>
+#import <Cocoa/Cocoa.h>
+#import <CoreServices/CoreServices.h>
+#import <Security/Security.h>
+#import <ServiceManagement/ServiceManagement.h>
+#import "app_darwin.h"
+
+@interface AppDelegate ()
+
+@property (strong, nonatomic) NSStatusItem *statusItem;
+
+@end
+
+@implementation AppDelegate
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+    // show status menu
+    NSMenu *menu = [[NSMenu alloc] init];
+
+    NSMenuItem *aboutMenuItem = [[NSMenuItem alloc] initWithTitle:@"About Ollama" action:@selector(aboutOllama) keyEquivalent:@""];
+    [aboutMenuItem setTarget:self];
+    [menu addItem:aboutMenuItem];
+
+    // Settings submenu
+    NSMenu *settingsMenu = [[NSMenu alloc] initWithTitle:@"Settings"];
+
+    // Submenu items
+    NSMenuItem *chooseModelDirectoryItem = [[NSMenuItem alloc] initWithTitle:@"Choose model directory..." action:@selector(chooseModelDirectory) keyEquivalent:@""];
+    [chooseModelDirectoryItem setTarget:self];
+    [chooseModelDirectoryItem setEnabled:YES];
+    [settingsMenu addItem:chooseModelDirectoryItem];
+
+    NSMenuItem *exposeExternallyItem = [[NSMenuItem alloc] initWithTitle:@"Allow external connections" action:@selector(toggleExposeExternally:) keyEquivalent:@""];
+    [exposeExternallyItem setTarget:self];
+    [exposeExternallyItem setState:NSOffState]; // Set initial state to off
+    [exposeExternallyItem setEnabled:YES];
+    [settingsMenu addItem:exposeExternallyItem];
+
+    NSMenuItem *allowCrossOriginItem = [[NSMenuItem alloc] initWithTitle:@"Allow browser requests" action:@selector(toggleCrossOrigin:) keyEquivalent:@""];
+    [allowCrossOriginItem setTarget:self];
+    [allowCrossOriginItem setState:NSOffState]; // Set initial state to off
+    [allowCrossOriginItem setEnabled:YES];
+    [settingsMenu addItem:allowCrossOriginItem];
+
+    NSMenuItem *settingsMenuItem = [[NSMenuItem alloc] initWithTitle:@"Settings" action:nil keyEquivalent:@""];
+    [settingsMenuItem setSubmenu:settingsMenu];
+    [menu addItem:settingsMenuItem];
+
+    [menu addItemWithTitle:@"Quit Ollama" action:@selector(quit) keyEquivalent:@"q"];
+
+    self.statusItem = [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength];
+    [self.statusItem addObserver:self forKeyPath:@"button.effectiveAppearance" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionInitial context:nil];
+
+    self.statusItem.menu = menu;
+    [self showIcon];
+}
+
+- (void)aboutOllama {
+    [[NSApplication sharedApplication] orderFrontStandardAboutPanel:nil];
+}
+
+- (void)toggleCrossOrigin:(id)sender {
+    NSMenuItem *item = (NSMenuItem *)sender;
+    if ([item state] == NSOffState) {
+        // Do something when cross-origin requests are allowed
+        [item setState:NSOnState];
+    } else {
+        // Do something when cross-origin requests are disallowed
+        [item setState:NSOffState];
+    }
+}
+
+- (void)toggleExposeExternally:(id)sender {
+    NSMenuItem *item = (NSMenuItem *)sender;
+    if ([item state] == NSOffState) {
+        // Do something when Ollama is exposed externally
+        [item setState:NSOnState];
+    } else {
+        // Do something when Ollama is not exposed externally
+        [item setState:NSOffState];
+    }
+}
+
+- (void)chooseModelDirectory {
+    NSOpenPanel *openPanel = [NSOpenPanel openPanel];
+    [openPanel setCanChooseFiles:NO];
+    [openPanel setCanChooseDirectories:YES];
+    [openPanel setAllowsMultipleSelection:NO];
+
+    NSInteger result = [openPanel runModal];
+    if (result == NSModalResponseOK) {
+        NSURL *selectedDirectoryURL = [openPanel URLs].firstObject;
+        // Do something with the selected directory URL
+    }
+}
+
+-(void) showIcon {
+    NSAppearance* appearance = self.statusItem.button.effectiveAppearance;
+    NSString* appearanceName = (NSString*)(appearance.name);
+    NSString* iconName = [[appearanceName lowercaseString] containsString:@"dark"] ? @"iconDark" : @"icon";
+    NSImage* statusImage = [NSImage imageNamed:iconName];
+    [statusImage setTemplate:YES];
+    self.statusItem.button.image = statusImage;
+}
+
+-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
+    [self showIcon];
+}
+
+- (void)quit {
+    [NSApp stop:nil];
+}
+
+@end
+
+void run() {
+    @autoreleasepool {
+        [NSApplication sharedApplication];
+        AppDelegate *appDelegate = [[AppDelegate alloc] init];
+        [NSApp setDelegate:appDelegate];
+        [NSApp run];
+    }
+}
+
+// killOtherInstances kills all other instances of the app currently
+// running. This way we can ensure that only the most recently started
+// instance of Ollama is running
+void killOtherInstances() {
+    pid_t pid = getpid();
+    NSArray *all = [[NSWorkspace sharedWorkspace] runningApplications];
+    NSMutableArray *apps = [NSMutableArray array];
+
+    for (NSRunningApplication *app in all) {
+        if ([app.bundleIdentifier isEqualToString:[[NSBundle mainBundle] bundleIdentifier]] ||
+            [app.bundleIdentifier isEqualToString:@"ai.ollama.ollama"] ||
+            [app.bundleIdentifier isEqualToString:@"com.electron.ollama"]) {
+            if (app.processIdentifier != pid) {
+                [apps addObject:app];
+            }
+        }
+    }
+
+    for (NSRunningApplication *app in apps) {
+        kill(app.processIdentifier, SIGTERM);
+    }
+
+    NSDate *startTime = [NSDate date];
+    for (NSRunningApplication *app in apps) {
+        while (!app.terminated) {
+            if (-[startTime timeIntervalSinceNow] >= 5) {
+                kill(app.processIdentifier, SIGKILL);
+                break;
+            }
+
+            [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+        }
+    }
+}
+
+bool askToMoveToApplications() {
+    NSString *bundlePath = [[NSBundle mainBundle] bundlePath];
+    if ([bundlePath hasPrefix:@"/Applications"]) {
+        return false;
+    }
+
+    NSAlert *alert = [[NSAlert alloc] init];
+    [alert setMessageText:@"Move to Applications?"];
+    [alert setInformativeText:@"Ollama works best when run from the Applications directory."];
+    [alert addButtonWithTitle:@"Move to Applications"];
+    [alert addButtonWithTitle:@"Don't move"];
+
+    [NSApp activateIgnoringOtherApps:YES];
+
+    if ([alert runModal] != NSAlertFirstButtonReturn) {
+        return false;
+    }
+
+    // move to applications
+    NSString *applicationsPath = @"/Applications";
+    NSString *newPath = [applicationsPath stringByAppendingPathComponent:@"Ollama.app"];
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+
+    // Check if the newPath already exists
+    if ([fileManager fileExistsAtPath:newPath]) {
+        NSError *removeError = nil;
+        [fileManager removeItemAtPath:newPath error:&removeError];
+        if (removeError) {
+            NSLog(@"Error removing file at %@: %@", newPath, removeError);
+            return false; // or handle the error
+        }
+    }
+
+    NSError *moveError = nil;
+    [fileManager moveItemAtPath:bundlePath toPath:newPath error:&moveError];
+    if (moveError) {
+        NSLog(@"Error moving file from %@ to %@: %@", bundlePath, newPath, moveError);
+        return false;
+    }
+
+    NSLog(@"Opening %@", newPath);
+    NSError *error = nil;
+    NSWorkspace *workspace = [NSWorkspace sharedWorkspace];
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    [workspace launchApplicationAtURL:[NSURL fileURLWithPath:newPath]
+               options:NSWorkspaceLaunchNewInstance | NSWorkspaceLaunchDefault
+               configuration:@{}
+               error:&error];
+
+    return true;
+}
+
+int installSymlink() {
+    NSString *linkPath = @"/usr/local/bin/ollama";
+    NSError *error = nil;
+
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSString *symlinkPath = [fileManager destinationOfSymbolicLinkAtPath:linkPath error:&error];
+    NSString *bundlePath = [[NSBundle mainBundle] bundlePath];
+    NSString *execPath = [[NSBundle mainBundle] executablePath];
+    NSString *resPath = [[NSBundle mainBundle] pathForResource:@"ollama" ofType:nil];
+
+    // if the symlink already exists and points to the right place, don't prompt
+    if ([symlinkPath isEqualToString:resPath]) {
+        NSLog(@"symbolic link already exists and points to the right place");
+        return 0;
+    }
+
+    NSString *authorizationPrompt = @"Ollama is trying to install its command line interface (CLI) tool.";
+
+    AuthorizationRef auth = NULL;
+    OSStatus createStatus = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment, kAuthorizationFlagDefaults, &auth);
+    if (createStatus != errAuthorizationSuccess) {
+        NSLog(@"Error creating authorization");
+        return -1;
+    }
+
+    NSString * bundleIdentifier = [[NSBundle mainBundle] bundleIdentifier];
+    NSString *rightNameString = [NSString stringWithFormat:@"%@.%@", bundleIdentifier, @"auth3"];
+    const char *rightName = rightNameString.UTF8String;
+
+    OSStatus getRightResult = AuthorizationRightGet(rightName, NULL);
+    if (getRightResult == errAuthorizationDenied) {
+        if (AuthorizationRightSet(auth, rightName, (__bridge CFTypeRef _Nonnull)(@(kAuthorizationRuleAuthenticateAsAdmin)), (__bridge CFStringRef _Nullable)(authorizationPrompt), NULL, NULL) != errAuthorizationSuccess) {
+            NSLog(@"Failed to set right");
+            return -1;
+        }
+    }
+
+    AuthorizationItem right = { .name = rightName, .valueLength = 0, .value = NULL, .flags = 0 };
+    AuthorizationRights rights = { .count = 1, .items = &right };
+    AuthorizationFlags flags = (AuthorizationFlags)(kAuthorizationFlagExtendRights | kAuthorizationFlagInteractionAllowed);
+    AuthorizationItem iconAuthorizationItem = {.name = kAuthorizationEnvironmentIcon, .valueLength = 0, .value = NULL, .flags = 0};
+    AuthorizationEnvironment authorizationEnvironment = {.count = 0, .items = NULL};
+
+    BOOL failedToUseSystemDomain = NO;
+    OSStatus copyStatus = AuthorizationCopyRights(auth, &rights, &authorizationEnvironment, flags, NULL);
+    if (copyStatus != errAuthorizationSuccess) {
+        failedToUseSystemDomain = YES;
+
+        if (copyStatus == errAuthorizationCanceled) {
+            NSLog(@"User cancelled authorization");
+            return -1;
+        } else {
+            NSLog(@"Failed copying system domain rights: %d", copyStatus);
+            return -1;
+        }
+    }
+
+    const char *toolPath = "/bin/ln";
+    const char *args[] = {"-s", "-F", [resPath UTF8String], "/usr/local/bin/ollama", NULL};
+    FILE *pipe = NULL;
+
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    OSStatus status = AuthorizationExecuteWithPrivileges(auth, toolPath, kAuthorizationFlagDefaults, (char *const *)args, &pipe);
+    if (status != errAuthorizationSuccess) {
+        NSLog(@"Failed to create symlink");
+        return -1;
+    }
+
+    AuthorizationFree(auth, kAuthorizationFlagDestroyRights);
+    return 0;
+}

app/app_windows.go

@@ -0,0 +1,166 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"log/slog"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+
+	"github.com/ollama/ollama/app/lifecycle"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/tray"
+	"github.com/ollama/ollama/app/updater"
+)
+
+func init() {
+	AppName += ".exe"
+	CLIName += ".exe"
+	// Logs, configs, downloads go to LOCALAPPDATA
+	localAppData := os.Getenv("LOCALAPPDATA")
+	AppDataDir = filepath.Join(localAppData, "Ollama")
+	AppLogFile = filepath.Join(AppDataDir, "app.log")
+	ServerLogFile = filepath.Join(AppDataDir, "server.log")
+
+	// Executables are stored in APPDATA
+	AppDir = filepath.Join(localAppData, "Programs", "Ollama")
+
+	// Make sure we have PATH set correctly for any spawned children
+	paths := strings.Split(os.Getenv("PATH"), ";")
+	// Start with whatever we find in the PATH/LD_LIBRARY_PATH
+	found := false
+	for _, path := range paths {
+		d, err := filepath.Abs(path)
+		if err != nil {
+			continue
+		}
+		if strings.EqualFold(AppDir, d) {
+			found = true
+		}
+	}
+	if !found {
+		paths = append(paths, AppDir)
+
+		pathVal := strings.Join(paths, ";")
+		slog.Debug("setting PATH=" + pathVal)
+		err := os.Setenv("PATH", pathVal)
+		if err != nil {
+			slog.Error(fmt.Sprintf("failed to update PATH: %s", err))
+		}
+	}
+
+	// Make sure our logging dir exists
+	_, err := os.Stat(AppDataDir)
+	if errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(AppDataDir, 0o755); err != nil {
+			slog.Error(fmt.Sprintf("create ollama dir %s: %v", AppDataDir, err))
+		}
+	}
+}
+
+func ShowLogs() {
+	cmd_path := "c:\\Windows\\system32\\cmd.exe"
+	slog.Debug(fmt.Sprintf("viewing logs with start %s", AppDataDir))
+	cmd := exec.Command(cmd_path, "/c", "start", AppDataDir)
+	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: false, CreationFlags: 0x08000000}
+	err := cmd.Start()
+	if err != nil {
+		slog.Error(fmt.Sprintf("Failed to open log dir: %s", err))
+	}
+}
+
+func Start() {
+	cmd_path := "c:\\Windows\\system32\\cmd.exe"
+	slog.Debug(fmt.Sprintf("viewing logs with start %s", AppDataDir))
+	cmd := exec.Command(cmd_path, "/c", "start", AppDataDir)
+	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: false, CreationFlags: 0x08000000}
+	err := cmd.Start()
+	if err != nil {
+		slog.Error(fmt.Sprintf("Failed to open log dir: %s", err))
+	}
+}
+
+func run() {
+	initLogging()
+
+	slog.Info("ollama windows app started")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	var done chan int
+
+	t, err := tray.NewTray()
+	if err != nil {
+		log.Fatalf("Failed to start: %s", err)
+	}
+	callbacks := t.GetCallbacks()
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		slog.Debug("starting callback loop")
+		for {
+			select {
+			case <-callbacks.Quit:
+				slog.Debug("quit called")
+				t.Quit()
+			case <-signals:
+				slog.Debug("shutting down due to signal")
+				t.Quit()
+			case <-callbacks.Update:
+				err := updater.DoUpgrade(cancel, done)
+				if err != nil {
+					slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
+				}
+			case <-callbacks.ShowLogs:
+				ShowLogs()
+			case <-callbacks.DoFirstUse:
+				err := lifecycle.GetStarted()
+				if err != nil {
+					slog.Warn(fmt.Sprintf("Failed to launch getting started shell: %s", err))
+				}
+			}
+		}
+	}()
+
+	if !store.GetFirstTimeRun() {
+		slog.Debug("First time run")
+		err = t.DisplayFirstUseNotification()
+		if err != nil {
+			slog.Debug(fmt.Sprintf("XXX failed to display first use notification %v", err))
+		}
+		store.SetFirstTimeRun(true)
+	} else {
+		slog.Debug("Not first time, skipping first run notification")
+	}
+
+	if isServerRunning(ctx) {
+		slog.Info("Detected another instance of ollama running, exiting")
+		os.Exit(1)
+	}
+
+	done, err = SpawnServer(ctx, CLIName)
+	if err != nil {
+		// TODO - should we retry in a backoff loop?
+		// TODO - should we pop up a warning and maybe add a menu item to view application logs?
+		slog.Error(fmt.Sprintf("Failed to spawn ollama server %s", err))
+		done = make(chan int, 1)
+		done <- 1
+	}
+
+	updater.StartBackgroundUpdaterChecker(ctx, t.UpdateAvailable)
+
+	t.Run()
+	cancel()
+	slog.Info("Waiting for ollama server to shutdown...")
+	if done != nil {
+		<-done
+	}
+	slog.Info("Ollama app exiting")
+}

app/assets/assets.go

@@ -1,5 +1,3 @@
-//go:build windows || darwin
-
 package assets
 
 import (

app/auth/connect.go

@@ -1,26 +0,0 @@
-//go:build windows || darwin
-
-package auth
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/url"
-	"os"
-
-	"github.com/ollama/ollama/auth"
-)
-
-// BuildConnectURL generates the connect URL with the public key and device name
-func BuildConnectURL(baseURL string) (string, error) {
-	pubKey, err := auth.GetPublicKey()
-	if err != nil {
-		return "", fmt.Errorf("failed to get public key: %w", err)
-	}
-
-	encodedKey := base64.RawURLEncoding.EncodeToString([]byte(pubKey))
-	hostname, _ := os.Hostname()
-	encodedDevice := url.QueryEscape(hostname)
-
-	return fmt.Sprintf("%s/connect?name=%s&key=%s&launch=true", baseURL, encodedDevice, encodedKey), nil
-}

app/cmd/app/app.go

@@ -1,547 +0,0 @@
-//go:build windows || darwin
-
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/ollama/ollama/app/auth"
-	"github.com/ollama/ollama/app/logrotate"
-	"github.com/ollama/ollama/app/server"
-	"github.com/ollama/ollama/app/store"
-	"github.com/ollama/ollama/app/tools"
-	"github.com/ollama/ollama/app/ui"
-	"github.com/ollama/ollama/app/updater"
-	"github.com/ollama/ollama/app/version"
-)
-
-var (
-	wv           = &Webview{}
-	uiServerPort int
-	appStore     *store.Store
-)
-
-var debug = strings.EqualFold(os.Getenv("OLLAMA_DEBUG"), "true") || os.Getenv("OLLAMA_DEBUG") == "1"
-
-var (
-	fastStartup = false
-	devMode     = false
-)
-
-type appMove int
-
-const (
-	CannotMove appMove = iota
-	UserDeclinedMove
-	MoveCompleted
-	AlreadyMoved
-	LoginSession
-	PermissionDenied
-	MoveError
-)
-
-func main() {
-	startHidden := false
-	var urlSchemeRequest string
-	if len(os.Args) > 1 {
-		for _, arg := range os.Args {
-			// Handle URL scheme requests (Windows)
-			if strings.HasPrefix(arg, "ollama://") {
-				urlSchemeRequest = arg
-				slog.Info("received URL scheme request", "url", arg)
-				continue
-			}
-			switch arg {
-			case "serve":
-				fmt.Fprintln(os.Stderr, "serve command not supported, use ollama")
-				os.Exit(1)
-			case "version", "-v", "--version":
-				fmt.Println(version.Version)
-				os.Exit(0)
-			case "background":
-				// When running the process in this "background" mode, we spawn a
-				// child process for the main app.  This is necessary so the
-				// "Allow in the Background" setting in MacOS can be unchecked
-				// without breaking the main app.  Two copies of the app are
-				// present in the bundle, one for the main app and one for the
-				// background initiator.
-				fmt.Fprintln(os.Stdout, "starting in background")
-				runInBackground()
-				os.Exit(0)
-			case "hidden", "-j", "--hide":
-				// startHidden suppresses the UI on startup, and can be triggered multiple ways
-				// On windows, path based via login startup detection
-				// On MacOS via [NSApp isHidden] from `open -j -a /Applications/Ollama.app` or equivalent
-				// On both via the "hidden" command line argument
-				startHidden = true
-			case "--fast-startup":
-				// Skip optional steps like pending updates to start quickly for immediate use
-				fastStartup = true
-			case "-dev", "--dev":
-				// Development mode: use local dev server and enable CORS
-				devMode = true
-			}
-		}
-	}
-
-	level := slog.LevelInfo
-	if debug {
-		level = slog.LevelDebug
-	}
-
-	logrotate.Rotate(appLogPath)
-	if _, err := os.Stat(filepath.Dir(appLogPath)); errors.Is(err, os.ErrNotExist) {
-		if err := os.MkdirAll(filepath.Dir(appLogPath), 0o755); err != nil {
-			slog.Error(fmt.Sprintf("failed to create server log dir %v", err))
-			return
-		}
-	}
-
-	var logFile io.Writer
-	var err error
-	logFile, err = os.OpenFile(appLogPath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0o755)
-	if err != nil {
-		slog.Error(fmt.Sprintf("failed to create server log %v", err))
-		return
-	}
-	// Detect if we're a GUI app on windows, and if not, send logs to console as well
-	if os.Stderr.Fd() != 0 {
-		// Console app detected
-		logFile = io.MultiWriter(os.Stderr, logFile)
-	}
-
-	handler := slog.NewTextHandler(logFile, &slog.HandlerOptions{
-		Level:     level,
-		AddSource: true,
-		ReplaceAttr: func(_ []string, attr slog.Attr) slog.Attr {
-			if attr.Key == slog.SourceKey {
-				source := attr.Value.Any().(*slog.Source)
-				source.File = filepath.Base(source.File)
-			}
-			return attr
-		},
-	})
-
-	slog.SetDefault(slog.New(handler))
-	logStartup()
-
-	// On Windows, check if another instance is running and send URL to it
-	// 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)
-	}
-
-	// Detect if this is a first start after an upgrade, in
-	// which case we need to do some cleanup
-	var skipMove bool
-	if _, err := os.Stat(updater.UpgradeMarkerFile); err == nil {
-		slog.Debug("first start after upgrade")
-		err = updater.DoPostUpgradeCleanup()
-		if err != nil {
-			slog.Error("failed to cleanup prior version", "error", err)
-		}
-		// We never prompt to move the app after an upgrade
-		skipMove = true
-		// Start hidden after updates to prevent UI from opening automatically
-		startHidden = true
-	}
-
-	if !skipMove && !fastStartup {
-		if maybeMoveAndRestart() == MoveCompleted {
-			return
-		}
-	}
-
-	// Check if another instance is already running
-	// On Windows, focus the existing instance; on other platforms, kill it
-	handleExistingInstance(startHidden)
-
-	// on macOS, offer the user to create a symlink
-	// from /usr/local/bin/ollama to the app bundle
-	installSymlink()
-
-	var ln net.Listener
-	if devMode {
-		// Use a fixed port in dev mode for predictable API access
-		ln, err = net.Listen("tcp", "127.0.0.1:3001")
-	} else {
-		ln, err = net.Listen("tcp", "127.0.0.1:0")
-	}
-	if err != nil {
-		slog.Error("failed to find available port", "error", err)
-		return
-	}
-
-	port := ln.Addr().(*net.TCPAddr).Port
-	token := uuid.NewString()
-	wv.port = port
-	wv.token = token
-	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 {
-		os.Setenv("OLLAMA_CORS", "1")
-
-		// Check if Vite dev server is running on port 5173
-		var conn net.Conn
-		var err error
-		for _, addr := range []string{"127.0.0.1:5173", "localhost:5173"} {
-			conn, err = net.DialTimeout("tcp", addr, 2*time.Second)
-			if err == nil {
-				conn.Close()
-				break
-			}
-		}
-
-		if err != nil {
-			slog.Error("Vite dev server not running on port 5173")
-			fmt.Fprintln(os.Stderr, "Error: Vite dev server is not running on port 5173")
-			fmt.Fprintln(os.Stderr, "Please run 'npm run dev' in the ui/app directory to start the UI in development mode")
-			os.Exit(1)
-		}
-	}
-
-	// Initialize tools registry
-	toolRegistry := tools.NewRegistry()
-	slog.Info("initialized tools registry", "tool_count", len(toolRegistry.List()))
-
-	// ctx is the app-level context that will be used to stop the app
-	ctx, cancel := context.WithCancel(context.Background())
-
-	// octx is the ollama server context that will be used to stop the ollama server
-	octx, ocancel := context.WithCancel(ctx)
-
-	// TODO (jmorganca): instead we should instantiate the
-	// webview with the store instead of assigning it here, however
-	// making the webview a global variable is easier for now
-	wv.Store = st
-	done := make(chan error, 1)
-	osrv := server.New(st, devMode)
-	go func() {
-		slog.Info("starting ollama server")
-		done <- osrv.Run(octx)
-	}()
-
-	upd := &updater.Updater{Store: st}
-
-	uiServer := ui.Server{
-		Token: token,
-		Restart: func() {
-			ocancel()
-			<-done
-			octx, ocancel = context.WithCancel(ctx)
-			go func() {
-				done <- osrv.Run(octx)
-			}()
-		},
-		Store:        st,
-		ToolRegistry: toolRegistry,
-		Dev:          devMode,
-		Logger:       slog.Default(),
-		Updater:      upd,
-		UpdateAvailableFunc: func() {
-			UpdateAvailable("")
-		},
-	}
-
-	srv := &http.Server{
-		Handler: uiServer.Handler(),
-	}
-
-	// Start the UI server
-	slog.Info("starting ui server", "port", port)
-	go func() {
-		slog.Debug("starting ui server on port", "port", port)
-		err = srv.Serve(ln)
-		if err != nil && !errors.Is(err, http.ErrServerClosed) {
-			slog.Warn("desktop server", "error", err)
-		}
-		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("")
-		}
-	}
-
-	hasCompletedFirstRun, err := st.HasCompletedFirstRun()
-	if err != nil {
-		slog.Error("failed to load has completed first run", "error", err)
-	}
-
-	if !hasCompletedFirstRun {
-		err = st.SetHasCompletedFirstRun(true)
-		if err != nil {
-			slog.Error("failed to set has completed first run", "error", err)
-		}
-	}
-
-	// capture SIGINT and SIGTERM signals and gracefully shutdown the app
-	signals := make(chan os.Signal, 1)
-	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
-	go func() {
-		<-signals
-		slog.Info("received SIGINT or SIGTERM signal, shutting down")
-		quit()
-	}()
-
-	if urlSchemeRequest != "" && runtime.GOOS != "windows" {
-		go func() {
-			handleURLSchemeInCurrentInstance(urlSchemeRequest)
-		}()
-	} else if urlSchemeRequest == "" {
-		slog.Debug("no URL scheme request to handle")
-	}
-
-	go func() {
-		slog.Debug("waiting for ollama server to be ready")
-		if err := ui.WaitForServer(ctx, 10*time.Second); err != nil {
-			slog.Warn("ollama server not ready, continuing anyway", "error", err)
-		}
-
-		if _, err := uiServer.UserData(ctx); err != nil {
-			slog.Warn("failed to load user data", "error", err)
-		}
-	}()
-
-	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)
-
-	slog.Info("shutting down desktop server")
-	if err := srv.Close(); err != nil {
-		slog.Warn("error shutting down desktop server", "error", err)
-	}
-
-	slog.Info("shutting down ollama server")
-	cancel()
-	<-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
-	// slow the user down with an upgrade.
-	if updater.IsUpdatePending() {
-		if fastStartup {
-			// 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
-				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("")
-			} else {
-				slog.Debug("launching new version...")
-				// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
-				LaunchNewApp()
-				os.Exit(0)
-			}
-		}
-	}
-}
-
-func checkUserLoggedIn(uiServerPort int) bool {
-	if uiServerPort == 0 {
-		slog.Debug("UI server not ready yet, skipping auth check")
-		return false
-	}
-
-	resp, err := http.Post(fmt.Sprintf("http://127.0.0.1:%d/api/me", uiServerPort), "application/json", nil)
-	if err != nil {
-		slog.Debug("failed to call local auth endpoint", "error", err)
-		return false
-	}
-	defer resp.Body.Close()
-
-	// Check if the response is successful
-	if resp.StatusCode != http.StatusOK {
-		slog.Debug("auth endpoint returned non-OK status", "status", resp.StatusCode)
-		return false
-	}
-
-	var user struct {
-		ID   string `json:"id"`
-		Name string `json:"name"`
-	}
-
-	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
-		slog.Debug("failed to parse user response", "error", err)
-		return false
-	}
-
-	// Verify we have a valid user with an ID and name
-	if user.ID == "" || user.Name == "" {
-		slog.Debug("user response missing required fields", "id", user.ID, "name", user.Name)
-		return false
-	}
-
-	slog.Debug("user is logged in", "user_id", user.ID, "user_name", user.Name)
-	return true
-}
-
-// handleConnectURLScheme fetches the connect URL and opens it in the browser
-func handleConnectURLScheme() {
-	if checkUserLoggedIn(uiServerPort) {
-		slog.Info("user is already logged in, opening app instead")
-		openUI("/")
-		return
-	}
-
-	connectURL, err := auth.BuildConnectURL("https://ollama.com")
-	if err != nil {
-		slog.Error("failed to build connect URL", "error", err)
-		openInBrowser("https://ollama.com/connect")
-		return
-	}
-
-	openInBrowser(connectURL)
-}
-
-// openInBrowser opens the specified URL in the default browser
-func openInBrowser(url string) {
-	var cmd string
-	var args []string
-
-	switch runtime.GOOS {
-	case "windows":
-		cmd = "rundll32"
-		args = []string{"url.dll,FileProtocolHandler", url}
-	case "darwin":
-		cmd = "open"
-		args = []string{url}
-	default: // "linux", "freebsd", "openbsd", "netbsd"... should not reach here
-		slog.Warn("unsupported OS for openInBrowser", "os", runtime.GOOS)
-	}
-
-	slog.Info("executing browser command", "cmd", cmd, "args", args)
-	if err := exec.Command(cmd, args...).Start(); err != nil {
-		slog.Error("failed to open URL in browser", "url", url, "cmd", cmd, "args", args, "error", err)
-	}
-}
-
-// parseURLScheme parses an ollama:// URL and validates it
-// Supports: ollama:// (open app) and ollama://connect (OAuth)
-func parseURLScheme(urlSchemeRequest string) (isConnect bool, err error) {
-	parsedURL, err := url.Parse(urlSchemeRequest)
-	if err != nil {
-		return false, fmt.Errorf("invalid URL: %w", err)
-	}
-
-	// Check if this is a connect URL
-	if parsedURL.Host == "connect" || strings.TrimPrefix(parsedURL.Path, "/") == "connect" {
-		return true, nil
-	}
-
-	// Allow bare ollama:// or ollama:/// to open the app
-	if (parsedURL.Host == "" && parsedURL.Path == "") || parsedURL.Path == "/" {
-		return false, nil
-	}
-
-	return false, fmt.Errorf("unsupported ollama:// URL path: %s", urlSchemeRequest)
-}
-
-// 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
-	}
-	if isConnect {
-		connect()
-	} else {
-		open()
-	}
-	return nil
-}

app/cmd/app/app_darwin.h

@@ -1,69 +0,0 @@
-#import <Cocoa/Cocoa.h>
-#import <Security/Security.h>
-
-@interface AppDelegate : NSObject <NSApplicationDelegate>
-- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
-@end
-
-enum AppMove
-{
-    CannotMove,
-    UserDeclinedMove,
-    MoveCompleted,
-    AlreadyMoved,
-    LoginSession,
-    PermissionDenied,
-    MoveError,
-};
-
-void run(bool showOnboarding, bool startHidden);
-void killOtherInstances();
-bool otherOllamaInstanceRunning(void);
-enum AppMove askToMoveToApplications();
-int createSymlinkWithAuthorization();
-int installSymlink(const char *cliPath);
-extern void Restart();
-// extern void Quit();
-void StartUI(const char *path);
-void ShowUI();
-bool IsOnboardingActive(void);
-void StopUI();
-void StartUpdate();
-void darwinStartHiddenTasks();
-void launchApp(const char *appPath);
-void updateAvailable();
-void quit();
-void uiRequest(char *path);
-void registerSelfAsLoginItem(bool firstTimeRun);
-void unregisterSelfFromLoginItem();
-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 *ClaudeDesktopDownloadRequest(char **authorization);
-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

@@ -1,440 +0,0 @@
-//go:build windows || darwin
-
-package main
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"log/slog"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"syscall"
-	"unsafe"
-
-	"github.com/ollama/ollama/app/updater"
-	"github.com/ollama/ollama/app/version"
-	"github.com/ollama/ollama/app/wintray"
-	"golang.org/x/sys/windows"
-)
-
-var (
-	u32                  = windows.NewLazySystemDLL("User32.dll")
-	pBringWindowToTop    = u32.NewProc("BringWindowToTop")
-	pShowWindow          = u32.NewProc("ShowWindow")
-	pSendMessage         = u32.NewProc("SendMessageA")
-	pGetSystemMetrics    = u32.NewProc("GetSystemMetrics")
-	pGetWindowRect       = u32.NewProc("GetWindowRect")
-	pSetWindowPos        = u32.NewProc("SetWindowPos")
-	pSetForegroundWindow = u32.NewProc("SetForegroundWindow")
-	pSetActiveWindow     = u32.NewProc("SetActiveWindow")
-	pIsIconic            = u32.NewProc("IsIconic")
-
-	appPath         = filepath.Join(os.Getenv("LOCALAPPDATA"), "Programs", "Ollama")
-	appLogPath      = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "app.log")
-	startupShortcut = filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "Ollama.lnk")
-	ollamaPath      string
-	DesktopAppName  = "ollama app.exe"
-)
-
-func init() {
-	// With alternate install location use executable location
-	exe, err := os.Executable()
-	if err != nil {
-		slog.Warn("error discovering executable directory", "error", err)
-	} else {
-		appPath = filepath.Dir(exe)
-	}
-	ollamaPath = filepath.Join(appPath, "ollama.exe")
-
-	// Handle developer mode (go run ./cmd/app)
-	if _, err := os.Stat(ollamaPath); err != nil {
-		pwd, err := os.Getwd()
-		if err != nil {
-			slog.Warn("missing ollama.exe and failed to get pwd", "error", err)
-			return
-		}
-		distAppPath := filepath.Join(pwd, "dist", "windows-"+runtime.GOARCH)
-		distOllamaPath := filepath.Join(distAppPath, "ollama.exe")
-		if _, err := os.Stat(distOllamaPath); err == nil {
-			slog.Info("detected developer mode")
-			appPath = distAppPath
-			ollamaPath = distOllamaPath
-		}
-	}
-}
-
-func maybeMoveAndRestart() appMove {
-	return 0
-}
-
-// handleExistingInstance checks for existing instances and optionally focuses them
-func handleExistingInstance(startHidden bool) {
-	if wintray.CheckAndFocusExistingInstance(!startHidden) {
-		slog.Info("existing instance found, exiting")
-		os.Exit(0)
-	}
-}
-
-func installSymlink() {}
-
-type appCallbacks struct {
-	t        wintray.TrayCallbacks
-	shutdown func()
-}
-
-var app = &appCallbacks{}
-
-func (ac *appCallbacks) UIRun(path string) {
-	wv.Run(path)
-}
-
-func (*appCallbacks) UIShow() {
-	openUI("/")
-}
-
-func openUI(path string) {
-	if wv.IsRunning() && wv.webview != nil {
-		showWindow(wv.webview.Window())
-		return
-	}
-	wv.Run(path)
-}
-
-func (*appCallbacks) UITerminate() {
-	wv.Terminate()
-}
-
-func (*appCallbacks) UIRunning() bool {
-	return wv.IsRunning()
-}
-
-func (*appCallbacks) UIOnboarding() bool {
-	return wv.OnboardingActive()
-}
-
-func (app *appCallbacks) Quit() {
-	app.t.Quit()
-	wv.Terminate()
-}
-
-// TODO - reconcile with above for consistency between mac/windows
-func quit() {
-	wv.Terminate()
-}
-
-func (app *appCallbacks) DoUpdate() {
-	// Safeguard in case we have requests in flight that need to drain...
-	slog.Info("Waiting for server to shutdown")
-
-	app.shutdown()
-
-	if err := updater.DoUpgrade(true); err != nil { //nolint:staticcheck,nolintlint // DoUpgrade may always return non-nil on Windows
-		slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
-	}
-}
-
-// HandleURLScheme implements the URLSchemeHandler interface
-func (app *appCallbacks) HandleURLScheme(urlScheme string) {
-	handleURLSchemeRequest(urlScheme)
-}
-
-// handleURLSchemeRequest processes URL scheme requests from other instances
-func handleURLSchemeRequest(urlScheme string) {
-	handleURLSchemeInCurrentInstance(urlScheme)
-}
-
-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) {
-	var err error
-	app.shutdown = shutdown
-	app.t, err = wintray.NewTray(app)
-	if err != nil {
-		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)
-
-	// TODO - can this be generalized?
-	go func() {
-		<-signals
-		slog.Debug("shutting down due to signal")
-		app.t.Quit()
-		wv.Terminate()
-	}()
-
-	// On windows, we run the final tasks in the main thread
-	// before starting the tray event loop.  These final tasks
-	// may trigger the UI, and must do that from the main thread.
-	if !startHidden {
-		// Determine if the process was started from a shortcut
-		// ~\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Ollama
-		const STARTF_TITLEISLINKNAME = 0x00000800
-		var info windows.StartupInfo
-		if err := windows.GetStartupInfo(&info); err != nil {
-			slog.Debug("unable to retrieve startup info", "error", err)
-		} else if info.Flags&STARTF_TITLEISLINKNAME == STARTF_TITLEISLINKNAME {
-			linkPath := windows.UTF16PtrToString(info.Title)
-			if strings.Contains(linkPath, "Startup") {
-				startHidden = true
-			}
-		}
-	}
-	runInitialWindowsUI(startHidden, showOnboarding, urlSchemeRequest, startHiddenTasks, handleURLSchemeInCurrentInstance, func(path string) {
-		ptr := wv.Run(path)
-
-		// Set the window icon using the tray icon
-		if ptr != nil {
-			iconHandle := app.t.GetIconHandle()
-			if iconHandle != 0 {
-				hwnd := uintptr(ptr)
-				const ICON_SMALL = 0
-				const ICON_BIG = 1
-				const WM_SETICON = 0x0080
-
-				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
-				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
-			}
-		}
-
-		centerWindow(ptr)
-	})
-
-	if !hasCompletedFirstRun {
-		// Only create the login shortcut on first start
-		// so we can respect users deletion of the link
-		err = createLoginShortcut()
-		if err != nil {
-			slog.Warn("unable to create login shortcut", "error", err)
-		}
-	}
-
-	app.t.TrayRun() // This will block the main thread
-}
-
-func createLoginShortcut() error {
-	// The installer lays down a shortcut for us so we can copy it without
-	// having to resort to calling COM APIs to establish the shortcut
-	shortcutOrigin := filepath.Join(appPath, "lib", "Ollama.lnk")
-
-	_, err := os.Stat(startupShortcut)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			in, err := os.Open(shortcutOrigin)
-			if err != nil {
-				return fmt.Errorf("unable to open shortcut %s : %w", shortcutOrigin, err)
-			}
-			defer in.Close()
-			out, err := os.Create(startupShortcut)
-			if err != nil {
-				return fmt.Errorf("unable to open startup link %s : %w", startupShortcut, err)
-			}
-			defer out.Close()
-			_, err = io.Copy(out, in)
-			if err != nil {
-				return fmt.Errorf("unable to copy shortcut %s : %w", startupShortcut, err)
-			}
-			err = out.Sync()
-			if err != nil {
-				return fmt.Errorf("unable to sync shortcut %s : %w", startupShortcut, err)
-			}
-			slog.Info("Created Startup shortcut", "shortcut", startupShortcut)
-		} else {
-			slog.Warn("unexpected error looking up Startup shortcut", "error", err)
-		}
-	} else {
-		slog.Debug("Startup link already exists", "shortcut", startupShortcut)
-	}
-	return nil
-}
-
-func LaunchNewApp() {
-}
-
-func logStartup() {
-	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
-}
-
-const (
-	SW_HIDE        = 0  // Hides the window
-	SW_SHOW        = 5  // Shows window in its current size/position
-	SW_SHOWNA      = 8  // Shows without activating
-	SW_MINIMIZE    = 6  // Minimizes the window
-	SW_RESTORE     = 9  // Restores to previous size/position
-	SW_SHOWDEFAULT = 10 // Sets show state based on program state
-	SM_CXSCREEN    = 0
-	SM_CYSCREEN    = 1
-	HWND_TOP       = 0
-	SWP_NOSIZE     = 0x0001
-	SWP_NOMOVE     = 0x0002
-	SWP_NOZORDER   = 0x0004
-	SWP_SHOWWINDOW = 0x0040
-
-	// Menu constants
-	MF_STRING     = 0x00000000
-	MF_SEPARATOR  = 0x00000800
-	MF_GRAYED     = 0x00000001
-	TPM_RETURNCMD = 0x0100
-)
-
-// POINT structure for cursor position
-type POINT struct {
-	X int32
-	Y int32
-}
-
-// Rect structure for GetWindowRect
-type Rect struct {
-	Left   int32
-	Top    int32
-	Right  int32
-	Bottom int32
-}
-
-func centerWindow(ptr unsafe.Pointer) {
-	hwnd := uintptr(ptr)
-	if hwnd == 0 {
-		return
-	}
-
-	var rect Rect
-	pGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&rect)))
-
-	screenWidth, _, _ := pGetSystemMetrics.Call(uintptr(SM_CXSCREEN))
-	screenHeight, _, _ := pGetSystemMetrics.Call(uintptr(SM_CYSCREEN))
-
-	windowWidth := rect.Right - rect.Left
-	windowHeight := rect.Bottom - rect.Top
-
-	x := (int32(screenWidth) - windowWidth) / 2
-	y := (int32(screenHeight) - windowHeight) / 2
-
-	// Ensure the window is not positioned off-screen
-	if x < 0 {
-		x = 0
-	}
-	if y < 0 {
-		y = 0
-	}
-
-	pSetWindowPos.Call(
-		hwnd,
-		uintptr(HWND_TOP),
-		uintptr(x),
-		uintptr(y),
-		uintptr(windowWidth),  // Keep original width
-		uintptr(windowHeight), // Keep original height
-		uintptr(SWP_SHOWWINDOW),
-	)
-}
-
-func showWindow(ptr unsafe.Pointer) {
-	hwnd := uintptr(ptr)
-	if hwnd != 0 {
-		iconHandle := app.t.GetIconHandle()
-		if iconHandle != 0 {
-			const ICON_SMALL = 0
-			const ICON_BIG = 1
-			const WM_SETICON = 0x0080
-
-			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
-			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
-		}
-
-		// Check if window is minimized
-		isMinimized, _, _ := pIsIconic.Call(hwnd)
-		if isMinimized != 0 {
-			// Restore the window if it's minimized
-			pShowWindow.Call(hwnd, uintptr(SW_RESTORE))
-		}
-
-		// Show the window
-		pShowWindow.Call(hwnd, uintptr(SW_SHOW))
-
-		// Bring window to top
-		pBringWindowToTop.Call(hwnd)
-
-		// Force window to foreground
-		pSetForegroundWindow.Call(hwnd)
-
-		// Make it the active window
-		pSetActiveWindow.Call(hwnd)
-
-		// Ensure window is positioned on top
-		pSetWindowPos.Call(
-			hwnd,
-			uintptr(HWND_TOP),
-			0, 0, 0, 0,
-			uintptr(SWP_NOSIZE|SWP_NOMOVE|SWP_SHOWWINDOW),
-		)
-	}
-}
-
-// HideWindow hides the application window
-func hideWindow(ptr unsafe.Pointer) {
-	hwnd := uintptr(ptr)
-	if hwnd != 0 {
-		pShowWindow.Call(
-			hwnd,
-			uintptr(SW_HIDE),
-		)
-	}
-}
-
-func setOnboardingWindowStyle(_ unsafe.Pointer, _ bool) {}
-
-func runInBackground() {
-	exe, err := os.Executable()
-	if err != nil {
-		slog.Error("failed to get executable path", "error", err)
-		os.Exit(1)
-	}
-	cmd := exec.Command(exe, "hidden")
-	if cmd != nil {
-		err = cmd.Run()
-		if err != nil {
-			slog.Error("failed to run Ollama", "exe", exe, "error", err)
-			os.Exit(1)
-		}
-	} else {
-		slog.Error("failed to start Ollama", "exe", exe)
-		os.Exit(1)
-	}
-}
-
-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) {
-	if urlSchemeRequest == "" {
-		return
-	}
-
-	// Try to send URL to existing instance using wintray messaging
-	if wintray.CheckAndSendToExistingInstance(urlSchemeRequest) {
-		os.Exit(0)
-	}
-}

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/menu.h

@@ -1,27 +0,0 @@
-#ifndef MENU_H
-#define MENU_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct
-{
-    char *label;
-    int enabled;
-    int separator;
-} menuItem;
-
-// TODO (jmorganca): these need to be forward declared in the webview.h file
-// for now but ideally they should be in this header file on windows too
-#ifndef WIN32
-int menu_get_item_count();
-void *menu_get_items();
-void menu_handle_selection(char *item);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

app/cmd/app/webview.go

@@ -1,539 +0,0 @@
-//go:build windows || darwin
-
-package main
-
-// #include "menu.h"
-import "C"
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"net/http"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-	"unsafe"
-
-	"github.com/ollama/ollama/app/dialog"
-	"github.com/ollama/ollama/app/store"
-	"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
-
-	Store *store.Store
-}
-
-// Run initializes the webview and starts its event loop.
-// Note: this must be called from the primary app thread
-// This returns the OS native window handle to the caller
-func (w *Webview) Run(path string) unsafe.Pointer {
-	var url string
-	if devMode {
-		// In development mode, use the local dev server
-		url = fmt.Sprintf("http://localhost:5173%s", path)
-	} else {
-		url = fmt.Sprintf("http://127.0.0.1:%d%s", w.port, path)
-	}
-	w.mutex.Lock()
-	defer w.mutex.Unlock()
-
-	if w.webview == nil {
-		// Note: turning on debug on macos throws errors but is marginally functional for debugging
-		// TODO (jmorganca): we should pre-create the window and then provide it here to
-		// webview so we can hide it from the start and make other modifications
-		wv := webview.New(debug)
-		// start the window hidden
-		hideWindow(wv.Window())
-		wv.SetTitle("Ollama")
-
-		// TODO (jmorganca): this isn't working yet since it needs to be set
-		// on the first page load, ideally in an interstitial page like `/token`
-		// that exists only to set the cookie and redirect to /
-		// wv.Init(fmt.Sprintf(`document.cookie = "token=%s; path=/"`, w.token))
-		init := `
-		// Disable reload
-		document.addEventListener('keydown', function(e) {
-			if ((e.ctrlKey || e.metaKey) && e.key === 'r') {
-				e.preventDefault();
-				return false;
-			}
-		});
-
-		// Prevent back/forward navigation
-		window.addEventListener('popstate', function(e) {
-			e.preventDefault();
-			history.pushState(null, '', window.location.pathname);
-			return false;
-		});
-
-		// Clear history on load
-		window.addEventListener('load', function() {
-			history.pushState(null, '', window.location.pathname);
-			window.history.replaceState(null, '', window.location.pathname);
-		});
-
-		// Set token cookie
-		document.cookie = "token=` + w.token + `; path=/";
-	`
-		// Windows-specific scrollbar styling
-		if runtime.GOOS == "windows" {
-			init += `
-				// Keep Edge WebView2 scrollbars aligned with the light-only app theme.
-				function updateScrollbarStyles() {
-					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;
-						}
-					` + "`" + `;
-					document.head.appendChild(style);
-				}
-
-				window.addEventListener('load', updateScrollbarStyles);
-			`
-		}
-		// on windows make ctrl+n open new chat
-		// TODO (jmorganca): later we should use proper accelerators
-		// once we introduce a native menu for the window
-		// this is only used on windows since macOS uses the proper accelerators
-		if runtime.GOOS == "windows" {
-			init += `
-				document.addEventListener('keydown', function(e) {
-					if ((e.ctrlKey || e.metaKey) && e.key === 'n') {
-						e.preventDefault();
-						// Use the existing navigation method
-						history.pushState({}, '', '/c/new');
-						window.dispatchEvent(new PopStateEvent('popstate'));
-						return false;
-					}
-				});
-			`
-		}
-
-		init += fmt.Sprintf(`
-			window.OLLAMA_PLATFORM = %q;
-			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();
-					window.zoomIn && window.zoomIn();
-					return false;
-				}
-
-				// CMD/Ctrl + Minus (zoom out)
-				if ((e.metaKey || e.ctrlKey) && e.key === '-') {
-					e.preventDefault();
-					window.zoomOut && window.zoomOut();
-					return false;
-				}
-
-				// CMD/Ctrl + 0 (reset zoom)
-				if ((e.metaKey || e.ctrlKey) && e.key === '0') {
-					e.preventDefault();
-					window.zoomReset && window.zoomReset();
-					return false;
-				}
-			}, true);
-		`)
-
-		wv.Bind("zoomIn", func() {
-			current := wv.GetZoom()
-			wv.SetZoom(current + 0.1)
-		})
-
-		wv.Bind("zoomOut", func() {
-			current := wv.GetZoom()
-			wv.SetZoom(current - 0.1)
-		})
-
-		wv.Bind("zoomReset", func() {
-			wv.SetZoom(1.0)
-		})
-
-		wv.Bind("ready", func() {
-			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() {
-			go func() {
-				// Helper function to call the JavaScript callback with data or null
-				callCallback := func(data interface{}) {
-					dataJSON, _ := json.Marshal(data)
-					wv.Dispatch(func() {
-						wv.Eval(fmt.Sprintf("window.__selectModelsDirectoryCallback && window.__selectModelsDirectoryCallback(%s)", dataJSON))
-					})
-				}
-
-				directory, err := dialog.Directory().Title("Select Model Directory").ShowHidden(true).Browse()
-				if err != nil {
-					slog.Debug("Directory selection cancelled or failed", "error", err)
-					callCallback(nil)
-					return
-				}
-				slog.Debug("Directory selected", "path", directory)
-				callCallback(directory)
-			}()
-		})
-
-		// Bind selectFiles function for selecting multiple files at once
-		wv.Bind("selectFiles", func() {
-			go func() {
-				// Helper function to call the JavaScript callback with data or null
-				callCallback := func(data interface{}) {
-					dataJSON, _ := json.Marshal(data)
-					wv.Dispatch(func() {
-						wv.Eval(fmt.Sprintf("window.__selectFilesCallback && window.__selectFilesCallback(%s)", dataJSON))
-					})
-				}
-
-				// Define allowed extensions for native dialog filtering
-				textExts := []string{
-					"pdf", "docx", "txt", "md", "csv", "json", "xml", "html", "htm",
-					"js", "jsx", "ts", "tsx", "py", "java", "cpp", "c", "cc", "h", "cs", "php", "rb",
-					"go", "rs", "swift", "kt", "scala", "sh", "bat", "yaml", "yml", "toml", "ini",
-					"cfg", "conf", "log", "rtf",
-				}
-				imageExts := []string{"png", "jpg", "jpeg", "webp"}
-				allowedExts := append(textExts, imageExts...)
-
-				// Use native multiple file selection with extension filtering
-				filenames, err := dialog.File().
-					Filter("Supported Files", allowedExts...).
-					Title("Select Files").
-					LoadMultiple()
-				if err != nil {
-					slog.Debug("Multiple file selection cancelled or failed", "error", err)
-					callCallback(nil)
-					return
-				}
-
-				if len(filenames) == 0 {
-					callCallback(nil)
-					return
-				}
-
-				var files []map[string]string
-				maxFileSize := int64(10 * 1024 * 1024) // 10MB
-
-				for _, filename := range filenames {
-					// Check file extension (double-check after native dialog filtering)
-					ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
-					validExt := false
-					for _, allowedExt := range allowedExts {
-						if ext == allowedExt {
-							validExt = true
-							break
-						}
-					}
-					if !validExt {
-						slog.Warn("file extension not allowed, skipping", "filename", filepath.Base(filename), "extension", ext)
-						continue
-					}
-
-					// Check file size before reading (pre-filter large files)
-					fileStat, err := os.Stat(filename)
-					if err != nil {
-						slog.Error("failed to get file info", "error", err, "filename", filename)
-						continue
-					}
-
-					if fileStat.Size() > maxFileSize {
-						slog.Warn("file too large, skipping", "filename", filepath.Base(filename), "size", fileStat.Size())
-						continue
-					}
-
-					fileBytes, err := os.ReadFile(filename)
-					if err != nil {
-						slog.Error("failed to read file", "error", err, "filename", filename)
-						continue
-					}
-
-					mimeType := http.DetectContentType(fileBytes)
-					dataURL := fmt.Sprintf("data:%s;base64,%s", mimeType, base64.StdEncoding.EncodeToString(fileBytes))
-
-					fileResult := map[string]string{
-						"filename": filepath.Base(filename),
-						"path":     filename,
-						"dataURL":  dataURL,
-					}
-
-					files = append(files, fileResult)
-				}
-
-				if len(files) == 0 {
-					callCallback(nil)
-				} else {
-					callCallback(files)
-				}
-			}()
-		})
-
-		wv.Bind("drag", func() {
-			wv.Dispatch(func() {
-				drag(wv.Window())
-			})
-		})
-
-		wv.Bind("doubleClick", func() {
-			wv.Dispatch(func() {
-				doubleClick(wv.Window())
-			})
-		})
-
-		// Add binding for working directory selection
-		wv.Bind("selectWorkingDirectory", func() {
-			go func() {
-				// Helper function to call the JavaScript callback with data or null
-				callCallback := func(data interface{}) {
-					dataJSON, _ := json.Marshal(data)
-					wv.Dispatch(func() {
-						wv.Eval(fmt.Sprintf("window.__selectWorkingDirectoryCallback && window.__selectWorkingDirectoryCallback(%s)", dataJSON))
-					})
-				}
-
-				directory, err := dialog.Directory().Title("Select Working Directory").ShowHidden(true).Browse()
-				if err != nil {
-					slog.Debug("Directory selection cancelled or failed", "error", err)
-					callCallback(nil)
-					return
-				}
-				slog.Debug("Directory selected", "path", directory)
-				callCallback(directory)
-			}()
-		})
-
-		wv.Bind("setContextMenuItems", func(items []map[string]interface{}) error {
-			menuMutex.Lock()
-			defer menuMutex.Unlock()
-
-			if len(menuItems) > 0 {
-				pinner.Unpin()
-			}
-
-			menuItems = nil
-			for _, item := range items {
-				menuItem := C.menuItem{
-					label:     C.CString(item["label"].(string)),
-					enabled:   0,
-					separator: 0,
-				}
-
-				if item["enabled"] != nil {
-					menuItem.enabled = 1
-				}
-
-				if item["separator"] != nil {
-					menuItem.separator = 1
-				}
-				menuItems = append(menuItems, menuItem)
-			}
-			return nil
-		})
-
-		// Debounce resize events
-		var resizeTimer *time.Timer
-		var resizeMutex sync.Mutex
-
-		wv.Bind("resize", func(width, height int) {
-			if w.Store != nil {
-				resizeMutex.Lock()
-				if resizeTimer != nil {
-					resizeTimer.Stop()
-				}
-				resizeTimer = time.AfterFunc(100*time.Millisecond, func() {
-					err := w.Store.SetWindowSize(width, height)
-					if err != nil {
-						slog.Error("failed to set window size", "error", err)
-					}
-				})
-				resizeMutex.Unlock()
-			}
-		})
-
-		// On Darwin, we can't have 2 threads both running global event loops
-		// but on Windows, the event loops are tied to the window, so we're
-		// able to run in both the tray and webview
-		if runtime.GOOS != "darwin" {
-			slog.Debug("starting webview event loop")
-			go func() {
-				wv.Run()
-				slog.Debug("webview event loop exited")
-			}()
-		}
-
-		width, height := defaultWindowWidth, defaultWindowHeight
-		if w.Store != nil {
-			storedWidth, storedHeight, 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
-			}
-		}
-		wv.SetSize(width, height, webview.HintNone)
-		wv.SetSize(minimumWindowWidth, minimumWindowHeight, webview.HintMin)
-
-		w.webview = wv
-		w.webview.Navigate(url)
-	} else {
-		w.webview.Eval(fmt.Sprintf(`
-			history.pushState({}, '', '%s');
-		`, path))
-		showWindow(w.webview.Window())
-	}
-
-	return w.webview.Window()
-}
-
-func (w *Webview) Terminate() {
-	w.onboarding.Store(false)
-	w.mutex.Lock()
-	if w.webview == nil {
-		w.mutex.Unlock()
-		return
-	}
-
-	wv := w.webview
-	w.webview = nil
-	w.mutex.Unlock()
-	wv.Terminate()
-	wv.Destroy()
-}
-
-func (w *Webview) OnboardingActive() bool {
-	return w.onboarding.Load()
-}
-
-func (w *Webview) IsRunning() bool {
-	w.mutex.Lock()
-	defer w.mutex.Unlock()
-	return w.webview != nil
-}
-
-var (
-	menuItems []C.menuItem
-	menuMutex sync.RWMutex
-	pinner    runtime.Pinner
-)
-
-//export menu_get_item_count
-func menu_get_item_count() C.int {
-	menuMutex.RLock()
-	defer menuMutex.RUnlock()
-	return C.int(len(menuItems))
-}
-
-//export menu_get_items
-func menu_get_items() unsafe.Pointer {
-	menuMutex.RLock()
-	defer menuMutex.RUnlock()
-
-	if len(menuItems) == 0 {
-		return nil
-	}
-
-	// Return pointer to the slice data
-	pinner.Pin(&menuItems[0])
-	return unsafe.Pointer(&menuItems[0])
-}
-
-//export menu_handle_selection
-func menu_handle_selection(item *C.char) {
-	wv.webview.Eval(fmt.Sprintf("window.handleContextMenuResult('%s')", C.GoString(item)))
-}

app/cmd/squirrel/Info.plist

@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-  <dict>
-    <key>CFBundleDevelopmentRegion</key>
-    <string>English</string>
-    <key>CFBundleExecutable</key>
-    <string>Squirrel</string>
-    <key>CFBundleIconFile</key>
-    <string/>
-    <key>CFBundleIdentifier</key>
-    <string>com.github.Squirrel</string>
-    <key>CFBundleInfoDictionaryVersion</key>
-    <string>6.0</string>
-    <key>CFBundleName</key>
-    <string>Squirrel</string>
-    <key>CFBundlePackageType</key>
-    <string>FMWK</string>
-    <key>CFBundleShortVersionString</key>
-    <string>1.0</string>
-    <key>CFBundleSignature</key>
-    <string>????</string>
-    <key>CFBundleVersion</key>
-    <string>1</string>
-    <key>DTCompiler</key>
-    <string>com.apple.compilers.llvm.clang.1_0</string>
-    <key>DTSDKBuild</key>
-    <string>22E245</string>
-    <key>DTSDKName</key>
-    <string>macosx13.3</string>
-    <key>DTXcode</key>
-    <string>1431</string>
-    <key>DTXcodeBuild</key>
-    <string>14E300c</string>
-    <key>NSHumanReadableCopyright</key>
-    <string>Copyright © 2013 GitHub. All rights reserved.</string>
-    <key>NSPrincipalClass</key>
-    <string/>
-  </dict>
-</plist>

app/darwin/Ollama.app/Contents/Info.plist

@@ -9,7 +9,7 @@
     <key>CFBundleIconFile</key>
     <string>icon.icns</string>
     <key>CFBundleIdentifier</key>
-    <string>com.electron.ollama</string>
+    <string>com.ollama.ollama</string>
     <key>CFBundleInfoDictionaryVersion</key>
     <string>6.0</string>
     <key>CFBundleName</key>
@@ -25,7 +25,7 @@
     <key>DTSDKBuild</key>
     <string>22E245</string>
     <key>DTSDKName</key>
-    <string>macosx14.0</string>
+    <string>macosx13.3</string>
     <key>DTXcode</key>
     <string>1431</string>
     <key>DTXcodeBuild</key>
@@ -33,19 +33,8 @@
     <key>LSApplicationCategoryType</key>
     <string>public.app-category.developer-tools</string>
     <key>LSMinimumSystemVersion</key>
-    <string>14.0</string>
+    <string>11.0</string>
     <key>LSUIElement</key>
     <true/>
-    <key>CFBundleURLTypes</key>
-    <array>
-      <dict>
-        <key>CFBundleURLName</key>
-        <string>Ollama URL</string>
-        <key>CFBundleURLSchemes</key>
-        <array>
-          <string>ollama</string>
-        </array>
-      </dict>
-    </array>
   </dict>
 </plist>

app/darwin/Ollama.app/Contents/Library/LaunchAgents/com.ollama.ollama.plist

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>com.ollama.ollama</string>
-    <key>BundleProgram</key>
-	<string>Contents/Frameworks/Squirrel.framework/Versions/A/Squirrel</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>Contents/Frameworks/Squirrel.framework/Versions/A/Squirrel</string>
-        <string>background</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>LimitLoadToSessionType</key>
-	<string>Aqua</string>
-	<key>POSIXSpawnType</key>
-	<string>Interactive</string>
-	<key>LSUIElement</key>
-	<true/>
-	<key>LSBackgroundOnly</key>
-	<false/>
-</dict>
-</plist>

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/LICENSE

@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2018, the dialog authors.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

app/dialog/cocoa/dlg.h

@@ -1,43 +0,0 @@
-#include <objc/NSObjCRuntime.h>
-
-typedef enum {
-	MSG_YESNO,
-	MSG_ERROR,
-	MSG_INFO,
-} AlertStyle;
-
-typedef struct {
-	char* msg;
-	char* title;
-	AlertStyle style;
-} AlertDlgParams;
-
-#define LOADDLG 0
-#define SAVEDLG 1
-#define DIRDLG 2 // browse for directory
-
-typedef struct {
-	int mode; /* which dialog style to invoke (see earlier defines) */
-	char* buf; /* buffer to store selected file */
-	int nbuf; /* number of bytes allocated at buf */
-	char* title; /* title for dialog box (can be nil) */
-	void** exts; /* list of valid extensions (elements actual type is NSString*) */
-	int numext; /* number of items in exts */
-	int relaxext; /* allow other extensions? */
-	char* startDir; /* directory to start in (can be nil) */
-	char* filename; /* default filename for dialog box (can be nil) */
-	int showHidden; /* show hidden files? */
-	int allowMultiple; /* allow multiple file selection? */
-} FileDlgParams;
-
-typedef enum {
-	DLG_OK,
-	DLG_CANCEL,
-	DLG_URLFAIL,
-} DlgResult;
-
-DlgResult alertDlg(AlertDlgParams*);
-DlgResult fileDlg(FileDlgParams*);
-
-void* NSStr(void* buf, int len);
-void NSRelease(void* obj);

app/dialog/cocoa/dlg.m

@@ -1,218 +0,0 @@
-#import <Cocoa/Cocoa.h>
-#include "dlg.h"
-#include <string.h>
-#include <sys/syslimits.h>
-
-// Import UniformTypeIdentifiers for macOS 11+
-#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 110000
-#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
-#endif
-
-void* NSStr(void* buf, int len) {
-	return (void*)[[NSString alloc] initWithBytes:buf length:len encoding:NSUTF8StringEncoding];
-}
-
-void checkActivationPolicy() {
-	NSApplicationActivationPolicy policy = [NSApp activationPolicy];
-	// prohibited NSApp will not show the panel at all.
-	// It probably means that this is not run in a GUI app, that would set the policy on its own,
-	// but in a terminal app - setting it to accessory will allow dialogs to show
-	if (policy == NSApplicationActivationPolicyProhibited) {
-		[NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
-	}
-}
-
-void NSRelease(void* obj) {
-	[(NSObject*)obj release];
-}
-
-@interface AlertDlg : NSObject {
-	AlertDlgParams* params;
-	DlgResult result;
-}
-+ (AlertDlg*)init:(AlertDlgParams*)params;
-- (DlgResult)run;
-@end
-
-DlgResult alertDlg(AlertDlgParams* params) {
-	return [[AlertDlg init:params] run];
-}
-
-@implementation AlertDlg
-+ (AlertDlg*)init:(AlertDlgParams*)params {
-	AlertDlg* d = [AlertDlg alloc];
-	d->params = params;
-	return d;
-}
-
-- (DlgResult)run {
-	if(![NSThread isMainThread]) {
-		[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
-		return self->result;
-	}
-	NSAlert* alert = [[NSAlert alloc] init];
-	if(self->params->title != nil) {
-		[[alert window] setTitle:[[NSString alloc] initWithUTF8String:self->params->title]];
-	}
-	[alert setMessageText:[[NSString alloc] initWithUTF8String:self->params->msg]];
-	switch (self->params->style) {
-	case MSG_YESNO:
-		[alert addButtonWithTitle:@"Yes"];
-		[alert addButtonWithTitle:@"No"];
-		break;
-	case MSG_ERROR:
-		[alert setIcon:[NSImage imageNamed:NSImageNameCaution]];
-		[alert addButtonWithTitle:@"OK"];
-		break;
-	case MSG_INFO:
-		[alert setIcon:[NSImage imageNamed:NSImageNameInfo]];
-		[alert addButtonWithTitle:@"OK"];
-		break;
-	}
-
-	checkActivationPolicy();
-
-	self->result = [alert runModal] == NSAlertFirstButtonReturn ? DLG_OK : DLG_CANCEL;
-	return self->result;
-}
-@end
-
-@interface FileDlg : NSObject {
-	FileDlgParams* params;
-	DlgResult result;
-}
-+ (FileDlg*)init:(FileDlgParams*)params;
-- (DlgResult)run;
-@end
-
-DlgResult fileDlg(FileDlgParams* params) {
-	return [[FileDlg init:params] run];
-}
-
-@implementation FileDlg
-+ (FileDlg*)init:(FileDlgParams*)params {
-	FileDlg* d = [FileDlg alloc];
-	d->params = params;
-	return d;
-}
-
-- (DlgResult)run {
-	if(![NSThread isMainThread]) {
-		[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
-	} else if(self->params->mode == SAVEDLG) {
-		self->result = [self save];
-	} else {
-		self->result = [self load];
-	}
-	return self->result;
-}
-
-- (NSInteger)runPanel:(NSSavePanel*)panel {
-	[panel setFloatingPanel:YES];
-	[panel setShowsHiddenFiles:self->params->showHidden ? YES : NO];
-	[panel setCanCreateDirectories:YES];
-	if(self->params->title != nil) {
-		[panel setTitle:[[NSString alloc] initWithUTF8String:self->params->title]];
-	}
-	// Use modern allowedContentTypes API for better file type support (especially video files)
-	if(self->params->numext > 0) {
-		NSMutableArray *utTypes = [NSMutableArray arrayWithCapacity:self->params->numext];
-		NSString** exts = (NSString**)self->params->exts;
-		for(int i = 0; i < self->params->numext; i++) {
-			UTType *type = [UTType typeWithFilenameExtension:exts[i]];
-			if(type) {
-				[utTypes addObject:type];
-			}
-		}
-		if([utTypes count] > 0) {
-			[panel setAllowedContentTypes:utTypes];
-		}
-	}
-	if(self->params->relaxext) {
-		[panel setAllowsOtherFileTypes:YES];
-	}
-	if(self->params->startDir) {
-		[panel setDirectoryURL:[NSURL URLWithString:[[NSString alloc] initWithUTF8String:self->params->startDir]]];
-	}
-	if(self->params->filename != nil) {
-		[panel setNameFieldStringValue:[[NSString alloc] initWithUTF8String:self->params->filename]];
-	}
-
-	checkActivationPolicy();
-
-	return [panel runModal];
-}
-
-- (DlgResult)save {
-	NSSavePanel* panel = [NSSavePanel savePanel];
-	if(![self runPanel:panel]) {
-		return DLG_CANCEL;
-	} else if(![[panel URL] getFileSystemRepresentation:self->params->buf maxLength:self->params->nbuf]) {
-		return DLG_URLFAIL;
-	}
-	return DLG_OK;
-}
-
-- (DlgResult)load {
-	NSOpenPanel* panel = [NSOpenPanel openPanel];
-	if(self->params->mode == DIRDLG) {
-		[panel setCanChooseDirectories:YES];
-		[panel setCanChooseFiles:NO];
-	}
-	
-	if(self->params->allowMultiple) {
-		[panel setAllowsMultipleSelection:YES];
-	}
-	
-	if(![self runPanel:panel]) {
-		return DLG_CANCEL;
-	}
-	
-	NSArray* urls = [panel URLs];
-	if([urls count] == 0) {
-		return DLG_CANCEL;
-	}
-	
-	if(self->params->allowMultiple) {
-		// For multiple files, we need to return all paths separated by null bytes
-		char* bufPtr = self->params->buf;
-		int remainingBuf = self->params->nbuf;
-		
-		// Calculate total required buffer size first
-		int totalSize = 0;
-		for(NSURL* url in urls) {
-			char tempBuf[PATH_MAX];
-			if(![url getFileSystemRepresentation:tempBuf maxLength:PATH_MAX]) {
-				return DLG_URLFAIL;
-			}
-			totalSize += strlen(tempBuf) + 1; // +1 for null terminator
-		}
-		totalSize += 1; // Final null terminator
-
-		if(totalSize > self->params->nbuf) {
-			// Not enough buffer space
-			return DLG_URLFAIL;
-		}
-
-		// Now actually copy the paths (we know we have space)
-		bufPtr = self->params->buf;
-		for(NSURL* url in urls) {
-			char tempBuf[PATH_MAX];
-			[url getFileSystemRepresentation:tempBuf maxLength:PATH_MAX];
-			int pathLen = strlen(tempBuf);
-			strcpy(bufPtr, tempBuf);
-			bufPtr += pathLen + 1;
-		}
-		*bufPtr = '\0'; // Final null terminator
-	} else {
-		// Single file/directory selection - write path to buffer
-		NSURL* url = [urls firstObject];
-		if(![url getFileSystemRepresentation:self->params->buf maxLength:self->params->nbuf]) {
-			return DLG_URLFAIL;
-		}
-	}
-	
-	return DLG_OK;
-}
-
-@end

app/dialog/cocoa/dlg_darwin.go

@@ -1,183 +0,0 @@
-package cocoa
-
-// #cgo darwin LDFLAGS: -framework Cocoa -framework UniformTypeIdentifiers
-// #include <stdlib.h>
-// #include <sys/syslimits.h>
-// #include "dlg.h"
-import "C"
-
-import (
-	"bytes"
-	"errors"
-	"unsafe"
-)
-
-type AlertParams struct {
-	p C.AlertDlgParams
-}
-
-func mkAlertParams(msg, title string, style C.AlertStyle) *AlertParams {
-	a := AlertParams{C.AlertDlgParams{msg: C.CString(msg), style: style}}
-	if title != "" {
-		a.p.title = C.CString(title)
-	}
-	return &a
-}
-
-func (a *AlertParams) run() C.DlgResult {
-	return C.alertDlg(&a.p)
-}
-
-func (a *AlertParams) free() {
-	C.free(unsafe.Pointer(a.p.msg))
-	if a.p.title != nil {
-		C.free(unsafe.Pointer(a.p.title))
-	}
-}
-
-func nsStr(s string) unsafe.Pointer {
-	return C.NSStr(unsafe.Pointer(&[]byte(s)[0]), C.int(len(s)))
-}
-
-func YesNoDlg(msg, title string) bool {
-	a := mkAlertParams(msg, title, C.MSG_YESNO)
-	defer a.free()
-	return a.run() == C.DLG_OK
-}
-
-func InfoDlg(msg, title string) {
-	a := mkAlertParams(msg, title, C.MSG_INFO)
-	defer a.free()
-	a.run()
-}
-
-func ErrorDlg(msg, title string) {
-	a := mkAlertParams(msg, title, C.MSG_ERROR)
-	defer a.free()
-	a.run()
-}
-
-const (
-	BUFSIZE             = C.PATH_MAX
-	MULTI_FILE_BUF_SIZE = 32768
-)
-
-// MultiFileDlg opens a file dialog that allows multiple file selection
-func MultiFileDlg(title string, exts []string, relaxExt bool, startDir string, showHidden bool) ([]string, error) {
-	return fileDlgWithOptions(C.LOADDLG, title, exts, relaxExt, startDir, "", showHidden, true)
-}
-
-// FileDlg opens a file dialog for single file selection (kept for compatibility)
-func FileDlg(save bool, title string, exts []string, relaxExt bool, startDir string, filename string, showHidden bool) (string, error) {
-	mode := C.LOADDLG
-	if save {
-		mode = C.SAVEDLG
-	}
-	files, err := fileDlgWithOptions(mode, title, exts, relaxExt, startDir, filename, showHidden, false)
-	if err != nil {
-		return "", err
-	}
-	if len(files) == 0 {
-		return "", nil
-	}
-	return files[0], nil
-}
-
-func DirDlg(title string, startDir string, showHidden bool) (string, error) {
-	files, err := fileDlgWithOptions(C.DIRDLG, title, nil, false, startDir, "", showHidden, false)
-	if err != nil {
-		return "", err
-	}
-	if len(files) == 0 {
-		return "", nil
-	}
-	return files[0], nil
-}
-
-// fileDlgWithOptions is the unified file dialog function that handles both single and multiple selection
-func fileDlgWithOptions(mode int, title string, exts []string, relaxExt bool, startDir, filename string, showHidden, allowMultiple bool) ([]string, error) {
-	// Use larger buffer for multiple files, smaller for single
-	bufSize := BUFSIZE
-	if allowMultiple {
-		bufSize = MULTI_FILE_BUF_SIZE
-	}
-
-	p := C.FileDlgParams{
-		mode: C.int(mode),
-		nbuf: C.int(bufSize),
-	}
-
-	if allowMultiple {
-		p.allowMultiple = C.int(1) // Enable multiple selection //nolint:structcheck
-	}
-	if showHidden {
-		p.showHidden = 1
-	}
-
-	p.buf = (*C.char)(C.malloc(C.size_t(bufSize)))
-	defer C.free(unsafe.Pointer(p.buf))
-	buf := (*(*[MULTI_FILE_BUF_SIZE]byte)(unsafe.Pointer(p.buf)))[:bufSize]
-
-	if title != "" {
-		p.title = C.CString(title)
-		defer C.free(unsafe.Pointer(p.title))
-	}
-	if startDir != "" {
-		p.startDir = C.CString(startDir)
-		defer C.free(unsafe.Pointer(p.startDir))
-	}
-	if filename != "" {
-		p.filename = C.CString(filename)
-		defer C.free(unsafe.Pointer(p.filename))
-	}
-
-	if len(exts) > 0 {
-		if len(exts) > 999 {
-			panic("more than 999 extensions not supported")
-		}
-		ptrSize := int(unsafe.Sizeof(&title))
-		p.exts = (*unsafe.Pointer)(C.malloc(C.size_t(ptrSize * len(exts))))
-		defer C.free(unsafe.Pointer(p.exts))
-		cext := (*(*[999]unsafe.Pointer)(unsafe.Pointer(p.exts)))[:]
-		for i, ext := range exts {
-			cext[i] = nsStr(ext)
-			defer C.NSRelease(cext[i])
-		}
-		p.numext = C.int(len(exts))
-		if relaxExt {
-			p.relaxext = 1
-		}
-	}
-
-	// Execute dialog and parse results
-	switch C.fileDlg(&p) {
-	case C.DLG_OK:
-		if allowMultiple {
-			// Parse multiple null-terminated strings from buffer
-			var files []string
-			start := 0
-			for i := range len(buf) - 1 {
-				if buf[i] == 0 {
-					if i > start {
-						files = append(files, string(buf[start:i]))
-					}
-					start = i + 1
-					// Check for double null (end of list)
-					if i+1 < len(buf) && buf[i+1] == 0 {
-						break
-					}
-				}
-			}
-			return files, nil
-		} else {
-			// Single file - return as array for consistency
-			filename := string(buf[:bytes.Index(buf, []byte{0})])
-			return []string{filename}, nil
-		}
-	case C.DLG_CANCEL:
-		return nil, nil
-	case C.DLG_URLFAIL:
-		return nil, errors.New("failed to get file-system representation for selected URL")
-	}
-	panic("unhandled case")
-}

app/dialog/dlgs.go

@@ -1,182 +0,0 @@
-//go:build windows || darwin
-
-// Package dialog provides a simple cross-platform common dialog API.
-// Eg. to prompt the user with a yes/no dialog:
-//
-//	if dialog.MsgDlg("%s", "Do you want to continue?").YesNo() {
-//	    // user pressed Yes
-//	}
-//
-// The general usage pattern is to call one of the toplevel *Dlg functions
-// which return a *Builder structure. From here you can optionally call
-// configuration functions (eg. Title) to customise the dialog, before
-// using a launcher function to run the dialog.
-package dialog
-
-import (
-	"errors"
-	"fmt"
-)
-
-// ErrCancelled is an error returned when a user cancels/closes a dialog.
-var ErrCancelled = errors.New("Cancelled")
-
-// Cancelled refers to ErrCancelled.
-// Deprecated: Use ErrCancelled instead.
-var Cancelled = ErrCancelled
-
-// Dlg is the common type for dialogs.
-type Dlg struct {
-	Title string
-}
-
-// MsgBuilder is used for creating message boxes.
-type MsgBuilder struct {
-	Dlg
-	Msg string
-}
-
-// Message initialises a MsgBuilder with the provided message.
-func Message(format string, args ...interface{}) *MsgBuilder {
-	return &MsgBuilder{Msg: fmt.Sprintf(format, args...)}
-}
-
-// Title specifies what the title of the message dialog will be.
-func (b *MsgBuilder) Title(title string) *MsgBuilder {
-	b.Dlg.Title = title
-	return b
-}
-
-// YesNo spawns the message dialog with two buttons, "Yes" and "No".
-// Returns true iff the user selected "Yes".
-func (b *MsgBuilder) YesNo() bool {
-	return b.yesNo()
-}
-
-// Info spawns the message dialog with an information icon and single button, "Ok".
-func (b *MsgBuilder) Info() {
-	b.info()
-}
-
-// Error spawns the message dialog with an error icon and single button, "Ok".
-func (b *MsgBuilder) Error() {
-	b.error()
-}
-
-// FileFilter represents a category of files (eg. audio files, spreadsheets).
-type FileFilter struct {
-	Desc       string
-	Extensions []string
-}
-
-// FileBuilder is used for creating file browsing dialogs.
-type FileBuilder struct {
-	Dlg
-	StartDir        string
-	StartFile       string
-	Filters         []FileFilter
-	ShowHiddenFiles bool
-}
-
-// File initialises a FileBuilder using the default configuration.
-func File() *FileBuilder {
-	return &FileBuilder{}
-}
-
-// Title specifies the title to be used for the dialog.
-func (b *FileBuilder) Title(title string) *FileBuilder {
-	b.Dlg.Title = title
-	return b
-}
-
-// Filter adds a category of files to the types allowed by the dialog. Multiple
-// calls to Filter are cumulative - any of the provided categories will be allowed.
-// By default all files can be selected.
-//
-// The special extension '*' allows all files to be selected when the Filter is active.
-func (b *FileBuilder) Filter(desc string, extensions ...string) *FileBuilder {
-	filt := FileFilter{desc, extensions}
-	if len(filt.Extensions) == 0 {
-		filt.Extensions = append(filt.Extensions, "*")
-	}
-	b.Filters = append(b.Filters, filt)
-	return b
-}
-
-// SetStartDir specifies the initial directory of the dialog.
-func (b *FileBuilder) SetStartDir(startDir string) *FileBuilder {
-	b.StartDir = startDir
-	return b
-}
-
-// SetStartFile specifies the initial file name of the dialog.
-func (b *FileBuilder) SetStartFile(startFile string) *FileBuilder {
-	b.StartFile = startFile
-	return b
-}
-
-// ShowHiddenFiles sets whether hidden files should be visible in the dialog.
-func (b *FileBuilder) ShowHidden(show bool) *FileBuilder {
-	b.ShowHiddenFiles = show
-	return b
-}
-
-// Load spawns the file selection dialog using the configured settings,
-// asking the user to select a single file. Returns ErrCancelled as the error
-// if the user cancels or closes the dialog.
-func (b *FileBuilder) Load() (string, error) {
-	return b.load()
-}
-
-// LoadMultiple spawns the file selection dialog using the configured settings,
-// asking the user to select multiple files. Returns ErrCancelled as the error
-// if the user cancels or closes the dialog.
-func (b *FileBuilder) LoadMultiple() ([]string, error) {
-	return b.loadMultiple()
-}
-
-// Save spawns the file selection dialog using the configured settings,
-// asking the user for a filename to save as. If the chosen file exists, the
-// user is prompted whether they want to overwrite the file. Returns
-// ErrCancelled as the error if the user cancels/closes the dialog, or selects
-// not to overwrite the file.
-func (b *FileBuilder) Save() (string, error) {
-	return b.save()
-}
-
-// DirectoryBuilder is used for directory browse dialogs.
-type DirectoryBuilder struct {
-	Dlg
-	StartDir        string
-	ShowHiddenFiles bool
-}
-
-// Directory initialises a DirectoryBuilder using the default configuration.
-func Directory() *DirectoryBuilder {
-	return &DirectoryBuilder{}
-}
-
-// Browse spawns the directory selection dialog using the configured settings,
-// asking the user to select a single folder. Returns ErrCancelled as the error
-// if the user cancels or closes the dialog.
-func (b *DirectoryBuilder) Browse() (string, error) {
-	return b.browse()
-}
-
-// Title specifies the title to be used for the dialog.
-func (b *DirectoryBuilder) Title(title string) *DirectoryBuilder {
-	b.Dlg.Title = title
-	return b
-}
-
-// StartDir specifies the initial directory to be used for the dialog.
-func (b *DirectoryBuilder) SetStartDir(dir string) *DirectoryBuilder {
-	b.StartDir = dir
-	return b
-}
-
-// ShowHiddenFiles sets whether hidden files should be visible in the dialog.
-func (b *DirectoryBuilder) ShowHidden(show bool) *DirectoryBuilder {
-	b.ShowHiddenFiles = show
-	return b
-}

app/dialog/dlgs_darwin.go

@@ -1,82 +0,0 @@
-package dialog
-
-import (
-	"github.com/ollama/ollama/app/dialog/cocoa"
-)
-
-func (b *MsgBuilder) yesNo() bool {
-	return cocoa.YesNoDlg(b.Msg, b.Dlg.Title)
-}
-
-func (b *MsgBuilder) info() {
-	cocoa.InfoDlg(b.Msg, b.Dlg.Title)
-}
-
-func (b *MsgBuilder) error() {
-	cocoa.ErrorDlg(b.Msg, b.Dlg.Title)
-}
-
-func (b *FileBuilder) load() (string, error) {
-	return b.run(false)
-}
-
-func (b *FileBuilder) loadMultiple() ([]string, error) {
-	return b.runMultiple()
-}
-
-func (b *FileBuilder) save() (string, error) {
-	return b.run(true)
-}
-
-func (b *FileBuilder) run(save bool) (string, error) {
-	star := false
-	var exts []string
-	for _, filt := range b.Filters {
-		for _, ext := range filt.Extensions {
-			if ext == "*" {
-				star = true
-			} else {
-				exts = append(exts, ext)
-			}
-		}
-	}
-	if star && save {
-		/* OSX doesn't allow the user to switch visible file types/extensions. Also
-		** NSSavePanel's allowsOtherFileTypes property has no effect for an open
-		** dialog, so if "*" is a possible extension we must always show all files. */
-		exts = nil
-	}
-	f, err := cocoa.FileDlg(save, b.Dlg.Title, exts, star, b.StartDir, b.StartFile, b.ShowHiddenFiles)
-	if f == "" && err == nil {
-		return "", ErrCancelled
-	}
-	return f, err
-}
-
-func (b *FileBuilder) runMultiple() ([]string, error) {
-	star := false
-	var exts []string
-	for _, filt := range b.Filters {
-		for _, ext := range filt.Extensions {
-			if ext == "*" {
-				star = true
-			} else {
-				exts = append(exts, ext)
-			}
-		}
-	}
-
-	files, err := cocoa.MultiFileDlg(b.Dlg.Title, exts, star, b.StartDir, b.ShowHiddenFiles)
-	if len(files) == 0 && err == nil {
-		return nil, ErrCancelled
-	}
-	return files, err
-}
-
-func (b *DirectoryBuilder) browse() (string, error) {
-	f, err := cocoa.DirDlg(b.Dlg.Title, b.StartDir, b.ShowHiddenFiles)
-	if f == "" && err == nil {
-		return "", ErrCancelled
-	}
-	return f, err
-}

app/dialog/dlgs_windows.go

@@ -1,241 +0,0 @@
-package dialog
-
-import (
-	"fmt"
-	"reflect"
-	"syscall"
-	"unicode/utf16"
-	"unsafe"
-
-	"github.com/TheTitanrain/w32"
-)
-
-const multiFileBufferSize = w32.MAX_PATH * 10
-
-type WinDlgError int
-
-func (e WinDlgError) Error() string {
-	return fmt.Sprintf("CommDlgExtendedError: %#x", int(e))
-}
-
-func err() error {
-	e := w32.CommDlgExtendedError()
-	if e == 0 {
-		return ErrCancelled
-	}
-	return WinDlgError(e)
-}
-
-func (b *MsgBuilder) yesNo() bool {
-	r := w32.MessageBox(w32.HWND(0), b.Msg, firstOf(b.Dlg.Title, "Confirm?"), w32.MB_YESNO)
-	return r == w32.IDYES
-}
-
-func (b *MsgBuilder) info() {
-	w32.MessageBox(w32.HWND(0), b.Msg, firstOf(b.Dlg.Title, "Information"), w32.MB_OK|w32.MB_ICONINFORMATION)
-}
-
-func (b *MsgBuilder) error() {
-	w32.MessageBox(w32.HWND(0), b.Msg, firstOf(b.Dlg.Title, "Error"), w32.MB_OK|w32.MB_ICONERROR)
-}
-
-type filedlg struct {
-	buf     []uint16
-	filters []uint16
-	opf     *w32.OPENFILENAME
-}
-
-func (d filedlg) Filename() string {
-	i := 0
-	for i < len(d.buf) && d.buf[i] != 0 {
-		i++
-	}
-	return string(utf16.Decode(d.buf[:i]))
-}
-
-func (d filedlg) parseMultipleFilenames() []string {
-	var files []string
-	i := 0
-
-	// Find first null terminator (directory path)
-	for i < len(d.buf) && d.buf[i] != 0 {
-		i++
-	}
-
-	if i >= len(d.buf) {
-		return files
-	}
-
-	// Get directory path
-	dirPath := string(utf16.Decode(d.buf[:i]))
-	i++ // Skip null terminator
-
-	// Check if there are more files (multiple selection)
-	if i < len(d.buf) && d.buf[i] != 0 {
-		// Multiple files selected - parse filenames
-		for i < len(d.buf) {
-			start := i
-			// Find next null terminator
-			for i < len(d.buf) && d.buf[i] != 0 {
-				i++
-			}
-			if i >= len(d.buf) {
-				break
-			}
-
-			if start < i {
-				filename := string(utf16.Decode(d.buf[start:i]))
-				if dirPath != "" {
-					files = append(files, dirPath+"\\"+filename)
-				} else {
-					files = append(files, filename)
-				}
-			}
-			i++ // Skip null terminator
-			if i >= len(d.buf) || d.buf[i] == 0 {
-				break // End of list
-			}
-		}
-	} else {
-		// Single file selected
-		files = append(files, dirPath)
-	}
-
-	return files
-}
-
-func (b *FileBuilder) load() (string, error) {
-	d := openfile(w32.OFN_FILEMUSTEXIST|w32.OFN_NOCHANGEDIR, b)
-	if w32.GetOpenFileName(d.opf) {
-		return d.Filename(), nil
-	}
-	return "", err()
-}
-
-func (b *FileBuilder) loadMultiple() ([]string, error) {
-	d := openfile(w32.OFN_FILEMUSTEXIST|w32.OFN_NOCHANGEDIR|w32.OFN_ALLOWMULTISELECT|w32.OFN_EXPLORER, b)
-	d.buf = make([]uint16, multiFileBufferSize)
-	d.opf.File = utf16ptr(d.buf)
-	d.opf.MaxFile = uint32(len(d.buf))
-
-	if w32.GetOpenFileName(d.opf) {
-		return d.parseMultipleFilenames(), nil
-	}
-	return nil, err()
-}
-
-func (b *FileBuilder) save() (string, error) {
-	d := openfile(w32.OFN_OVERWRITEPROMPT|w32.OFN_NOCHANGEDIR, b)
-	if w32.GetSaveFileName(d.opf) {
-		return d.Filename(), nil
-	}
-	return "", err()
-}
-
-/* syscall.UTF16PtrFromString not sufficient because we need to encode embedded NUL bytes */
-func utf16ptr(utf16 []uint16) *uint16 {
-	if utf16[len(utf16)-1] != 0 {
-		panic("refusing to make ptr to non-NUL terminated utf16 slice")
-	}
-	h := (*reflect.SliceHeader)(unsafe.Pointer(&utf16))
-	return (*uint16)(unsafe.Pointer(h.Data))
-}
-
-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
-	i := 0
-	for slice[len(slice)-1] != 0 {
-		i++
-	}
-	hdr.Len = i
-	slice = *(*[]uint16)(unsafe.Pointer(&hdr)) //nolint:govet
-	return slice
-}
-
-func openfile(flags uint32, b *FileBuilder) (d filedlg) {
-	d.buf = make([]uint16, w32.MAX_PATH)
-	if b.StartFile != "" {
-		initialName, _ := syscall.UTF16FromString(b.StartFile)
-		for i := 0; i < len(initialName) && i < w32.MAX_PATH; i++ {
-			d.buf[i] = initialName[i]
-		}
-	}
-	d.opf = &w32.OPENFILENAME{
-		File:    utf16ptr(d.buf),
-		MaxFile: uint32(len(d.buf)),
-		Flags:   flags,
-	}
-	d.opf.StructSize = uint32(unsafe.Sizeof(*d.opf))
-	if b.StartDir != "" {
-		d.opf.InitialDir, _ = syscall.UTF16PtrFromString(b.StartDir)
-	}
-	if b.Dlg.Title != "" {
-		d.opf.Title, _ = syscall.UTF16PtrFromString(b.Dlg.Title)
-	}
-	for _, filt := range b.Filters {
-		/* build utf16 string of form "Music File\0*.mp3;*.ogg;*.wav;\0" */
-		d.filters = append(d.filters, utf16.Encode([]rune(filt.Desc))...)
-		d.filters = append(d.filters, 0)
-		for _, ext := range filt.Extensions {
-			s := fmt.Sprintf("*.%s;", ext)
-			d.filters = append(d.filters, utf16.Encode([]rune(s))...)
-		}
-		d.filters = append(d.filters, 0)
-	}
-	if d.filters != nil {
-		d.filters = append(d.filters, 0, 0) // two extra NUL chars to terminate the list
-		d.opf.Filter = utf16ptr(d.filters)
-	}
-	return d
-}
-
-type dirdlg struct {
-	bi *w32.BROWSEINFO
-}
-
-const (
-	bffm_INITIALIZED     = 1
-	bffm_SELCHANGED      = 2
-	bffm_VALIDATEFAILEDA = 3
-	bffm_VALIDATEFAILEDW = 4
-	bffm_SETSTATUSTEXTA  = (w32.WM_USER + 100)
-	bffm_SETSTATUSTEXTW  = (w32.WM_USER + 104)
-	bffm_ENABLEOK        = (w32.WM_USER + 101)
-	bffm_SETSELECTIONA   = (w32.WM_USER + 102)
-	bffm_SETSELECTIONW   = (w32.WM_USER + 103)
-	bffm_SETOKTEXT       = (w32.WM_USER + 105)
-	bffm_SETEXPANDED     = (w32.WM_USER + 106)
-	bffm_SETSTATUSTEXT   = bffm_SETSTATUSTEXTW
-	bffm_SETSELECTION    = bffm_SETSELECTIONW
-	bffm_VALIDATEFAILED  = bffm_VALIDATEFAILEDW
-)
-
-func callbackDefaultDir(hwnd w32.HWND, msg uint, lParam, lpData uintptr) int {
-	if msg == bffm_INITIALIZED {
-		_ = w32.SendMessage(hwnd, bffm_SETSELECTION, w32.TRUE, lpData)
-	}
-	return 0
-}
-
-func selectdir(b *DirectoryBuilder) (d dirdlg) {
-	d.bi = &w32.BROWSEINFO{Flags: w32.BIF_RETURNONLYFSDIRS | w32.BIF_NEWDIALOGSTYLE}
-	if b.Dlg.Title != "" {
-		d.bi.Title, _ = syscall.UTF16PtrFromString(b.Dlg.Title)
-	}
-	if b.StartDir != "" {
-		s16, _ := syscall.UTF16PtrFromString(b.StartDir)
-		d.bi.LParam = uintptr(unsafe.Pointer(s16))
-		d.bi.CallbackFunc = syscall.NewCallback(callbackDefaultDir)
-	}
-	return d
-}
-
-func (b *DirectoryBuilder) browse() (string, error) {
-	d := selectdir(b)
-	res := w32.SHBrowseForFolder(d.bi)
-	if res == 0 {
-		return "", ErrCancelled
-	}
-	return w32.SHGetPathFromIDList(res), nil
-}

app/dialog/util.go

@@ -1,12 +0,0 @@
-//go:build windows
-
-package dialog
-
-func firstOf(args ...string) string {
-	for _, arg := range args {
-		if arg != "" {
-			return arg
-		}
-	}
-	return ""
-}

app/format/field.go

@@ -1,30 +0,0 @@
-//go:build windows || darwin
-
-package format
-
-import (
-	"strings"
-	"unicode"
-)
-
-// KebabCase converts a string from camelCase or PascalCase to kebab-case.
-// (e.g. "camelCase" -> "camel-case")
-func KebabCase(str string) string {
-	var result strings.Builder
-
-	for i, char := range str {
-		if i > 0 {
-			prevChar := rune(str[i-1])
-
-			// Add hyphen before uppercase letters
-			if unicode.IsUpper(char) &&
-				(unicode.IsLower(prevChar) || unicode.IsDigit(prevChar) ||
-					(i < len(str)-1 && unicode.IsLower(rune(str[i+1])))) {
-				result.WriteRune('-')
-			}
-		}
-		result.WriteRune(unicode.ToLower(char))
-	}
-
-	return result.String()
-}

app/format/field_test.go

@@ -1,34 +0,0 @@
-//go:build windows || darwin
-
-package format
-
-import "testing"
-
-func TestKebabCase(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"already-kebab-case", "already-kebab-case"},
-		{"simpleCamelCase", "simple-camel-case"},
-		{"PascalCase", "pascal-case"},
-		{"camelCaseWithNumber123", "camel-case-with-number123"},
-		{"APIResponse", "api-response"},
-		{"mixedCASE", "mixed-case"},
-		{"WithACRONYMS", "with-acronyms"},
-		{"ALLCAPS", "allcaps"},
-		{"camelCaseWITHMixedACRONYMS", "camel-case-with-mixed-acronyms"},
-		{"numbers123in456string", "numbers123in456string"},
-		{"5", "5"},
-		{"S", "s"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			result := KebabCase(tt.input)
-			if result != tt.expected {
-				t.Errorf("toKebabCase(%q) = %q, want %q", tt.input, result, tt.expected)
-			}
-		})
-	}
-}

app/lifecycle/getstarted_darwin.go

@@ -0,0 +1,7 @@
+package lifecycle
+
+import "fmt"
+
+func GetStarted() error {
+	return fmt.Errorf("GetStarted not implemented")
+}

app/lifecycle/getstarted_windows.go

@@ -0,0 +1,44 @@
+package lifecycle
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+)
+
+func GetStarted() error {
+	const CREATE_NEW_CONSOLE = 0x00000010
+	var err error
+	bannerScript := filepath.Join(AppDir, "ollama_welcome.ps1")
+	args := []string{
+		// TODO once we're signed, the execution policy bypass should be removed
+		"powershell", "-noexit", "-ExecutionPolicy", "Bypass", "-nologo", "-file", bannerScript,
+	}
+	args[0], err = exec.LookPath(args[0])
+	if err != nil {
+		return err
+	}
+
+	// Make sure the script actually exists
+	_, err = os.Stat(bannerScript)
+	if err != nil {
+		return fmt.Errorf("getting started banner script error %s", err)
+	}
+
+	slog.Info(fmt.Sprintf("opening getting started terminal with %v", args))
+	attrs := &os.ProcAttr{
+		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
+		Sys:   &syscall.SysProcAttr{CreationFlags: CREATE_NEW_CONSOLE, HideWindow: false},
+	}
+	proc, err := os.StartProcess(args[0], args, attrs)
+
+	if err != nil {
+		return fmt.Errorf("unable to start getting started shell %w", err)
+	}
+
+	slog.Debug(fmt.Sprintf("getting started terminal PID: %d", proc.Pid))
+	return proc.Release()
+}

app/lifecycle/paths.go

@@ -0,0 +1,74 @@
+package lifecycle
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+var (
+	AppName    = "ollama app"
+	CLIName    = "ollama"
+	AppDir     = "/opt/Ollama"
+	AppDataDir = "/opt/Ollama"
+	// TODO - should there be a distinct log dir?
+	UpdateStageDir = "/tmp"
+	AppLogFile     = "/tmp/ollama_app.log"
+	ServerLogFile  = "/tmp/ollama.log"
+	UpgradeLogFile = "/tmp/ollama_update.log"
+	Installer      = "OllamaSetup.exe"
+)
+
+func init() {
+	if runtime.GOOS == "windows" {
+		AppName += ".exe"
+		CLIName += ".exe"
+		// Logs, configs, downloads go to LOCALAPPDATA
+		localAppData := os.Getenv("LOCALAPPDATA")
+		AppDataDir = filepath.Join(localAppData, "Ollama")
+		UpdateStageDir = filepath.Join(AppDataDir, "updates")
+		AppLogFile = filepath.Join(AppDataDir, "app.log")
+		ServerLogFile = filepath.Join(AppDataDir, "server.log")
+		UpgradeLogFile = filepath.Join(AppDataDir, "upgrade.log")
+
+		// Executables are stored in APPDATA
+		AppDir = filepath.Join(localAppData, "Programs", "Ollama")
+
+		// Make sure we have PATH set correctly for any spawned children
+		paths := strings.Split(os.Getenv("PATH"), ";")
+		// Start with whatever we find in the PATH/LD_LIBRARY_PATH
+		found := false
+		for _, path := range paths {
+			d, err := filepath.Abs(path)
+			if err != nil {
+				continue
+			}
+			if strings.EqualFold(AppDir, d) {
+				found = true
+			}
+		}
+		if !found {
+			paths = append(paths, AppDir)
+
+			pathVal := strings.Join(paths, ";")
+			slog.Debug("setting PATH=" + pathVal)
+			err := os.Setenv("PATH", pathVal)
+			if err != nil {
+				slog.Error(fmt.Sprintf("failed to update PATH: %s", err))
+			}
+		}
+
+		// Make sure our logging dir exists
+		_, err := os.Stat(AppDataDir)
+		if errors.Is(err, os.ErrNotExist) {
+			if err := os.MkdirAll(AppDataDir, 0o755); err != nil {
+				slog.Error(fmt.Sprintf("create ollama dir %s: %v", AppDataDir, err))
+			}
+		}
+
+	}
+}

app/log.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+)
+
+func initLogging() {
+	level := slog.LevelInfo
+
+	if debug := os.Getenv("OLLAMA_DEBUG"); debug != "" {
+		level = slog.LevelDebug
+	}
+
+	var logFile *os.File
+	var err error
+	// Detect if we're a GUI app on windows, and if not, send logs to console
+	if os.Stderr.Fd() != 0 {
+		// Console app detected
+		logFile = os.Stderr
+		// TODO - write one-line to the app.log file saying we're running in console mode to help avoid confusion
+	} else {
+		logFile, err = os.OpenFile(AppLogFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0755)
+		if err != nil {
+			slog.Error(fmt.Sprintf("failed to create server log %v", err))
+			return
+		}
+	}
+	handler := slog.NewTextHandler(logFile, &slog.HandlerOptions{
+		Level:     level,
+		AddSource: true,
+		ReplaceAttr: func(_ []string, attr slog.Attr) slog.Attr {
+			if attr.Key == slog.SourceKey {
+				source := attr.Value.Any().(*slog.Source)
+				source.File = filepath.Base(source.File)
+			}
+			return attr
+		},
+	})
+
+	slog.SetDefault(slog.New(handler))
+}

app/logrotate/logrotate.go

@@ -1,45 +0,0 @@
-//go:build windows || darwin
-
-// package logrotate provides utilities for rotating logs
-// TODO (jmorgan): this most likely doesn't need it's own
-// package and can be moved to app where log files are created
-package logrotate
-
-import (
-	"log/slog"
-	"os"
-	"strconv"
-	"strings"
-)
-
-const MaxLogFiles = 5
-
-func Rotate(filename string) {
-	if _, err := os.Stat(filename); os.IsNotExist(err) {
-		return
-	}
-
-	index := strings.LastIndex(filename, ".")
-	pre := filename[:index]
-	post := "." + filename[index+1:]
-	for i := MaxLogFiles; i > 0; i-- {
-		older := pre + "-" + strconv.Itoa(i) + post
-		newer := pre + "-" + strconv.Itoa(i-1) + post
-		if i == 1 {
-			newer = pre + post
-		}
-		if _, err := os.Stat(newer); err == nil {
-			if _, err := os.Stat(older); err == nil {
-				err := os.Remove(older)
-				if err != nil {
-					slog.Warn("Failed to remove older log", "older", older, "error", err)
-					continue
-				}
-			}
-			err := os.Rename(newer, older)
-			if err != nil {
-				slog.Warn("Failed to rotate log", "older", older, "newer", newer, "error", err)
-			}
-		}
-	}
-}

app/logrotate/logrotate_test.go

@@ -1,70 +0,0 @@
-//go:build windows || darwin
-
-package logrotate
-
-import (
-	"os"
-	"path/filepath"
-	"strconv"
-	"testing"
-)
-
-func TestRotate(t *testing.T) {
-	logDir := t.TempDir()
-	logFile := filepath.Join(logDir, "testlog.log")
-
-	// No log exists
-	Rotate(logFile)
-
-	if err := os.WriteFile(logFile, []byte("1"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(logFile); os.IsNotExist(err) {
-		t.Fatal("expected log file to exist")
-	}
-
-	// First rotation
-	Rotate(logFile)
-	if _, err := os.Stat(filepath.Join(logDir, "testlog-1.log")); os.IsNotExist(err) {
-		t.Fatal("expected rotated log file to exist")
-	}
-	if _, err := os.Stat(filepath.Join(logDir, "testlog-2.log")); !os.IsNotExist(err) {
-		t.Fatal("expected no second rotated log file")
-	}
-	if _, err := os.Stat(logFile); !os.IsNotExist(err) {
-		t.Fatal("expected original log file to be moved")
-	}
-
-	// Should be a no-op without a new log
-	Rotate(logFile)
-	if _, err := os.Stat(filepath.Join(logDir, "testlog-1.log")); os.IsNotExist(err) {
-		t.Fatal("expected rotated log file to still exist")
-	}
-	if _, err := os.Stat(filepath.Join(logDir, "testlog-2.log")); !os.IsNotExist(err) {
-		t.Fatal("expected no second rotated log file")
-	}
-	if _, err := os.Stat(logFile); !os.IsNotExist(err) {
-		t.Fatal("expected no original log file")
-	}
-
-	for i := 2; i <= MaxLogFiles+1; i++ {
-		if err := os.WriteFile(logFile, []byte(strconv.Itoa(i)), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := os.Stat(logFile); os.IsNotExist(err) {
-			t.Fatal("expected log file to exist")
-		}
-		Rotate(logFile)
-		if _, err := os.Stat(logFile); !os.IsNotExist(err) {
-			t.Fatal("expected log file to be moved")
-		}
-		for j := 1; j < i; j++ {
-			if _, err := os.Stat(filepath.Join(logDir, "testlog-"+strconv.Itoa(j)+".log")); os.IsNotExist(err) {
-				t.Fatalf("expected rotated log file %d to exist", j)
-			}
-		}
-		if _, err := os.Stat(filepath.Join(logDir, "testlog-"+strconv.Itoa(i+1)+".log")); !os.IsNotExist(err) {
-			t.Fatalf("expected no rotated log file %d", i+1)
-		}
-	}
-}

app/main.go

@@ -0,0 +1,16 @@
+package main
+
+// Compile with the following to get rid of the cmd pop up on windows
+// go build -ldflags="-H windowsgui" .
+var (
+	AppName       string
+	CLIName       string
+	AppDir        string
+	AppDataDir    string
+	AppLogFile    string
+	ServerLogFile string
+)
+
+func main() {
+	run()
+}

app/ollama.iss

@@ -1,334 +0,0 @@
-; Inno Setup Installer for Ollama
-;
-; To build the installer use the build script invoked from the top of the source tree
-; 
-; powershell -ExecutionPolicy Bypass -File .\scripts\build_windows.ps
-
-
-#define MyAppName "Ollama"
-#if GetEnv("PKG_VERSION") != ""
-  #define MyAppVersion GetEnv("PKG_VERSION")
-#else
-  #define MyAppVersion "0.0.0"
-#endif
-#define MyAppPublisher "Ollama"
-#define MyAppURL "https://ollama.com/"
-#define MyAppExeName "ollama app.exe"
-#define LlamaServerExeName "llama-server.exe"
-#define MyIcon ".\assets\app.ico"
-
-[Setup]
-; NOTE: The value of AppId uniquely identifies this application. Do not use the same AppId value in installers for other applications.
-; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
-AppId={{44E83376-CE68-45EB-8FC1-393500EB558C}
-AppName={#MyAppName}
-AppVersion={#MyAppVersion}
-VersionInfoVersion={#MyAppVersion}
-;AppVerName={#MyAppName} {#MyAppVersion}
-AppPublisher={#MyAppPublisher}
-AppPublisherURL={#MyAppURL}
-AppSupportURL={#MyAppURL}
-AppUpdatesURL={#MyAppURL}
-ArchitecturesAllowed=x64compatible arm64
-ArchitecturesInstallIn64BitMode=x64compatible arm64
-DefaultDirName={localappdata}\Programs\{#MyAppName}
-DefaultGroupName={#MyAppName}
-DisableProgramGroupPage=yes
-PrivilegesRequired=lowest
-OutputBaseFilename="OllamaSetup"
-SetupIconFile={#MyIcon}
-UninstallDisplayIcon={uninstallexe}
-Compression=lzma2/ultra64
-LZMAUseSeparateProcess=yes
-LZMANumBlockThreads=8
-SolidCompression=yes
-WizardStyle=modern
-ChangesEnvironment=yes
-OutputDir=..\dist\
-
-; Disable logging once everything's battle tested
-; Filename will be %TEMP%\Setup Log*.txt
-SetupLogging=yes
-CloseApplications=no
-RestartApplications=no
-RestartIfNeededByRun=no
-
-; https://jrsoftware.org/ishelp/index.php?topic=setup_wizardimagefile
-WizardSmallImageFile=.\assets\setup.bmp
-
-; Ollama requires Windows 10 22H2 or newer for proper unicode rendering
-; TODO: consider setting this to 10.0.19045
-MinVersion=10.0.10240
-
-; First release that supports WinRT UI Composition for win32 apps
-; MinVersion=10.0.17134
-; First release with XAML Islands - possible UI path forward
-; MinVersion=10.0.18362
-
-; quiet...
-DisableDirPage=yes
-DisableFinishedPage=yes
-DisableReadyMemo=yes
-DisableReadyPage=yes
-DisableStartupPrompt=yes
-
-; TODO - percentage can't be set less than 100, so how to make it shorter?
-; WizardSizePercent=100,80
-
-#if GetEnv("KEY_CONTAINER")
-SignTool=MySignTool
-SignedUninstaller=yes
-#endif
-
-SetupMutex=OllamaSetupMutex
-
-[Languages]
-Name: "english"; MessagesFile: "compiler:Default.isl"
-
-[LangOptions]
-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\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
-#endif
-
-; For local development, rely on binary compatibility at runtime since we can't cross compile
-#if FileExists("..\dist\windows-ollama-app-arm64.exe")
-Source: "..\dist\windows-ollama-app-arm64.exe"; DestDir: "{app}"; DestName: "{#MyAppExeName}" ;Check: IsArm64();  Flags: ignoreversion 64bit; BeforeInstall: TaskKill('{#MyAppExeName}')
-#else 
-Source: "..\dist\windows-ollama-app-amd64.exe"; DestDir: "{app}"; DestName: "{#MyAppExeName}" ;Check: IsArm64();  Flags: ignoreversion 64bit; BeforeInstall: TaskKill('{#MyAppExeName}')
-#endif
-
-#if FileExists("..\dist\windows-arm64\ollama.exe")
-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
-
-[Icons]
-Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app.ico"
-Name: "{app}\lib\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app.ico"
-Name: "{userprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app.ico"
-
-[InstallDelete]
-Type: files; Name: "{%LOCALAPPDATA}\Ollama\updates"
-
-[Run]
-Filename: "{cmd}"; Parameters: "/C set PATH={app};%PATH% & ""{app}\{#MyAppExeName}"""; Flags: postinstall nowait runhidden
-
-[UninstallRun]
-; Filename: "{cmd}"; Parameters: "/C ""taskkill /im ''{#MyAppExeName}'' /f /t"; Flags: runhidden
-; 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
-
-[UninstallDelete]
-Type: filesandordirs; Name: "{%TEMP}\ollama*"
-Type: filesandordirs; Name: "{%LOCALAPPDATA}\Ollama"
-Type: filesandordirs; Name: "{%LOCALAPPDATA}\Programs\Ollama"
-Type: filesandordirs; Name: "{%USERPROFILE}\.ollama\history"
-Type: filesandordirs; Name: "{userstartup}\{#MyAppName}.lnk"
-; NOTE: if the user has a custom OLLAMA_MODELS it will be preserved
-
-[InstallDelete]
-Type: filesandordirs; Name: "{%TEMP}\ollama*"
-Type: filesandordirs; Name: "{app}\lib\ollama"
-
-[Messages]
-WizardReady=Ollama
-ReadyLabel1=%nLet's get you up and running with your own large language models.
-SetupAppRunningError=Another Ollama installer is running.%n%nPlease cancel or finish the other installer, then click OK to continue with this install, or Cancel to exit.
-
-
-;FinishedHeadingLabel=Run your first model
-;FinishedLabel=%nRun this command in a PowerShell or cmd terminal.%n%n%n    ollama run llama3.2
-;ClickFinish=%n
-
-[Registry]
-Root: HKCU; Subkey: "Environment"; \
-    ValueType: expandsz; ValueName: "Path"; ValueData: "{olddata};{app}"; \
-    Check: NeedsAddPath('{app}')
-; Register ollama:// URL protocol
-Root: HKCU; Subkey: "Software\Classes\ollama"; ValueType: string; ValueName: ""; ValueData: "URL:Ollama Protocol"; Flags: uninsdeletekey
-Root: HKCU; Subkey: "Software\Classes\ollama"; ValueType: string; ValueName: "URL Protocol"; ValueData: ""; Flags: uninsdeletekey
-Root: HKCU; Subkey: "Software\Classes\ollama\shell\open\command"; ValueType: string; ValueName: ""; ValueData: """{app}\{#MyAppExeName}"" ""%1"""; Flags: uninsdeletekey
-
-[Code]
-
-function NeedsAddPath(Param: string): boolean;
-var
-  OrigPath: string;
-begin
-  if not RegQueryStringValue(HKEY_CURRENT_USER,
-    'Environment',
-    'Path', OrigPath)
-  then begin
-    Result := True;
-    exit;
-  end;
-  { look for the path with leading and trailing semicolon }
-  { Pos() returns 0 if not found }
-  Result := Pos(';' + ExpandConstant(Param) + ';', ';' + OrigPath + ';') = 0;
-end;
-
-function GetDirSize(Path: String): Int64;
-var
-  FindRec: TFindRec;
-  FilePath: string;
-  Size: Int64;
-begin
-  if FindFirst(Path + '\*', FindRec) then begin
-    Result := 0;
-    try
-      repeat
-        if (FindRec.Name <> '.') and (FindRec.Name <> '..') then begin
-          FilePath := Path + '\' + FindRec.Name;
-          if (FindRec.Attributes and FILE_ATTRIBUTE_DIRECTORY) <> 0 then begin
-            Size := GetDirSize(FilePath);
-          end else begin
-            Size := Int64(FindRec.SizeHigh) shl 32 + FindRec.SizeLow;
-          end;
-          Result := Result + Size;
-        end;
-      until not FindNext(FindRec);
-    finally
-      FindClose(FindRec);
-    end;
-  end else begin
-    Log(Format('Failed to list %s', [Path]));
-    Result := -1;
-  end;
-end;
-
-var
-  DeleteModelsChecked: Boolean;
-  ModelsDir: string;
-
-procedure InitializeUninstallProgressForm();
-var
-  UninstallPage: TNewNotebookPage;
-  UninstallButton: TNewButton;
-  DeleteModelsCheckbox: TNewCheckBox;
-  OriginalPageNameLabel: string;
-  OriginalPageDescriptionLabel: string;
-  OriginalCancelButtonEnabled: Boolean;
-  OriginalCancelButtonModalResult: Integer;
-  ctrl: TWinControl;
-  ModelDirA: AnsiString;
-  ModelsSize: Int64;
-begin
-  if not UninstallSilent then begin
-    ctrl := UninstallProgressForm.CancelButton;
-    UninstallButton := TNewButton.Create(UninstallProgressForm);
-    UninstallButton.Parent := UninstallProgressForm;
-    UninstallButton.Left := ctrl.Left - ctrl.Width - ScaleX(10);
-    UninstallButton.Top := ctrl.Top;
-    UninstallButton.Width := ctrl.Width;
-    UninstallButton.Height := ctrl.Height;
-    UninstallButton.TabOrder := ctrl.TabOrder;
-    UninstallButton.Caption := 'Uninstall';
-    UninstallButton.ModalResult := mrOK;    
-    UninstallProgressForm.CancelButton.TabOrder := UninstallButton.TabOrder + 1;
-    UninstallPage := TNewNotebookPage.Create(UninstallProgressForm);
-    UninstallPage.Notebook := UninstallProgressForm.InnerNotebook;
-    UninstallPage.Parent := UninstallProgressForm.InnerNotebook;
-    UninstallPage.Align := alClient;
-    UninstallProgressForm.InnerNotebook.ActivePage := UninstallPage;
-
-    ctrl := UninstallProgressForm.StatusLabel;
-    with TNewStaticText.Create(UninstallProgressForm) do begin
-      Parent := UninstallPage;
-      Top := ctrl.Top;
-      Left := ctrl.Left;
-      Width := ctrl.Width;
-      Height := ctrl.Height;
-      AutoSize := False;
-      ShowAccelChar := False;
-      Caption := '';
-    end;
-
-    if (DirExists(GetEnv('USERPROFILE') + '\.ollama\models\blobs')) then begin
-      ModelsDir := GetEnv('USERPROFILE') + '\.ollama\models';
-      ModelsSize := GetDirSize(ModelsDir);
-    end;
-
-    DeleteModelsCheckbox := TNewCheckBox.Create(UninstallProgressForm);
-    DeleteModelsCheckbox.Parent := UninstallPage;
-    DeleteModelsCheckbox.Top := ctrl.Top + ScaleY(30);
-    DeleteModelsCheckbox.Left := ctrl.Left;
-    DeleteModelsCheckbox.Width := ScaleX(300);
-    if ModelsSize > 1024*1024*1024 then begin
-      DeleteModelsCheckbox.Caption := 'Remove models (' + IntToStr(ModelsSize/(1024*1024*1024)) + ' GB) ' + ModelsDir;
-    end else if ModelsSize > 1024*1024 then begin
-      DeleteModelsCheckbox.Caption := 'Remove models (' + IntToStr(ModelsSize/(1024*1024)) + ' MB) ' + ModelsDir;
-    end else begin
-      DeleteModelsCheckbox.Caption := 'Remove models ' + ModelsDir;
-    end;
-    DeleteModelsCheckbox.Checked := True;
-
-    OriginalPageNameLabel := UninstallProgressForm.PageNameLabel.Caption;
-    OriginalPageDescriptionLabel := UninstallProgressForm.PageDescriptionLabel.Caption;
-    OriginalCancelButtonEnabled := UninstallProgressForm.CancelButton.Enabled;
-    OriginalCancelButtonModalResult := UninstallProgressForm.CancelButton.ModalResult;
-
-    UninstallProgressForm.PageNameLabel.Caption := '';
-    UninstallProgressForm.PageDescriptionLabel.Caption := '';
-    UninstallProgressForm.CancelButton.Enabled := True;
-    UninstallProgressForm.CancelButton.ModalResult := mrCancel;
-
-    if UninstallProgressForm.ShowModal = mrCancel then Abort;
-
-    UninstallButton.Visible := False;   
-    UninstallProgressForm.PageNameLabel.Caption := OriginalPageNameLabel;
-    UninstallProgressForm.PageDescriptionLabel.Caption := OriginalPageDescriptionLabel;
-    UninstallProgressForm.CancelButton.Enabled := OriginalCancelButtonEnabled;
-    UninstallProgressForm.CancelButton.ModalResult := OriginalCancelButtonModalResult;
-
-    UninstallProgressForm.InnerNotebook.ActivePage := UninstallProgressForm.InstallingPage;
-
-    if DeleteModelsCheckbox.Checked then begin
-      DeleteModelsChecked:=True;
-    end else begin
-      DeleteModelsChecked:=False;
-    end;
-  end;
-end;
-
-procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
-begin
-  if CurUninstallStep = usDone then begin
-    if DeleteModelsChecked then begin
-      Log('user requested model cleanup');
-      if (VarIsEmpty(ModelsDir)) then begin
-        Log('cleaning up home directory models')
-        DelTree(GetEnv('USERPROFILE') + '\.ollama\models', True, True, True);
-      end else begin
-        Log('cleaning up custom directory models ' + ModelsDir)
-        DelTree(ModelsDir + '\blobs', True, True, True);
-        DelTree(ModelsDir + '\manifests', True, True, True);
-      end;
-    end else begin
-      Log('user requested to preserve model dir');
-    end;
-  end;
-end;
-
-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;
-end;

app/server.go

@@ -0,0 +1,163 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+
+	"github.com/ollama/ollama/api"
+)
+
+type ServerOptions struct {
+	Cors       bool
+	Expose     bool
+	ModelsPath string
+}
+
+func start(ctx context.Context, command string, options ServerOptions) (*exec.Cmd, error) {
+	cmd := getCmd(ctx, command)
+
+	// set environment variables
+	if options.ModelsPath != "" {
+		cmd.Env = append(cmd.Env, fmt.Sprintf("OLLAMA_MODELS=%s", options.ModelsPath))
+	}
+
+	if options.Cors {
+		cmd.Env = append(cmd.Env, "OLLAMA_ORIGINS=*")
+	}
+
+	if options.Expose {
+		cmd.Env = append(cmd.Env, "OLLAMA_HOST=0.0.0.0")
+	}
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to spawn server stdout pipe: %w", err)
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to spawn server stderr pipe: %w", err)
+	}
+
+	// TODO - rotation
+	logFile, err := os.OpenFile(ServerLogFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0755)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create server log: %w", err)
+	}
+	go func() {
+		defer logFile.Close()
+		io.Copy(logFile, stdout) //nolint:errcheck
+	}()
+	go func() {
+		defer logFile.Close()
+		io.Copy(logFile, stderr) //nolint:errcheck
+	}()
+
+	// Re-wire context done behavior to attempt a graceful shutdown of the server
+	cmd.Cancel = func() error {
+		if cmd.Process != nil {
+			err := terminate(cmd)
+			if err != nil {
+				slog.Warn("error trying to gracefully terminate server", "err", err)
+				return cmd.Process.Kill()
+			}
+
+			tick := time.NewTicker(10 * time.Millisecond)
+			defer tick.Stop()
+
+			for {
+				select {
+				case <-tick.C:
+					exited, err := isProcessExited(cmd.Process.Pid)
+					if err != nil {
+						return err
+					}
+
+					if exited {
+						return nil
+					}
+				case <-time.After(5 * time.Second):
+					slog.Warn("graceful server shutdown timeout, killing", "pid", cmd.Process.Pid)
+					return cmd.Process.Kill()
+				}
+			}
+		}
+		return nil
+	}
+
+	// run the command and wait for it to finish
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("failed to start server %w", err)
+	}
+	if cmd.Process != nil {
+		slog.Info(fmt.Sprintf("started ollama server with pid %d", cmd.Process.Pid))
+	}
+	slog.Info(fmt.Sprintf("ollama server logs %s", ServerLogFile))
+
+	return cmd, nil
+}
+
+func SpawnServer(ctx context.Context, command string, options ServerOptions) (chan int, error) {
+	logDir := filepath.Dir(ServerLogFile)
+	_, err := os.Stat(logDir)
+	if errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(logDir, 0o755); err != nil {
+			return nil, fmt.Errorf("create ollama server log dir %s: %v", logDir, err)
+		}
+	}
+
+	done := make(chan int)
+
+	go func() {
+		// Keep the server running unless we're shuttind down the app
+		crashCount := 0
+		for {
+			slog.Info(fmt.Sprintf("starting server..."))
+			cmd, err := start(ctx, command, options)
+			if err != nil {
+				slog.Error(fmt.Sprintf("failed to start server %s", err))
+			}
+
+			cmd.Wait() //nolint:errcheck
+			var code int
+			if cmd.ProcessState != nil {
+				code = cmd.ProcessState.ExitCode()
+			}
+
+			select {
+			case <-ctx.Done():
+				slog.Info(fmt.Sprintf("server shutdown with exit code %d", code))
+				done <- code
+				return
+			default:
+				crashCount++
+				slog.Warn(fmt.Sprintf("server crash %d - exit code %d - respawning", crashCount, code))
+				time.Sleep(500 * time.Millisecond * time.Duration(crashCount))
+				break
+			}
+		}
+	}()
+
+	return done, nil
+}
+
+func isServerRunning(ctx context.Context) bool {
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		slog.Info("unable to connect to server")
+		return false
+	}
+	err = client.Heartbeat(ctx)
+	if err != nil {
+		slog.Debug(fmt.Sprintf("heartbeat from server: %s", err))
+		slog.Info("unable to connect to server")
+		return false
+	}
+	return true
+}

app/server/server.go

@@ -1,409 +0,0 @@
-//go:build windows || darwin
-
-package server
-
-import (
-	"bufio"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/app/logrotate"
-	"github.com/ollama/ollama/app/store"
-)
-
-const restartDelay = time.Second
-
-// Server is a managed ollama server process
-type Server struct {
-	store *store.Store
-	bin   string // resolved path to `ollama`
-	log   io.WriteCloser
-	dev   bool // true if running with the dev flag
-}
-
-type InferenceCompute struct {
-	Library string
-	Variant string
-	Compute string
-	Driver  string
-	Name    string
-	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}
-}
-
-func resolvePath(name string) string {
-	// look in the app bundle first
-	if exe, _ := os.Executable(); exe != "" {
-		var dir string
-		if runtime.GOOS == "windows" {
-			dir = filepath.Dir(exe)
-		} else {
-			dir = filepath.Join(filepath.Dir(exe), "..", "Resources")
-		}
-		if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
-			return filepath.Join(dir, name)
-		}
-	}
-
-	// check the development dist path
-	for _, path := range []string{
-		filepath.Join("dist", runtime.GOOS, name),
-		filepath.Join("dist", runtime.GOOS+"-"+runtime.GOARCH, name),
-	} {
-		if _, err := os.Stat(path); err == nil {
-			return path
-		}
-	}
-
-	// fallback to system path
-	if p, _ := exec.LookPath(name); p != "" {
-		return p
-	}
-
-	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 {
-	data, err := os.ReadFile(pidFile)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return err
-	}
-	defer os.Remove(pidFile)
-
-	pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
-	if err != nil {
-		return err
-	}
-
-	proc, err := os.FindProcess(pid)
-	if err != nil {
-		return nil
-	}
-
-	ok, err := terminated(pid)
-	if err != nil {
-		slog.Debug("cleanup: error checking if terminated", "pid", pid, "err", err)
-	}
-	if ok {
-		return nil
-	}
-
-	slog.Info("detected previous ollama process, cleaning up", "pid", pid)
-	return stop(proc)
-}
-
-// stop waits for a process with the provided pid to exit by polling
-// `terminated(pid)`. If the process has not exited within 5 seconds, it logs a
-// warning and kills the process.
-func stop(proc *os.Process) error {
-	if proc == nil {
-		return nil
-	}
-
-	if err := terminate(proc); err != nil {
-		slog.Warn("graceful terminate failed, killing", "err", err)
-		return proc.Kill()
-	}
-
-	deadline := time.NewTimer(5 * time.Second)
-	defer deadline.Stop()
-
-	for {
-		select {
-		case <-deadline.C:
-			slog.Warn("timeout waiting for graceful shutdown; killing", "pid", proc.Pid)
-			return proc.Kill()
-		default:
-			ok, err := terminated(proc.Pid)
-			if err != nil {
-				slog.Error("error checking if ollama process is terminated", "err", err)
-				return err
-			}
-			if ok {
-				return nil
-			}
-			time.Sleep(10 * time.Millisecond)
-		}
-	}
-}
-
-func (s *Server) Run(ctx context.Context) error {
-	l, err := openRotatingLog()
-	if err != nil {
-		return err
-	}
-	s.log = l
-	defer s.log.Close()
-
-	if err := cleanup(); err != nil {
-		slog.Warn("failed to cleanup previous ollama process", "err", err)
-	}
-
-	reaped := false
-	for ctx.Err() == nil {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case <-time.After(restartDelay):
-		}
-
-		cmd, err := s.cmd(ctx)
-		if err != nil {
-			return err
-		}
-
-		if err := cmd.Start(); err != nil {
-			return err
-		}
-
-		err = os.WriteFile(pidFile, []byte(strconv.Itoa(cmd.Process.Pid)), 0o644)
-		if err != nil {
-			slog.Warn("failed to write pid file", "file", pidFile, "err", err)
-		}
-
-		if err = cmd.Wait(); err != nil && !errors.Is(err, context.Canceled) {
-			var exitErr *exec.ExitError
-			if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 && !s.dev && !reaped {
-				reaped = true
-				// This could be a port conflict, try to kill any existing ollama processes
-				if err := reapServers(); err != nil {
-					slog.Warn("failed to stop existing ollama server", "err", err)
-				} else {
-					slog.Debug("conflicting server stopped, waiting for port to be released")
-					continue
-				}
-			}
-			slog.Error("ollama exited", "err", err)
-		}
-	}
-	return ctx.Err()
-}
-
-func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
-	settings, err := s.store.Settings()
-	if err != nil {
-		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
-
-	// Copy and mutate the environment to merge in settings the user has specified without dups
-	env := map[string]string{}
-	for _, kv := range os.Environ() {
-		s := strings.SplitN(kv, "=", 2)
-		env[s[0]] = s[1]
-	}
-	if settings.Expose {
-		env["OLLAMA_HOST"] = "0.0.0.0"
-	}
-	if settings.Browser {
-		env["OLLAMA_ORIGINS"] = "*"
-	}
-	if settings.Models != "" {
-		if _, err := os.Stat(settings.Models); err == nil {
-			env["OLLAMA_MODELS"] = settings.Models
-		} else {
-			slog.Warn("models path not accessible, using default", "path", settings.Models, "err", err)
-		}
-	}
-	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)
-	}
-
-	cmd.Cancel = func() error {
-		if cmd.Process == nil {
-			return nil
-		}
-		return stop(cmd.Process)
-	}
-
-	return cmd, nil
-}
-
-func openRotatingLog() (io.WriteCloser, error) {
-	// TODO consider rotation based on size or time, not just every server invocation
-	dir := filepath.Dir(serverLogPath)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return nil, fmt.Errorf("create log directory: %w", err)
-	}
-
-	logrotate.Rotate(serverLogPath)
-	f, err := os.OpenFile(serverLogPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
-	if err != nil {
-		return nil, fmt.Errorf("open log file: %w", err)
-	}
-	return f, nil
-}
-
-// 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+)`)
-
-	q := `inference compute.*%s=["]([^"]*)["]`
-	nq := `inference compute.*%s=(\S+)\s`
-	type regex struct {
-		q  *regexp.Regexp
-		nq *regexp.Regexp
-	}
-	regexes := map[string]regex{
-		"library": {
-			q:  regexp.MustCompile(fmt.Sprintf(q, "library")),
-			nq: regexp.MustCompile(fmt.Sprintf(nq, "library")),
-		},
-		"variant": {
-			q:  regexp.MustCompile(fmt.Sprintf(q, "variant")),
-			nq: regexp.MustCompile(fmt.Sprintf(nq, "variant")),
-		},
-		"compute": {
-			q:  regexp.MustCompile(fmt.Sprintf(q, "compute")),
-			nq: regexp.MustCompile(fmt.Sprintf(nq, "compute")),
-		},
-		"driver": {
-			q:  regexp.MustCompile(fmt.Sprintf(q, "driver")),
-			nq: regexp.MustCompile(fmt.Sprintf(nq, "driver")),
-		},
-		"name": {
-			q:  regexp.MustCompile(fmt.Sprintf(q, "name")),
-			nq: regexp.MustCompile(fmt.Sprintf(nq, "name")),
-		},
-		"total": {
-			q:  regexp.MustCompile(fmt.Sprintf(q, "total")),
-			nq: regexp.MustCompile(fmt.Sprintf(nq, "total")),
-		},
-	}
-	get := func(field, line string) string {
-		regex, ok := regexes[field]
-		if !ok {
-			slog.Warn("missing field", "field", field)
-			return ""
-		}
-		match := regex.q.FindStringSubmatch(line)
-
-		if len(match) > 1 {
-			return match[1]
-		}
-		match = regex.nq.FindStringSubmatch(line)
-		if len(match) > 1 {
-			return match[1]
-		}
-		return ""
-	}
-	for {
-		select {
-		case <-ctx.Done():
-			return nil, fmt.Errorf("timeout scanning server log for inference compute details")
-		default:
-		}
-		file, err := os.Open(serverLogPath)
-		if err != nil {
-			slog.Debug("failed to open server log", "log", serverLogPath, "error", err)
-			time.Sleep(time.Second)
-			continue
-		}
-		defer file.Close()
-		scanner := bufio.NewScanner(file)
-		for scanner.Scan() {
-			line := scanner.Text()
-			// Check for inference compute lines
-			if computeMarker.MatchString(line) {
-				ic := InferenceCompute{
-					Library: get("library", line),
-					Variant: get("variant", line),
-					Compute: get("compute", line),
-					Driver:  get("driver", line),
-					Name:    get("name", line),
-					VRAM:    get("total", line),
-				}
-
-				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)
-					}
-				}
-				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

@@ -1,400 +0,0 @@
-//go:build windows || darwin
-
-package server
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ollama/ollama/app/store"
-)
-
-func TestNew(t *testing.T) {
-	tmpDir := t.TempDir()
-	st := &store.Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
-	defer st.Close() // Ensure database is closed before cleanup
-	s := New(st, false)
-
-	if s == nil {
-		t.Fatal("expected non-nil server")
-	}
-
-	if s.bin == "" {
-		t.Error("expected non-empty bin path")
-	}
-}
-
-func TestServerCmd(t *testing.T) {
-	os.Unsetenv("OLLAMA_HOST")
-	os.Unsetenv("OLLAMA_ORIGINS")
-	os.Unsetenv("OLLAMA_MODELS")
-	var defaultModels string
-	home, err := os.UserHomeDir()
-	if err == nil {
-		defaultModels = filepath.Join(home, ".ollama", "models")
-		os.MkdirAll(defaultModels, 0o755)
-	}
-
-	tmpModels := t.TempDir()
-	tests := []struct {
-		name     string
-		settings store.Settings
-		want     []string
-		dont     []string
-	}{
-		{
-			name:     "default",
-			settings: store.Settings{},
-			want:     []string{"OLLAMA_MODELS=" + defaultModels},
-			dont:     []string{"OLLAMA_HOST=", "OLLAMA_ORIGINS="},
-		},
-		{
-			name:     "expose",
-			settings: store.Settings{Expose: true},
-			want:     []string{"OLLAMA_HOST=0.0.0.0", "OLLAMA_MODELS=" + defaultModels},
-			dont:     []string{"OLLAMA_ORIGINS="},
-		},
-		{
-			name:     "browser",
-			settings: store.Settings{Browser: true},
-			want:     []string{"OLLAMA_ORIGINS=*", "OLLAMA_MODELS=" + defaultModels},
-			dont:     []string{"OLLAMA_HOST="},
-		},
-		{
-			name:     "models",
-			settings: store.Settings{Models: tmpModels},
-			want:     []string{"OLLAMA_MODELS=" + tmpModels},
-			dont:     []string{"OLLAMA_HOST=", "OLLAMA_ORIGINS="},
-		},
-		{
-			name:     "inaccessible_models",
-			settings: store.Settings{Models: "/nonexistent/external/drive/models"},
-			want:     []string{},
-			dont:     []string{"OLLAMA_MODELS="},
-		},
-		{
-			name: "all",
-			settings: store.Settings{
-				Expose:  true,
-				Browser: true,
-				Models:  tmpModels,
-			},
-			want: []string{
-				"OLLAMA_HOST=0.0.0.0",
-				"OLLAMA_ORIGINS=*",
-				"OLLAMA_MODELS=" + tmpModels,
-			},
-			dont: []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpDir := t.TempDir()
-			st := &store.Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
-			defer st.Close() // Ensure database is closed before cleanup
-			st.SetSettings(tt.settings)
-			s := &Server{
-				store: st,
-			}
-
-			cmd, err := s.cmd(t.Context())
-			if err != nil {
-				t.Fatalf("s.cmd() error = %v", err)
-			}
-
-			for _, want := range tt.want {
-				found := false
-				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, want) {
-						found = true
-						break
-					}
-				}
-				if !found {
-					t.Errorf("expected environment variable containing %s", want)
-				}
-			}
-
-			for _, dont := range tt.dont {
-				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, dont) {
-						t.Errorf("unexpected environment variable: %s", env)
-					}
-				}
-			}
-
-			if cmd.Cancel == nil {
-				t.Error("expected non-nil cancel function")
-			}
-		})
-	}
-}
-
-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) {
-	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
-	}{
-		{
-			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{{
-				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{{
-				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{{
-				Library: "cuda",
-				Variant: "v12",
-				Compute: "6.1",
-				Driver:  "12.7",
-				Name:    "NVIDIA GeForce GT 1030",
-				VRAM:    "3.9 GiB",
-			}},
-			expDefaultCtxLen: 4096,
-		},
-		{
-			name: "frank",
-			log: `time=2025-07-01T19:36:13.315Z level=INFO source=amd_linux.go:386 msg="amdgpu is supported" gpu=GPU-9abb57639fa80c50 gpu_type=gfx1030
-		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{
-				{
-					Library: "cuda",
-					Variant: "v12",
-					Compute: "7.5",
-					Driver:  "12.8",
-					Name:    "NVIDIA GeForce RTX 2080 Ti",
-					VRAM:    "10.6 GiB",
-				},
-				{
-					Library: "rocm",
-					Compute: "gfx1030",
-					Driver:  "6.3",
-					Name:    "1002:73bf",
-					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 {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpDir := t.TempDir()
-			serverLogPath = filepath.Join(tmpDir, "server.log")
-			err := os.WriteFile(serverLogPath, []byte(tt.log), 0o644)
-			if err != nil {
-				t.Fatalf("failed to write log file %s: %s", serverLogPath, err)
-			}
-			ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
-			defer cancel()
-			info, err := GetInferenceInfo(ctx)
-			if err != nil {
-				t.Fatalf("failed to get inference info: %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)
-			}
-		})
-	}
-}
-
-func TestGetInferenceInfoTimeout(t *testing.T) {
-	ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
-	defer cancel()
-	tmpDir := t.TempDir()
-	serverLogPath = filepath.Join(tmpDir, "server.log")
-	err := os.WriteFile(serverLogPath, []byte("foo\nbar\nbaz\n"), 0o644)
-	if err != nil {
-		t.Fatalf("failed to write log file %s: %s", serverLogPath, err)
-	}
-	_, err = GetInferenceInfo(ctx)
-	if err == nil {
-		t.Fatal("expected timeout")
-	}
-	if !strings.Contains(err.Error(), "timeout") {
-		t.Fatalf("unexpected error: %s", err)
-	}
-}

app/server/server_unix.go

@@ -1,117 +0,0 @@
-//go:build darwin
-
-package server
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log/slog"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-)
-
-var (
-	pidFile       = filepath.Join(os.Getenv("HOME"), "Library", "Application Support", "Ollama", "ollama.pid")
-	serverLogPath = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "server.log")
-)
-
-func commandContext(ctx context.Context, name string, arg ...string) *exec.Cmd {
-	return exec.CommandContext(ctx, name, arg...)
-}
-
-func terminate(proc *os.Process) error {
-	return proc.Signal(os.Interrupt)
-}
-
-func terminated(pid int) (bool, error) {
-	proc, err := os.FindProcess(pid)
-	if err != nil {
-		return false, fmt.Errorf("failed to find process: %v", err)
-	}
-
-	err = proc.Signal(syscall.Signal(0))
-	if err != nil {
-		if errors.Is(err, os.ErrProcessDone) || errors.Is(err, syscall.ESRCH) {
-			return true, nil
-		}
-
-		return false, fmt.Errorf("error signaling process: %v", err)
-	}
-
-	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.
-func reapServers() error {
-	// Get our own PID to avoid killing ourselves
-	currentPID := os.Getpid()
-
-	// Use pkill to kill ollama processes
-	// -x matches the whole command name exactly
-	// We'll get the list first, then kill selectively
-	cmd := exec.Command("pgrep", "-x", "ollama")
-	output, err := cmd.Output()
-	if err != nil {
-		// No ollama processes found
-		slog.Debug("no ollama processes found")
-		return nil //nolint:nilerr
-	}
-
-	pidsStr := strings.TrimSpace(string(output))
-	if pidsStr == "" {
-		return nil
-	}
-
-	pids := strings.Split(pidsStr, "\n")
-	for _, pidStr := range pids {
-		pidStr = strings.TrimSpace(pidStr)
-		if pidStr == "" {
-			continue
-		}
-
-		pid, err := strconv.Atoi(pidStr)
-		if err != nil {
-			slog.Debug("failed to parse PID", "pidStr", pidStr, "err", err)
-			continue
-		}
-		if pid == currentPID {
-			continue
-		}
-		if !ollamaServeProcess(pid) {
-			continue
-		}
-
-		proc, err := os.FindProcess(pid)
-		if err != nil {
-			slog.Debug("failed to find process", "pid", pid, "err", err)
-			continue
-		}
-
-		if err := proc.Signal(syscall.SIGTERM); err != nil {
-			// Try SIGKILL if SIGTERM fails
-			if err := proc.Signal(syscall.SIGKILL); err != nil {
-				slog.Warn("failed to stop external ollama process", "pid", pid, "err", err)
-				continue
-			}
-		}
-
-		slog.Info("stopped external ollama process", "pid", pid)
-	}
-
-	return nil
-}

app/server/server_windows.go

@@ -1,174 +0,0 @@
-package server
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-
-	"golang.org/x/sys/windows"
-)
-
-var (
-	pidFile       = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "ollama.pid")
-	serverLogPath = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "server.log")
-)
-
-func commandContext(ctx context.Context, name string, arg ...string) *exec.Cmd {
-	cmd := exec.CommandContext(ctx, name, arg...)
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		HideWindow:    true,
-		CreationFlags: windows.CREATE_NEW_PROCESS_GROUP,
-	}
-
-	return cmd
-}
-
-func terminate(proc *os.Process) error {
-	dll, err := windows.LoadDLL("kernel32.dll")
-	if err != nil {
-		return err
-	}
-	defer dll.Release()
-
-	pid := proc.Pid
-
-	f, err := dll.FindProc("AttachConsole")
-	if err != nil {
-		return err
-	}
-
-	r1, _, err := f.Call(uintptr(pid))
-	if r1 == 0 && err != syscall.ERROR_ACCESS_DENIED {
-		return err
-	}
-
-	f, err = dll.FindProc("SetConsoleCtrlHandler")
-	if err != nil {
-		return err
-	}
-
-	r1, _, err = f.Call(0, 1)
-	if r1 == 0 {
-		return err
-	}
-
-	f, err = dll.FindProc("GenerateConsoleCtrlEvent")
-	if err != nil {
-		return err
-	}
-
-	r1, _, err = f.Call(windows.CTRL_BREAK_EVENT, uintptr(pid))
-	if r1 == 0 {
-		return err
-	}
-
-	r1, _, err = f.Call(windows.CTRL_C_EVENT, uintptr(pid))
-	if r1 == 0 {
-		return err
-	}
-
-	return nil
-}
-
-const STILL_ACTIVE = 259
-
-func terminated(pid int) (bool, error) {
-	hProcess, err := windows.OpenProcess(windows.PROCESS_QUERY_INFORMATION, false, uint32(pid))
-	if err != nil {
-		if errno, ok := err.(windows.Errno); ok && errno == windows.ERROR_INVALID_PARAMETER {
-			return true, nil
-		}
-		return false, fmt.Errorf("failed to open process: %v", err)
-	}
-	defer windows.CloseHandle(hProcess)
-
-	var exitCode uint32
-	err = windows.GetExitCodeProcess(hProcess, &exitCode)
-	if err != nil {
-		return false, fmt.Errorf("failed to get exit code: %v", err)
-	}
-
-	if exitCode == STILL_ACTIVE {
-		return false, nil
-	}
-
-	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.
-func reapServers() error {
-	// Get current process ID to avoid killing ourselves
-	currentPID := os.Getpid()
-
-	// Use wmic to find ollama processes
-	cmd := exec.Command("wmic", "process", "where", "name='ollama.exe'", "get", "ProcessId")
-	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
-	output, err := cmd.Output()
-	if err != nil {
-		// No ollama processes found
-		slog.Debug("no ollama processes found")
-		return nil //nolint:nilerr
-	}
-
-	lines := strings.Split(string(output), "\n")
-	var pids []string
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" || line == "ProcessId" {
-			continue
-		}
-
-		if _, err := strconv.Atoi(line); err == nil {
-			pids = append(pids, line)
-		}
-	}
-
-	for _, pidStr := range pids {
-		pid, err := strconv.Atoi(pidStr)
-		if err != nil {
-			continue
-		}
-
-		if pid == currentPID {
-			continue
-		}
-		if !ollamaServeProcess(pid) {
-			continue
-		}
-
-		cmd := exec.Command("taskkill", "/F", "/T", "/PID", pidStr)
-		if err := cmd.Run(); err != nil {
-			slog.Warn("failed to kill ollama process", "pid", pid, "err", err)
-		}
-	}
-
-	return nil
-}

app/server_darwin.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+func getCmd(ctx context.Context, cmd string) *exec.Cmd {
+	return exec.CommandContext(ctx, cmd, "serve")
+}
+
+func terminate(cmd *exec.Cmd) error {
+	return cmd.Process.Signal(os.Interrupt)
+}
+
+func isProcessExited(pid int) (bool, error) {
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return false, fmt.Errorf("failed to find process: %v", err)
+	}
+
+	err = proc.Signal(syscall.Signal(0))
+	if err != nil {
+		if errors.Is(err, os.ErrProcessDone) || errors.Is(err, syscall.ESRCH) {
+			return true, nil
+		}
+
+		return false, fmt.Errorf("error signaling process: %v", err)
+	}
+
+	return false, nil
+}

app/server_windows.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"syscall"
+
+	"golang.org/x/sys/windows"
+)
+
+func getCmd(ctx context.Context, exePath string) *exec.Cmd {
+	cmd := exec.CommandContext(ctx, exePath, "serve")
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    true,
+		CreationFlags: windows.CREATE_NEW_PROCESS_GROUP,
+	}
+
+	return cmd
+}
+
+func terminate(cmd *exec.Cmd) error {
+	dll, err := windows.LoadDLL("kernel32.dll")
+	if err != nil {
+		return err
+	}
+	defer dll.Release() // nolint: errcheck
+
+	pid := cmd.Process.Pid
+
+	f, err := dll.FindProc("AttachConsole")
+	if err != nil {
+		return err
+	}
+
+	r1, _, err := f.Call(uintptr(pid))
+	if r1 == 0 && err != syscall.ERROR_ACCESS_DENIED {
+		return err
+	}
+
+	f, err = dll.FindProc("SetConsoleCtrlHandler")
+	if err != nil {
+		return err
+	}
+
+	r1, _, err = f.Call(0, 1)
+	if r1 == 0 {
+		return err
+	}
+
+	f, err = dll.FindProc("GenerateConsoleCtrlEvent")
+	if err != nil {
+		return err
+	}
+
+	r1, _, err = f.Call(windows.CTRL_BREAK_EVENT, uintptr(pid))
+	if r1 == 0 {
+		return err
+	}
+
+	r1, _, err = f.Call(windows.CTRL_C_EVENT, uintptr(pid))
+	if r1 == 0 {
+		return err
+	}
+
+	return nil
+}
+
+const STILL_ACTIVE = 259
+
+func isProcessExited(pid int) (bool, error) {
+	hProcess, err := windows.OpenProcess(windows.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+	if err != nil {
+		return false, fmt.Errorf("failed to open process: %v", err)
+	}
+	defer windows.CloseHandle(hProcess) // nolint: errcheck
+
+	var exitCode uint32
+	err = windows.GetExitCodeProcess(hProcess, &exitCode)
+	if err != nil {
+		return false, fmt.Errorf("failed to get exit code: %v", err)
+	}
+
+	if exitCode == STILL_ACTIVE {
+		return false, nil
+	}
+
+	return true, nil
+}

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"
-	}
-}