openai: finish streaming tool calls as tool_calls

.dockerignore

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

.gitattributes

@@ -7,22 +7,5 @@ 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

.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,596 +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: 'ROCm 7'
-            build-steps: rocm7
-            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-26.Q1-Win11-For-HIP.exe
-            rocm-version: '7.1'
-          - os: windows
-            arch: amd64
-            preset: Vulkan
-            build-steps: vulkan
-            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
-    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
-    steps:
-      - name: Install system dependencies
-        run: |
-          choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: matrix.preset == 'CPU'
-        name: Install Windows ARM64 cross compiler
-        run: |
-          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
-          Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
-          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
-          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
-            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
-          }
-      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan')
-        id: cache-install
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
-            C:\Program Files\AMD\ROCm
-            C:\VulkanSDK
-          key: ${{ matrix.install }}
-      - if: startsWith(matrix.preset, 'CUDA ')
-        name: Install CUDA ${{ matrix.cuda-version }}
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            $subpackages = @(${{ join(matrix.cuda-components, ', ') }}) | Foreach-Object {"${_}_${{ matrix.cuda-version }}"}
-            Start-Process -FilePath .\install.exe -ArgumentList (@("-s") + $subpackages) -NoNewWindow -Wait
-          }
-
-          $cudaPath = (Resolve-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\*").path
-          echo "$cudaPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-      - if: startsWith(matrix.preset, 'ROCm')
-        name: Install ROCm ${{ matrix.rocm-version }}
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            Start-Process -FilePath .\install.exe -ArgumentList '-install' -NoNewWindow -Wait
-          }
-
-          $hipPath = (Resolve-Path "C:\Program Files\AMD\ROCm\*").path
-          echo "$hipPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo "CC=$hipPath\bin\clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CXX=$hipPath\bin\clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "HIPCXX=$hipPath\bin\clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "HIP_PLATFORM=amd" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CMAKE_PREFIX_PATH=$hipPath" | Out-File -FilePath $env:GITHUB_ENV -Append
-      - if: matrix.preset == 'Vulkan'
-        name: Install Vulkan
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            Start-Process -FilePath .\install.exe -ArgumentList "-c","--am","--al","in" -NoNewWindow -Wait
-          }
-
-          $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
-          $vulkanRuntime = Join-Path $vulkanPath "Helpers\VulkanRT.exe"
-          if (Test-Path $vulkanRuntime) {
-            Start-Process -FilePath $vulkanRuntime -ArgumentList "/s" -NoNewWindow -Wait
-          }
-          echo "$vulkanPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo "VULKAN_SDK=$vulkanPath" >> $env:GITHUB_ENV
-      - if: ${{ !cancelled() && matrix.preset != 'CPU' && steps.cache-install.outputs.cache-hit != 'true' }}
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
-            C:\Program Files\AMD\ROCm
-            C:\VulkanSDK
-          key: ${{ matrix.install }}
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
-        with:
-          path: ${{ github.workspace }}\.ccache
-          key: ccache-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}-${{ needs.setup-environment.outputs.vendorsha }}
-      - name: Build Windows dependencies
-        run: |
-          Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
-          Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation -DevCmdArguments '-arch=x64 -no_logo'
-          $steps = "${{ matrix.build-steps }}".Split(' ', [System.StringSplitOptions]::RemoveEmptyEntries)
-          ./scripts/build_windows.ps1 @steps
-        env:
-          CMAKE_GENERATOR: Ninja
-      - name: Log build results
-        run: |
-          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
-      - if: matrix.preset == 'CPU'
-        name: Verify Windows CPU payloads
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/windows-amd64/lib/ollama/llama-server.exe \
-            dist/windows-arm64/lib/ollama/llama-server.exe
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: depends-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}
-          path: dist\*
-          compression-level: 0
-
-  windows-build:
-    runs-on: windows
-    needs: setup-environment
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
-    steps:
-      - name: Install clang and gcc-compat
-        run: |
-          $ErrorActionPreference = "Stop"
-          Set-ExecutionPolicy Bypass -Scope Process -Force
-          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
-          Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
-          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
-          echo "$installPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
-            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
-          }
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          cache-dependency-path: |
-            go.sum
-            LLAMA_CPP_VERSION
-            MLX_VERSION
-            MLX_C_VERSION
-      - name: Verify gcc is actually clang
-        run: |
-          $ErrorActionPreference='Continue'
-          $version=& gcc -v 2>&1
-          $version=$version -join "`n"
-          echo "gcc is $version"
-          if ($version -notmatch 'clang') {
-            echo "ERROR: GCC must be clang for proper utf16 handling"
-            exit 1
-          }
-          $ErrorActionPreference='Stop'
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-      - name: Build Windows binaries and app launchers
-        run: ./scripts/build_windows.ps1 ollama ollamaArm64 app appArm64
-      - name: Verify Windows build payloads
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/windows-amd64/ollama.exe \
-            dist/windows-arm64/ollama.exe
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - name: Log build results
-        run: |
-          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
-      - uses: actions/upload-artifact@v4
-        with:
-          name: build-windows-amd64
-          path: dist\*
-          compression-level: 0
-
-  windows-package:
-    runs-on: windows
-    needs: [setup-environment, windows-build, windows-depends]
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          cache-dependency-path: |
-            go.sum
-            LLAMA_CPP_VERSION
-            MLX_VERSION
-            MLX_C_VERSION
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: depends-windows*
-          path: dist
-          merge-multiple: true
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: build-windows*
-          path: dist
-          merge-multiple: true
-      - name: Copy unsigned install script
-        run: Copy-Item -Path .\scripts\install.ps1 -Destination .\dist\install.ps1 -ErrorAction Stop
-      - name: Log dist contents after download
-        run: gci -path .\dist -recurse
-      - name: Verify Windows package inputs
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/windows-amd64/ollama.exe \
-            dist/windows-amd64/lib/ollama/llama-server.exe \
-            dist/windows-arm64/ollama.exe \
-            dist/windows-arm64/lib/ollama/llama-server.exe
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - name: Build unsigned Windows installer and zips
-        run: ./scripts/build_windows.ps1 deps installer zip
-      - name: Log contents after build
-        run: |
-          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
-      - name: Verify Windows package outputs
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/ollama-windows-amd64.zip \
-            dist/ollama-windows-arm64.zip \
-            dist/ollama-windows-amd64-rocm.zip \
-            dist/OllamaSetup.exe \
-            dist/install.ps1
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ollama-windows-amd64.zip
-          path: dist/ollama-windows-amd64.zip
-          compression-level: 0
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ollama-windows-arm64.zip
-          path: dist/ollama-windows-arm64.zip
-          compression-level: 0
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ollama-windows-amd64-rocm.zip
-          path: dist/ollama-windows-amd64-rocm.zip
-          compression-level: 0
-      - uses: actions/upload-artifact@v4
-        with:
-          name: OllamaSetup.exe
-          path: dist/OllamaSetup.exe
-          compression-level: 0
-      - uses: actions/upload-artifact@v4
-        with:
-          name: install.ps1
-          path: dist/install.ps1
-          compression-level: 0

.github/workflows/test.yaml

@@ -1,5 +1,11 @@
 name: test
 
+env:
+  ROCM_WINDOWS_URL: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-24.Q3-WinSvr2022-For-HIP.exe
+  MSYS2_URL: https://github.com/msys2/msys2-installer/releases/download/2024-07-27/msys2-x86_64-20240727.exe
+  CUDA_12_WINDOWS_URL: https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_551.61_windows.exe
+  CUDA_12_WINDOWS_VER: 12.4
+
 concurrency:
   # For PRs, later CI runs preempt previous ones. e.g. a force push on a PR
   # cancels running CI jobs and starts all new ones.
@@ -21,9 +27,7 @@ jobs:
   changes:
     runs-on: ubuntu-latest
     outputs:
-      changed: ${{ steps.changes.outputs.changed }}
-      app_changed: ${{ steps.changes.outputs.app_changed }}
-      enginehash: ${{ steps.changes.outputs.enginehash }}
+      RUNNERS: ${{ steps.changes.outputs.RUNNERS }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -31,390 +35,291 @@ 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" \
+            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; from pathlib import Path; print(any(Path(x).match(glob) for x in sys.argv[1:] for glob in '$*'.split(' ')))"
           }
 
-          echo changed=$(changed \
-            'CMakeLists.txt' \
-            'CMakePresets.json' \
-            'cmake/**' \
-            'cmake/**/*' \
-            'llama/server/**/*' \
-            'llama/compat/**/*' \
-            'LLAMA_CPP_VERSION' \
-            'MLX_VERSION' \
-            'MLX_C_VERSION' \
-            'llama/llama.cpp/**/*' \
-            'ml/backend/ggml/ggml/**/*' \
-            'x/imagegen/mlx/**' \
-            'x/imagegen/mlx/**/*' \
-            '.github/**/*') | tee -a $GITHUB_OUTPUT
-          echo app_changed=$(changed 'app/**' 'app/**/*') | tee -a $GITHUB_OUTPUT
-          echo enginehash=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION) | tee -a $GITHUB_OUTPUT
+          {
+            echo RUNNERS=$(changed 'llama/**')
+          } >>$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:
+  runners-linux-cuda:
     needs: [changes]
-    if: needs.changes.outputs.changed == 'True'
+    if: ${{ needs.changes.outputs.RUNNERS == '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
+        cuda-version:
+          - '11.8.0'
     runs-on: linux
-    container: ${{ matrix.container }}
+    container: nvidia/cuda:${{ matrix.cuda-version }}-devel-ubuntu20.04
     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
+          apt-get update && apt-get install -y git build-essential curl
         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
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@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:
+          go-version-file: go.mod
+          cache: true
+      - run: go get ./...
+      - run: |
+          git config --global --add safe.directory /__w/ollama/ollama
+          cores=$(grep '^core id' /proc/cpuinfo |sort -u|wc -l)
+          make -j $cores cuda_v11
+  runners-linux-rocm:
     needs: [changes]
-    if: needs.changes.outputs.changed == 'True'
+    if: ${{ needs.changes.outputs.RUNNERS == '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
+        rocm-version:
+          - '6.1.2'
+    runs-on: linux
+    container: rocm/dev-ubuntu-20.04:${{ matrix.rocm-version }}
     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 }}"
-          }
+          apt-get update && apt-get install -y git build-essential curl rocm-libs
         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
+          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
+          cores=$(grep '^core id' /proc/cpuinfo |sort -u|wc -l)
+          make -j $cores rocm
+
+  # ROCm generation step
+  runners-windows-rocm:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.RUNNERS == 'True' }}
+    runs-on: windows
     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)
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+      - name: Set make jobs default
+        run: |
+          echo "MAKEFLAGS=--jobs=$((Get-ComputerInfo -Property CsProcessors).CsProcessors.NumberOfCores)" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 
-  test:
+      # ROCM installation steps
+      - name: 'Cache ROCm installer'
+        id: cache-rocm
+        uses: actions/cache@v4
+        with:
+          path: rocm-install.exe
+          key: ${{ env.ROCM_WINDOWS_URL }}
+      - name: 'Conditionally Download ROCm'
+        if: steps.cache-rocm.outputs.cache-hit != 'true'
+        run: |
+          $ErrorActionPreference = "Stop"
+          Invoke-WebRequest -Uri "${env:ROCM_WINDOWS_URL}" -OutFile "rocm-install.exe"
+      - name: 'Install ROCm'
+        run: |
+          Start-Process "rocm-install.exe" -ArgumentList '-install' -NoNewWindow -Wait
+      - name: 'Verify ROCm'
+        run: |
+          & 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' --version
+          echo "HIP_PATH=$(Resolve-Path 'C:\Program Files\AMD\ROCm\*\bin\clang.exe' | split-path | split-path | select -first 1)" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Add msys paths
+        run: |
+          echo "c:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "C:\msys64\clang64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+      - name: Install msys2 tools
+        run: |
+          Start-Process "c:\msys64\usr\bin\pacman.exe" -ArgumentList @("-S", "--noconfirm", "mingw-w64-clang-x86_64-gcc-compat", "mingw-w64-clang-x86_64-clang") -NoNewWindow -Wait
+
+      - name: make rocm runner
+        run: |
+          import-module 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
+          Enter-VsDevShell -vsinstallpath 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise' -skipautomaticlocation -DevCmdArguments '-arch=x64 -no_logo'
+          if (!(gcc --version | select-string -quiet clang)) { throw "wrong gcc compiler detected - must be clang" }
+          make -C llama print-HIP_PATH print-HIP_LIB_DIR
+          make rocm
+
+  # CUDA generation step
+  runners-windows-cuda:
     needs: [changes]
+    if: ${{ needs.changes.outputs.RUNNERS == 'True' }}
+    runs-on: windows
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+      - name: Set make jobs default
+        run: |
+          echo "MAKEFLAGS=--jobs=$((Get-ComputerInfo -Property CsProcessors).CsProcessors.NumberOfCores)" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      # CUDA installation steps
+      - name: 'Cache CUDA installer'
+        id: cache-cuda
+        uses: actions/cache@v4
+        with:
+          path: cuda-install.exe
+          key: ${{ env.CUDA_12_WINDOWS_URL }}
+      - name: 'Conditionally Download CUDA'
+        if: steps.cache-cuda.outputs.cache-hit != 'true'
+        run: |
+          $ErrorActionPreference = "Stop"
+          Invoke-WebRequest -Uri "${env:CUDA_12_WINDOWS_URL}" -OutFile "cuda-install.exe"
+      - name: 'Install CUDA'
+        run: |
+          $subpackages = @("cudart", "nvcc", "cublas", "cublas_dev") | foreach-object {"${_}_${{ env.CUDA_12_WINDOWS_VER }}"}
+          Start-Process "cuda-install.exe" -ArgumentList (@("-s") + $subpackages) -NoNewWindow -Wait
+      - name: 'Verify CUDA'
+        run: |
+          & (resolve-path "c:\Program Files\NVIDIA*\CUDA\v*\bin\nvcc.exe")[0] --version
+          $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" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "CUDA_PATH=$cudaPath" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+          echo "CUDA_PATH_V${cudaVer}=$cudaPath" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+          echo "CUDA_PATH_VX_Y=CUDA_PATH_V${cudaVer}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Add msys paths
+        run: |
+          echo "c:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "C:\msys64\clang64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+      - name: Install msys2 tools
+        run: |
+          Start-Process "c:\msys64\usr\bin\pacman.exe" -ArgumentList @("-S", "--noconfirm", "mingw-w64-clang-x86_64-gcc-compat", "mingw-w64-clang-x86_64-clang") -NoNewWindow -Wait
+      - name: make cuda runner
+        run: |
+          import-module 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
+          Enter-VsDevShell -vsinstallpath 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise' -skipautomaticlocation -DevCmdArguments '-arch=x64 -no_logo'
+          if (!(gcc --version | select-string -quiet clang)) { throw "wrong gcc compiler detected - must be clang" }
+          make cuda_v$(($env:CUDA_PATH | split-path -leaf) -replace 'v(\d+).*', '$1')
+
+  runners-cpu:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.RUNNERS == 'True' }}
     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:
+      GOARCH: ${{ matrix.arch }}
+      ARCH: ${{ matrix.arch }}
       CGO_ENABLED: '1'
     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
-        with:
-          node-version: '20'
-      - name: Install UI dependencies
-        working-directory: ./app/ui/app
-        run: npm ci
-      - name: Install tscriptify
+          go-version-file: go.mod
+          cache: true
+      - name: Add msys paths
+        if: ${{ startsWith(matrix.os, 'windows-') }}
         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') }}
+          echo "c:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "C:\msys64\clang64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+      - name: Install msys2 tools
+        if: ${{ startsWith(matrix.os, 'windows-') }}
         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 ./...
+          Start-Process "c:\msys64\usr\bin\pacman.exe" -ArgumentList @("-S", "--noconfirm", "mingw-w64-clang-x86_64-gcc-compat", "mingw-w64-clang-x86_64-clang") -NoNewWindow -Wait
+      - name: 'Build Windows Go Runners'
+        if: ${{ startsWith(matrix.os, 'windows-') }}
+        run: |
+          $gopath=(get-command go).source | split-path -parent
+          $gccpath=(get-command gcc).source | split-path -parent
+          import-module 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
+          Enter-VsDevShell -vsinstallpath 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise' -skipautomaticlocation -DevCmdArguments '-arch=x64 -no_logo'
+          $env:CMAKE_SYSTEM_VERSION="10.0.22621.0"
+          $env:PATH="$gopath;$gccpath;$env:PATH"
+          echo $env:PATH
+          if (!(gcc --version | select-string -quiet clang)) { throw "wrong gcc compiler detected - must be clang" }
+          make -j 4
+      - name: 'Build Unix Go Runners'
+        if: ${{ ! startsWith(matrix.os, 'windows-') }}
+        run: make -j 4
+      - run: go build .
 
-      - name: go test
-        if: always()
-        run: go test -count=1 -benchtime=1x ./...
-
-      - name: go test app with live updater tag
-        if: ${{ needs.changes.outputs.app_changed == 'True' && contains(fromJSON('["macos-latest","windows-latest"]'), matrix.os) }}
-        run: go test -count=1 -tags updater_live ./app/...
-
-      - uses: golangci/golangci-lint-action@v9
+  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:
-          only-new-issues: true
+          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
+      - uses: golangci/golangci-lint-action@v6
+        with:
+          args: --timeout 10m0s -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'
+    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=amd64 ;;
+            arm64) echo ARCH=arm64 ;;
+          esac >>$GITHUB_ENV
+        shell: bash
+      - run: go test ./...
+
+  patches:
+    needs: [changes]
+    if: ${{ needs.changes.outputs.RUNNERS == 'True' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Verify patches carry all the changes
+        run: |
+          make apply-patches sync && git diff --compact-summary --exit-code llama

.gitignore

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

.golangci.yaml

@@ -1,51 +1,47 @@
-version: "2"
+run:
+  timeout: 5m
 linters:
   enable:
     - asasalint
     - bidichk
     - bodyclose
     - containedctx
+    - contextcheck
+    - errcheck
+    - exportloopref
+    - gci
     - gocheckcompilerdirectives
+    - gofmt
+    - gofumpt
+    - gosimple
+    - govet
+    - ineffassign
     - intrange
     - makezero
     - misspell
     - nilerr
     - nolintlint
     - nosprintfhostport
+    - staticcheck
+    - tenv
     - unconvert
-    - usetesting
+    - unused
+    - usestdlibvars
     - 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
+linters-settings:
+  gci:
+    sections: [standard, default, localmodule]
+  staticcheck:
+    checks:
+      - all
+      - -SA1019 # omit Deprecated check
 severity:
-  default: error
+  default-severity: error
   rules:
     - linters:
         - gofmt
         - goimports
         - intrange
+        - usestdlibvars
       severity: info
-formatters:
-  enable:
-    - gofmt
-    - gofumpt

.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,66 +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)
-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

@@ -6,6 +6,8 @@ Thank you for your interest in contributing to Ollama! Here are a few guidelines
 
 See the [development documentation](./docs/development.md) for instructions on how to build and run Ollama locally.
 
+## Pull requests
+
 ### 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.
@@ -16,7 +18,7 @@ See the [development documentation](./docs/development.md) for instructions on h
 
 * 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.
+* Documentation: small updates to fill in or correct missing documentation is helpful, however large documentation additions can be hard to maintain over time.
 
 ### Issues that may not be accepted
 
@@ -24,64 +26,11 @@ See the [development documentation](./docs/development.md) for instructions on h
 * 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
+### Best practices
 
-> 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.
+* Commit messages: please leave both a title and a description in your commit messages. The title should be a short summary of the changes, with a leading word that explains the section of the code being changed (e.g. `api: fix parsing of prompt field`) . In the description, leave a short 2-3 sentences that explain more about the change and its impact.
+* Tests: please add test coverage to changes where possible.
+* Minimize dependencies: avoid adding new dependencies unless absolutely necessary.
 
 ## Need help?
 

Dockerfile

@@ -1,319 +1,272 @@
-# vim: filetype=dockerfile
-
-ARG FLAVOR=${TARGETARCH}
-
-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-11-gcc gcc-toolset-11-gcc-c++ gcc-toolset-11-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-11/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
+ARG GOLANG_VERSION=1.22.8
+ARG CMAKE_VERSION=3.22.1
+ARG CUDA_VERSION_11=11.3.1
+ARG CUDA_V11_ARCHITECTURES="50;52;53;60;61;62;70;72;75;80;86"
+ARG CUDA_VERSION_12=12.4.0
+ARG CUDA_V12_ARCHITECTURES="60;61;62;70;72;75;80;86;87;89;90;90a"
+ARG ROCM_VERSION=6.1.2
+ARG JETPACK_6=r36.2.0
+ARG JETPACK_5=r35.4.1
 
+### To create a local image for building linux binaries on mac or windows with efficient incremental builds
 #
-# GPU toolchain stages — provide compilers for llama-server GPU builds
+# docker build --platform linux/amd64 -t builder-amd64 -f Dockerfile --target unified-builder-amd64 .
+# docker run --platform linux/amd64 --rm -it -v $(pwd):/go/src/github.com/ollama/ollama/ builder-amd64
 #
-
-FROM base AS cpu-deps
-RUN dnf install -y gcc-toolset-11-gcc gcc-toolset-11-gcc-c++
-ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
-
-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
-
+### Then incremental builds will be much faster in this container
 #
-# llama-server stages — rebuild when LLAMA_CPP_VERSION, llama/server/, or llama/compat/ changes.
+# make -j 10 && go build -trimpath -o dist/linux-amd64/ollama .
 #
-# CPU stage: llama-server + ggml-base + ggml-cpu variants → lib/ollama/
-# GPU stages: GPU backend .so only → lib/ollama/<variant>/
+FROM --platform=linux/amd64 rocm/dev-centos-7:${ROCM_VERSION}-complete AS unified-builder-amd64
+ARG CMAKE_VERSION
+ARG GOLANG_VERSION
+ARG CUDA_VERSION_11
+ARG CUDA_VERSION_12
+COPY ./scripts/rh_linux_deps.sh /
+ENV PATH /opt/rh/devtoolset-10/root/usr/bin:/usr/local/cuda/bin:$PATH
+ENV LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/cuda/lib64
+ENV LIBRARY_PATH=/usr/local/cuda/lib64/stubs:/opt/amdgpu/lib64
+RUN CMAKE_VERSION=${CMAKE_VERSION} GOLANG_VERSION=${GOLANG_VERSION} sh /rh_linux_deps.sh
+RUN yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel7/x86_64/cuda-rhel7.repo && \
+    dnf clean all && \
+    dnf install -y \
+    zsh \
+    cuda-$(echo ${CUDA_VERSION_11} | cut -f1-2 -d. | sed -e "s/\./-/g") \
+    cuda-$(echo ${CUDA_VERSION_12} | cut -f1-2 -d. | sed -e "s/\./-/g")
+# TODO intel oneapi goes here...
+ENV GOARCH amd64
+ENV CGO_ENABLED 1
+WORKDIR /go/src/github.com/ollama/ollama/
+ENTRYPOINT [ "zsh" ]
+
+### To create a local image for building linux binaries on mac or linux/arm64 with efficient incremental builds
+# Note: this does not contain jetson variants
 #
-
-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-11/root/usr/lib64/libgomp.so* \
-            /opt/rh/gcc-toolset-11/root/usr/lib64/libomp.so*; do \
-                [ -e "$lib" ] && cp -a "$lib" dist/lib/ollama/ || true; \
-            done
-
-FROM scratch AS publish-llama-server-cpu
-COPY --from=llama-server-cpu dist/lib/ollama /lib/ollama/
-
-FROM cuda-12-deps AS llama-server-cuda_v12
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_v12_linux \
-        && cmake --build build/llama-server-cuda_v12 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_v12 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_v12
-COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
-
-FROM cuda-13-deps AS llama-server-cuda_v13
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_v13_linux \
-        && cmake --build build/llama-server-cuda_v13 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_v13 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_v13
-COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
-
-FROM rocm-7-deps AS llama-server-rocm_v7_2
-ENV CC=clang CXX=clang++
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset rocm_v7_2_linux \
-        && cmake --build build/llama-server-rocm_v7_2 -- -l $(nproc) \
-        && cmake --install build/llama-server-rocm_v7_2 --component llama-server --strip
-RUN rm -f dist/lib/ollama/rocm_v7_2/rocblas/library/*gfx90[06]*
-
-FROM scratch AS publish-llama-server-rocm_v7_2
-COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama/
-
-FROM vulkan-deps AS llama-server-vulkan
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset vulkan \
-        && cmake --build build/llama-server-vulkan -- -l $(nproc) \
-        && cmake --install build/llama-server-vulkan --component llama-server --strip
-
-FROM scratch AS publish-llama-server-vulkan
-COPY --from=llama-server-vulkan dist/lib/ollama /lib/ollama/
-
-#
-# JetPack stages — self-contained with their own base images
+# docker build --platform linux/arm64 -t builder-arm64 -f Dockerfile --target unified-builder-arm64 .
+# docker run --platform linux/arm64 --rm -it -v $(pwd):/go/src/github.com/ollama/ollama/ builder-arm64
 #
+FROM --platform=linux/arm64 rockylinux:8 AS unified-builder-arm64
+ARG CMAKE_VERSION
+ARG GOLANG_VERSION
+ARG CUDA_VERSION_11
+ARG CUDA_VERSION_12
+COPY ./scripts/rh_linux_deps.sh /
+RUN CMAKE_VERSION=${CMAKE_VERSION} GOLANG_VERSION=${GOLANG_VERSION} sh /rh_linux_deps.sh
+RUN yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/sbsa/cuda-rhel8.repo && \
+    dnf config-manager --set-enabled appstream && \
+    dnf clean all && \
+    dnf install -y \
+    zsh \
+    cuda-toolkit-$(echo ${CUDA_VERSION_11} | cut -f1-2 -d. | sed -e "s/\./-/g") \
+    cuda-toolkit-$(echo ${CUDA_VERSION_12} | cut -f1-2 -d. | sed -e "s/\./-/g")
+ENV PATH /opt/rh/gcc-toolset-10/root/usr/bin:$PATH:/usr/local/cuda/bin
+ENV LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/cuda/lib64
+ENV LIBRARY_PATH=/usr/local/cuda/lib64/stubs:/opt/amdgpu/lib64
+ENV GOARCH amd64
+ENV CGO_ENABLED 1
+WORKDIR /go/src/github.com/ollama/ollama/
+ENTRYPOINT [ "zsh" ]
 
-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 x/imagegen/mlx x/imagegen/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
+FROM --platform=linux/amd64 unified-builder-amd64 AS runners-amd64
+COPY . .
+ARG OLLAMA_SKIP_CUDA_GENERATE
+ARG OLLAMA_SKIP_CUDA_11_GENERATE
+ARG OLLAMA_SKIP_CUDA_12_GENERATE
+ARG OLLAMA_SKIP_ROCM_GENERATE
+ARG CUDA_V11_ARCHITECTURES
+ARG CUDA_V12_ARCHITECTURES
+ARG OLLAMA_FAST_BUILD
+RUN --mount=type=cache,target=/root/.ccache \
+    if grep "^flags" /proc/cpuinfo|grep avx>/dev/null; then \
+        make -j $(expr $(nproc) / 2 ) ; \
+    else \
+        make -j 5 ; \
+    fi
+
+FROM --platform=linux/arm64 unified-builder-arm64 AS runners-arm64
+COPY . .
+ARG OLLAMA_SKIP_CUDA_GENERATE
+ARG OLLAMA_SKIP_CUDA_11_GENERATE
+ARG OLLAMA_SKIP_CUDA_12_GENERATE
+ARG CUDA_V11_ARCHITECTURES
+ARG CUDA_V12_ARCHITECTURES
+ARG OLLAMA_FAST_BUILD
+RUN --mount=type=cache,target=/root/.ccache \
+    make -j 5
+
+# Jetsons need to be built in discrete stages
+FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK_5} AS runners-jetpack5-arm64
+ARG GOLANG_VERSION
+RUN apt-get update && apt-get install -y git curl ccache && \
+    curl -s -L https://dl.google.com/go/go${GOLANG_VERSION}.linux-arm64.tar.gz | tar xz -C /usr/local && \
+    ln -s /usr/local/go/bin/go /usr/local/bin/go && \
+    ln -s /usr/local/go/bin/gofmt /usr/local/bin/gofmt && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+WORKDIR /go/src/github.com/ollama/ollama/
 COPY . .
-ARG GOFLAGS="'-ldflags=-w -s'"
-ENV CGO_ENABLED=1
 ARG CGO_CFLAGS
-ARG CGO_CXXFLAGS
-ENV CGO_CFLAGS="${CGO_CFLAGS}"
-ENV CGO_CXXFLAGS="${CGO_CXXFLAGS}"
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    go build -trimpath -buildmode=pie -o /bin/ollama .
+ENV GOARCH arm64
+RUN --mount=type=cache,target=/root/.ccache \
+    make -j 5 cuda_v11 \
+        CUDA_ARCHITECTURES="72;87" \
+        GPU_RUNNER_VARIANT=_jetpack5 \
+        CGO_EXTRA_LDFLAGS_LINUX=-L/usr/local/cuda/lib64/stubs \
+        DIST_LIB_DIR=/go/src/github.com/ollama/ollama/dist/linux-arm64-jetpack5/lib/ollama \
+        DIST_GPU_RUNNER_DEPS_DIR=/go/src/github.com/ollama/ollama/dist/linux-arm64-jetpack5/lib/ollama/cuda_jetpack5
 
-FROM scratch AS publish-go
-COPY --from=build /bin/ollama /bin/ollama
+FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK_6} AS runners-jetpack6-arm64
+ARG GOLANG_VERSION
+RUN apt-get update && apt-get install -y git curl ccache && \
+    curl -s -L https://dl.google.com/go/go${GOLANG_VERSION}.linux-arm64.tar.gz | tar xz -C /usr/local && \
+    ln -s /usr/local/go/bin/go /usr/local/bin/go && \
+    ln -s /usr/local/go/bin/gofmt /usr/local/bin/gofmt && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+WORKDIR /go/src/github.com/ollama/ollama/
+COPY . .
+ARG CGO_CFLAGS
+ENV GOARCH arm64
+RUN --mount=type=cache,target=/root/.ccache \
+    make -j 5 cuda_v12 \
+        CUDA_ARCHITECTURES="87" \
+        GPU_RUNNER_VARIANT=_jetpack6 \
+        CGO_EXTRA_LDFLAGS_LINUX=-L/usr/local/cuda/lib64/stubs \
+        DIST_LIB_DIR=/go/src/github.com/ollama/ollama/dist/linux-arm64-jetpack6/lib/ollama \
+        DIST_GPU_RUNNER_DEPS_DIR=/go/src/github.com/ollama/ollama/dist/linux-arm64-jetpack6/lib/ollama/cuda_jetpack6
 
-#
-# Assembly stages — combine llama-server variants + GPU runtime libs
-#
 
-FROM --platform=linux/amd64 scratch AS amd64
-COPY --from=llama-server-cpu      dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-vulkan   dist/lib/ollama /lib/ollama/
-COPY --from=mlx     /go/src/github.com/ollama/ollama/dist/lib/ollama /lib/ollama/
+# Intermediate stages used for ./scripts/build_linux.sh
+FROM --platform=linux/amd64 centos:7 AS 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
+ENV CGO_ENABLED 1
+ENV GOARCH amd64
+WORKDIR /go/src/github.com/ollama/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 builder-amd64 AS build-amd64
+COPY . .
+COPY --from=runners-amd64 /go/src/github.com/ollama/ollama/dist/ dist/
+COPY --from=runners-amd64 /go/src/github.com/ollama/ollama/build/ build/
+ARG GOFLAGS
+ARG CGO_CFLAGS
+ARG OLLAMA_SKIP_ROCM_GENERATE
+RUN --mount=type=cache,target=/root/.ccache \
+    go build -trimpath -o dist/linux-amd64/bin/ollama .
+RUN cd dist/linux-$GOARCH && \
+    tar --exclude runners -cf - . | pigz --best > ../ollama-linux-$GOARCH.tgz
+RUN if [ -z ${OLLAMA_SKIP_ROCM_GENERATE} ] ; then \
+    cd dist/linux-$GOARCH-rocm && \
+    tar -cf - . | pigz --best > ../ollama-linux-$GOARCH-rocm.tgz ;\
+    fi
 
-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/arm64 rockylinux:8 AS 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/gcc-toolset-10/root/usr/bin:$PATH
+ENV CGO_ENABLED 1
+ENV GOARCH arm64
+WORKDIR /go/src/github.com/ollama/ollama
 
-FROM --platform=linux/amd64 scratch AS amd64-archive
-COPY --from=amd64 /lib/ollama /lib/ollama/
-COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama/
+FROM --platform=linux/arm64 builder-arm64 AS build-arm64
+COPY . .
+COPY --from=runners-arm64 /go/src/github.com/ollama/ollama/dist/ dist/
+COPY --from=runners-arm64 /go/src/github.com/ollama/ollama/build/ build/
+COPY --from=runners-jetpack5-arm64 /go/src/github.com/ollama/ollama/dist/ dist/
+COPY --from=runners-jetpack5-arm64 /go/src/github.com/ollama/ollama/build/ build/
+COPY --from=runners-jetpack6-arm64 /go/src/github.com/ollama/ollama/dist/ dist/
+COPY --from=runners-jetpack6-arm64 /go/src/github.com/ollama/ollama/build/ build/
+ARG GOFLAGS
+ARG CGO_CFLAGS
+RUN --mount=type=cache,target=/root/.ccache \
+    go build -trimpath -o dist/linux-arm64/bin/ollama .
+RUN cd dist/linux-$GOARCH && \
+    tar --exclude runners -cf - . | pigz --best > ../ollama-linux-$GOARCH.tgz
+RUN cd dist/linux-$GOARCH-jetpack5 && \
+    tar --exclude runners -cf - . | pigz --best > ../ollama-linux-$GOARCH-jetpack5.tgz
+RUN cd dist/linux-$GOARCH-jetpack6 && \
+    tar --exclude runners -cf - . | pigz --best > ../ollama-linux-$GOARCH-jetpack6.tgz
 
-FROM --platform=linux/arm64 scratch AS arm64-archive
-COPY --from=arm64 /lib/ollama /lib/ollama/
+FROM --platform=linux/amd64 scratch AS dist-amd64
+COPY --from=build-amd64 /go/src/github.com/ollama/ollama/dist/ollama-linux-*.tgz /
+FROM --platform=linux/arm64 scratch AS dist-arm64
+COPY --from=build-arm64 /go/src/github.com/ollama/ollama/dist/ollama-linux-*.tgz /
+FROM dist-$TARGETARCH AS dist
 
-FROM ${TARGETARCH}-archive AS archive
-COPY --from=build /bin/ollama /bin/ollama
 
-FROM ${FLAVOR} AS image-archive
-COPY --from=build /bin/ollama /bin/ollama
+# Optimized container images do not cary nested payloads
+FROM --platform=linux/amd64 builder-amd64 AS container-build-amd64
+WORKDIR /go/src/github.com/ollama/ollama
+COPY . .
+ARG GOFLAGS
+ARG CGO_CFLAGS
+RUN --mount=type=cache,target=/root/.ccache \
+    go build -trimpath -o dist/linux-amd64/bin/ollama .
 
-FROM ubuntu:24.04
-ARG APT_MIRROR=http://archive.ubuntu.com/ubuntu
-ARG APT_PORTS_MIRROR=http://ports.ubuntu.com/ubuntu-ports
-RUN sed -i \
-        -e "s|http://archive.ubuntu.com/ubuntu|$APT_MIRROR|g" \
-        -e "s|http://ports.ubuntu.com/ubuntu-ports|$APT_PORTS_MIRROR|g" \
-        /etc/apt/sources.list.d/ubuntu.sources \
-    && apt-get update \
-    && 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
+FROM --platform=linux/arm64 builder-arm64 AS container-build-arm64
+WORKDIR /go/src/github.com/ollama/ollama
+COPY . .
+ARG GOFLAGS
+ARG CGO_CFLAGS
+RUN --mount=type=cache,target=/root/.ccache \
+    go build -trimpath -o dist/linux-arm64/bin/ollama .
+
+# For amd64 container images, filter out cuda/rocm to minimize size
+FROM runners-amd64 AS runners-cuda-amd64
+RUN rm -rf \
+    ./dist/linux-amd64/lib/ollama/libggml_hipblas.so \
+    ./dist/linux-amd64/lib/ollama/runners/rocm*
+
+FROM runners-amd64 AS runners-rocm-amd64
+RUN rm -rf \
+    ./dist/linux-amd64/lib/ollama/libggml_cuda*.so \
+    ./dist/linux-amd64/lib/ollama/libcu*.so* \
+    ./dist/linux-amd64/lib/ollama/runners/cuda*
+
+FROM --platform=linux/amd64 ubuntu:22.04 AS runtime-amd64
+RUN apt-get update && \
+    apt-get install -y ca-certificates && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+COPY --from=container-build-amd64 /go/src/github.com/ollama/ollama/dist/linux-amd64/bin/ /bin/
+COPY --from=runners-cuda-amd64 /go/src/github.com/ollama/ollama/dist/linux-amd64/lib/ /lib/
+
+FROM --platform=linux/arm64 ubuntu:22.04 AS runtime-arm64
+RUN apt-get update && \
+    apt-get install -y ca-certificates && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+COPY --from=container-build-arm64 /go/src/github.com/ollama/ollama/dist/linux-arm64/bin/ /bin/
+COPY --from=runners-arm64 /go/src/github.com/ollama/ollama/dist/linux-arm64/lib/ /lib/
+COPY --from=runners-jetpack5-arm64 /go/src/github.com/ollama/ollama/dist/linux-arm64-jetpack5/lib/ /lib/
+COPY --from=runners-jetpack6-arm64 /go/src/github.com/ollama/ollama/dist/linux-arm64-jetpack6/lib/ /lib/
+
+
+# ROCm libraries larger so we keep it distinct from the CPU/CUDA image
+FROM --platform=linux/amd64 ubuntu:22.04 AS runtime-rocm
+# Frontload the rocm libraries which are large, and rarely change to increase chance of a common layer
+# across releases
+COPY --from=build-amd64 /go/src/github.com/ollama/ollama/dist/linux-amd64-rocm/lib/ /lib/
+RUN apt-get update && \
+    apt-get install -y ca-certificates && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+COPY --from=container-build-amd64 /go/src/github.com/ollama/ollama/dist/linux-amd64/bin/ /bin/
+COPY --from=runners-rocm-amd64 /go/src/github.com/ollama/ollama/dist/linux-amd64/lib/ /lib/
+
+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 @@
-b9509

MLX_C_VERSION

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

MLX_VERSION

@@ -1 +0,0 @@
-2165dc08d7b33258260aa849d39f087d50e62962

Makefile

@@ -0,0 +1,4 @@
+GOALS := $(or $(MAKECMDGOALS),all)
+.PHONY: $(GOALS)
+$(GOALS):
+	$(MAKE) -C llama $@

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.
 
 ### macOS
 
-```shell
-curl -fsSL https://ollama.com/install.sh | sh
-```
-
-or [download manually](https://ollama.com/download/Ollama.dmg)
+[Download](https://ollama.com/download/Ollama-darwin.zip)
 
 ### 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,493 @@ 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.2](https://ollama.com/library/llama3.2):
 
 ```
-ollama
+ollama run llama3.2
 ```
 
-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.2          | 3B         | 2.0GB | `ollama run llama3.2`            |
+| Llama 3.2          | 1B         | 1.3GB | `ollama run llama3.2:1b`         |
+| Llama 3.2 Vision   | 11B        | 7.9GB | `ollama run llama3.2-vision`     |
+| Llama 3.2 Vision   | 90B        | 55GB  | `ollama run llama3.2-vision:90b` |
+| Llama 3.1          | 8B         | 4.7GB | `ollama run llama3.1`            |
+| Llama 3.1          | 70B        | 40GB  | `ollama run llama3.1:70b`        |
+| Llama 3.1          | 405B       | 231GB | `ollama run llama3.1:405b`       |
+| Phi 3 Mini         | 3.8B       | 2.3GB | `ollama run phi3`                |
+| Phi 3 Medium       | 14B        | 7.9GB | `ollama run phi3:medium`         |
+| Gemma 2            | 2B         | 1.6GB | `ollama run gemma2:2b`           |
+| Gemma 2            | 9B         | 5.5GB | `ollama run gemma2`              |
+| Gemma 2            | 27B        | 16GB  | `ollama run gemma2:27b`          |
+| Mistral            | 7B         | 4.1GB | `ollama run mistral`             |
+| Moondream 2        | 1.4B       | 829MB | `ollama run moondream`           |
+| Neural Chat        | 7B         | 4.1GB | `ollama run neural-chat`         |
+| Starling           | 7B         | 4.1GB | `ollama run starling-lm`         |
+| Code Llama         | 7B         | 3.8GB | `ollama run codellama`           |
+| Llama 2 Uncensored | 7B         | 3.8GB | `ollama run llama2-uncensored`   |
+| LLaVA              | 7B         | 4.5GB | `ollama run llava`               |
+| 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.2` model:
 
 ```
-ollama launch claude
+ollama pull llama3.2
 ```
 
-Supported integrations include [Claude Code](https://docs.ollama.com/integrations/claude-code), [Codex](https://docs.ollama.com/integrations/codex), [Copilot CLI](https://docs.ollama.com/integrations/copilot-cli), [Droid](https://docs.ollama.com/integrations/droid), and [OpenCode](https://docs.ollama.com/integrations/opencode).
-
-### AI assistant
-
-Use [OpenClaw](https://docs.ollama.com/integrations/openclaw) to turn Ollama into a personal AI assistant across WhatsApp, Telegram, Slack, Discord, and more:
+Create a `Modelfile`:
 
 ```
-ollama launch openclaw
+FROM llama3.2
+
+# set the temperature to 1 [higher is more creative, lower is more coherent]
+PARAMETER temperature 1
+
+# set the system message
+SYSTEM """
+You are Mario from Super Mario Bros. Answer as Mario, the assistant, only.
+"""
 ```
 
-### Chat with a model
-
-Run and chat with [Gemma 4](https://ollama.com/library/gemma4):
+Next, create and run the model:
 
 ```
-ollama run gemma4
+ollama create mario -f ./Modelfile
+ollama run mario
+>>> hi
+Hello! It's your friend Mario.
 ```
 
-See [ollama.com/library](https://ollama.com/library) for the full list.
+For more 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.2
+```
+
+> This command can also be used to update a local model. Only the diff will be pulled.
+
+### Remove a model
+
+```
+ollama rm llama3.2
+```
+
+### Copy a model
+
+```
+ollama cp llama3.2 my-model
+```
+
+### Multiline input
+
+For multiline input, you can wrap text with `"""`:
+
+```
+>>> """Hello,
+... world!
+... """
+I'm a basic program that prints the famous "Hello, world!" message to the console.
+```
+
+### Multimodal models
+
+```
+ollama run llava "What's in this image? /Users/jmorgan/Desktop/smile.png"
+The image features a yellow smiley face, which is likely the central focus of the picture.
+```
+
+### Pass the prompt as an argument
+
+```
+$ ollama run llama3.2 "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.
+```
+
+### Show model information
+
+```
+ollama show llama3.2
+```
+
+### List models on your computer
+
+```
+ollama list
+```
+
+### List which models are currently loaded
+
+```
+ollama ps
+```
+
+### Stop a model which is currently running
+
+```
+ollama stop llama3.2
+```
+
+### Start Ollama
+
+`ollama serve` is used when you want to start ollama without running the desktop application.
+
+## Building
+
+See the [developer guide](https://github.com/ollama/ollama/blob/main/docs/development.md)
+
+### Running local builds
+
+Next, start the server:
+
+```
+./ollama serve
+```
+
+Finally, in a separate shell, run a model:
+
+```
+./ollama run llama3.2
+```
 
 ## 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.2",
+  "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.2",
+  "messages": [
+    { "role": "user", "content": "why is the sky blue?" }
+  ]
+}'
 ```
 
-```python
-from ollama import chat
-
-response = chat(model='gemma4', messages=[
-  {
-    'role': 'user',
-    'content': 'Why is the sky blue?',
-  },
-])
-print(response.message.content)
-```
-
-### JavaScript
-
-```
-npm i ollama
-```
-
-```javascript
-import ollama from "ollama";
-
-const response = await ollama.chat({
-  model: "gemma4",
-  messages: [{ role: "user", content: "Why is the sky blue?" }],
-});
-console.log(response.message.content);
-```
-
-## Supported backends
-
-- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
-
-## Documentation
-
-- [CLI reference](https://docs.ollama.com/cli)
-- [REST API reference](https://docs.ollama.com/api)
-- [Importing models](https://docs.ollama.com/import)
-- [Modelfile reference](https://docs.ollama.com/modelfile)
-- [Building from source](https://github.com/ollama/ollama/blob/main/docs/development.md)
+See the [API documentation](./docs/api.md) for all endpoints.
 
 ## Community Integrations
 
-> Want to add your project? Open a pull request.
+### Web & Desktop
 
-### Chat Interfaces
+- [Open WebUI](https://github.com/open-webui/open-webui)
+- [Enchanted (macOS native)](https://github.com/AugustDev/enchanted)
+- [Hollama](https://github.com/fmaclen/hollama)
+- [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](https://github.com/mrdjohnson/llm-x) (Progressive Web App)
+- [AnythingLLM (Docker + MacOs/Windows/Linux native app)](https://github.com/Mintplex-Labs/anything-llm)
+- [Ollama Basic Chat: Uses HyperDiv Reactive UI](https://github.com/rapidarchitect/ollama_basic_chat)
+- [Ollama-chats RPG](https://github.com/drazdra/ollama-chats)
+- [QA-Pilot](https://github.com/reid41/QA-Pilot) (Interactive chat tool that can leverage Ollama models for rapid understanding and navigation of GitHub code repositories)
+- [ChatOllama](https://github.com/sugarforever/chat-ollama) (Open Source Chatbot based on Ollama with Knowledge Bases)
+- [CRAG Ollama Chat](https://github.com/Nagi-ovo/CRAG-Ollama-Chat) (Simple Web Search with Corrective RAG)
+- [RAGFlow](https://github.com/infiniflow/ragflow) (Open-source Retrieval-Augmented Generation engine based on deep document understanding)
+- [StreamDeploy](https://github.com/StreamDeploy-DevRel/streamdeploy-llm-app-scaffold) (LLM Application Scaffold)
+- [chat](https://github.com/swuecho/chat) (chat web app for teams)
+- [Lobe Chat](https://github.com/lobehub/lobe-chat) with [Integrating Doc](https://lobehub.com/docs/self-hosting/examples/ollama)
+- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) (Local Chat with multiple PDFs using Ollama and RAG)
+- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) (Flexible native client with RAG & multi-agent automation)
+- [macai](https://github.com/Renset/macai) (macOS client for Ollama, ChatGPT, and other compatible API back-ends)
+- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) (RWKV offline LLM deployment tool, also usable as a client for ChatGPT and Ollama)
+- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) (app to evaluate and compare models)
+- [Olpaka](https://github.com/Otacon/olpaka) (User-friendly Flutter Web App for Ollama)
+- [OllamaSpring](https://github.com/CrazyNeil/OllamaSpring) (Ollama Client for macOS)
+- [LLocal.in](https://github.com/kartikm7/llocal) (Easy to use Electron Desktop Client for Ollama)
+- [Shinkai Desktop](https://github.com/dcSpark/shinkai-apps) (Two click install Local AI using Ollama + Files + RAG)
+- [AiLama](https://github.com/zeyoyt/ailama) (A Discord User App that allows you to interact with Ollama anywhere in discord )
+- [Ollama with Google Mesop](https://github.com/rapidarchitect/ollama_mesop/) (Mesop Chat Client implementation with Ollama)
+- [R2R](https://github.com/SciPhi-AI/R2R) (Open-source RAG engine)
+- [Ollama-Kis](https://github.com/elearningshow/ollama-kis) (A simple easy to use GUI with sample custom LLM for Drivers Education)
+- [OpenGPA](https://opengpa.org) (Open-source offline-first Enterprise Agentic Application)
+- [Painting Droid](https://github.com/mateuszmigas/painting-droid) (Painting app with AI integrations)
+- [Kerlig AI](https://www.kerlig.com/) (AI writing assistant for macOS)
+- [AI Studio](https://github.com/MindWorkAI/AI-Studio)
+- [Sidellama](https://github.com/gyopak/sidellama) (browser-based LLM client)
+- [LLMStack](https://github.com/trypromptly/LLMStack) (No-code multi-agent framework to build LLM agents and workflows)
+- [BoltAI for Mac](https://boltai.com) (AI Chat Client for Mac)
+- [Harbor](https://github.com/av/harbor) (Containerized LLM Toolkit with Ollama as default backend)
+- [PyGPT](https://github.com/szczyglis-dev/py-gpt) (AI desktop assistant for Linux, Windows and Mac)
+- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) (AutoGPT Ollama integration)
+- [Go-CREW](https://www.jonathanhecl.com/go-crew/) (Powerful Offline RAG in Golang)
+- [PartCAD](https://github.com/openvmp/partcad/) (CAD model generation with OpenSCAD and CadQuery)
+- [Ollama4j Web UI](https://github.com/ollama4j/ollama4j-web-ui) - Java-based Web UI for Ollama built with Vaadin, Spring Boot and Ollama4j
+- [PyOllaMx](https://github.com/kspviswa/pyOllaMx) - macOS application capable of chatting with both Ollama and Apple MLX models.
+- [Claude Dev](https://github.com/saoudrizwan/claude-dev) - VSCode extension for multi-file/whole-repo coding
+- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) (Desktop client with Ollama support)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy focused LLM chat interface with optional encryption)
+- [Archyve](https://github.com/nickthecook/archyve) (RAG-enabling document library)
+- [crewAI with Mesop](https://github.com/rapidarchitect/ollama-crew-mesop) (Mesop Web Interface to run crewAI with Ollama)
+- [Tkinter-based client](https://github.com/chyok/ollama-gui) (Python tkinter-based Client for Ollama)
+- [LLMChat](https://github.com/trendy-design/llmchat) (Privacy focused, 100% local, intuitive all-in-one chat interface)
+- [Local Multimodal AI Chat](https://github.com/Leon-Sander/Local-Multimodal-AI-Chat) (Ollama-based LLM Chat with support for multiple features, including PDF RAG, voice chat, image-based interactions, and integration with OpenAI.)
+- [ARGO](https://github.com/xark-argo/argo) (Locally download and run Ollama and Huggingface models with RAG on Mac/Windows/Linux)
+- [OrionChat](https://github.com/EliasPereirah/OrionChat) - OrionChat is a web interface for chatting with different AI providers
+- [G1](https://github.com/bklieger-groq/g1) (Prototype of using prompting strategies to improve the LLM's reasoning through o1-like reasoning chains.)
+- [Web management](https://github.com/lemonit-eric-mao/ollama-web-management) (Web management page)
+- [Promptery](https://github.com/promptery/promptery) (desktop client for Ollama.)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [SpaceLlama](https://github.com/tcsenpai/spacellama) (Firefox and Chrome extension to quickly summarize web pages with ollama in a sidebar)
+- [YouLama](https://github.com/tcsenpai/youlama) (Webapp to quickly summarize any YouTube video, supporting Invidious as well)
+- [DualMind](https://github.com/tcsenpai/dualmind) (Experimental app allowing two models to talk to each other in the terminal or in a web interface)
+- [ollamarama-matrix](https://github.com/h1ddenpr0cess20/ollamarama-matrix) (Ollama chatbot for the Matrix chat protocol)
+- [ollama-chat-app](https://github.com/anan1213095357/ollama-chat-app) (Flutter-based chat app)
+- [Perfect Memory AI](https://www.perfectmemory.ai/) (Productivity AI assists personalized by what you have seen on your screen, heard and said in the meetings)
+- [Hexabot](https://github.com/hexastack/hexabot) (A conversational AI builder)
+- [Reddit Rate](https://github.com/rapidarchitect/reddit_analyzer) (Search and Rate Reddit topics with a weighted summation)
+- [OpenTalkGpt](https://github.com/adarshM84/OpenTalkGpt) (Chrome Extension to manage open-source models supported by Ollama, create custom models, and chat with models from a user-friendly UI)
+- [VT](https://github.com/vinhnx/vt.ai) (A minimal multimodal AI chat app, with dynamic conversation routing. Supports local models via Ollama)
+- [Nosia](https://github.com/nosia-ai/nosia) (Easy to install and use RAG platform based on Ollama)
+- [Witsy](https://github.com/nbonamy/witsy) (An AI Desktop application avaiable for Mac/Windows/Linux)
+- [Abbey](https://github.com/US-Artificial-Intelligence/abbey) (A configurable AI interface server with notebooks, document storage, and YouTube support)
+- [Minima](https://github.com/dmayboroda/minima) (RAG with on-premises or fully local workflow)
 
-#### Web
-
-- [Open WebUI](https://github.com/open-webui/open-webui) - Extensible, self-hosted AI interface
-- [Onyx](https://github.com/onyx-dot-app/onyx) - Connected AI workspace
-- [LibreChat](https://github.com/danny-avila/LibreChat) - Enhanced ChatGPT clone with multi-provider support
-- [Lobe Chat](https://github.com/lobehub/lobe-chat) - Modern chat framework with plugin ecosystem ([docs](https://lobehub.com/docs/self-hosting/examples/ollama))
-- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) - Cross-platform ChatGPT UI ([docs](https://docs.nextchat.dev/models/ollama))
-- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) - AI-powered search engine, open-source Perplexity alternative
-- [big-AGI](https://github.com/enricoros/big-AGI) - AI suite for professionals
-- [Lollms WebUI](https://github.com/ParisNeo/lollms-webui) - Multi-model web interface
-- [ChatOllama](https://github.com/sugarforever/chat-ollama) - Chatbot with knowledge bases
-- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt) - On-premise AI platform
-- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama) - ChatGPT-style web interface
-- [Hollama](https://github.com/fmaclen/hollama) - Minimal web interface
-- [Chatbox](https://github.com/Bin-Huang/Chatbox) - Desktop and web AI client
-- [chat](https://github.com/swuecho/chat) - Chat web app for teams
-- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) - Chat with multiple PDFs using RAG
-- [Tkinter-based client](https://github.com/chyok/ollama-gui) - Python desktop client
-
-#### Desktop
-
-- [Dify.AI](https://github.com/langgenius/dify) - LLM app development platform
-- [AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) - All-in-one AI app for Mac, Windows, and Linux
-- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid) - Cross-platform mobile and desktop client
-- [Witsy](https://github.com/nbonamy/witsy) - AI desktop app for Mac, Windows, and Linux
-- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) - Multi-provider desktop client
-- [Ollama App](https://github.com/JHubi1/ollama-app) - Multi-platform client for desktop and mobile
-- [PyGPT](https://github.com/szczyglis-dev/py-gpt) - AI desktop assistant for Linux, Windows, and Mac
-- [Alpaca](https://github.com/Jeffser/Alpaca) - GTK4 client for Linux and macOS
-- [SwiftChat](https://github.com/aws-samples/swift-chat) - Cross-platform including iOS, Android, and Apple Vision Pro
-- [Enchanted](https://github.com/AugustDev/enchanted) - Native macOS and iOS client
-- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) - Multi-model desktop runner
-- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) - Evaluate and compare models
-- [macai](https://github.com/Renset/macai) - macOS client for Ollama and ChatGPT
-- [AI Studio](https://github.com/MindWorkAI/AI-Studio) - Multi-provider desktop IDE
-- [Reins](https://github.com/ibrahimcetin/reins) - Parameter tuning and reasoning model support
-- [ConfiChat](https://github.com/1runeberg/confichat) - Privacy-focused with optional encryption
-- [LLocal.in](https://github.com/kartikm7/llocal) - Electron desktop client
-- [MindMac](https://mindmac.app) - AI chat client for Mac
-- [Msty](https://msty.app) - Multi-model desktop client
-- [BoltAI for Mac](https://boltai.com) - AI chat client for Mac
-- [IntelliBar](https://intellibar.app/) - AI-powered assistant for macOS
-- [Kerlig AI](https://www.kerlig.com/) - AI writing assistant for macOS
-- [Hillnote](https://hillnote.com) - Markdown-first AI workspace
-- [Perfect Memory AI](https://www.perfectmemory.ai/) - Productivity AI personalized by screen and meeting history
-
-#### Mobile
-
-- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) - One-click Ollama on Android
-
-> SwiftChat, Enchanted, Maid, Ollama App, Reins, and ConfiChat listed above also support mobile platforms.
-
-### Code Editors & Development
-
-- [Cline](https://github.com/cline/cline) - VS Code extension for multi-file/whole-repo coding
-- [Continue](https://github.com/continuedev/continue) - Open-source AI code assistant for any IDE
-- [Void](https://github.com/voideditor/void) - Open source AI code editor, Cursor alternative
-- [Copilot for Obsidian](https://github.com/logancyang/obsidian-copilot) - AI assistant for Obsidian
-- [twinny](https://github.com/rjmacarthy/twinny) - Copilot and Copilot chat alternative
-- [gptel Emacs client](https://github.com/karthink/gptel) - LLM client for Emacs
-- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) - Use Ollama as GitHub Copilot
-- [Obsidian Local GPT](https://github.com/pfrankov/obsidian-local-gpt) - Local AI for Obsidian
-- [Ellama Emacs client](https://github.com/s-kostyaev/ellama) - LLM tool for Emacs
-- [orbiton](https://github.com/xyproto/orbiton) - Config-free text editor with Ollama tab completion
-- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) - Sublime Text 4 AI assistant
-- [VT Code](https://github.com/vinhnx/vtcode) - Rust-based terminal coding agent with Tree-sitter
-- [QodeAssist](https://github.com/Palm1r/QodeAssist) - AI coding assistant for Qt Creator
-- [AI Toolkit for VS Code](https://aka.ms/ai-tooklit/ollama-docs) - Microsoft-official VS Code extension
-- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama) - Natural language interface for computers
-
-### Libraries & SDKs
-
-- [LiteLLM](https://github.com/BerriAI/litellm) - Unified API for 100+ LLM providers
-- [Semantic Kernel](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama) - Microsoft AI orchestration SDK
-- [LangChain4j](https://github.com/langchain4j/langchain4j) - Java LangChain ([example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java))
-- [LangChainGo](https://github.com/tmc/langchaingo/) - Go LangChain ([example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example))
-- [Spring AI](https://github.com/spring-projects/spring-ai) - Spring framework AI support ([docs](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html))
-- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
-- [Ollama for Ruby](https://github.com/crmne/ruby_llm) - Ruby LLM library
-- [any-llm](https://github.com/mozilla-ai/any-llm) - Unified LLM interface by Mozilla
-- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp) - .NET SDK
-- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) - Rust LangChain ([example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs))
-- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) - Java agent framework ([example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama))
-- [Elixir LangChain](https://github.com/brainlid/langchain) - Elixir LangChain
-- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs) - Rust SDK
-- [LangChain for .NET](https://github.com/tryAGI/LangChain) - .NET LangChain ([example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs))
-- [chromem-go](https://github.com/philippgille/chromem-go) - Go vector database with Ollama embeddings ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
-- [LangChainDart](https://github.com/davidmigloz/langchain_dart) - Dart LangChain
-- [LlmTornado](https://github.com/lofcz/llmtornado) - Unified C# interface for multiple inference APIs
-- [Ollama4j for Java](https://github.com/ollama4j/ollama4j) - Java SDK
-- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel) - Laravel integration
-- [Ollama for Swift](https://github.com/mattt/ollama-swift) - Swift SDK
-- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama) - Data framework for LLM apps
-- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md) - AI pipeline framework
-- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama) - Google AI framework
-- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp) - C++ SDK
-- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) - Julia LLM toolkit ([example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama))
-- [Ollama for R - rollama](https://github.com/JBGruber/rollama) - R SDK
-- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama) - AI gateway
-- [Testcontainers](https://testcontainers.com/modules/ollama/) - Container-based testing
-- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama) - PHP AI framework
-
-### Frameworks & Agents
-
-- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) - Autonomous AI agent platform
-- [crewAI](https://github.com/crewAIInc/crewAI) - Multi-agent orchestration framework
-- [Strands Agents](https://github.com/strands-agents/sdk-python) - Model-driven agent building by AWS
-- [Cheshire Cat](https://github.com/cheshire-cat-ai/core) - AI assistant framework
-- [any-agent](https://github.com/mozilla-ai/any-agent) - Unified agent framework interface by Mozilla
-- [Stakpak](https://github.com/stakpak/agent) - Open source DevOps agent
-- [Hexabot](https://github.com/hexastack/hexabot) - Conversational AI builder
-- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) - Multi-agent orchestration ([docs](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama))
-
-### RAG & Knowledge Bases
-
-- [RAGFlow](https://github.com/infiniflow/ragflow) - RAG engine based on deep document understanding
-- [R2R](https://github.com/SciPhi-AI/R2R) - Open-source RAG engine
-- [MaxKB](https://github.com/1Panel-dev/MaxKB/) - Ready-to-use RAG chatbot
-- [Minima](https://github.com/dmayboroda/minima) - On-premises or fully local RAG
-- [Chipper](https://github.com/TilmanGriesel/chipper) - AI interface with Haystack RAG
-- [ARGO](https://github.com/xark-argo/argo) - RAG and deep research on Mac/Windows/Linux
-- [Archyve](https://github.com/nickthecook/archyve) - RAG-enabling document library
-- [Casibase](https://casibase.org) - AI knowledge base with RAG and SSO
-- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) - Native client with RAG and multi-agent automation
-
-### Bots & Messaging
-
-- [LangBot](https://github.com/RockChinQ/LangBot) - Multi-platform messaging bots with agents and RAG
-- [AstrBot](https://github.com/Soulter/AstrBot/) - Multi-platform chatbot with RAG and plugins
-- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) - TypeScript Discord bot
-- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram) - Telegram bot
-- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) - Telegram bot for roleplay
-
-### Terminal & CLI
-
-- [aichat](https://github.com/sigoden/aichat) - All-in-one LLM CLI with Shell Assistant, RAG, and AI tools
-- [oterm](https://github.com/ggozad/oterm) - Terminal client for Ollama
-- [gollama](https://github.com/sammcj/gollama) - Go-based model manager for Ollama
-- [tlm](https://github.com/yusufcanb/tlm) - Local shell copilot
-- [tenere](https://github.com/pythops/tenere) - TUI for LLMs
-- [ParLlama](https://github.com/paulrobello/parllama) - TUI for Ollama
-- [llm-ollama](https://github.com/taketwo/llm-ollama) - Plugin for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/)
-- [ShellOracle](https://github.com/djcopley/ShellOracle) - Shell command suggestions
-- [LLM-X](https://github.com/mrdjohnson/llm-x) - Progressive web app for LLMs
-- [cmdh](https://github.com/pgibler/cmdh) - Natural language to shell commands
-- [VT](https://github.com/vinhnx/vt.ai) - Minimal multimodal AI chat app
-
-### Productivity & Apps
-
-- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) - AI collaborative workspace, self-hostable Notion alternative
-- [Screenpipe](https://github.com/mediar-ai/screenpipe) - 24/7 screen and mic recording with AI-powered search
-- [Vibe](https://github.com/thewh1teagle/vibe) - Transcribe and analyze meetings
-- [Page Assist](https://github.com/n4ze3m/page-assist) - Chrome extension for AI-powered browsing
-- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) - Private, on-device browser AI assistant
-- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server) - Security proxy for Ollama
-- [1Panel](https://github.com/1Panel-dev/1Panel/) - Web-based Linux server management
-- [Writeopia](https://github.com/Writeopia/Writeopia) - Text editor with Ollama integration
-- [QA-Pilot](https://github.com/reid41/QA-Pilot) - GitHub code repository understanding
-- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama) - Ollama in Raycast
-- [Painting Droid](https://github.com/mateuszmigas/painting-droid) - Painting app with AI integrations
-- [Serene Pub](https://github.com/doolijb/serene-pub) - AI roleplaying app
-- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) - Document management with Ollama workflows
-- [TagSpaces](https://www.tagspaces.org) - File management with [AI tagging](https://docs.tagspaces.org/ai/)
-
-### Observability & Monitoring
-
-- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) - Debug, evaluate, and monitor LLM applications
-- [OpenLIT](https://github.com/openlit/openlit) - OpenTelemetry-native monitoring for Ollama and GPUs
-- [Lunary](https://lunary.ai/docs/integrations/ollama) - LLM observability with analytics and PII masking
-- [Langfuse](https://langfuse.com/docs/integrations/ollama) - Open source LLM observability
-- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) - AI observability and evaluation for agents
-- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) - Open source LLM observability
-
-### Database & Embeddings
-
-- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database ([guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md))
-- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) - Connect Ollama with 200+ data platforms
-- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) - Embeddable vector database for Go ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
-- [Kangaroo](https://github.com/dbkangaroo/kangaroo) - AI-powered SQL client
-
-### Infrastructure & Deployment
-
-#### Cloud
+### Cloud
 
 - [Google Cloud](https://cloud.google.com/run/docs/tutorials/gpu-gemma2-with-ollama)
 - [Fly.io](https://fly.io/docs/python/do-more/add-ollama/)
 - [Koyeb](https://www.koyeb.com/deploy/ollama)
-- [Harbor](https://github.com/av/harbor) - Containerized LLM toolkit with Ollama as default backend
 
-#### Package Managers
+### Terminal
+
+- [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)(Interact with models via pure shell scripts on Linux or macOS)
+- [tenere](https://github.com/pythops/tenere)
+- [llm-ollama](https://github.com/taketwo/llm-ollama) for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/).
+- [typechat-cli](https://github.com/anaisbetts/typechat-cli)
+- [ShellOracle](https://github.com/djcopley/ShellOracle)
+- [tlm](https://github.com/yusufcanb/tlm)
+- [podman-ollama](https://github.com/ericcurtin/podman-ollama)
+- [gollama](https://github.com/sammcj/gollama)
+- [ParLlama](https://github.com/paulrobello/parllama)
+- [Ollama eBook Summary](https://github.com/cognitivetech/ollama-ebook-summary/)
+- [Ollama Mixture of Experts (MOE) in 50 lines of code](https://github.com/rapidarchitect/ollama_moe)
+- [vim-intelligence-bridge](https://github.com/pepo-ec/vim-intelligence-bridge) Simple interaction of "Ollama" with the Vim editor
+- [x-cmd ollama](https://x-cmd.com/mod/ollama)
+- [bb7](https://github.com/drunkwcodes/bb7)
+- [SwollamaCLI](https://github.com/marcusziade/Swollama) bundled with the Swollama Swift package. [Demo](https://github.com/marcusziade/Swollama?tab=readme-ov-file#cli-usage)
+- [aichat](https://github.com/sigoden/aichat) All-in-one LLM CLI tool featuring Shell Assistant, Chat-REPL, RAG, AI tools & agents, with access to OpenAI, Claude, Gemini, Ollama, Groq, and more.
+- [PowershAI](https://github.com/rrg92/powershai) PowerShell module that brings AI to terminal on Windows, including support for Ollama
+- [orbiton](https://github.com/xyproto/orbiton) Configuration-free text editor and IDE with support for tab completion with Ollama.
+
+### Apple Vision Pro
+
+- [Enchanted](https://github.com/AugustDev/enchanted)
+
+### Database
+
+- [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)
+
+### 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)
+- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Guix channel](https://codeberg.org/tusharhero/ollama-guix)
+- [Nix package](https://search.nixos.org/packages?channel=24.05&show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
+- [Flox](https://flox.dev/blog/ollama-part-one)
+
+### Libraries
+
+- [LangChain](https://python.langchain.com/docs/integrations/llms/ollama) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
+- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama)
+- [crewAI](https://github.com/crewAIInc/crewAI)
+- [Spring AI](https://github.com/spring-projects/spring-ai) with [reference](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html) and [example](https://github.com/tzolov/ollama-tools)
+- [LangChainGo](https://github.com/tmc/langchaingo/) with [example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example)
+- [LangChain4j](https://github.com/langchain4j/langchain4j) with [example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java)
+- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) with [example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs)
+- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama)
+- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama)
+- [LiteLLM](https://github.com/BerriAI/litellm)
+- [OllamaFarm for Go](https://github.com/presbrey/ollamafarm)
+- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp)
+- [Ollama for Ruby](https://github.com/gbaptista/ollama-ai)
+- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs)
+- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp)
+- [Ollama4j for Java](https://github.com/ollama4j/ollama4j)
+- [ModelFusion Typescript Library](https://modelfusion.dev/integration/model-provider/ollama)
+- [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
+- [Ollama for Dart](https://github.com/breitburg/dart-ollama)
+- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel)
+- [LangChainDart](https://github.com/davidmigloz/langchain_dart)
+- [Semantic Kernel - Python](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama)
+- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md)
+- [Elixir LangChain](https://github.com/brainlid/langchain)
+- [Ollama for R - rollama](https://github.com/JBGruber/rollama)
+- [Ollama for R - ollama-r](https://github.com/hauselin/ollama-r)
+- [Ollama-ex for Elixir](https://github.com/lebrunel/ollama-ex)
+- [Ollama Connector for SAP ABAP](https://github.com/b-tocs/abap_btocs_ollama)
+- [Testcontainers](https://testcontainers.com/modules/ollama/)
+- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama)
+- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) with an [example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama)
+- [LlamaScript](https://github.com/Project-Llama/llamascript)
+- [llm-axe](https://github.com/emirsahin1/llm-axe) (Python Toolkit for Building LLM Powered Apps)
+- [Gollm](https://docs.gollm.co/examples/ollama-example)
+- [Gollama for Golang](https://github.com/jonathanhecl/gollama)
+- [Ollamaclient for Golang](https://github.com/xyproto/ollamaclient)
+- [High-level function abstraction in Go](https://gitlab.com/tozd/go/fun)
+- [Ollama PHP](https://github.com/ArdaGnsrn/ollama-php)
+- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) with [example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama)
+- [Parakeet](https://github.com/parakeet-nest/parakeet) is a GoLang library, made to simplify the development of small generative AI applications with Ollama.
+- [Haverscript](https://github.com/andygill/haverscript) with [examples](https://github.com/andygill/haverscript/tree/main/examples)
+- [Ollama for Swift](https://github.com/mattt/ollama-swift)
+- [Swollama for Swift](https://github.com/marcusziade/Swollama) with [DocC](https://marcusziade.github.io/Swollama/documentation/swollama/)
+- [GoLamify](https://github.com/prasad89/golamify)
+- [Ollama for Haskell](https://github.com/tusharad/ollama-haskell)
+- [multi-llm-ts](https://github.com/nbonamy/multi-llm-ts) (A Typescript/JavaScript library allowing access to different LLM in unified API)
+
+### Mobile
+
+- [Enchanted](https://github.com/AugustDev/enchanted)
+- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy focused LLM chat interface with optional encryption)
+
+### Extensions & Plugins
+
+- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)
+- [Discollama](https://github.com/mxyng/discollama) (Discord bot inside the Ollama discord channel)
+- [Continue](https://github.com/continuedev/continue)
+- [Vibe](https://github.com/thewh1teagle/vibe) (Transcribe and analyze meetings with Ollama)
+- [Obsidian Ollama plugin](https://github.com/hinterdupfinger/obsidian-ollama)
+- [Logseq Ollama plugin](https://github.com/omagdy7/ollama-logseq)
+- [NotesOllama](https://github.com/andersrex/notesollama) (Apple Notes Ollama plugin)
+- [Dagger Chatbot](https://github.com/samalba/dagger-chatbot)
+- [Discord AI Bot](https://github.com/mekb-turtle/discord-ai-bot)
+- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram)
+- [Hass Ollama Conversation](https://github.com/ej52/hass-ollama-conversation)
+- [Rivet plugin](https://github.com/abrenneke/rivet-plugin-ollama)
+- [Obsidian BMO Chatbot plugin](https://github.com/longy2k/obsidian-bmo-chatbot)
+- [Cliobot](https://github.com/herval/cliobot) (Telegram bot with Ollama support)
+- [Copilot for Obsidian plugin](https://github.com/logancyang/obsidian-copilot)
+- [Obsidian Local GPT plugin](https://github.com/pfrankov/obsidian-local-gpt)
+- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama)
+- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using Ollama)
+- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) (Proxy that allows you to use ollama as a copilot like Github copilot)
+- [twinny](https://github.com/rjmacarthy/twinny) (Copilot and Copilot chat alternative using Ollama)
+- [Wingman-AI](https://github.com/RussellCanfield/wingman-ai) (Copilot code and chat alternative using Ollama and Hugging Face)
+- [Page Assist](https://github.com/n4ze3m/page-assist) (Chrome Extension)
+- [Plasmoid Ollama Control](https://github.com/imoize/plasmoid-ollamacontrol) (KDE Plasma extension that allows you to quickly manage/control Ollama model)
+- [AI Telegram Bot](https://github.com/tusharhero/aitelegrambot) (Telegram bot using Ollama in backend)
+- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) (Sublime Text 4 AI assistant plugin with Ollama support)
+- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) (Generalized TypeScript Discord Bot w/ Tuning Documentation)
+- [ChatGPTBox: All in one browser extension](https://github.com/josStorer/chatGPTBox) with [Integrating Tutorial](https://github.com/josStorer/chatGPTBox/issues/616#issuecomment-1975186467)
+- [Discord AI chat/moderation bot](https://github.com/rapmd73/Companion) Chat/moderation bot written in python. Uses Ollama to create personalities.
+- [Headless Ollama](https://github.com/nischalj10/headless-ollama) (Scripts to automatically install ollama client & models on any OS for apps that depends on ollama server)
+- [Terraform AWS Ollama & Open WebUI](https://github.com/xuyangbocn/terraform-aws-self-host-llm) (A Terraform module to deploy on AWS a ready-to-use Ollama service, together with its front end Open WebUI service.)
+- [node-red-contrib-ollama](https://github.com/jakubburkiewicz/node-red-contrib-ollama)
+- [Local AI Helper](https://github.com/ivostoykov/localAI) (Chrome and Firefox extensions that enable interactions with the active tab and customisable API endpoints. Includes secure storage for user prompts.)
+- [vnc-lm](https://github.com/jake83741/vnc-lm) (Discord bot for messaging with LLMs through Ollama and LiteLLM. Seamlessly move between local and flagship models.)
+- [LSP-AI](https://github.com/SilasMarvin/lsp-ai) (Open-source language server for AI-powered functionality)
+- [QodeAssist](https://github.com/Palm1r/QodeAssist) (AI-powered coding assistant plugin for Qt Creator)
+- [Obsidian Quiz Generator plugin](https://github.com/ECuiDev/obsidian-quiz-generator)
+- [TextCraft](https://github.com/suncloudsmoon/TextCraft) (Copilot in Word alternative using Ollama)
+- [Alfred Ollama](https://github.com/zeitlings/alfred-ollama) (Alfred Workflow)
+
+### Supported backends
+
+- [llama.cpp](https://github.com/ggerganov/llama.cpp) project founded by Georgi Gerganov.
+
+### Observability
+
+- [OpenLIT](https://github.com/openlit/openlit) is an OpenTelemetry-native tool for monitoring Ollama Applications & GPUs using traces and metrics.
+- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) is an AI observability and evaluation platform for AI agents. Use HoneyHive to evaluate agent performance, interrogate failures, and monitor quality in production. 

SECURITY.md

@@ -14,7 +14,7 @@ Please include the following details in your report:
 
 ## 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:
+While the maintainer team does their 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

agent/approval.go

@@ -1,905 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"slices"
-	"strings"
-	"sync"
-	"unicode"
-)
-
-type ApprovalDecision string
-
-const (
-	ApprovalAllowOnce    ApprovalDecision = "allow_once"
-	ApprovalAllowSession ApprovalDecision = "allow_session"
-	ApprovalDeny         ApprovalDecision = "deny"
-)
-
-type ApprovalRisk string
-
-const (
-	ApprovalRiskLow    ApprovalRisk = "low"
-	ApprovalRiskMedium ApprovalRisk = "medium"
-	ApprovalRiskHigh   ApprovalRisk = "high"
-)
-
-type ApprovalRequest struct {
-	ToolCallID           string
-	ToolName             string
-	Args                 map[string]any
-	WorkingDir           string
-	ToolApprovalRequired bool
-	Summary              string
-	Risk                 ApprovalRisk
-	Reasons              []string
-}
-
-type ApprovalResult struct {
-	Decision ApprovalDecision
-	Reason   string
-}
-
-type ApprovalHandler interface {
-	RequiresApproval(context.Context, Tool, ApprovalRequest) bool
-	Approve(context.Context, ApprovalRequest) (ApprovalResult, error)
-}
-
-type ApprovalPrompter interface {
-	PromptApproval(context.Context, ApprovalRequest) (ApprovalResult, error)
-}
-
-type ApprovalPolicy interface {
-	EvaluateApproval(context.Context, ApprovalRequest) ApprovalEvaluation
-}
-
-type ApprovalEvaluation struct {
-	Decision      ApprovalDecision
-	RequirePrompt bool
-	Risk          ApprovalRisk
-	Summary       string
-	Reasons       []string
-	SessionKey    string
-}
-
-type AutoAllowApproval struct{}
-
-func (AutoAllowApproval) RequiresApproval(context.Context, Tool, ApprovalRequest) bool {
-	return false
-}
-
-func (AutoAllowApproval) Approve(context.Context, ApprovalRequest) (ApprovalResult, error) {
-	return ApprovalResult{Decision: ApprovalAllowOnce}, nil
-}
-
-type ApprovalManagerOptions struct {
-	Policy   ApprovalPolicy
-	Prompter ApprovalPrompter
-}
-
-type ApprovalManager struct {
-	policy   ApprovalPolicy
-	prompter ApprovalPrompter
-
-	mu             *sync.Mutex
-	sessionAllowed map[string]struct{}
-}
-
-func NewApprovalManager(opts ApprovalManagerOptions) *ApprovalManager {
-	policy := opts.Policy
-	if policy == nil {
-		policy = DefaultApprovalPolicy{}
-	}
-	return &ApprovalManager{
-		policy:         policy,
-		prompter:       opts.Prompter,
-		mu:             &sync.Mutex{},
-		sessionAllowed: make(map[string]struct{}),
-	}
-}
-
-func (m *ApprovalManager) WithPrompter(prompter ApprovalPrompter) *ApprovalManager {
-	if m == nil {
-		return NewApprovalManager(ApprovalManagerOptions{Prompter: prompter})
-	}
-	return &ApprovalManager{
-		policy:         m.policy,
-		prompter:       prompter,
-		mu:             m.mu,
-		sessionAllowed: m.sessionAllowed,
-	}
-}
-
-func (m *ApprovalManager) RequiresApproval(ctx context.Context, tool Tool, req ApprovalRequest) bool {
-	if m == nil {
-		return false
-	}
-	req.ToolApprovalRequired = req.ToolApprovalRequired || ToolRequiresApproval(tool, req.Args)
-	evaluation := applyToolApprovalRequirement(req, m.evaluate(ctx, req))
-	if evaluation.Decision == ApprovalDeny {
-		return true
-	}
-	if evaluation.RequirePrompt {
-		return !m.sessionAllowedFor(evaluation.SessionKey)
-	}
-	return false
-}
-
-func (m *ApprovalManager) Approve(ctx context.Context, req ApprovalRequest) (ApprovalResult, error) {
-	if m == nil {
-		return ApprovalResult{Decision: ApprovalAllowOnce}, nil
-	}
-
-	evaluation := applyToolApprovalRequirement(req, m.evaluate(ctx, req))
-	req = approvalRequestWithEvaluation(req, evaluation)
-
-	if evaluation.Decision == ApprovalDeny {
-		reason := strings.Join(evaluation.Reasons, "; ")
-		if reason == "" {
-			reason = "Tool execution denied."
-		}
-		return ApprovalResult{Decision: ApprovalDeny, Reason: reason}, nil
-	}
-
-	if !evaluation.RequirePrompt || m.sessionAllowedFor(evaluation.SessionKey) {
-		return ApprovalResult{Decision: ApprovalAllowOnce}, nil
-	}
-
-	if m.prompter == nil {
-		return ApprovalResult{
-			Decision: ApprovalDeny,
-			Reason:   "Tool execution requires approval, but no approval prompter is available. Re-run with --auto-approve-tools or --yolo to allow tool execution.",
-		}, nil
-	}
-
-	result, err := m.prompter.PromptApproval(ctx, req)
-	if err != nil {
-		return ApprovalResult{}, err
-	}
-	if result.Decision == "" {
-		result.Decision = ApprovalDeny
-	}
-	if result.Decision == ApprovalAllowSession {
-		m.allowSession(evaluation.SessionKey)
-	}
-	return result, nil
-}
-
-func (m *ApprovalManager) evaluate(ctx context.Context, req ApprovalRequest) ApprovalEvaluation {
-	if m == nil || m.policy == nil {
-		return DefaultApprovalPolicy{}.EvaluateApproval(ctx, req)
-	}
-	evaluation := m.policy.EvaluateApproval(ctx, req)
-	if evaluation.Risk == "" {
-		evaluation.Risk = ApprovalRiskLow
-	}
-	if evaluation.SessionKey == "" {
-		evaluation.SessionKey = approvalSessionKey(req)
-	}
-	return evaluation
-}
-
-func applyToolApprovalRequirement(req ApprovalRequest, evaluation ApprovalEvaluation) ApprovalEvaluation {
-	if !req.ToolApprovalRequired || evaluation.Decision == ApprovalDeny {
-		return evaluation
-	}
-	evaluation.RequirePrompt = true
-	if evaluation.Summary == "" {
-		evaluation.Summary = fmt.Sprintf("%s wants to run", ToolDisplayName(req.ToolName))
-	}
-	if len(evaluation.Reasons) == 0 {
-		evaluation.Reasons = []string{"tool requires approval"}
-	}
-	return evaluation
-}
-
-func (m *ApprovalManager) sessionAllowedFor(key string) bool {
-	if m == nil || key == "" {
-		return false
-	}
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	_, ok := m.sessionAllowed[key]
-	return ok
-}
-
-func (m *ApprovalManager) allowSession(key string) {
-	if m == nil || key == "" {
-		return
-	}
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.sessionAllowed[key] = struct{}{}
-}
-
-func approvalRequestWithEvaluation(req ApprovalRequest, evaluation ApprovalEvaluation) ApprovalRequest {
-	req.Summary = evaluation.Summary
-	req.Risk = evaluation.Risk
-	req.Reasons = slices.Clone(evaluation.Reasons)
-	return req
-}
-
-func approvalSessionKey(req ApprovalRequest) string {
-	if IsShellToolName(req.ToolName) {
-		if command, ok := stringApprovalArg(req.Args, "command"); ok {
-			return req.ToolName + ":" + command
-		}
-	}
-	switch req.ToolName {
-	case "edit":
-		if path, ok := stringApprovalArg(req.Args, "path"); ok {
-			return "edit:" + path
-		}
-	case "web_search":
-		if query, ok := stringApprovalArg(req.Args, "query"); ok {
-			return "web_search:" + query
-		}
-	case "web_fetch":
-		if targetURL, ok := stringApprovalArg(req.Args, "url"); ok {
-			return "web_fetch:" + targetURL
-		}
-	}
-	return req.ToolName + ":" + stableApprovalArgs(req.Args)
-}
-
-type DefaultApprovalPolicy struct{}
-
-func (DefaultApprovalPolicy) EvaluateApproval(_ context.Context, req ApprovalRequest) ApprovalEvaluation {
-	switch req.ToolName {
-	case "read":
-		if path, ok := stringApprovalArg(req.Args, "path"); ok {
-			if reason := approvalPathEscapeReason(req.WorkingDir, path); reason != "" {
-				return denyApproval(req.ToolName, ApprovalRiskHigh, reason)
-			}
-		}
-		return ApprovalEvaluation{Decision: ApprovalAllowOnce, Risk: ApprovalRiskLow, Summary: fmt.Sprintf("%s can run without approval", ToolDisplayName(req.ToolName))}
-	case "web_search", "web_fetch":
-		return evaluateWebApproval(req)
-	case "edit":
-		return evaluateEditApproval(req)
-	case "bash", "powershell":
-		return evaluateShellApproval(req)
-	default:
-		return ApprovalEvaluation{
-			RequirePrompt: true,
-			Risk:          ApprovalRiskMedium,
-			Summary:       fmt.Sprintf("%s wants to run", ToolDisplayName(req.ToolName)),
-			Reasons:       []string{"unknown tool effects"},
-			SessionKey:    approvalSessionKey(req),
-		}
-	}
-}
-
-func evaluateEditApproval(req ApprovalRequest) ApprovalEvaluation {
-	path, ok := stringApprovalArg(req.Args, "path")
-	if !ok {
-		return denyApproval("edit", ApprovalRiskHigh, "missing path argument")
-	}
-	if reason := approvalPathEscapeReason(req.WorkingDir, path); reason != "" {
-		return denyApproval("edit", ApprovalRiskHigh, reason)
-	}
-
-	reasons := []string{"writes to a file"}
-	if replaceAll, _ := req.Args["replace_all"].(bool); replaceAll {
-		reasons = append(reasons, "may replace multiple matches")
-	}
-	return ApprovalEvaluation{
-		RequirePrompt: true,
-		Risk:          ApprovalRiskMedium,
-		Summary:       fmt.Sprintf("Edit wants to modify %s", sanitizeApprovalDisplay(path)),
-		Reasons:       reasons,
-		SessionKey:    "edit:" + path,
-	}
-}
-
-func evaluateWebApproval(req ApprovalRequest) ApprovalEvaluation {
-	switch req.ToolName {
-	case "web_search":
-		query, ok := stringApprovalArg(req.Args, "query")
-		if !ok {
-			return denyApproval("web_search", ApprovalRiskHigh, "missing query argument")
-		}
-		return ApprovalEvaluation{
-			RequirePrompt: true,
-			Risk:          ApprovalRiskMedium,
-			Summary:       fmt.Sprintf("Web Search wants to search for %q", sanitizeApprovalDisplay(query)),
-			Reasons:       []string{"searches the web"},
-			SessionKey:    "web_search:" + query,
-		}
-	case "web_fetch":
-		targetURL, ok := stringApprovalArg(req.Args, "url")
-		if !ok {
-			return denyApproval("web_fetch", ApprovalRiskHigh, "missing url argument")
-		}
-		return ApprovalEvaluation{
-			RequirePrompt: true,
-			Risk:          ApprovalRiskMedium,
-			Summary:       fmt.Sprintf("Web Fetch wants to fetch %s", sanitizeApprovalDisplay(targetURL)),
-			Reasons:       []string{"fetches web content"},
-			SessionKey:    "web_fetch:" + targetURL,
-		}
-	}
-	return ApprovalEvaluation{
-		RequirePrompt: true,
-		Risk:          ApprovalRiskMedium,
-		Summary:       fmt.Sprintf("%s wants to run", ToolDisplayName(req.ToolName)),
-		Reasons:       []string{"accesses the web"},
-		SessionKey:    approvalSessionKey(req),
-	}
-}
-
-func sanitizeApprovalDisplay(value string) string {
-	value = approvalANSIEscapePattern.ReplaceAllString(value, "")
-	value = strings.Map(func(r rune) rune {
-		switch r {
-		case '\n', '\r', '\t':
-			return ' '
-		}
-		if unicode.IsControl(r) {
-			return -1
-		}
-		return r
-	}, value)
-	value = strings.Join(strings.Fields(value), " ")
-	if value == "" {
-		return "(empty)"
-	}
-	return value
-}
-
-func evaluateShellApproval(req ApprovalRequest) ApprovalEvaluation {
-	command, ok := stringApprovalArg(req.Args, "command")
-	if !ok || strings.TrimSpace(command) == "" {
-		return denyApproval(req.ToolName, ApprovalRiskHigh, "missing command argument")
-	}
-
-	risk, reasons := classifyBashCommand(command)
-	if len(reasons) == 0 {
-		reasons = append(reasons, "runs shell commands")
-	}
-	return ApprovalEvaluation{
-		RequirePrompt: true,
-		Risk:          risk,
-		Summary:       fmt.Sprintf("%s wants to run a command", ToolDisplayName(req.ToolName)),
-		Reasons:       reasons,
-		SessionKey:    req.ToolName + ":" + command,
-	}
-}
-
-func denyApproval(toolName string, risk ApprovalRisk, reason string) ApprovalEvaluation {
-	return ApprovalEvaluation{
-		Decision:   ApprovalDeny,
-		Risk:       risk,
-		Summary:    fmt.Sprintf("%s cannot run", ToolDisplayName(toolName)),
-		Reasons:    []string{reason},
-		SessionKey: approvalSessionKey(ApprovalRequest{ToolName: toolName}),
-	}
-}
-
-// Shell approval is static analysis of model-generated commands, not a sandbox.
-// Globs, aliases, environment, and runtime shell state are intentionally out of scope.
-func classifyBashCommand(command string) (ApprovalRisk, []string) {
-	classifier := bashClassifier{risk: ApprovalRiskMedium}
-
-	tokens, scannerReasons, scannerHigh := scanBashTokens(command)
-	for _, reason := range scannerReasons {
-		classifier.addReason(reason)
-	}
-	if scannerHigh {
-		classifier.high = true
-	}
-
-	if bashFunctionDeclPattern.MatchString(command) {
-		classifier.addReason("defines shell functions")
-		classifier.high = true
-	}
-	if bashSubshellPattern.MatchString(command) {
-		classifier.addReason("uses a subshell")
-		classifier.high = true
-	}
-
-	for _, token := range tokens {
-		if token.kind != bashTokenOperator {
-			continue
-		}
-		switch token.value {
-		case "&&", "||", "|":
-			classifier.addReason("uses shell control operator " + token.value)
-			classifier.high = true
-		case ";", "\n":
-			classifier.addReason("uses shell statement separator")
-			classifier.high = true
-		case "&":
-			classifier.addReason("runs a command in the background")
-			classifier.high = true
-		case "$(", "`":
-			classifier.addReason("uses command substitution")
-			classifier.high = true
-		case "<(", ">(":
-			classifier.addReason("uses process substitution")
-			classifier.high = true
-		case ">", ">>", ">|", ">&", "&>":
-			classifier.addReason("writes or redirects files")
-			classifier.high = true
-		case "<", "<<", "<&":
-			classifier.addReason("uses shell redirection")
-		}
-	}
-
-	for _, args := range bashCommandCalls(tokens) {
-		classifier.addCall(args)
-	}
-
-	if classifier.high {
-		classifier.risk = ApprovalRiskHigh
-	}
-	return classifier.risk, classifier.reasons
-}
-
-type bashClassifier struct {
-	risk    ApprovalRisk
-	high    bool
-	reasons []string
-}
-
-func (c *bashClassifier) addReason(reason string) {
-	if reason == "" || slices.Contains(c.reasons, reason) {
-		return
-	}
-	c.reasons = append(c.reasons, reason)
-}
-
-func (c *bashClassifier) addCall(args []string) {
-	args = shellCommandArgs(args)
-	if len(args) == 0 {
-		return
-	}
-	if isDynamicCommandName(args[0]) {
-		c.addReason("uses dynamic command name")
-		c.high = true
-	}
-	name := shellCommandBase(args[0])
-	switch name {
-	case "cd":
-		c.addReason("changes directory")
-		c.high = true
-	case "eval":
-		c.addReason("evaluates shell code")
-		c.high = true
-	case "source", ".":
-		c.addReason("sources shell code")
-		c.high = true
-	case "exec":
-		c.addReason("replaces the shell process")
-		c.high = true
-	case "sudo":
-		c.addReason("runs with elevated privileges")
-		c.high = true
-	case "rm":
-		if hasAnyFlag(args[1:], "r", "R", "recursive") || hasAnyFlag(args[1:], "f", "force") {
-			c.addReason("removes files destructively")
-			c.high = true
-		}
-	case "git":
-		if isGitResetHard(args) {
-			c.addReason("runs destructive git reset")
-			c.high = true
-		}
-		if isGitCleanDestructive(args) {
-			c.addReason("runs destructive git clean")
-			c.high = true
-		}
-	case "find":
-		c.addFindReasons(args)
-	case "chmod", "chown":
-		if hasAnyFlag(args[1:], "R", "recursive") {
-			c.addReason("changes permissions or ownership recursively")
-			c.high = true
-		}
-	case "dd", "diskutil":
-		c.addReason("can write directly to disks")
-		c.high = true
-	case "mkfs", "newfs":
-		c.addReason("formats filesystems")
-		c.high = true
-	case "curl", "wget":
-		c.addReason("downloads remote content")
-	case "sh", "bash", "zsh":
-		if len(args) > 1 {
-			c.addReason("runs a shell interpreter")
-			c.high = true
-		}
-	}
-}
-
-func (c *bashClassifier) addFindReasons(args []string) {
-	for i := 1; i < len(args); i++ {
-		switch args[i] {
-		case "-delete":
-			c.addReason("deletes files via find")
-			c.high = true
-		case "-exec", "-execdir":
-			c.addReason("executes commands via find")
-			c.high = true
-			end := i + 1
-			for end < len(args) && args[end] != ";" && args[end] != `\;` && args[end] != "+" {
-				end++
-			}
-			if end > i+1 {
-				c.addCall(args[i+1 : end])
-			}
-			i = end
-		}
-	}
-}
-
-func hasAnyFlag(args []string, flags ...string) bool {
-	for _, arg := range args {
-		if arg == "--" {
-			return false
-		}
-		if !strings.HasPrefix(arg, "-") {
-			continue
-		}
-		for _, flag := range flags {
-			short := len(flag) == 1
-			if short && strings.HasPrefix(arg, "-") && !strings.HasPrefix(arg, "--") && strings.Contains(arg[1:], flag) {
-				return true
-			}
-			if arg == "--"+flag {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func isGitResetHard(args []string) bool {
-	subcommand := gitSubcommandArgs(args)
-	return len(subcommand) >= 2 && subcommand[0] == "reset" && slices.Contains(subcommand[1:], "--hard")
-}
-
-func isGitCleanDestructive(args []string) bool {
-	subcommand := gitSubcommandArgs(args)
-	if len(subcommand) < 1 || subcommand[0] != "clean" {
-		return false
-	}
-	return hasAnyFlag(subcommand[1:], "f", "force") && (hasAnyFlag(subcommand[1:], "d") || hasAnyFlag(subcommand[1:], "x", "X"))
-}
-
-func gitSubcommandArgs(args []string) []string {
-	for i := 1; i < len(args); i++ {
-		arg := args[i]
-		if arg == "--" {
-			return args[i+1:]
-		}
-		switch {
-		case arg == "-C", arg == "-c", arg == "--git-dir", arg == "--work-tree":
-			i++
-			continue
-		case strings.HasPrefix(arg, "-C"), strings.HasPrefix(arg, "-c"):
-			continue
-		case strings.HasPrefix(arg, "--git-dir="), strings.HasPrefix(arg, "--work-tree="):
-			continue
-		case strings.HasPrefix(arg, "-"):
-			continue
-		default:
-			return args[i:]
-		}
-	}
-	return nil
-}
-
-type bashTokenKind int
-
-const (
-	bashTokenWord bashTokenKind = iota
-	bashTokenOperator
-)
-
-type bashToken struct {
-	kind  bashTokenKind
-	value string
-}
-
-var (
-	approvalANSIEscapePattern = regexp.MustCompile(`\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))`)
-	bashFunctionDeclPattern   = regexp.MustCompile(`(?m)(^|[;&|[:space:]])(?:function[[:space:]]+)?[A-Za-z_][A-Za-z0-9_]*[[:space:]]*(?:\(\)[[:space:]]*)?\{`)
-	bashSubshellPattern       = regexp.MustCompile(`(?m)(^|[;&|[:space:]])\(`)
-)
-
-func scanBashTokens(command string) ([]bashToken, []string, bool) {
-	var tokens []bashToken
-	var reasons []string
-	var word strings.Builder
-	var quote byte
-	escaped := false
-	high := false
-
-	flushWord := func() {
-		if word.Len() == 0 {
-			return
-		}
-		tokens = append(tokens, bashToken{kind: bashTokenWord, value: word.String()})
-		word.Reset()
-	}
-	addOperator := func(op string) {
-		tokens = append(tokens, bashToken{kind: bashTokenOperator, value: op})
-	}
-
-	for i := 0; i < len(command); i++ {
-		ch := command[i]
-		if escaped {
-			word.WriteByte(ch)
-			escaped = false
-			continue
-		}
-		if ch == '\\' && quote != '\'' {
-			escaped = true
-			continue
-		}
-
-		if quote == '\'' {
-			if ch == '\'' {
-				quote = 0
-			} else {
-				word.WriteByte(ch)
-			}
-			continue
-		}
-		if quote == '"' {
-			switch {
-			case ch == '"':
-				quote = 0
-			case ch == '`':
-				addOperator("`")
-				word.WriteByte(ch)
-			case ch == '$' && i+1 < len(command) && command[i+1] == '(':
-				addOperator("$(")
-				word.WriteString("$(")
-				i++
-			default:
-				word.WriteByte(ch)
-			}
-			continue
-		}
-
-		if ch == '\'' || ch == '"' {
-			quote = ch
-			continue
-		}
-		if ch == '`' {
-			addOperator("`")
-			word.WriteByte(ch)
-			continue
-		}
-		if ch == '$' && i+1 < len(command) && command[i+1] == '(' {
-			addOperator("$(")
-			word.WriteString("$(")
-			i++
-			continue
-		}
-		if (ch == '<' || ch == '>') && i+1 < len(command) && command[i+1] == '(' {
-			flushWord()
-			addOperator(string([]byte{ch, '('}))
-			i++
-			continue
-		}
-		if ch == '\n' {
-			flushWord()
-			addOperator("\n")
-			continue
-		}
-		if ch == ' ' || ch == '\t' || ch == '\r' {
-			flushWord()
-			continue
-		}
-
-		switch ch {
-		case '&':
-			flushWord()
-			switch {
-			case i+1 < len(command) && command[i+1] == '&':
-				addOperator("&&")
-				i++
-			case i+1 < len(command) && command[i+1] == '>':
-				addOperator("&>")
-				i++
-			default:
-				addOperator("&")
-			}
-		case '|':
-			flushWord()
-			if i+1 < len(command) && command[i+1] == '|' {
-				addOperator("||")
-				i++
-			} else {
-				addOperator("|")
-			}
-		case ';':
-			flushWord()
-			addOperator(";")
-		case '<':
-			flushWord()
-			if i+1 < len(command) && command[i+1] == '<' {
-				addOperator("<<")
-				i++
-			} else if i+1 < len(command) && command[i+1] == '&' {
-				addOperator("<&")
-				i++
-			} else {
-				addOperator("<")
-			}
-		case '>':
-			flushWord()
-			if i+1 < len(command) && command[i+1] == '>' {
-				addOperator(">>")
-				i++
-			} else if i+1 < len(command) && command[i+1] == '|' {
-				addOperator(">|")
-				i++
-			} else if i+1 < len(command) && command[i+1] == '&' {
-				addOperator(">&")
-				i++
-			} else {
-				addOperator(">")
-			}
-		default:
-			word.WriteByte(ch)
-		}
-	}
-	if escaped || quote != 0 {
-		reasons = append(reasons, "could not parse shell command")
-		high = true
-	}
-	flushWord()
-	return tokens, reasons, high
-}
-
-func bashCommandCalls(tokens []bashToken) [][]string {
-	var calls [][]string
-	var current []string
-	flush := func() {
-		if len(current) == 0 {
-			return
-		}
-		calls = append(calls, current)
-		current = nil
-	}
-	for _, token := range tokens {
-		if token.kind == bashTokenWord {
-			current = append(current, token.value)
-			continue
-		}
-		if isBashCommandBoundary(token.value) {
-			flush()
-		}
-	}
-	flush()
-	return calls
-}
-
-func isBashCommandBoundary(op string) bool {
-	switch op {
-	case "&&", "||", "|", ";", "&", "\n":
-		return true
-	default:
-		return false
-	}
-}
-
-func shellCommandArgs(args []string) []string {
-	for len(args) > 0 && isShellAssignment(args[0]) {
-		args = args[1:]
-	}
-	return args
-}
-
-func isShellAssignment(word string) bool {
-	name, _, ok := strings.Cut(word, "=")
-	if !ok || name == "" {
-		return false
-	}
-	for i := range len(name) {
-		ch := name[i]
-		if i == 0 {
-			if !((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch == '_') {
-				return false
-			}
-			continue
-		}
-		if !((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_') {
-			return false
-		}
-	}
-	return true
-}
-
-func isDynamicCommandName(name string) bool {
-	return strings.HasPrefix(name, "$") || strings.HasPrefix(name, "`") || strings.Contains(name, "$(") || strings.Contains(name, "`")
-}
-
-func shellCommandBase(name string) string {
-	name = strings.TrimSpace(name)
-	if i := strings.LastIndexAny(name, `/\`); i >= 0 && i+1 < len(name) {
-		name = name[i+1:]
-	}
-	return name
-}
-
-func approvalPathEscapeReason(workingDir, path string) string {
-	if strings.TrimSpace(path) == "" {
-		return ""
-	}
-	if filepath.IsAbs(path) {
-		return "absolute paths are not allowed"
-	}
-
-	base := workingDir
-	if base == "" {
-		var err error
-		base, err = os.Getwd()
-		if err != nil {
-			return "could not determine working directory"
-		}
-	}
-
-	base, err := canonicalApprovalPath(base)
-	if err != nil {
-		return "could not resolve working directory"
-	}
-	resolved := filepath.Clean(filepath.Join(base, path))
-	resolvedForCheck := resolved
-	if canonical, err := canonicalApprovalPath(resolved); err == nil {
-		resolvedForCheck = canonical
-	}
-	rel, err := filepath.Rel(base, resolvedForCheck)
-	if err != nil {
-		return "could not resolve path"
-	}
-	if rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
-		return "path escapes working directory"
-	}
-	return ""
-}
-
-func canonicalApprovalPath(path string) (string, error) {
-	abs, err := filepath.Abs(path)
-	if err != nil {
-		return "", err
-	}
-	resolved, err := filepath.EvalSymlinks(abs)
-	if err == nil {
-		return resolved, nil
-	}
-	return abs, nil
-}
-
-func stringApprovalArg(args map[string]any, key string) (string, bool) {
-	value, ok := args[key].(string)
-	return value, ok && strings.TrimSpace(value) != ""
-}
-
-func stableApprovalArgs(args map[string]any) string {
-	if len(args) == 0 {
-		return ""
-	}
-	keys := make([]string, 0, len(args))
-	for key := range args {
-		keys = append(keys, key)
-	}
-	slices.Sort(keys)
-	var b bytes.Buffer
-	for _, key := range keys {
-		if b.Len() > 0 {
-			b.WriteByte(',')
-		}
-		fmt.Fprintf(&b, "%s=%v", key, args[key])
-	}
-	return b.String()
-}

agent/approval_test.go

@@ -1,384 +0,0 @@
-package agent
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/ollama/ollama/api"
-)
-
-type recordingApprovalPrompter struct {
-	requests []ApprovalRequest
-	results  []ApprovalResult
-}
-
-type allowWithoutPromptPolicy struct{}
-
-type approvalRequiredTestTool struct{}
-
-func (p *recordingApprovalPrompter) PromptApproval(_ context.Context, request ApprovalRequest) (ApprovalResult, error) {
-	p.requests = append(p.requests, request)
-	if len(p.results) == 0 {
-		return ApprovalResult{Decision: ApprovalAllowOnce}, nil
-	}
-	result := p.results[0]
-	p.results = p.results[1:]
-	return result, nil
-}
-
-func (allowWithoutPromptPolicy) EvaluateApproval(context.Context, ApprovalRequest) ApprovalEvaluation {
-	return ApprovalEvaluation{Decision: ApprovalAllowOnce, Risk: ApprovalRiskLow}
-}
-
-func (approvalRequiredTestTool) Name() string {
-	return "approval_required"
-}
-
-func (approvalRequiredTestTool) Description() string {
-	return "requires approval"
-}
-
-func (approvalRequiredTestTool) Schema() api.ToolFunction {
-	return api.ToolFunction{Name: "approval_required"}
-}
-
-func (approvalRequiredTestTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
-	return ToolResult{Content: "ok"}, nil
-}
-
-func (approvalRequiredTestTool) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func TestApprovalManagerAllowsSafeToolsWithoutPrompt(t *testing.T) {
-	prompter := &recordingApprovalPrompter{}
-	manager := NewApprovalManager(ApprovalManagerOptions{Prompter: prompter})
-
-	result, err := manager.Approve(context.Background(), ApprovalRequest{
-		ToolName:   "read",
-		Args:       map[string]any{"path": "README.md"},
-		WorkingDir: t.TempDir(),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalAllowOnce {
-		t.Fatalf("decision = %q, want allow_once", result.Decision)
-	}
-	if len(prompter.requests) != 0 {
-		t.Fatalf("safe tool prompted: %#v", prompter.requests)
-	}
-}
-
-func TestApprovalManagerToolRequiredOverridePromptsInApprove(t *testing.T) {
-	prompter := &recordingApprovalPrompter{}
-	manager := NewApprovalManager(ApprovalManagerOptions{Policy: allowWithoutPromptPolicy{}, Prompter: prompter})
-	tool := approvalRequiredTestTool{}
-	request := ApprovalRequest{
-		ToolName:             tool.Name(),
-		Args:                 map[string]any{},
-		ToolApprovalRequired: ToolRequiresApproval(tool, nil),
-	}
-
-	if !manager.RequiresApproval(context.Background(), tool, request) {
-		t.Fatal("tool-required approval should require a prompt")
-	}
-	result, err := manager.Approve(context.Background(), request)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalAllowOnce {
-		t.Fatalf("decision = %q, want allow_once", result.Decision)
-	}
-	if len(prompter.requests) != 1 {
-		t.Fatalf("prompts = %d, want 1", len(prompter.requests))
-	}
-}
-
-func TestApprovalManagerDeniesEscapingPath(t *testing.T) {
-	manager := NewApprovalManager(ApprovalManagerOptions{})
-
-	result, err := manager.Approve(context.Background(), ApprovalRequest{
-		ToolName:   "edit",
-		Args:       map[string]any{"path": "../outside.txt"},
-		WorkingDir: t.TempDir(),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalDeny {
-		t.Fatalf("decision = %q, want deny", result.Decision)
-	}
-	if !strings.Contains(result.Reason, "path escapes working directory") {
-		t.Fatalf("reason = %q", result.Reason)
-	}
-}
-
-func TestApprovalManagerSanitizesEditSummary(t *testing.T) {
-	evaluation := evaluateEditApproval(ApprovalRequest{
-		ToolName:   "edit",
-		Args:       map[string]any{"path": "notes/\x1b[31mred\nfile.txt"},
-		WorkingDir: t.TempDir(),
-	})
-	if strings.ContainsAny(evaluation.Summary, "\n\r\x1b") {
-		t.Fatalf("summary contains control characters: %q", evaluation.Summary)
-	}
-	if !strings.Contains(evaluation.Summary, "notes/red file.txt") {
-		t.Fatalf("summary = %q, want sanitized path", evaluation.Summary)
-	}
-}
-
-func TestApprovalManagerPromptsForEdit(t *testing.T) {
-	prompter := &recordingApprovalPrompter{}
-	manager := NewApprovalManager(ApprovalManagerOptions{Prompter: prompter})
-
-	result, err := manager.Approve(context.Background(), ApprovalRequest{
-		ToolName:   "edit",
-		Args:       map[string]any{"path": "note.txt", "old_text": "old", "new_text": "new"},
-		WorkingDir: t.TempDir(),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalAllowOnce {
-		t.Fatalf("decision = %q, want allow_once", result.Decision)
-	}
-	if len(prompter.requests) != 1 {
-		t.Fatalf("prompts = %d, want 1", len(prompter.requests))
-	}
-	request := prompter.requests[0]
-	if request.Risk != ApprovalRiskMedium {
-		t.Fatalf("risk = %q, want medium", request.Risk)
-	}
-	if !strings.Contains(strings.Join(request.Reasons, " "), "writes to a file") {
-		t.Fatalf("reasons = %#v", request.Reasons)
-	}
-}
-
-func TestApprovalManagerHeadlessDeniesPromptRequiredTools(t *testing.T) {
-	manager := NewApprovalManager(ApprovalManagerOptions{})
-
-	result, err := manager.Approve(context.Background(), ApprovalRequest{
-		ToolName: "bash",
-		Args:     map[string]any{"command": "pwd"},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalDeny {
-		t.Fatalf("decision = %q, want deny", result.Decision)
-	}
-	if !strings.Contains(result.Reason, "--auto-approve-tools") {
-		t.Fatalf("reason = %q", result.Reason)
-	}
-}
-
-func TestApprovalManagerSessionAllowList(t *testing.T) {
-	prompter := &recordingApprovalPrompter{
-		results: []ApprovalResult{{Decision: ApprovalAllowSession}},
-	}
-	manager := NewApprovalManager(ApprovalManagerOptions{Prompter: prompter})
-	request := ApprovalRequest{
-		ToolName: "bash",
-		Args:     map[string]any{"command": "go test ./agent"},
-	}
-
-	result, err := manager.Approve(context.Background(), request)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalAllowSession {
-		t.Fatalf("decision = %q, want allow_session", result.Decision)
-	}
-	result, err = manager.Approve(context.Background(), request)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Decision != ApprovalAllowOnce {
-		t.Fatalf("second decision = %q, want allow_once", result.Decision)
-	}
-	if len(prompter.requests) != 1 {
-		t.Fatalf("prompts = %d, want 1", len(prompter.requests))
-	}
-}
-
-func TestBashApprovalClassifiesHighRiskShell(t *testing.T) {
-	evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-		ToolName: "bash",
-		Args:     map[string]any{"command": "cd / && rm -rf tmp"},
-	})
-
-	if !evaluation.RequirePrompt {
-		t.Fatal("bash should require prompt")
-	}
-	if evaluation.Risk != ApprovalRiskHigh {
-		t.Fatalf("risk = %q, want high", evaluation.Risk)
-	}
-	reasons := strings.Join(evaluation.Reasons, " ")
-	for _, want := range []string{"changes directory", "control operator", "removes files"} {
-		if !strings.Contains(reasons, want) {
-			t.Fatalf("reasons = %#v, want %q", evaluation.Reasons, want)
-		}
-	}
-}
-
-func TestPowerShellApprovalUsesShellPolicy(t *testing.T) {
-	evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-		ToolName: "powershell",
-		Args:     map[string]any{"command": "Remove-Item -Recurse tmp"},
-	})
-
-	if !evaluation.RequirePrompt {
-		t.Fatal("powershell should require prompt")
-	}
-	if evaluation.Summary != "PowerShell wants to run a command" {
-		t.Fatalf("summary = %q", evaluation.Summary)
-	}
-	if evaluation.SessionKey != "powershell:Remove-Item -Recurse tmp" {
-		t.Fatalf("session key = %q", evaluation.SessionKey)
-	}
-}
-
-func TestBashApprovalClassifiesDynamicShellEvasions(t *testing.T) {
-	tests := []struct {
-		name   string
-		cmd    string
-		reason string
-	}{
-		{name: "function declaration", cmd: "f() { rm -rf /; } && f", reason: "defines shell functions"},
-		{name: "eval", cmd: `eval "$cmd"`, reason: "evaluates shell code"},
-		{name: "variable command name", cmd: "$DANGER --flag", reason: "dynamic command name"},
-		{name: "command substitution command name", cmd: "$(echo rm) -rf /", reason: "dynamic command name"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-				ToolName: "bash",
-				Args:     map[string]any{"command": tt.cmd},
-			})
-			if !evaluation.RequirePrompt {
-				t.Fatal("bash evasion should require prompt")
-			}
-			if evaluation.Risk != ApprovalRiskHigh {
-				t.Fatalf("risk = %q, want high", evaluation.Risk)
-			}
-			if reasons := strings.Join(evaluation.Reasons, " "); !strings.Contains(reasons, tt.reason) {
-				t.Fatalf("reasons = %#v, want %q", evaluation.Reasons, tt.reason)
-			}
-		})
-	}
-}
-
-func TestBashApprovalClassifiesDestructiveGitWithGlobalOptions(t *testing.T) {
-	tests := []struct {
-		name   string
-		cmd    string
-		reason string
-	}{
-		{name: "git reset hard after cwd", cmd: "git -C /tmp reset --hard", reason: "runs destructive git reset"},
-		{name: "git reset hard after config", cmd: "git -c core.autocrlf=false reset --hard", reason: "runs destructive git reset"},
-		{name: "git clean after work tree", cmd: "git --work-tree=/tmp clean -fdx", reason: "runs destructive git clean"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-				ToolName: "bash",
-				Args:     map[string]any{"command": tt.cmd},
-			})
-			if evaluation.Risk != ApprovalRiskHigh {
-				t.Fatalf("risk = %q, want high", evaluation.Risk)
-			}
-			if reasons := strings.Join(evaluation.Reasons, " "); !strings.Contains(reasons, tt.reason) {
-				t.Fatalf("reasons = %#v, want %q", evaluation.Reasons, tt.reason)
-			}
-		})
-	}
-}
-
-func TestBashApprovalClassifiesFindMutations(t *testing.T) {
-	tests := []struct {
-		name   string
-		cmd    string
-		reason string
-	}{
-		{name: "delete", cmd: "find . -name '*.tmp' -delete", reason: "deletes files via find"},
-		{name: "exec", cmd: `find . -name '*.tmp' -exec rm -rf {} \;`, reason: "executes commands via find"},
-		{name: "exec nested destructive command", cmd: `find . -name '*.tmp' -exec rm -rf {} \;`, reason: "removes files destructively"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-				ToolName: "bash",
-				Args:     map[string]any{"command": tt.cmd},
-			})
-			if evaluation.Risk != ApprovalRiskHigh {
-				t.Fatalf("risk = %q, want high", evaluation.Risk)
-			}
-			if reasons := strings.Join(evaluation.Reasons, " "); !strings.Contains(reasons, tt.reason) {
-				t.Fatalf("reasons = %#v, want %q", evaluation.Reasons, tt.reason)
-			}
-		})
-	}
-}
-
-func TestWebApprovalRequiresPrompt(t *testing.T) {
-	tests := []struct {
-		name    string
-		tool    string
-		args    map[string]any
-		summary string
-	}{
-		{
-			name:    "search",
-			tool:    "web_search",
-			args:    map[string]any{"query": "Ollama agents"},
-			summary: "Web Search wants to search for \"Ollama agents\"",
-		},
-		{
-			name:    "fetch",
-			tool:    "web_fetch",
-			args:    map[string]any{"url": "https://ollama.com"},
-			summary: "Web Fetch wants to fetch https://ollama.com",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-				ToolName: tt.tool,
-				Args:     tt.args,
-			})
-			if !evaluation.RequirePrompt {
-				t.Fatal("web tool should require prompt")
-			}
-			if evaluation.Decision != "" && evaluation.Decision != ApprovalAllowOnce {
-				t.Fatalf("decision = %q, want allow once", evaluation.Decision)
-			}
-			if evaluation.Risk != ApprovalRiskMedium {
-				t.Fatalf("risk = %q, want medium", evaluation.Risk)
-			}
-			if evaluation.Summary != tt.summary {
-				t.Fatalf("summary = %q, want %q", evaluation.Summary, tt.summary)
-			}
-		})
-	}
-}
-
-func TestWebApprovalDeniesMissingArgs(t *testing.T) {
-	for _, tool := range []string{"web_search", "web_fetch"} {
-		evaluation := DefaultApprovalPolicy{}.EvaluateApproval(context.Background(), ApprovalRequest{
-			ToolName: tool,
-			Args:     map[string]any{},
-		})
-		if evaluation.Decision != ApprovalDeny {
-			t.Fatalf("%s missing args decision = %q, want deny", tool, evaluation.Decision)
-		}
-		if evaluation.Risk != ApprovalRiskHigh {
-			t.Fatalf("%s missing args risk = %q, want high", tool, evaluation.Risk)
-		}
-	}
-}

agent/compactor.go

@@ -1,636 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/ollama/ollama/api"
-)
-
-// Compaction wire-format. These constants and helpers are the single canonical
-// definition of how a compacted turn is represented in message history; both
-// the in-memory compactor (this package) and the on-disk chat store
-// (package store) build and detect summaries through them.
-const (
-	CompactionSummaryMessagePrefix = "Conversation summary:\n"
-	CompactionToolName             = "summary"
-	CompactionToolCallID           = "ollama_compaction"
-	CompactionContinueInstruction  = "continue the task in progress. the history has been compacted, do not mention compaction to the user"
-)
-
-const (
-	defaultCompactionContextWindowTokens = 32768
-	defaultCompactionKeepUserTurns       = 3
-	defaultCompactionThreshold           = 0.8
-	compactOnlySummaryContextTokens      = 16000
-
-	maxCompactionSummaryBytes  = 16 * 1024
-	compactionSummaryTruncated = "\n\n[summary truncated]"
-
-	compactionSystemPrompt = "Summarize the archived part of an Ollama CLI agent conversation. Preserve user goals, decisions, files, commands, tool results, and unresolved tasks needed to continue. Omit private reasoning and return only the summary."
-)
-
-type Compactor interface {
-	MaybeCompact(context.Context, CompactionRequest) (CompactionResult, error)
-}
-
-type CompactionStore interface {
-	ArchiveForCompaction(context.Context, string, int, string, bool) error
-}
-
-type CompactionOptions struct {
-	ContextWindowTokens int
-	KeepUserTurns       int
-	Threshold           float64
-}
-
-type CompactionRequest struct {
-	ChatID        string
-	Model         string
-	SystemPrompt  string
-	Messages      []api.Message
-	Tools         api.Tools
-	Format        string
-	Latest        api.ChatResponse
-	Options       map[string]any
-	KeepAlive     *api.Duration
-	Think         *api.ThinkValue
-	Force         bool
-	ContinueTask  bool
-	KeepUserTurns *int
-	Progress      func(CompactionProgress)
-}
-
-type CompactionProgress struct {
-	Tokens int
-}
-
-type CompactionResult struct {
-	Messages  []api.Message
-	Compacted bool
-	Due       bool
-	Summary   string
-	Reason    string
-}
-
-type SimpleCompactor struct {
-	Client  ChatClient
-	Store   CompactionStore
-	Options CompactionOptions
-}
-
-func NewSimpleCompactor(client ChatClient, store CompactionStore, opts CompactionOptions) *SimpleCompactor {
-	return &SimpleCompactor{Client: client, Store: store, Options: opts}
-}
-
-func (c *SimpleCompactor) MaybeCompact(ctx context.Context, req CompactionRequest) (CompactionResult, error) {
-	result := CompactionResult{Messages: req.Messages}
-	if c == nil {
-		return result, nil
-	}
-
-	result.Due = req.Force || c.shouldCompact(req)
-	if !result.Due {
-		return result, nil
-	}
-	if c.Client == nil {
-		result.Reason = "compaction is unavailable"
-		return result, nil
-	}
-
-	keepUserTurns := c.keepUserTurns(req.Options)
-	if req.KeepUserTurns != nil {
-		keepUserTurns = *req.KeepUserTurns
-	}
-	prefix, previousSummary, archive, suffix, keptUserTurns, ok := splitCompactionMessages(req.Messages, keepUserTurns)
-	if !ok || len(archive) == 0 {
-		result.Reason = "nothing to compact"
-		return result, nil
-	}
-
-	summary, err := c.summarize(ctx, req, previousSummary, archive)
-	if err != nil {
-		result.Reason = err.Error()
-		return result, err
-	}
-	summary = truncateCompactionSummary(strings.TrimSpace(summary))
-	if summary == "" {
-		summary, err = c.summarizeEmptyFallback(ctx, req, previousSummary, archive)
-		if err != nil {
-			result.Reason = err.Error()
-			return result, err
-		}
-		summary = truncateCompactionSummary(strings.TrimSpace(summary))
-	}
-	if summary == "" {
-		// TODO(parthsareen): Investigate models that stream compaction output
-		// without final content, such as thinking-only summaries.
-		result.Reason = "summary was empty"
-		return result, nil
-	}
-
-	if c.Store != nil && req.ChatID != "" {
-		if err := c.Store.ArchiveForCompaction(ctx, req.ChatID, keptUserTurns, summary, req.ContinueTask); err != nil {
-			result.Reason = err.Error()
-			return result, err
-		}
-	}
-
-	compacted := make([]api.Message, 0, len(prefix)+len(suffix)+2)
-	compacted = append(compacted, prefix...)
-	compacted = append(compacted, CompactionSummaryMessages(summary, req.ContinueTask)...)
-	compacted = append(compacted, suffix...)
-	result.Messages = compacted
-	result.Compacted = true
-	result.Summary = summary
-	return result, nil
-}
-
-func (c *SimpleCompactor) shouldCompact(req CompactionRequest) bool {
-	contextWindow := c.contextWindowTokens(req.Options)
-	threshold := int(float64(contextWindow) * c.threshold())
-	if threshold <= 0 {
-		return false
-	}
-	if req.Latest.PromptEvalCount > 0 && req.Latest.PromptEvalCount >= threshold {
-		return true
-	}
-	// TODO(parthsareen): If the newest kept user turn contains the oversized
-	// tool output, compaction can remove older history but still leave the next
-	// prompt above the safety threshold. Pair this estimate trigger with
-	// context-aware tool-output paging/range reads so the kept suffix can shrink.
-	return estimateCompactionRequestTokens(req) >= threshold
-}
-
-func (c *SimpleCompactor) contextWindowTokens(options map[string]any) int {
-	return ResolveContextWindowTokens(options, c.Options.ContextWindowTokens)
-}
-
-func (c *SimpleCompactor) keepUserTurns(options map[string]any) int {
-	contextWindow := c.contextWindowTokens(options)
-	if contextWindow > 0 && contextWindow < compactOnlySummaryContextTokens {
-		return 0
-	}
-	if c.Options.KeepUserTurns > 0 {
-		return c.Options.KeepUserTurns
-	}
-	return defaultCompactionKeepUserTurns
-}
-
-func (c *SimpleCompactor) threshold() float64 {
-	return ResolveCompactionThreshold(c.Options.Threshold)
-}
-
-func ResolveContextWindowTokens(options map[string]any, configured int) int {
-	if n := intOption(options, "num_ctx"); n > 0 {
-		return n
-	}
-	if configured > 0 {
-		return configured
-	}
-	return defaultCompactionContextWindowTokens
-}
-
-func ResolveCompactionThreshold(configured float64) float64 {
-	if configured > 0 {
-		return configured
-	}
-	return defaultCompactionThreshold
-}
-
-func (c *SimpleCompactor) summarize(ctx context.Context, req CompactionRequest, previousSummary string, archive []api.Message) (string, error) {
-	body, err := compactionPrompt(previousSummary, archive, c.compactionPromptBodyBudgetTokens(req.Options))
-	if err != nil {
-		return "", err
-	}
-
-	chatReq := &api.ChatRequest{
-		Model: req.Model,
-		Messages: []api.Message{
-			{
-				Role:    "system",
-				Content: compactionSystemPrompt,
-			},
-			{
-				Role:    "user",
-				Content: body,
-			},
-		},
-		Options: req.Options,
-		Think:   req.Think,
-	}
-	if req.KeepAlive != nil {
-		chatReq.KeepAlive = req.KeepAlive
-	}
-
-	var summary strings.Builder
-	if err := c.Client.Chat(ctx, chatReq, func(response api.ChatResponse) error {
-		summary.WriteString(response.Message.Content)
-		if req.Progress != nil {
-			tokens := response.EvalCount
-			if tokens <= 0 {
-				tokens = estimateCompactionTokens(summary.String())
-			}
-			req.Progress(CompactionProgress{Tokens: tokens})
-		}
-		return nil
-	}); err != nil {
-		return "", err
-	}
-	return summary.String(), nil
-}
-
-func (c *SimpleCompactor) summarizeEmptyFallback(ctx context.Context, req CompactionRequest, previousSummary string, archive []api.Message) (string, error) {
-	retry := req
-	retry.Think = &api.ThinkValue{Value: false}
-	summary, err := c.summarize(ctx, retry, previousSummary, archive)
-	if err == nil {
-		return summary, nil
-	}
-	if !isUnsupportedCompactionThinkError(err) {
-		return "", err
-	}
-	if req.Think == nil {
-		return "", nil
-	}
-	retry.Think = nil
-	return c.summarize(ctx, retry, previousSummary, archive)
-}
-
-func isUnsupportedCompactionThinkError(err error) bool {
-	if err == nil {
-		return false
-	}
-	text := strings.ToLower(err.Error())
-	if !strings.Contains(text, "think") {
-		return false
-	}
-	var statusErr api.StatusError
-	if errors.As(err, &statusErr) && statusErr.StatusCode != 0 {
-		return statusErr.StatusCode == http.StatusBadRequest
-	}
-	return strings.Contains(text, "does not support") || strings.Contains(text, "not supported") || strings.Contains(text, "unsupported")
-}
-
-// compactionSummaryMessageForTask renders a compaction summary as the content
-// string stored on the synthetic tool-result message.
-func compactionSummaryMessageForTask(summary string, continueTask bool) string {
-	content := CompactionSummaryMessagePrefix + strings.TrimSpace(summary)
-	if continueTask {
-		content = strings.TrimSpace(content) + "\n\n" + CompactionContinueInstruction
-	}
-	return content
-}
-
-// CompactionSummaryMessages renders a compaction summary as the assistant
-// tool-call plus tool-result pair that represents a compacted turn in the
-// message history. This is the canonical builder used by both the compactor
-// and the chat store.
-func CompactionSummaryMessages(summary string, continueTask bool) []api.Message {
-	return []api.Message{
-		{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{{
-				ID: CompactionToolCallID,
-				Function: api.ToolCallFunction{
-					Name: CompactionToolName,
-				},
-			}},
-		},
-		{
-			Role:       "tool",
-			ToolName:   CompactionToolName,
-			ToolCallID: CompactionToolCallID,
-			Content:    compactionSummaryMessageForTask(summary, continueTask),
-		},
-	}
-}
-
-func (c *SimpleCompactor) compactionPromptBodyBudgetTokens(options map[string]any) int {
-	contextWindow := c.contextWindowTokens(options)
-	threshold := int(float64(contextWindow) * c.threshold())
-	if threshold <= 0 {
-		return 0
-	}
-	systemTokens := estimateCompactionTokens("system") + estimateCompactionTokens(compactionSystemPrompt)
-	userRoleTokens := estimateCompactionTokens("user")
-	budget := threshold - systemTokens - userRoleTokens
-	if budget <= 0 {
-		return 0
-	}
-	return budget
-}
-
-func truncateCompactionSummary(summary string) string {
-	if len(summary) <= maxCompactionSummaryBytes {
-		return summary
-	}
-	limit := maxCompactionSummaryBytes - len(compactionSummaryTruncated)
-	if limit < 0 {
-		limit = 0
-	}
-	var b strings.Builder
-	for _, r := range summary {
-		if b.Len()+len(string(r)) > limit {
-			break
-		}
-		b.WriteRune(r)
-	}
-	return strings.TrimSpace(b.String()) + compactionSummaryTruncated
-}
-
-func estimateCompactionTokens(text string) int {
-	text = strings.TrimSpace(text)
-	if text == "" {
-		return 0
-	}
-	return max(1, (len([]rune(text))+3)/4)
-}
-
-// EstimateTokens returns the agent's lightweight token estimate for UI hints.
-func EstimateTokens(text string) int {
-	return estimateCompactionTokens(text)
-}
-
-// EstimatePromptTokens returns the agent's lightweight estimate for the prompt
-// payload sent to /api/chat.
-func EstimatePromptTokens(systemPrompt string, messages []api.Message, tools api.Tools, format string) int {
-	return estimateCompactionRequestTokens(CompactionRequest{
-		SystemPrompt: systemPrompt,
-		Messages:     messages,
-		Tools:        tools,
-		Format:       format,
-	})
-}
-
-func estimateMessagesTokens(messages []api.Message) int {
-	var total int
-	for _, msg := range messages {
-		total += estimateCompactionTokens(msg.Role)
-		total += estimateCompactionTokens(msg.Content)
-		total += estimateCompactionTokens(msg.Thinking)
-		total += estimateCompactionTokens(msg.ToolName)
-		total += estimateCompactionTokens(msg.ToolCallID)
-		for _, call := range msg.ToolCalls {
-			total += estimateCompactionTokens(call.Function.Name)
-			total += estimateCompactionTokens(call.Function.Arguments.String())
-		}
-	}
-	return total
-}
-
-func estimateCompactionRequestTokens(req CompactionRequest) int {
-	requestMessages := sanitizeMessagesForEstimate(req.Messages)
-	if strings.TrimSpace(req.SystemPrompt) != "" {
-		requestMessages = make([]api.Message, 0, len(req.Messages)+1)
-		requestMessages = append(requestMessages, api.Message{Role: "system", Content: strings.TrimSpace(req.SystemPrompt)})
-		requestMessages = append(requestMessages, sanitizeMessagesForEstimate(req.Messages)...)
-	}
-
-	payload := struct {
-		Messages []api.Message   `json:"messages,omitempty"`
-		Tools    api.Tools       `json:"tools,omitempty"`
-		Format   json.RawMessage `json:"format,omitempty"`
-	}{
-		Messages: requestMessages,
-		Tools:    req.Tools,
-	}
-	if rawFormat, ok := compactionFormatForEstimate(req.Format); ok {
-		payload.Format = rawFormat
-	}
-	if data, err := json.Marshal(payload); err == nil {
-		return estimateCompactionTokens(string(data))
-	}
-
-	total := estimateMessagesTokens(requestMessages)
-	total += estimateCompactionTokens(req.Tools.String())
-	total += estimateCompactionTokens(req.Format)
-	return total
-}
-
-func sanitizeMessagesForEstimate(messages []api.Message) []api.Message {
-	requestMessages := sanitizeMessagesForRequest(messages)
-	for i := range requestMessages {
-		// Image token accounting is model-specific. Without the active model's
-		// tokenizer and vision accounting, raw image bytes/base64 make the
-		// estimate look much larger than the prompt the model actually sees.
-		requestMessages[i].Images = nil
-	}
-	return requestMessages
-}
-
-func compactionFormatForEstimate(format string) (json.RawMessage, bool) {
-	format = strings.TrimSpace(format)
-	if format == "" {
-		return nil, false
-	}
-	if format == "json" {
-		return json.RawMessage(`"json"`), true
-	}
-	if !json.Valid([]byte(format)) {
-		return nil, false
-	}
-	return json.RawMessage(format), true
-}
-
-func compactionPrompt(previousSummary string, archive []api.Message, maxTokens int) (string, error) {
-	messages := make([]api.Message, 0, len(archive))
-	for _, msg := range archive {
-		msg.Thinking = ""
-		msg.Images = nil
-		messages = append(messages, msg)
-	}
-	return renderCompactionPrompt(previousSummary, fitCompactionMessagesToBudget(previousSummary, messages, maxTokens))
-}
-
-func renderCompactionPrompt(previousSummary string, messages []api.Message) (string, error) {
-	payload, err := json.MarshalIndent(messages, "", "  ")
-	if err != nil {
-		return "", fmt.Errorf("marshal compaction messages: %w", err)
-	}
-
-	var b strings.Builder
-	if strings.TrimSpace(previousSummary) != "" {
-		b.WriteString("Previous summary:\n")
-		b.WriteString(strings.TrimSpace(previousSummary))
-		b.WriteString("\n\n")
-	}
-	b.WriteString("Messages to archive as JSON:\n")
-	b.Write(payload)
-	return b.String(), nil
-}
-
-func fitCompactionMessagesToBudget(previousSummary string, messages []api.Message, maxTokens int) []api.Message {
-	if maxTokens <= 0 {
-		return messages
-	}
-	fitted := append([]api.Message(nil), messages...)
-	for range 16 {
-		body, err := renderCompactionPrompt(previousSummary, fitted)
-		if err != nil || estimateCompactionTokens(body) <= maxTokens {
-			return fitted
-		}
-
-		idx := largestCompactionContentMessage(fitted)
-		if idx < 0 {
-			return fitted
-		}
-		overageTokens := estimateCompactionTokens(body) - maxTokens
-		currentRunes := len([]rune(fitted[idx].Content))
-		nextRunes := currentRunes - overageTokens*4 - 256
-		if nextRunes >= currentRunes {
-			nextRunes = currentRunes / 2
-		}
-		fitted[idx].Content = truncateToolResultContentTo(fitted[idx].Content, nextRunes)
-	}
-	return fitted
-}
-
-func largestCompactionContentMessage(messages []api.Message) int {
-	idx := -1
-	size := 0
-	for i, msg := range messages {
-		n := len([]rune(msg.Content))
-		if n > size {
-			idx = i
-			size = n
-		}
-	}
-	return idx
-}
-
-func splitCompactionMessages(messages []api.Message, keepUserTurns int) (prefix []api.Message, previousSummary string, archive []api.Message, suffix []api.Message, keptUserTurns int, ok bool) {
-	if keepUserTurns < 0 {
-		keepUserTurns = defaultCompactionKeepUserTurns
-	}
-
-	start := 0
-	for start < len(messages) && messages[start].Role == "system" && !isCompactionSummary(messages[start]) {
-		prefix = append(prefix, messages[start])
-		start++
-	}
-
-	candidates := make([]api.Message, 0, len(messages)-start)
-	for i := start; i < len(messages); i++ {
-		msg := messages[i]
-		if isCompactionSummary(msg) {
-			previousSummary = CompactionSummaryText(msg.Content)
-			continue
-		}
-		if isCompactionToolCall(msg) {
-			if i+1 < len(messages) && isCompactionSummary(messages[i+1]) {
-				previousSummary = CompactionSummaryText(messages[i+1].Content)
-				i++
-			}
-			continue
-		}
-		candidates = append(candidates, msg)
-	}
-
-	userTurnIndexes := make([]int, 0, keepUserTurns)
-	for i := len(candidates) - 1; i >= 0; i-- {
-		if candidates[i].Role == "user" {
-			userTurnIndexes = append(userTurnIndexes, i)
-		}
-	}
-	keptUserTurns = keepUserTurns
-	if len(userTurnIndexes) <= keptUserTurns {
-		keptUserTurns = len(userTurnIndexes) - 1
-	}
-	if keptUserTurns < 0 {
-		keptUserTurns = 0
-	}
-
-	suffixStart := len(candidates)
-	if keptUserTurns > 0 {
-		suffixStart = userTurnIndexes[keptUserTurns-1]
-	}
-	if suffixStart <= 0 || len(candidates[:suffixStart]) == 0 {
-		return prefix, previousSummary, nil, nil, keptUserTurns, false
-	}
-
-	return prefix, previousSummary, candidates[:suffixStart], candidates[suffixStart:], keptUserTurns, true
-}
-
-func isCompactionToolName(name string) bool {
-	return name == CompactionToolName
-}
-
-func isCompactionSummary(msg api.Message) bool {
-	return (msg.Role == "user" || msg.Role == "system" || (msg.Role == "tool" && isCompactionToolName(msg.ToolName))) &&
-		strings.HasPrefix(msg.Content, CompactionSummaryMessagePrefix)
-}
-
-// IsCompactionSummary reports whether msg uses the canonical compaction
-// summary message representation.
-func IsCompactionSummary(msg api.Message) bool {
-	return isCompactionSummary(msg)
-}
-
-// CompactionSummaryContent returns the user-visible summary from msg when it
-// is a canonical compaction summary.
-func CompactionSummaryContent(msg api.Message) (string, bool) {
-	if !isCompactionSummary(msg) {
-		return "", false
-	}
-	return CompactionSummaryText(msg.Content), true
-}
-
-// IsCompactionToolResult reports whether msg is the synthetic tool result used
-// to represent compaction in message history.
-func IsCompactionToolResult(msg api.Message) bool {
-	return msg.Role == "tool" && (isCompactionToolName(msg.ToolName) || msg.ToolCallID == CompactionToolCallID)
-}
-
-// IsCompactionToolCall reports whether msg is the synthetic assistant tool
-// call paired with a compaction summary result.
-func IsCompactionToolCall(msg api.Message) bool {
-	return isCompactionToolCall(msg)
-}
-
-func isCompactionToolCall(msg api.Message) bool {
-	if msg.Role != "assistant" {
-		return false
-	}
-	for _, call := range msg.ToolCalls {
-		if isCompactionToolName(call.Function.Name) {
-			return true
-		}
-	}
-	return false
-}
-
-// CompactionSummaryText reverses CompactionSummaryMessages, returning the
-// user-visible summary text with the prefix and any continuation instruction
-// removed.
-func CompactionSummaryText(content string) string {
-	return strings.TrimSpace(strings.TrimSuffix(
-		strings.TrimSpace(strings.TrimPrefix(content, CompactionSummaryMessagePrefix)),
-		CompactionContinueInstruction,
-	))
-}
-
-func intOption(options map[string]any, key string) int {
-	if options == nil {
-		return 0
-	}
-	switch v := options[key].(type) {
-	case int:
-		return v
-	case int64:
-		return int(v)
-	case float64:
-		return int(v)
-	case float32:
-		return int(v)
-	case json.Number:
-		n, _ := v.Int64()
-		return int(n)
-	default:
-		return 0
-	}
-}

agent/compactor_test.go

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

agent/events.go

@@ -1,96 +0,0 @@
-package agent
-
-import (
-	"context"
-	"time"
-
-	"github.com/ollama/ollama/api"
-)
-
-type EventType string
-
-const (
-	EventMessageStarted     EventType = "message_started"
-	EventMessageDelta       EventType = "message_delta"
-	EventThinkingDelta      EventType = "thinking_delta"
-	EventToolCallDetected   EventType = "tool_call_detected"
-	EventToolStarted        EventType = "tool_started"
-	EventToolFinished       EventType = "tool_finished"
-	EventToolsUnavailable   EventType = "tools_unavailable"
-	EventCompactionStarted  EventType = "compaction_started"
-	EventCompactionProgress EventType = "compaction_progress"
-	EventCompacted          EventType = "compacted"
-	EventCompactionSkipped  EventType = "compaction_skipped"
-	EventLoopStep           EventType = "loop_step"
-	EventRequestBuilt       EventType = "request_built"
-	EventModelStreamDone    EventType = "model_stream_done"
-	EventRunFinished        EventType = "run_finished"
-	EventError              EventType = "error"
-)
-
-type Event struct {
-	Type         EventType         `json:"type"`
-	RunID        string            `json:"runId,omitempty"`
-	ChatID       string            `json:"chatId,omitempty"`
-	MessageID    string            `json:"messageId,omitempty"`
-	Model        string            `json:"model,omitempty"`
-	Status       string            `json:"status,omitempty"`
-	ToolCallID   string            `json:"toolCallId,omitempty"`
-	ToolName     string            `json:"toolName,omitempty"`
-	WorkingDir   string            `json:"workingDir,omitempty"`
-	Content      string            `json:"content,omitempty"`
-	Thinking     string            `json:"thinking,omitempty"`
-	ToolCalls    []api.ToolCall    `json:"toolCalls,omitempty"`
-	Messages     []api.Message     `json:"messages,omitempty"`
-	Args         map[string]any    `json:"args,omitempty"`
-	Tokens       int               `json:"tokens,omitempty"`
-	PromptTokens int               `json:"promptTokens,omitempty"`
-	Error        string            `json:"error,omitempty"`
-	StartedAt    time.Time         `json:"startedAt,omitempty"`
-	FinishedAt   time.Time         `json:"finishedAt,omitempty"`
-	Response     *api.ChatResponse `json:"-"`
-}
-
-type EventSink interface {
-	Emit(Event) error
-}
-
-type MultiEventSink []EventSink
-
-func (s MultiEventSink) Emit(event Event) error {
-	var firstErr error
-	for _, sink := range s {
-		if sink == nil {
-			continue
-		}
-		if err := sink.Emit(event); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	return firstErr
-}
-
-type EventSinkFunc func(Event) error
-
-func (fn EventSinkFunc) Emit(event Event) error {
-	if fn == nil {
-		return nil
-	}
-	return fn(event)
-}
-
-func emit(sink EventSink, event Event) error {
-	if sink == nil {
-		return nil
-	}
-	return sink.Emit(event)
-}
-
-func emitIgnoringCanceled(ctx context.Context, sink EventSink, event Event) error {
-	err := emit(sink, event)
-	if err != nil && ctx != nil && ctx.Err() != nil {
-		//nolint:nilerr // Event sinks may close during cancellation; cancellation is not a user-facing emit failure.
-		return nil
-	}
-	return err
-}

agent/policy.go

@@ -1,92 +0,0 @@
-package agent
-
-import "sync"
-
-type ToolMode int
-
-const (
-	ToolModeReview ToolMode = iota
-	ToolModeFullAccess
-	ToolModeDisabled
-)
-
-type RunPolicy struct {
-	ToolMode       ToolMode
-	ApprovalPolicy ApprovalPolicy
-	// MaxToolRounds limits consecutive model/tool cycles.
-	// Zero uses the default guard; negative disables the guard for tests or
-	// special callers.
-	MaxToolRounds int
-}
-
-func (p RunPolicy) UsesTools() bool {
-	switch p.ToolMode {
-	case ToolModeReview, ToolModeFullAccess:
-		return true
-	default:
-		return false
-	}
-}
-
-func (p RunPolicy) Tools(registry *Registry) *Registry {
-	if !p.UsesTools() {
-		return nil
-	}
-	return registry
-}
-
-func (p RunPolicy) ApprovalHandler(prompter ApprovalPrompter) ApprovalHandler {
-	if p.ToolMode == ToolModeFullAccess {
-		return AutoAllowApproval{}
-	}
-	policy := p.ApprovalPolicy
-	if policy == nil {
-		policy = DefaultApprovalPolicy{}
-	}
-	return NewApprovalManager(ApprovalManagerOptions{
-		Policy:   policy,
-		Prompter: prompter,
-	})
-}
-
-func (p RunPolicy) ReviewApprovalHandler(prompter ApprovalPrompter) ApprovalHandler {
-	policy := p.ApprovalPolicy
-	if policy == nil {
-		policy = DefaultApprovalPolicy{}
-	}
-	return NewApprovalManager(ApprovalManagerOptions{
-		Policy:   policy,
-		Prompter: prompter,
-	})
-}
-
-type RunPolicyState struct {
-	mu     sync.Mutex
-	policy RunPolicy
-}
-
-func NewRunPolicyState(policy RunPolicy) *RunPolicyState {
-	return &RunPolicyState{policy: policy}
-}
-
-func (s *RunPolicyState) Policy() RunPolicy {
-	if s == nil {
-		return RunPolicy{}
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.policy
-}
-
-func (s *RunPolicyState) ToolMode() ToolMode {
-	return s.Policy().ToolMode
-}
-
-func (s *RunPolicyState) SetToolMode(mode ToolMode) {
-	if s == nil {
-		return
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.policy.ToolMode = mode
-}

agent/registry.go

@@ -1,103 +0,0 @@
-package agent
-
-import (
-	"context"
-	"fmt"
-	"sort"
-
-	"github.com/ollama/ollama/api"
-)
-
-type ToolContext struct {
-	WorkingDir string
-}
-
-type ToolResult struct {
-	Content    string
-	WorkingDir string
-}
-
-type Tool interface {
-	Name() string
-	Description() string
-	Schema() api.ToolFunction
-	Execute(context.Context, ToolContext, map[string]any) (ToolResult, error)
-}
-
-type ApprovalRequired interface {
-	RequiresApproval(map[string]any) bool
-}
-
-type Registry struct {
-	tools map[string]Tool
-}
-
-func NewRegistry() *Registry {
-	return &Registry{tools: make(map[string]Tool)}
-}
-
-func (r *Registry) Register(tool Tool) {
-	if r == nil || tool == nil {
-		return
-	}
-	r.tools[tool.Name()] = tool
-}
-
-func (r *Registry) Has(name string) bool {
-	if r == nil {
-		return false
-	}
-	_, ok := r.tools[name]
-	return ok
-}
-
-func (r *Registry) Get(name string) (Tool, bool) {
-	if r == nil {
-		return nil, false
-	}
-	tool, ok := r.tools[name]
-	return tool, ok
-}
-
-func (r *Registry) Names() []string {
-	if r == nil {
-		return nil
-	}
-	names := make([]string, 0, len(r.tools))
-	for name := range r.tools {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return names
-}
-
-func (r *Registry) Tools() api.Tools {
-	names := r.Names()
-	apiTools := make(api.Tools, 0, len(names))
-	for _, name := range names {
-		tool := r.tools[name]
-		apiTools = append(apiTools, api.Tool{
-			Type:     "function",
-			Function: tool.Schema(),
-		})
-	}
-	return apiTools
-}
-
-func (r *Registry) Execute(ctx context.Context, toolCtx ToolContext, call api.ToolCall) (ToolResult, error) {
-	tool, ok := r.Get(call.Function.Name)
-	if !ok {
-		return ToolResult{}, fmt.Errorf("unknown tool: %s", call.Function.Name)
-	}
-	return tool.Execute(ctx, toolCtx, call.Function.Arguments.ToMap())
-}
-
-func ToolRequiresApproval(tool Tool, args map[string]any) bool {
-	if tool == nil {
-		return false
-	}
-	if t, ok := tool.(ApprovalRequired); ok {
-		return t.RequiresApproval(args)
-	}
-	return false
-}

agent/request_preview.go

@@ -1,64 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"strings"
-
-	"github.com/ollama/ollama/api"
-)
-
-// ChatRequestPreview is the request body plus the estimated prompt tokens for it.
-type ChatRequestPreview struct {
-	Request      api.ChatRequest
-	PromptTokens int
-}
-
-// BuildChatRequestPreview builds the chat request shape used for a run and its estimated prompt tokens.
-func BuildChatRequestPreview(opts RunOptions, messages []api.Message, tools api.Tools) ChatRequestPreview {
-	return ChatRequestPreview{
-		Request:      buildChatRequest(opts, messages, tools),
-		PromptTokens: EstimateChatRequestPromptTokens(opts, messages, tools),
-	}
-}
-
-// EstimateChatRequestPromptTokens estimates the prompt tokens for a chat request before sending it.
-func EstimateChatRequestPromptTokens(opts RunOptions, messages []api.Message, tools api.Tools) int {
-	return estimateCompactionRequestTokens(CompactionRequest{
-		SystemPrompt: opts.SystemPrompt,
-		Messages:     sanitizeMessagesForRequest(messages),
-		Tools:        tools,
-		Format:       opts.Format,
-		Options:      opts.Options,
-	})
-}
-
-func buildChatRequest(opts RunOptions, messages []api.Message, tools api.Tools) api.ChatRequest {
-	requestMessages := sanitizeMessagesForRequest(messages)
-	if strings.TrimSpace(opts.SystemPrompt) != "" {
-		withSystem := make([]api.Message, 0, len(requestMessages)+1)
-		withSystem = append(withSystem, api.Message{Role: "system", Content: opts.SystemPrompt})
-		requestMessages = append(withSystem, requestMessages...)
-	}
-
-	req := api.ChatRequest{
-		Model:    opts.Model,
-		Messages: requestMessages,
-		Format:   json.RawMessage(chatRequestFormat(opts.Format)),
-		Options:  opts.Options,
-		Think:    opts.Think,
-	}
-	if opts.KeepAlive != nil {
-		req.KeepAlive = opts.KeepAlive
-	}
-	if len(tools) > 0 {
-		req.Tools = tools
-	}
-	return req
-}
-
-func chatRequestFormat(format string) string {
-	if format == "json" {
-		return `"` + format + `"`
-	}
-	return format
-}

agent/request_preview_test.go

@@ -1,46 +0,0 @@
-package agent
-
-import (
-	"testing"
-
-	"github.com/ollama/ollama/api"
-)
-
-func TestBuildChatRequestPreviewBuildsModelRequest(t *testing.T) {
-	tools := api.Tools{{
-		Type: "function",
-		Function: api.ToolFunction{
-			Name:        "read",
-			Description: "read a file",
-			Parameters:  api.ToolFunctionParameters{Type: "object"},
-		},
-	}}
-	preview := BuildChatRequestPreview(RunOptions{
-		Model:        "llama3.2",
-		SystemPrompt: "You are Ollama.",
-		Format:       "json",
-		Options:      map[string]any{"temperature": 0.1},
-	}, []api.Message{{Role: "user", Content: "hello"}}, tools)
-
-	if preview.Request.Model != "llama3.2" {
-		t.Fatalf("model = %q, want llama3.2", preview.Request.Model)
-	}
-	if got := string(preview.Request.Format); got != `"json"` {
-		t.Fatalf("format = %q, want quoted json", got)
-	}
-	if len(preview.Request.Messages) != 2 {
-		t.Fatalf("messages = %d, want 2", len(preview.Request.Messages))
-	}
-	if preview.Request.Messages[0].Role != "system" || preview.Request.Messages[0].Content != "You are Ollama." {
-		t.Fatalf("system message = %#v", preview.Request.Messages[0])
-	}
-	if preview.Request.Messages[1].Role != "user" || preview.Request.Messages[1].Content != "hello" {
-		t.Fatalf("user message = %#v", preview.Request.Messages[1])
-	}
-	if len(preview.Request.Tools) != 1 {
-		t.Fatalf("tools = %d, want 1", len(preview.Request.Tools))
-	}
-	if preview.PromptTokens <= 0 {
-		t.Fatalf("prompt tokens = %d, want positive", preview.PromptTokens)
-	}
-}

agent/skills/import.go

@@ -1,165 +0,0 @@
-package skills
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-)
-
-type ImportResult struct {
-	Source  string
-	Skill   Skill
-	From    string
-	To      string
-	Skipped bool
-	Error   string
-}
-
-type skillDirCandidate struct {
-	Dir     string
-	Skipped bool
-	Error   string
-}
-
-func Import(source string, force bool) ([]ImportResult, error) {
-	dest, err := DefaultDir()
-	if err != nil {
-		return nil, err
-	}
-	return ImportToDir(source, dest, force)
-}
-
-func ImportToDir(source, dest string, force bool) ([]ImportResult, error) {
-	roots, err := SourceDirs(source)
-	if err != nil {
-		return nil, err
-	}
-	if err := os.MkdirAll(dest, 0o755); err != nil {
-		return nil, fmt.Errorf("create skills directory: %w", err)
-	}
-
-	var results []ImportResult
-	for _, root := range roots {
-		candidates, err := skillDirs(root)
-		if err != nil {
-			if errors.Is(err, os.ErrNotExist) {
-				continue
-			}
-			results = append(results, ImportResult{Source: source, From: root, Skipped: true, Error: err.Error()})
-			continue
-		}
-		for _, candidate := range candidates {
-			result := ImportResult{Source: source, From: candidate.Dir}
-			if candidate.Skipped {
-				result.Skipped = true
-				result.Error = candidate.Error
-				results = append(results, result)
-				continue
-			}
-
-			skill, err := ReadMetadata(filepath.Join(candidate.Dir, SkillFile))
-			if err != nil {
-				result.Skipped = true
-				result.Error = err.Error()
-				results = append(results, result)
-				continue
-			}
-
-			result.Skill = skill
-			result.To = filepath.Join(dest, skill.Name)
-			copyResult, err := copyDir(candidate.Dir, result.To, force)
-			if errors.Is(err, os.ErrExist) {
-				result.Skipped = true
-				result.Error = "already exists"
-			} else if err != nil {
-				result.Skipped = true
-				result.Error = err.Error()
-			} else if len(copyResult.Skipped) > 0 {
-				result.Error = "skipped symlinks: " + strings.Join(copyResult.Skipped, ", ")
-			}
-			results = append(results, result)
-		}
-	}
-
-	slices.SortFunc(results, func(a, b ImportResult) int {
-		return strings.Compare(a.Skill.Name+a.From, b.Skill.Name+b.From)
-	})
-	return results, nil
-}
-
-func SourceDirs(source string) ([]string, error) {
-	source = strings.ToLower(strings.TrimSpace(source))
-	if source == "" {
-		source = "all"
-	}
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return nil, fmt.Errorf("resolve home directory: %w", err)
-	}
-
-	dirs := map[string][]string{
-		"claude": {filepath.Join(home, ".claude", "skills")},
-		"codex":  {filepath.Join(home, ".codex", "skills")},
-		"pi":     {filepath.Join(home, ".pi", "skills"), filepath.Join(home, ".agents", "skills")},
-		"agents": {filepath.Join(home, ".agents", "skills")},
-	}
-	if source == "all" {
-		var all []string
-		for _, name := range []string{"claude", "codex", "pi"} {
-			all = append(all, dirs[name]...)
-		}
-		return uniqueStrings(all), nil
-	}
-	if roots, ok := dirs[source]; ok {
-		return roots, nil
-	}
-	return nil, fmt.Errorf("unknown skill source %q (use claude, codex, pi, agents, or all)", source)
-}
-
-func skillDirs(root string) ([]skillDirCandidate, error) {
-	entries, err := os.ReadDir(root)
-	if err != nil {
-		return nil, err
-	}
-	var dirs []skillDirCandidate
-	for _, entry := range entries {
-		if strings.HasPrefix(entry.Name(), ".") {
-			continue
-		}
-		dir := filepath.Join(root, entry.Name())
-		if entry.Type()&os.ModeSymlink != 0 {
-			dirs = append(dirs, skillDirCandidate{
-				Dir:     dir,
-				Skipped: true,
-				Error:   "symlinked skill directories are not supported",
-			})
-			continue
-		}
-		if !entry.IsDir() {
-			continue
-		}
-		if _, err := os.Stat(filepath.Join(dir, SkillFile)); err == nil {
-			dirs = append(dirs, skillDirCandidate{Dir: dir})
-		}
-	}
-	slices.SortFunc(dirs, func(a, b skillDirCandidate) int {
-		return strings.Compare(a.Dir, b.Dir)
-	})
-	return dirs, nil
-}
-
-func uniqueStrings(values []string) []string {
-	seen := make(map[string]bool)
-	var out []string
-	for _, value := range values {
-		if seen[value] {
-			continue
-		}
-		seen[value] = true
-		out = append(out, value)
-	}
-	return out
-}

agent/skills/skills.go

@@ -1,319 +0,0 @@
-package skills
-
-import (
-	"errors"
-	"fmt"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"regexp"
-	"slices"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-const (
-	SkillFile         = "SKILL.md"
-	maxSkillFileBytes = 1 << 20
-)
-
-var validName = regexp.MustCompile(`^[a-z0-9][a-z0-9-]{0,63}$`)
-
-type Skill struct {
-	Name        string
-	Description string
-	Dir         string
-	File        string
-}
-
-type Catalog struct {
-	Dir      string
-	Skills   []Skill
-	Warnings []string
-}
-
-type frontmatter struct {
-	Name        string `yaml:"name"`
-	Description string `yaml:"description"`
-}
-
-func DefaultDir() (string, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return "", fmt.Errorf("resolve home directory: %w", err)
-	}
-	return filepath.Join(home, ".ollama", "skills"), nil
-}
-
-func LoadDefault() (*Catalog, error) {
-	dir, err := DefaultDir()
-	if err != nil {
-		return nil, err
-	}
-	return Load(dir)
-}
-
-func Load(dir string) (*Catalog, error) {
-	catalog := &Catalog{Dir: dir}
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return catalog, nil
-		}
-		return nil, fmt.Errorf("read skills directory: %w", err)
-	}
-
-	seen := make(map[string]string)
-	for _, entry := range entries {
-		if !entry.IsDir() || strings.HasPrefix(entry.Name(), ".") {
-			continue
-		}
-
-		skillDir := filepath.Join(dir, entry.Name())
-		skill, err := ReadMetadata(filepath.Join(skillDir, SkillFile))
-		if err != nil {
-			catalog.Warnings = append(catalog.Warnings, fmt.Sprintf("%s: %v", skillDir, err))
-			continue
-		}
-		skill.Dir = skillDir
-		skill.File = filepath.Join(skillDir, SkillFile)
-		if previous, ok := seen[skill.Name]; ok {
-			catalog.Warnings = append(catalog.Warnings, fmt.Sprintf("%s: duplicate skill name %q already loaded from %s", skillDir, skill.Name, previous))
-			continue
-		}
-		seen[skill.Name] = skillDir
-		catalog.Skills = append(catalog.Skills, skill)
-	}
-
-	slices.SortFunc(catalog.Skills, func(a, b Skill) int {
-		return strings.Compare(a.Name, b.Name)
-	})
-	return catalog, nil
-}
-
-func ReadMetadata(path string) (Skill, error) {
-	data, err := readSkillFile(path)
-	if err != nil {
-		return Skill{}, err
-	}
-
-	meta, _, err := parseSkillFile(data)
-	if err != nil {
-		return Skill{}, err
-	}
-	if err := validateMetadata(meta); err != nil {
-		return Skill{}, err
-	}
-	return Skill{Name: meta.Name, Description: meta.Description}, nil
-}
-
-func (c *Catalog) Empty() bool {
-	return c == nil || len(c.Skills) == 0
-}
-
-func (c *Catalog) Find(name string) (Skill, bool) {
-	if c == nil {
-		return Skill{}, false
-	}
-	name = NormalizeName(name)
-	for _, skill := range c.Skills {
-		if skill.Name == name {
-			return skill, true
-		}
-	}
-	return Skill{}, false
-}
-
-func (c *Catalog) SummaryMarkdown() string {
-	if c.Empty() {
-		return "No skills are installed."
-	}
-	var b strings.Builder
-	b.WriteString("Installed skills:\n\n")
-	for _, skill := range c.Skills {
-		b.WriteString("- **")
-		b.WriteString(skill.Name)
-		b.WriteString("**: ")
-		b.WriteString(skill.Description)
-		b.WriteByte('\n')
-	}
-	return strings.TrimRight(b.String(), "\n")
-}
-
-func (c *Catalog) SystemPrompt(toolAvailable bool) string {
-	if c.Empty() {
-		return ""
-	}
-
-	var b strings.Builder
-	b.WriteString("Agent skills are available. Skills are reusable instruction packages stored under ")
-	b.WriteString(c.Dir)
-	b.WriteString(".\n")
-	b.WriteString("Use a skill when its description matches the user's task. Load only metadata up front; load full instructions only when needed.\n")
-	if toolAvailable {
-		b.WriteString("To load a skill, call the skill tool with the skill name. After loading SKILL.md, follow it. Resolve relative references from the returned skill directory.\n")
-	} else {
-		b.WriteString("This model cannot call tools in this session. Follow any skill instructions that are explicitly provided by the user or system.\n")
-	}
-	b.WriteString("\nAvailable skills:\n")
-	for _, skill := range c.Skills {
-		b.WriteString("- ")
-		b.WriteString(skill.Name)
-		b.WriteString(": ")
-		b.WriteString(skill.Description)
-		b.WriteByte('\n')
-	}
-	return strings.TrimRight(b.String(), "\n")
-}
-
-func (s Skill) Read() (string, error) {
-	if s.File == "" {
-		return "", fmt.Errorf("skill %q has no %s path", s.Name, SkillFile)
-	}
-	data, err := readSkillFile(s.File)
-	if err != nil {
-		return "", err
-	}
-	return string(data), nil
-}
-
-func readSkillFile(path string) ([]byte, error) {
-	info, err := os.Lstat(path)
-	if err != nil {
-		return nil, err
-	}
-	if info.Mode()&os.ModeSymlink != 0 {
-		return nil, fmt.Errorf("%s must not be a symlink", SkillFile)
-	}
-	if !info.Mode().IsRegular() {
-		return nil, fmt.Errorf("%s must be a regular file", SkillFile)
-	}
-	if info.Size() > maxSkillFileBytes {
-		return nil, fmt.Errorf("%s exceeds %d bytes", SkillFile, maxSkillFileBytes)
-	}
-	return os.ReadFile(path)
-}
-
-func NormalizeName(name string) string {
-	name = strings.TrimSpace(name)
-	name = strings.TrimPrefix(name, "/")
-	return strings.ToLower(name)
-}
-
-func parseSkillFile(data []byte) (frontmatter, string, error) {
-	text := strings.ReplaceAll(string(data), "\r\n", "\n")
-	if !strings.HasPrefix(text, "---\n") {
-		return frontmatter{}, "", fmt.Errorf("%s must start with YAML frontmatter", SkillFile)
-	}
-
-	rest := text[len("---\n"):]
-	end := strings.Index(rest, "\n---")
-	if end < 0 {
-		return frontmatter{}, "", fmt.Errorf("%s frontmatter is not closed", SkillFile)
-	}
-
-	var meta frontmatter
-	if err := yaml.Unmarshal([]byte(rest[:end]), &meta); err != nil {
-		return frontmatter{}, "", fmt.Errorf("parse frontmatter: %w", err)
-	}
-
-	body := rest[end+len("\n---"):]
-	body = strings.TrimPrefix(body, "\n")
-	return meta, body, nil
-}
-
-func validateMetadata(meta frontmatter) error {
-	if !validName.MatchString(meta.Name) {
-		return fmt.Errorf("invalid skill name %q", meta.Name)
-	}
-	if strings.TrimSpace(meta.Description) == "" {
-		return fmt.Errorf("skill %q has empty description", meta.Name)
-	}
-	if len([]rune(meta.Description)) > 1024 {
-		return fmt.Errorf("skill %q description exceeds 1024 characters", meta.Name)
-	}
-	return nil
-}
-
-type copyDirResult struct {
-	Skipped []string
-}
-
-func copyDir(src, dst string, force bool) (copyDirResult, error) {
-	if _, err := os.Stat(dst); err == nil && !force {
-		return copyDirResult{}, fs.ErrExist
-	} else if err != nil && !errors.Is(err, os.ErrNotExist) {
-		return copyDirResult{}, err
-	}
-
-	parent := filepath.Dir(dst)
-	if err := os.MkdirAll(parent, 0o755); err != nil {
-		return copyDirResult{}, err
-	}
-	tmp, err := os.MkdirTemp(parent, "."+filepath.Base(dst)+".tmp-*")
-	if err != nil {
-		return copyDirResult{}, err
-	}
-	moved := false
-	defer func() {
-		if !moved {
-			_ = os.RemoveAll(tmp)
-		}
-	}()
-
-	var result copyDirResult
-	if err := filepath.WalkDir(src, func(path string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(src, path)
-		if err != nil {
-			return err
-		}
-		if rel == "." {
-			return nil
-		}
-		target := filepath.Join(tmp, rel)
-
-		if d.Type()&os.ModeSymlink != 0 {
-			result.Skipped = append(result.Skipped, rel)
-			return nil
-		}
-		if d.IsDir() {
-			info, err := d.Info()
-			if err != nil {
-				return err
-			}
-			return os.MkdirAll(target, info.Mode().Perm())
-		}
-
-		info, err := d.Info()
-		if err != nil {
-			return err
-		}
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return err
-		}
-		return os.WriteFile(target, data, info.Mode().Perm())
-	}); err != nil {
-		return result, err
-	}
-
-	if force {
-		if err := os.RemoveAll(dst); err != nil {
-			return result, err
-		}
-	}
-	if _, err := os.Stat(dst); err == nil {
-		return result, fs.ErrExist
-	} else if err != nil && !errors.Is(err, os.ErrNotExist) {
-		return result, err
-	}
-	if err := os.Rename(tmp, dst); err != nil {
-		return result, err
-	}
-	moved = true
-	return result, nil
-}

agent/skills/skills_test.go

@@ -1,157 +0,0 @@
-package skills
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestLoadCatalogReadsSkillMetadata(t *testing.T) {
-	dir := t.TempDir()
-	writeSkill(t, filepath.Join(dir, "go-code"), "go-code", "Write idiomatic Go code.")
-
-	catalog, err := Load(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(catalog.Skills) != 1 {
-		t.Fatalf("skills = %d, want 1: %#v", len(catalog.Skills), catalog)
-	}
-	if got := catalog.Skills[0].Name; got != "go-code" {
-		t.Fatalf("skill name = %q", got)
-	}
-	if prompt := catalog.SystemPrompt(true); !strings.Contains(prompt, "go-code: Write idiomatic Go code.") || !strings.Contains(prompt, "call the skill tool") {
-		t.Fatalf("system prompt missing skill metadata: %q", prompt)
-	}
-}
-
-func TestLoadCatalogSkipsInvalidSkills(t *testing.T) {
-	dir := t.TempDir()
-	writeSkill(t, filepath.Join(dir, "bad"), "Bad_Name", "bad")
-
-	catalog, err := Load(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(catalog.Skills) != 0 {
-		t.Fatalf("skills = %#v, want none", catalog.Skills)
-	}
-	if len(catalog.Warnings) == 0 {
-		t.Fatal("expected invalid skill warning")
-	}
-}
-
-func TestImportToDirCopiesCanonicalSkill(t *testing.T) {
-	home := t.TempDir()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	src := filepath.Join(home, ".claude", "skills", "go-code")
-	writeSkill(t, src, "go-code", "Write idiomatic Go code.")
-	if err := os.WriteFile(filepath.Join(src, "notes.md"), []byte("notes"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	dest := filepath.Join(home, ".ollama", "skills")
-	results, err := ImportToDir("claude", dest, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(results) != 1 || results[0].Skipped {
-		t.Fatalf("results = %#v", results)
-	}
-	if _, err := os.Stat(filepath.Join(dest, "go-code", "notes.md")); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestReadMetadataRejectsSymlink(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("symlink permissions vary on Windows")
-	}
-	dir := t.TempDir()
-	real := filepath.Join(dir, "real.md")
-	if err := os.WriteFile(real, []byte("---\nname: go-code\ndescription: Write idiomatic Go code.\n---\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	link := filepath.Join(dir, SkillFile)
-	if err := os.Symlink(real, link); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := ReadMetadata(link); err == nil || !strings.Contains(err.Error(), "must not be a symlink") {
-		t.Fatalf("ReadMetadata error = %v, want symlink rejection", err)
-	}
-}
-
-func TestImportToDirReportsSymlinkedSkillDirectory(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("symlink permissions vary on Windows")
-	}
-	home := t.TempDir()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	srcRoot := filepath.Join(home, ".claude", "skills")
-	real := filepath.Join(home, "elsewhere", "go-code")
-	writeSkill(t, real, "go-code", "Write idiomatic Go code.")
-	if err := os.MkdirAll(srcRoot, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(real, filepath.Join(srcRoot, "go-code")); err != nil {
-		t.Fatal(err)
-	}
-
-	results, err := ImportToDir("claude", filepath.Join(home, ".ollama", "skills"), false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(results) != 1 || !results[0].Skipped {
-		t.Fatalf("results = %#v, want one skipped symlink directory", results)
-	}
-	if !strings.Contains(results[0].Error, "symlinked skill directories") {
-		t.Fatalf("error = %q, want symlink directory warning", results[0].Error)
-	}
-}
-
-func TestImportToDirReportsSkippedSymlinkEntries(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("symlink permissions vary on Windows")
-	}
-	home := t.TempDir()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	src := filepath.Join(home, ".claude", "skills", "go-code")
-	writeSkill(t, src, "go-code", "Write idiomatic Go code.")
-	target := filepath.Join(home, "outside.md")
-	if err := os.WriteFile(target, []byte("outside"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(target, filepath.Join(src, "outside.md")); err != nil {
-		t.Fatal(err)
-	}
-
-	results, err := ImportToDir("claude", filepath.Join(home, ".ollama", "skills"), false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(results) != 1 || results[0].Skipped {
-		t.Fatalf("results = %#v, want one imported skill", results)
-	}
-	if !strings.Contains(results[0].Error, "skipped symlinks: outside.md") {
-		t.Fatalf("error = %q, want skipped symlink warning", results[0].Error)
-	}
-	if _, err := os.Lstat(filepath.Join(home, ".ollama", "skills", "go-code", "outside.md")); !os.IsNotExist(err) {
-		t.Fatalf("copied symlink err = %v, want missing symlink", err)
-	}
-}
-
-func writeSkill(t *testing.T, dir, name, description string) {
-	t.Helper()
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	content := "---\nname: " + name + "\ndescription: " + description + "\n---\n\n# " + name + "\n\nUse this skill.\n"
-	if err := os.WriteFile(filepath.Join(dir, SkillFile), []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}

agent/store/store.go

@@ -1,991 +0,0 @@
-package store
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-
-	_ "github.com/mattn/go-sqlite3"
-)
-
-type Store struct {
-	DBPath string
-
-	dbMu sync.Mutex
-	db   *database
-}
-
-type database struct {
-	conn *sql.DB
-}
-
-type AgentChat struct {
-	ID        string
-	Title     string
-	Model     string
-	CreatedAt time.Time
-	Messages  []api.Message
-}
-
-type ChatSummary struct {
-	ID           string
-	Title        string
-	Model        string
-	CreatedAt    time.Time
-	UpdatedAt    time.Time
-	MessageCount int
-	ApproxBytes  int64
-}
-
-func New(path string) (*Store, error) {
-	store := &Store{DBPath: path}
-	if err := store.ensureDB(); err != nil {
-		return nil, err
-	}
-	return store, nil
-}
-
-func (s *Store) ensureDB() error {
-	if s.db != nil {
-		return nil
-	}
-
-	s.dbMu.Lock()
-	defer s.dbMu.Unlock()
-
-	if s.db != nil {
-		return nil
-	}
-
-	dbPath := s.DBPath
-	if dbPath == "" {
-		dbPath = defaultDBPath()
-	}
-	if err := os.MkdirAll(filepath.Dir(dbPath), 0o755); err != nil {
-		return fmt.Errorf("create database directory: %w", err)
-	}
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		return err
-	}
-	s.db = db
-	return nil
-}
-
-func (s *Store) Close() error {
-	if s == nil || s.db == nil {
-		return nil
-	}
-	err := s.db.Close()
-	s.db = nil
-	return err
-}
-
-func defaultDBPath() string {
-	switch runtime.GOOS {
-	case "windows":
-		return filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "db.sqlite")
-	case "darwin":
-		return filepath.Join(os.Getenv("HOME"), "Library", "Application Support", "Ollama", "db.sqlite")
-	default:
-		return filepath.Join(os.Getenv("HOME"), ".ollama", "db.sqlite")
-	}
-}
-
-func newDatabase(dbPath string) (*database, error) {
-	conn, err := sql.Open("sqlite3", dbPath+"?_foreign_keys=on&_journal_mode=WAL&_busy_timeout=5000&_txlock=immediate")
-	if err != nil {
-		return nil, fmt.Errorf("open database: %w", err)
-	}
-	if err := conn.Ping(); err != nil {
-		conn.Close()
-		return nil, fmt.Errorf("ping database: %w", err)
-	}
-	db := &database{conn: conn}
-	if err := db.init(); err != nil {
-		conn.Close()
-		return nil, fmt.Errorf("initialize database: %w", err)
-	}
-	return db, nil
-}
-
-func (db *database) Close() error {
-	_, _ = db.conn.Exec("PRAGMA wal_checkpoint(TRUNCATE);")
-	return db.conn.Close()
-}
-
-func (db *database) init() error {
-	if _, err := db.conn.Exec("PRAGMA foreign_keys = ON"); err != nil {
-		return fmt.Errorf("enable foreign keys: %w", err)
-	}
-	if _, err := db.conn.Exec(`
-		CREATE TABLE IF NOT EXISTS chats (
-			id TEXT PRIMARY KEY,
-			title TEXT NOT NULL DEFAULT '',
-			model_name TEXT NOT NULL DEFAULT '',
-			source TEXT NOT NULL DEFAULT 'app',
-			created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			browser_state TEXT
-		);
-
-		CREATE TABLE IF NOT EXISTS messages (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			chat_id TEXT NOT NULL,
-			role TEXT NOT NULL,
-			content TEXT NOT NULL DEFAULT '',
-			thinking TEXT NOT NULL DEFAULT '',
-			images TEXT NOT NULL DEFAULT '[]',
-			stream BOOLEAN NOT NULL DEFAULT 0,
-			model_name TEXT,
-			model_cloud BOOLEAN,
-			model_ollama_host BOOLEAN,
-			created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			thinking_time_start TIMESTAMP,
-			thinking_time_end TIMESTAMP,
-			tool_result TEXT,
-			tool_name TEXT NOT NULL DEFAULT '',
-			tool_call_id TEXT NOT NULL DEFAULT '',
-			archived BOOLEAN NOT NULL DEFAULT 0,
-			FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
-		);
-
-		CREATE TABLE IF NOT EXISTS tool_calls (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			message_id INTEGER NOT NULL,
-			type TEXT NOT NULL,
-			tool_call_id TEXT NOT NULL DEFAULT '',
-			function_name TEXT NOT NULL,
-			function_arguments TEXT NOT NULL,
-			function_result TEXT,
-			FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
-		);
-
-		CREATE TABLE IF NOT EXISTS compactions (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			chat_id TEXT NOT NULL,
-			summary TEXT NOT NULL,
-			archived_message_ids TEXT NOT NULL DEFAULT '[]',
-			created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
-		);
-
-	`); err != nil {
-		return err
-	}
-	return db.ensureAgentSchema()
-}
-
-func (db *database) ensureAgentSchema() error {
-	for _, stmt := range []struct {
-		sql string
-		msg string
-	}{
-		{`ALTER TABLE chats ADD COLUMN model_name TEXT NOT NULL DEFAULT ''`, "add chats.model_name"},
-		{`ALTER TABLE chats ADD COLUMN source TEXT NOT NULL DEFAULT 'app'`, "add chats.source"},
-		{`ALTER TABLE messages ADD COLUMN images TEXT NOT NULL DEFAULT '[]'`, "add messages.images"},
-		{`ALTER TABLE messages ADD COLUMN tool_name TEXT NOT NULL DEFAULT ''`, "add messages.tool_name"},
-		{`ALTER TABLE messages ADD COLUMN tool_call_id TEXT NOT NULL DEFAULT ''`, "add messages.tool_call_id"},
-		{`ALTER TABLE messages ADD COLUMN archived BOOLEAN NOT NULL DEFAULT 0`, "add messages.archived"},
-		{`ALTER TABLE tool_calls ADD COLUMN tool_call_id TEXT NOT NULL DEFAULT ''`, "add tool_calls.tool_call_id"},
-	} {
-		_, err := db.conn.Exec(stmt.sql)
-		if err != nil && !duplicateColumnError(err) {
-			return fmt.Errorf("%s: %w", stmt.msg, err)
-		}
-	}
-	_, err := db.conn.Exec(`
-		CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id);
-		CREATE INDEX IF NOT EXISTS idx_messages_chat_id_id ON messages(chat_id, id);
-		CREATE INDEX IF NOT EXISTS idx_messages_chat_id_archived ON messages(chat_id, archived, id);
-		CREATE INDEX IF NOT EXISTS idx_tool_calls_message_id ON tool_calls(message_id);
-		CREATE TABLE IF NOT EXISTS compactions (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			chat_id TEXT NOT NULL,
-			summary TEXT NOT NULL,
-			archived_message_ids TEXT NOT NULL DEFAULT '[]',
-			created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
-		);
-		CREATE INDEX IF NOT EXISTS idx_compactions_chat_id ON compactions(chat_id, id);
-	`)
-	if err != nil {
-		return fmt.Errorf("create agent chat persistence tables: %w", err)
-	}
-	return nil
-}
-
-func duplicateColumnError(err error) bool {
-	return err != nil && strings.Contains(strings.ToLower(err.Error()), "duplicate column")
-}
-
-func (s *Store) EnsureChat(ctx context.Context, id string, title string) error {
-	if id == "" {
-		return fmt.Errorf("chat id is required")
-	}
-	if err := s.ensureDB(); err != nil {
-		return err
-	}
-	_, err := s.db.conn.ExecContext(ctx, `
-		INSERT INTO chats (id, title, created_at, source)
-		VALUES (?, ?, ?, 'agent')
-		ON CONFLICT(id) DO UPDATE SET
-			title = CASE
-				WHEN excluded.title != '' THEN excluded.title
-				ELSE chats.title
-			END,
-			source = 'agent'
-	`, id, title, time.Now())
-	if err != nil {
-		return fmt.Errorf("ensure chat: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) SetChatModel(ctx context.Context, chatID string, model string) error {
-	chatID = strings.TrimSpace(chatID)
-	model = strings.TrimSpace(model)
-	if chatID == "" {
-		return fmt.Errorf("chat id is required")
-	}
-	if model == "" {
-		return fmt.Errorf("model is required")
-	}
-	if err := s.EnsureChat(ctx, chatID, ""); err != nil {
-		return err
-	}
-	if _, err := s.db.conn.ExecContext(ctx, `UPDATE chats SET model_name = ? WHERE id = ?`, model, chatID); err != nil {
-		return fmt.Errorf("set chat model: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) AppendAgentMessage(ctx context.Context, chatID string, msg api.Message, model string) error {
-	if err := s.EnsureChat(ctx, chatID, ""); err != nil {
-		return err
-	}
-
-	tx, err := s.db.conn.BeginTx(ctx, nil)
-	if err != nil {
-		return fmt.Errorf("begin transaction: %w", err)
-	}
-	defer tx.Rollback()
-
-	messageID, err := insertAgentMessage(ctx, tx, chatID, msg, model)
-	if err != nil {
-		return err
-	}
-	for _, toolCall := range msg.ToolCalls {
-		if err := insertAgentToolCall(ctx, tx, messageID, toolCall); err != nil {
-			return err
-		}
-	}
-
-	if msg.Role == "user" && strings.TrimSpace(msg.Content) != "" {
-		if err := maybeSetAgentTitle(ctx, tx, chatID, msg.Content); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (s *Store) UpdateLastAgentMessage(ctx context.Context, chatID string, msg api.Message, model string) error {
-	if err := s.ensureDB(); err != nil {
-		return err
-	}
-	tx, err := s.db.conn.BeginTx(ctx, nil)
-	if err != nil {
-		return fmt.Errorf("begin transaction: %w", err)
-	}
-	defer tx.Rollback()
-
-	var messageID int64
-	if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(id), 0) FROM messages WHERE chat_id = ? AND archived = 0`, chatID).Scan(&messageID); err != nil {
-		return fmt.Errorf("get last message id: %w", err)
-	}
-	if messageID == 0 {
-		return fmt.Errorf("no message found to update")
-	}
-
-	now := time.Now()
-	modelName := sql.NullString{}
-	if model != "" {
-		modelName = sql.NullString{String: model, Valid: true}
-	}
-
-	imagesJSON, err := marshalAgentMessageImages(msg.Images)
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.ExecContext(ctx, `
-		UPDATE messages
-		SET role = ?, content = ?, thinking = ?, images = ?, tool_name = ?, tool_call_id = ?, model_name = ?, updated_at = ?
-		WHERE id = ?
-	`, msg.Role, msg.Content, msg.Thinking, imagesJSON, msg.ToolName, msg.ToolCallID, modelName, now, messageID)
-	if err != nil {
-		return fmt.Errorf("update last message: %w", err)
-	}
-
-	if _, err := tx.ExecContext(ctx, `DELETE FROM tool_calls WHERE message_id = ?`, messageID); err != nil {
-		return fmt.Errorf("delete old tool calls: %w", err)
-	}
-	for _, toolCall := range msg.ToolCalls {
-		if err := insertAgentToolCall(ctx, tx, messageID, toolCall); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (s *Store) AgentChat(ctx context.Context, id string) (*AgentChat, error) {
-	if err := s.ensureDB(); err != nil {
-		return nil, err
-	}
-	var chat AgentChat
-	var chatModel string
-	if err := s.db.conn.QueryRowContext(ctx, `
-		SELECT id, title, model_name, created_at FROM chats WHERE id = ?
-	`, id).Scan(&chat.ID, &chat.Title, &chatModel, &chat.CreatedAt); err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(chatModel) != "" {
-		chat.Model = chatModel
-	} else {
-		model, err := latestAgentModelForChat(ctx, s.db.conn, id)
-		if err != nil {
-			return nil, err
-		}
-		chat.Model = model
-	}
-
-	rows, err := s.db.conn.QueryContext(ctx, `
-		SELECT id, role, content, thinking, images, tool_name, tool_call_id FROM messages WHERE chat_id = ? AND archived = 0 ORDER BY id ASC
-	`, id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var messageID int64
-		var msg api.Message
-		var imagesJSON string
-		if err := rows.Scan(&messageID, &msg.Role, &msg.Content, &msg.Thinking, &imagesJSON, &msg.ToolName, &msg.ToolCallID); err != nil {
-			return nil, err
-		}
-		images, err := unmarshalAgentMessageImages(imagesJSON)
-		if err != nil {
-			return nil, err
-		}
-		msg.Images = images
-		toolCalls, err := getAgentToolCalls(ctx, s.db.conn, messageID)
-		if err != nil {
-			return nil, err
-		}
-		msg.ToolCalls = toolCalls
-		chat.Messages = append(chat.Messages, msg)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	summary, err := latestCompactionSummary(ctx, s.db.conn, id)
-	if err != nil {
-		return nil, err
-	}
-	if summary != "" && !messagesContainCompactionSummary(chat.Messages) {
-		chat.Messages = insertCompactionSummaryAfterLeadingSystemMessages(chat.Messages, agent.CompactionSummaryMessages(summary, false))
-	} else {
-		chat.Messages = moveCompactionSummaryBeforeKeptMessages(chat.Messages)
-	}
-	chat.Messages = repairDanglingToolCalls(chat.Messages)
-
-	return &chat, nil
-}
-
-func (s *Store) LatestChat(ctx context.Context) (*AgentChat, error) {
-	if err := s.ensureDB(); err != nil {
-		return nil, err
-	}
-	var chatID string
-	query := fmt.Sprintf(`
-			SELECT c.id
-			FROM chats c
-			JOIN messages m ON m.chat_id = c.id AND m.archived = 0
-			WHERE c.source = 'agent'
-			GROUP BY c.id
-			HAVING %[1]s IS NOT NULL
-			ORDER BY MAX(m.updated_at) DESC, MAX(m.id) DESC
-			LIMIT 1
-		`, currentAgentModelSelectExpr("c"))
-	if err := s.db.conn.QueryRowContext(ctx, query).Scan(&chatID); err != nil {
-		return nil, err
-	}
-	return s.AgentChat(ctx, chatID)
-}
-
-func (s *Store) LatestChatForModel(ctx context.Context, model string) (*AgentChat, error) {
-	if strings.TrimSpace(model) == "" {
-		return nil, fmt.Errorf("model is required")
-	}
-	if err := s.ensureDB(); err != nil {
-		return nil, err
-	}
-
-	var chatID string
-	query := fmt.Sprintf(`
-			SELECT c.id
-			FROM chats c
-			JOIN messages m ON m.chat_id = c.id AND m.archived = 0
-			WHERE c.source = 'agent'
-			GROUP BY c.id
-			HAVING %[1]s = ?
-			ORDER BY MAX(m.updated_at) DESC, MAX(m.id) DESC
-			LIMIT 1
-		`, currentAgentModelSelectExpr("c"))
-	if err := s.db.conn.QueryRowContext(ctx, query, model).Scan(&chatID); err != nil {
-		return nil, err
-	}
-	return s.AgentChat(ctx, chatID)
-}
-
-func (s *Store) ListChats(ctx context.Context, limit int) ([]ChatSummary, error) {
-	if err := s.ensureDB(); err != nil {
-		return nil, err
-	}
-	if limit <= 0 {
-		limit = 50
-	}
-
-	query := fmt.Sprintf(`
-			SELECT
-				c.id,
-				c.title,
-				c.created_at,
-				MAX(m.updated_at) AS updated_at,
-				COUNT(m.id) AS message_count,
-				COALESCE(SUM(
-					LENGTH(m.role) +
-					LENGTH(m.content) +
-					LENGTH(m.thinking) +
-					LENGTH(m.tool_name) +
-					LENGTH(m.tool_call_id)
-				), 0) AS approx_bytes,
-				%[1]s AS current_model
-			FROM chats c
-			JOIN messages m ON m.chat_id = c.id AND m.archived = 0
-			WHERE c.source = 'agent'
-			GROUP BY c.id
-			ORDER BY updated_at DESC, MAX(m.id) DESC
-			LIMIT ?
-		`, currentAgentModelSelectExpr("c"))
-	rows, err := s.db.conn.QueryContext(ctx, query, limit)
-	if err != nil {
-		return nil, fmt.Errorf("list chats: %w", err)
-	}
-	defer rows.Close()
-
-	var summaries []ChatSummary
-	for rows.Next() {
-		var summary ChatSummary
-		var updatedAt string
-		var modelName sql.NullString
-		if err := rows.Scan(&summary.ID, &summary.Title, &summary.CreatedAt, &updatedAt, &summary.MessageCount, &summary.ApproxBytes, &modelName); err != nil {
-			return nil, fmt.Errorf("scan chat summary: %w", err)
-		}
-		if modelName.Valid {
-			summary.Model = modelName.String
-		}
-		summary.UpdatedAt, err = parseAgentSQLiteTime(updatedAt)
-		if err != nil {
-			return nil, fmt.Errorf("parse chat updated_at: %w", err)
-		}
-		summaries = append(summaries, summary)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("read chat summaries: %w", err)
-	}
-
-	return summaries, nil
-}
-
-func (s *Store) ListUserMessages(ctx context.Context, limit int) ([]string, error) {
-	if err := s.ensureDB(); err != nil {
-		return nil, err
-	}
-	if limit <= 0 {
-		limit = 50
-	}
-
-	rows, err := s.db.conn.QueryContext(ctx, `
-		SELECT content
-		FROM (
-			SELECT id, content
-			FROM messages
-			WHERE role = 'user'
-				AND archived = 0
-				AND TRIM(content) != ''
-				AND content NOT LIKE ?
-			ORDER BY id DESC
-			LIMIT ?
-		)
-		ORDER BY id ASC
-	`, agent.CompactionSummaryMessagePrefix+"%", limit)
-	if err != nil {
-		return nil, fmt.Errorf("list user messages: %w", err)
-	}
-	defer rows.Close()
-
-	var messages []string
-	for rows.Next() {
-		var content string
-		if err := rows.Scan(&content); err != nil {
-			return nil, fmt.Errorf("scan user message: %w", err)
-		}
-		messages = append(messages, content)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("read user messages: %w", err)
-	}
-	return messages, nil
-}
-
-func (s *Store) ArchiveForCompaction(ctx context.Context, chatID string, keepUserTurns int, summary string, continueTask bool) error {
-	return s.archiveForCompaction(ctx, chatID, keepUserTurns, summary, continueTask)
-}
-
-func (s *Store) archiveForCompaction(ctx context.Context, chatID string, keepUserTurns int, summary string, continueTask bool) error {
-	if err := s.ensureDB(); err != nil {
-		return err
-	}
-	if chatID == "" {
-		return fmt.Errorf("chat id is required")
-	}
-	if keepUserTurns < 0 {
-		return fmt.Errorf("keep user turns must be non-negative")
-	}
-	if strings.TrimSpace(summary) == "" {
-		return fmt.Errorf("summary is required")
-	}
-
-	tx, err := s.db.conn.BeginTx(ctx, nil)
-	if err != nil {
-		return fmt.Errorf("begin transaction: %w", err)
-	}
-	defer tx.Rollback()
-
-	var keepStartID int64
-	if keepUserTurns == 0 {
-		if err := tx.QueryRowContext(ctx, `
-			SELECT COALESCE(MAX(id) + 1, 0)
-			FROM messages
-			WHERE chat_id = ? AND archived = 0
-		`, chatID).Scan(&keepStartID); err != nil {
-			return fmt.Errorf("find compaction boundary: %w", err)
-		}
-		if keepStartID == 0 {
-			return nil
-		}
-	} else {
-		if err := tx.QueryRowContext(ctx, `
-			SELECT id
-			FROM messages
-			WHERE chat_id = ? AND archived = 0 AND role = 'user'
-			ORDER BY id DESC
-			LIMIT 1 OFFSET ?
-		`, chatID, keepUserTurns-1).Scan(&keepStartID); err != nil {
-			if errors.Is(err, sql.ErrNoRows) {
-				return nil
-			}
-			return fmt.Errorf("find compaction boundary: %w", err)
-		}
-	}
-
-	rows, err := tx.QueryContext(ctx, `
-		SELECT m.id
-		FROM messages m
-		WHERE m.chat_id = ? AND m.archived = 0 AND (
-			m.id < ?
-			OR m.tool_name = ?
-			OR EXISTS (
-				SELECT 1 FROM tool_calls tc
-				WHERE tc.message_id = m.id AND tc.function_name = ?
-			)
-		)
-		ORDER BY id ASC
-	`, chatID, keepStartID, agent.CompactionToolName, agent.CompactionToolName)
-	if err != nil {
-		return fmt.Errorf("list archived messages: %w", err)
-	}
-	var archivedIDs []int64
-	for rows.Next() {
-		var id int64
-		if err := rows.Scan(&id); err != nil {
-			rows.Close()
-			return fmt.Errorf("scan archived message id: %w", err)
-		}
-		archivedIDs = append(archivedIDs, id)
-	}
-	if err := rows.Err(); err != nil {
-		rows.Close()
-		return fmt.Errorf("read archived message ids: %w", err)
-	}
-	rows.Close()
-	if len(archivedIDs) == 0 {
-		return nil
-	}
-
-	idsJSON, err := json.Marshal(archivedIDs)
-	if err != nil {
-		return fmt.Errorf("marshal archived message ids: %w", err)
-	}
-
-	if _, err := tx.ExecContext(ctx, `
-		INSERT INTO compactions (chat_id, summary, archived_message_ids, created_at)
-		VALUES (?, ?, ?, ?)
-	`, chatID, summary, string(idsJSON), time.Now()); err != nil {
-		return fmt.Errorf("insert compaction: %w", err)
-	}
-
-	if _, err := tx.ExecContext(ctx, `
-		UPDATE messages
-		SET archived = 1
-			WHERE chat_id = ? AND archived = 0 AND (
-				id < ?
-				OR tool_name = ?
-				OR EXISTS (
-					SELECT 1 FROM tool_calls
-					WHERE tool_calls.message_id = messages.id AND tool_calls.function_name = ?
-				)
-			)
-		`, chatID, keepStartID, agent.CompactionToolName, agent.CompactionToolName); err != nil {
-		return fmt.Errorf("archive messages: %w", err)
-	}
-
-	for _, msg := range agent.CompactionSummaryMessages(summary, continueTask) {
-		messageID, err := insertAgentMessage(ctx, tx, chatID, msg, "")
-		if err != nil {
-			return err
-		}
-		for _, toolCall := range msg.ToolCalls {
-			if err := insertAgentToolCall(ctx, tx, messageID, toolCall); err != nil {
-				return err
-			}
-		}
-	}
-
-	return tx.Commit()
-}
-
-func parseAgentSQLiteTime(value string) (time.Time, error) {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return time.Time{}, nil
-	}
-	for _, layout := range []string{
-		time.RFC3339Nano,
-		"2006-01-02 15:04:05.999999999-07:00",
-		"2006-01-02 15:04:05.999999999Z07:00",
-		"2006-01-02 15:04:05.999999999",
-		"2006-01-02 15:04:05-07:00",
-		"2006-01-02 15:04:05Z07:00",
-		"2006-01-02 15:04:05",
-	} {
-		t, err := time.Parse(layout, value)
-		if err == nil {
-			return t, nil
-		}
-	}
-	return time.Time{}, fmt.Errorf("unsupported time format %q", value)
-}
-
-func latestAgentModelForChat(ctx context.Context, db *sql.DB, chatID string) (string, error) {
-	var modelName string
-	if err := db.QueryRowContext(ctx, `
-		SELECT model_name
-		FROM messages
-		WHERE chat_id = ? AND archived = 0 AND model_name IS NOT NULL AND model_name != ''
-		ORDER BY updated_at DESC, id DESC
-		LIMIT 1
-	`, chatID).Scan(&modelName); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return "", nil
-		}
-		return "", err
-	}
-	return modelName, nil
-}
-
-func currentAgentModelSelectExpr(chatAlias string) string {
-	return fmt.Sprintf(`COALESCE(
-				NULLIF(%[1]s.model_name, ''),
-				(
-					SELECT lm.model_name
-					FROM messages lm
-					WHERE lm.chat_id = %[1]s.id AND lm.archived = 0 AND lm.model_name IS NOT NULL AND lm.model_name != ''
-					ORDER BY lm.updated_at DESC, lm.id DESC
-					LIMIT 1
-				)
-			)`, chatAlias)
-}
-
-func messagesContainCompactionSummary(messages []api.Message) bool {
-	for _, msg := range messages {
-		if agent.IsCompactionSummary(msg) {
-			return true
-		}
-	}
-	return false
-}
-
-func moveCompactionSummaryBeforeKeptMessages(messages []api.Message) []api.Message {
-	start := -1
-	end := -1
-	for i, msg := range messages {
-		if agent.IsCompactionToolCall(msg) {
-			start = i
-			end = i + 1
-			if end < len(messages) && agent.IsCompactionToolResult(messages[end]) {
-				end++
-			}
-		}
-		if start >= 0 {
-			break
-		}
-	}
-	if start <= 0 || end <= start {
-		return messages
-	}
-
-	insertAt := leadingSystemMessageCount(messages[:start])
-	reordered := make([]api.Message, 0, len(messages))
-	reordered = append(reordered, messages[:insertAt]...)
-	reordered = append(reordered, messages[start:end]...)
-	reordered = append(reordered, messages[insertAt:start]...)
-	reordered = append(reordered, messages[end:]...)
-	return reordered
-}
-
-func insertCompactionSummaryAfterLeadingSystemMessages(messages, summary []api.Message) []api.Message {
-	insertAt := leadingSystemMessageCount(messages)
-	reordered := make([]api.Message, 0, len(messages)+len(summary))
-	reordered = append(reordered, messages[:insertAt]...)
-	reordered = append(reordered, summary...)
-	reordered = append(reordered, messages[insertAt:]...)
-	return reordered
-}
-
-func leadingSystemMessageCount(messages []api.Message) int {
-	for i, msg := range messages {
-		if msg.Role != "system" {
-			return i
-		}
-	}
-	return len(messages)
-}
-
-type pendingToolCall struct {
-	key  string
-	call api.ToolCall
-}
-
-func repairDanglingToolCalls(messages []api.Message) []api.Message {
-	var pending []pendingToolCall
-	pendingByKey := map[string]struct{}{}
-	repaired := make([]api.Message, 0, len(messages))
-
-	flushPending := func() {
-		for _, pendingCall := range pending {
-			if _, ok := pendingByKey[pendingCall.key]; !ok {
-				continue
-			}
-			repaired = append(repaired, api.Message{
-				Role:       "tool",
-				Content:    "Tool execution interrupted before a result was recorded.",
-				ToolName:   pendingCall.call.Function.Name,
-				ToolCallID: pendingCall.call.ID,
-			})
-		}
-		pending = nil
-		pendingByKey = map[string]struct{}{}
-	}
-
-	for _, msg := range messages {
-		if len(pendingByKey) > 0 && msg.Role != "tool" {
-			flushPending()
-		}
-
-		repaired = append(repaired, msg)
-
-		switch msg.Role {
-		case "assistant":
-			for _, call := range msg.ToolCalls {
-				key := agentToolCallKey(call, len(pending))
-				pending = append(pending, pendingToolCall{key: key, call: call})
-				pendingByKey[key] = struct{}{}
-			}
-		case "tool":
-			if key := msg.ToolCallID; key != "" {
-				delete(pendingByKey, key)
-			} else if msg.ToolName != "" {
-				for _, pendingCall := range pending {
-					if pendingCall.call.ID == "" && pendingCall.call.Function.Name == msg.ToolName {
-						delete(pendingByKey, pendingCall.key)
-						break
-					}
-				}
-			}
-			if len(pendingByKey) == 0 {
-				pending = nil
-			}
-		}
-	}
-	if len(pendingByKey) > 0 {
-		flushPending()
-	}
-
-	return repaired
-}
-
-func agentToolCallKey(call api.ToolCall, index int) string {
-	if call.ID != "" {
-		return call.ID
-	}
-	return fmt.Sprintf("#%d:%s", index, call.Function.Name)
-}
-
-func insertAgentMessage(ctx context.Context, tx *sql.Tx, chatID string, msg api.Message, model string) (int64, error) {
-	now := time.Now()
-	modelName := sql.NullString{}
-	if model != "" {
-		modelName = sql.NullString{String: model, Valid: true}
-	}
-	imagesJSON, err := marshalAgentMessageImages(msg.Images)
-	if err != nil {
-		return 0, err
-	}
-	result, err := tx.ExecContext(ctx, `
-		INSERT INTO messages (chat_id, role, content, thinking, images, tool_name, tool_call_id, model_name, created_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-	`, chatID, msg.Role, msg.Content, msg.Thinking, imagesJSON, msg.ToolName, msg.ToolCallID, modelName, now, now)
-	if err != nil {
-		return 0, fmt.Errorf("insert message: %w", err)
-	}
-	id, err := result.LastInsertId()
-	if err != nil {
-		return 0, fmt.Errorf("get message id: %w", err)
-	}
-	return id, nil
-}
-
-func marshalAgentMessageImages(images []api.ImageData) (string, error) {
-	if len(images) == 0 {
-		return "[]", nil
-	}
-	data, err := json.Marshal(images)
-	if err != nil {
-		return "", fmt.Errorf("marshal message images: %w", err)
-	}
-	return string(data), nil
-}
-
-func unmarshalAgentMessageImages(value string) ([]api.ImageData, error) {
-	value = strings.TrimSpace(value)
-	if value == "" || value == "null" {
-		return nil, nil
-	}
-	var images []api.ImageData
-	if err := json.Unmarshal([]byte(value), &images); err != nil {
-		return nil, fmt.Errorf("unmarshal message images: %w", err)
-	}
-	return images, nil
-}
-
-func insertAgentToolCall(ctx context.Context, tx *sql.Tx, messageID int64, call api.ToolCall) error {
-	args, err := json.Marshal(call.Function.Arguments)
-	if err != nil {
-		return fmt.Errorf("marshal tool arguments: %w", err)
-	}
-	_, err = tx.ExecContext(ctx, `
-		INSERT INTO tool_calls (message_id, type, tool_call_id, function_name, function_arguments)
-		VALUES (?, ?, ?, ?, ?)
-	`, messageID, "function", call.ID, call.Function.Name, string(args))
-	if err != nil {
-		return fmt.Errorf("insert tool call: %w", err)
-	}
-	return nil
-}
-
-func getAgentToolCalls(ctx context.Context, db *sql.DB, messageID int64) ([]api.ToolCall, error) {
-	rows, err := db.QueryContext(ctx, `
-		SELECT tool_call_id, function_name, function_arguments FROM tool_calls WHERE message_id = ? ORDER BY id ASC
-	`, messageID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var calls []api.ToolCall
-	for rows.Next() {
-		var id, name, argsJSON string
-		if err := rows.Scan(&id, &name, &argsJSON); err != nil {
-			return nil, err
-		}
-		var args api.ToolCallFunctionArguments
-		if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
-			return nil, err
-		}
-		calls = append(calls, api.ToolCall{
-			ID: id,
-			Function: api.ToolCallFunction{
-				Name:      name,
-				Arguments: args,
-			},
-		})
-	}
-	return calls, rows.Err()
-}
-
-func latestCompactionSummary(ctx context.Context, db *sql.DB, chatID string) (string, error) {
-	var summary string
-	if err := db.QueryRowContext(ctx, `
-		SELECT summary
-		FROM compactions
-		WHERE chat_id = ?
-		ORDER BY id DESC
-		LIMIT 1
-	`, chatID).Scan(&summary); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return "", nil
-		}
-		return "", fmt.Errorf("get latest compaction summary: %w", err)
-	}
-	return summary, nil
-}
-
-func maybeSetAgentTitle(ctx context.Context, tx *sql.Tx, chatID string, content string) error {
-	title := strings.TrimSpace(content)
-	if len([]rune(title)) > 64 {
-		title = string([]rune(title)[:64])
-	}
-	_, err := tx.ExecContext(ctx, `
-		UPDATE chats
-		SET title = CASE WHEN title = '' THEN ? ELSE title END
-		WHERE id = ?
-	`, title, chatID)
-	return err
-}

agent/store/store_test.go

@@ -1,466 +0,0 @@
-package store
-
-import (
-	"bytes"
-	"context"
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-)
-
-func newTestAgentStore(t *testing.T) *Store {
-	t.Helper()
-	t.Setenv("HOME", t.TempDir())
-	t.Setenv("LOCALAPPDATA", t.TempDir())
-	store, err := New(filepath.Join(t.TempDir(), "db.sqlite"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() {
-		if err := store.Close(); err != nil {
-			t.Fatal(err)
-		}
-	})
-	return store
-}
-
-func TestAgentStoreWritesSharedChatRows(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	if err := store.EnsureChat(ctx, "chat-1", ""); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{Role: "user", Content: "hello from cli"}, ""); err != nil {
-		t.Fatal(err)
-	}
-
-	args := api.NewToolCallFunctionArguments()
-	args.Set("command", "pwd")
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{
-		Role:    "assistant",
-		Content: "I'll check.",
-		ToolCalls: []api.ToolCall{{
-			ID: "call-1",
-			Function: api.ToolCallFunction{
-				Name:      "bash",
-				Arguments: args,
-			},
-		}},
-	}, "llama3.2"); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{
-		Role:       "tool",
-		Content:    "cwd",
-		ToolName:   "bash",
-		ToolCallID: "call-1",
-	}, ""); err != nil {
-		t.Fatal(err)
-	}
-
-	agentChat, err := store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(agentChat.Messages) != 3 {
-		t.Fatalf("messages = %d, want 3", len(agentChat.Messages))
-	}
-	if agentChat.Title != "hello from cli" {
-		t.Fatalf("title = %q, want %q", agentChat.Title, "hello from cli")
-	}
-	if got := agentChat.Messages[1].ToolCalls[0].Function.Name; got != "bash" {
-		t.Fatalf("tool name = %q, want bash", got)
-	}
-	if got := agentChat.Messages[1].ToolCalls[0].ID; got != "call-1" {
-		t.Fatalf("tool call id = %q, want call-1", got)
-	}
-	if agentChat.Messages[2].Role != "tool" || agentChat.Messages[2].ToolCallID != "call-1" {
-		t.Fatalf("tool result = %#v", agentChat.Messages[2])
-	}
-
-	var source string
-	if err := store.db.conn.QueryRowContext(ctx, `SELECT source FROM chats WHERE id = ?`, "chat-1").Scan(&source); err != nil {
-		t.Fatal(err)
-	}
-	if source != "agent" {
-		t.Fatalf("source = %q, want agent", source)
-	}
-}
-
-func TestAgentStoreRepairsDanglingToolCallsOnResume(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	args := api.NewToolCallFunctionArguments()
-	args.Set("command", "pwd")
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{Role: "user", Content: "start"}, ""); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{
-		Role: "assistant",
-		ToolCalls: []api.ToolCall{{
-			ID: "call-1",
-			Function: api.ToolCallFunction{
-				Name:      "bash",
-				Arguments: args,
-			},
-		}},
-	}, "llama3.2"); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{Role: "user", Content: "after restart"}, ""); err != nil {
-		t.Fatal(err)
-	}
-
-	agentChat, err := store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(agentChat.Messages) != 4 {
-		t.Fatalf("messages = %#v, want synthetic tool result inserted", agentChat.Messages)
-	}
-	repair := agentChat.Messages[2]
-	if repair.Role != "tool" || repair.ToolName != "bash" || repair.ToolCallID != "call-1" || !strings.Contains(repair.Content, "interrupted") {
-		t.Fatalf("repair message = %#v", repair)
-	}
-	if agentChat.Messages[3].Role != "user" || agentChat.Messages[3].Content != "after restart" {
-		t.Fatalf("message after repair = %#v", agentChat.Messages[3])
-	}
-}
-
-func TestAgentStoreRoundTripsToolMetadataAndImages(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	first := api.ImageData([]byte("first image"))
-	second := api.ImageData([]byte{0, 1, 2, 3})
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{
-		Role:       "tool",
-		Content:    "tool output",
-		Images:     []api.ImageData{first, second},
-		ToolName:   "bash",
-		ToolCallID: "call-1",
-	}, ""); err != nil {
-		t.Fatal(err)
-	}
-
-	chat, err := store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(chat.Messages) != 1 {
-		t.Fatalf("messages = %d, want 1", len(chat.Messages))
-	}
-	msg := chat.Messages[0]
-	if msg.ToolName != "bash" || msg.ToolCallID != "call-1" {
-		t.Fatalf("tool metadata = %#v", msg)
-	}
-	if len(msg.Images) != 2 || !bytes.Equal(msg.Images[0], first) || !bytes.Equal(msg.Images[1], second) {
-		t.Fatalf("images = %#v, want %#v", msg.Images, []api.ImageData{first, second})
-	}
-
-	updated := api.ImageData([]byte("updated image"))
-	if err := store.UpdateLastAgentMessage(ctx, "chat-1", api.Message{
-		Role:    "user",
-		Content: "updated",
-		Images:  []api.ImageData{updated},
-	}, ""); err != nil {
-		t.Fatal(err)
-	}
-	chat, err = store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(chat.Messages) != 1 || len(chat.Messages[0].Images) != 1 || !bytes.Equal(chat.Messages[0].Images[0], updated) {
-		t.Fatalf("updated images = %#v", chat.Messages)
-	}
-}
-
-func TestAgentStoreLatestAndListChats(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	if err := store.AppendAgentMessage(ctx, "chat-old", api.Message{Role: "user", Content: "old topic"}, ""); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-old", api.Message{Role: "assistant", Content: "old answer"}, "llama3.2"); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-new", api.Message{Role: "user", Content: "new topic"}, ""); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.AppendAgentMessage(ctx, "chat-new", api.Message{Role: "assistant", Content: "new answer"}, "qwen3"); err != nil {
-		t.Fatal(err)
-	}
-
-	chat, err := store.LatestChat(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if chat.ID != "chat-new" || chat.Model != "qwen3" {
-		t.Fatalf("latest chat = %#v, want chat-new with qwen3", chat)
-	}
-
-	chat, err = store.LatestChatForModel(ctx, "llama3.2")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if chat.ID != "chat-old" {
-		t.Fatalf("llama latest chat = %q, want chat-old", chat.ID)
-	}
-	if _, err := store.LatestChatForModel(ctx, "missing"); !errors.Is(err, sql.ErrNoRows) {
-		t.Fatalf("missing model err = %v, want sql.ErrNoRows", err)
-	}
-
-	summaries, err := store.ListChats(ctx, 10)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(summaries) != 2 {
-		t.Fatalf("summaries = %d, want 2", len(summaries))
-	}
-	if summaries[0].ID != "chat-new" || summaries[0].Title != "new topic" || summaries[0].Model != "qwen3" {
-		t.Fatalf("newest summary = %#v", summaries[0])
-	}
-	if summaries[1].ID != "chat-old" || summaries[1].Model != "llama3.2" {
-		t.Fatalf("older summary = %#v", summaries[1])
-	}
-
-	future := time.Date(2099, 1, 1, 12, 0, 0, 0, time.UTC)
-	if _, err := store.db.conn.ExecContext(ctx, `
-		INSERT INTO chats (id, title, created_at)
-		VALUES (?, ?, ?)
-	`, "chat-archived", "archived topic", future); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := store.db.conn.ExecContext(ctx, `
-		INSERT INTO messages (chat_id, role, content, model_name, created_at, updated_at, archived)
-		VALUES (?, ?, ?, ?, ?, ?, 1)
-	`, "chat-archived", "assistant", "archived answer", "ghost-model", future, future); err != nil {
-		t.Fatal(err)
-	}
-
-	chat, err = store.LatestChat(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if chat.ID != "chat-new" {
-		t.Fatalf("latest chat = %q, want chat-new after archived future row", chat.ID)
-	}
-	if _, err := store.LatestChatForModel(ctx, "ghost-model"); !errors.Is(err, sql.ErrNoRows) {
-		t.Fatalf("archived model err = %v, want sql.ErrNoRows", err)
-	}
-	summaries, err = store.ListChats(ctx, 10)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(summaries) != 2 {
-		t.Fatalf("summaries = %d, want archived-only chat hidden", len(summaries))
-	}
-}
-
-func TestAgentStoreUpdateLastMessageIgnoresArchivedRows(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{Role: "assistant", Content: "active"}, "llama3.2"); err != nil {
-		t.Fatal(err)
-	}
-
-	future := time.Date(2099, 1, 1, 12, 0, 0, 0, time.UTC)
-	if _, err := store.db.conn.ExecContext(ctx, `
-		INSERT INTO messages (chat_id, role, content, created_at, updated_at, archived)
-		VALUES (?, ?, ?, ?, ?, 1)
-	`, "chat-1", "assistant", "archived", future, future); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := store.UpdateLastAgentMessage(ctx, "chat-1", api.Message{Role: "assistant", Content: "active updated"}, "llama3.2"); err != nil {
-		t.Fatal(err)
-	}
-
-	chat, err := store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(chat.Messages) != 1 || chat.Messages[0].Content != "active updated" {
-		t.Fatalf("active messages = %#v, want updated active message only", chat.Messages)
-	}
-
-	var archivedContent string
-	if err := store.db.conn.QueryRowContext(ctx, `
-		SELECT content
-		FROM messages
-		WHERE chat_id = ? AND archived = 1
-		ORDER BY id DESC
-		LIMIT 1
-	`, "chat-1").Scan(&archivedContent); err != nil {
-		t.Fatal(err)
-	}
-	if archivedContent != "archived" {
-		t.Fatalf("archived content = %q, want archived", archivedContent)
-	}
-}
-
-func TestAgentStoreListUserMessages(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	for _, msg := range []api.Message{
-		{Role: "user", Content: "old prompt"},
-		{Role: "assistant", Content: "not user"},
-		{Role: "user", Content: "middle prompt"},
-		{Role: "user", Content: "   "},
-		{Role: "user", Content: agent.CompactionSummaryMessagePrefix + "old context"},
-		{Role: "user", Content: "new prompt"},
-	} {
-		if err := store.AppendAgentMessage(ctx, "chat-1", msg, ""); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	if _, err := store.db.conn.ExecContext(ctx, `UPDATE messages SET archived = 1 WHERE content = ?`, "middle prompt"); err != nil {
-		t.Fatal(err)
-	}
-
-	messages, err := store.ListUserMessages(ctx, 2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := []string{"old prompt", "new prompt"}
-	if !slices.Equal(messages, want) {
-		t.Fatalf("messages = %#v, want %#v", messages, want)
-	}
-}
-
-func TestAgentStoreRepairsPreAgentSchema(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "db.sqlite")
-	db, err := sql.Open("sqlite3", path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := db.Exec(`
-		CREATE TABLE chats (
-			id TEXT PRIMARY KEY,
-			title TEXT NOT NULL DEFAULT '',
-			created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			browser_state TEXT
-		);
-		CREATE TABLE messages (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			chat_id TEXT NOT NULL,
-			role TEXT NOT NULL,
-			content TEXT NOT NULL DEFAULT '',
-			thinking TEXT NOT NULL DEFAULT '',
-			stream BOOLEAN NOT NULL DEFAULT 0,
-			model_name TEXT,
-			created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
-		);
-		CREATE TABLE tool_calls (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			message_id INTEGER NOT NULL,
-			type TEXT NOT NULL,
-			function_name TEXT NOT NULL,
-			function_arguments TEXT NOT NULL,
-			function_result TEXT,
-			FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
-		);
-	`); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	store, err := New(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() {
-		if err := store.Close(); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	ctx := context.Background()
-	if err := store.AppendAgentMessage(ctx, "chat-1", api.Message{Role: "user", Content: "hello"}, "llama3.2"); err != nil {
-		t.Fatal(err)
-	}
-	chat, err := store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if chat.Model != "llama3.2" || len(chat.Messages) != 1 || chat.Messages[0].Content != "hello" {
-		t.Fatalf("chat = %#v", chat)
-	}
-
-	var source string
-	if err := store.db.conn.QueryRowContext(ctx, `SELECT source FROM chats WHERE id = ?`, "chat-1").Scan(&source); err != nil {
-		t.Fatal(err)
-	}
-	if source != "agent" {
-		t.Fatalf("source = %q, want agent", source)
-	}
-}
-
-func TestAgentStoreArchivesCompactedMessages(t *testing.T) {
-	store := newTestAgentStore(t)
-	ctx := context.Background()
-
-	for _, msg := range []api.Message{
-		{Role: "user", Content: "old request"},
-		{Role: "assistant", Content: "old answer"},
-		{Role: "user", Content: "recent request"},
-	} {
-		if err := store.AppendAgentMessage(ctx, "chat-1", msg, ""); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	if err := store.ArchiveForCompaction(ctx, "chat-1", 1, "summary", true); err != nil {
-		t.Fatal(err)
-	}
-
-	agentChat, err := store.AgentChat(ctx, "chat-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(agentChat.Messages) != 3 {
-		t.Fatalf("active messages = %#v, want compaction pair plus latest request", agentChat.Messages)
-	}
-	if agentChat.Messages[0].Role != "assistant" || len(agentChat.Messages[0].ToolCalls) != 1 || agentChat.Messages[0].ToolCalls[0].Function.Name != agent.CompactionToolName {
-		t.Fatalf("summary tool call = %#v", agentChat.Messages[0])
-	}
-	content := agentChat.Messages[1].Content
-	if !strings.Contains(content, agent.CompactionContinueInstruction) {
-		t.Fatalf("summary tool result missing continuation instruction: %q", content)
-	}
-	if agentChat.Messages[2].Content != "recent request" {
-		t.Fatalf("kept message = %#v, want recent request", agentChat.Messages[2])
-	}
-
-	var idsJSON string
-	if err := store.db.conn.QueryRowContext(ctx, `
-		SELECT archived_message_ids FROM compactions WHERE chat_id = ?
-	`, "chat-1").Scan(&idsJSON); err != nil {
-		t.Fatal(err)
-	}
-	var ids []int64
-	if err := json.Unmarshal([]byte(idsJSON), &ids); err != nil {
-		t.Fatal(err)
-	}
-	if len(ids) != 2 {
-		t.Fatalf("archived ids = %v, want 2 ids", ids)
-	}
-}

agent/tool_display.go

@@ -1,91 +0,0 @@
-package agent
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-const maxToolInvocationCommandRunes = 100
-
-// ToolDisplayName returns the user-facing label for a tool name.
-func ToolDisplayName(name string) string {
-	switch name {
-	case "web_search":
-		return "Web Search"
-	case "web_fetch":
-		return "Web Fetch"
-	case "bash":
-		return "Bash"
-	case "powershell":
-		return "PowerShell"
-	case "read":
-		return "Read"
-	case "list":
-		return "List"
-	case "edit":
-		return "Edit"
-	case "skill":
-		return "Skill"
-	default:
-		if name == "" {
-			return "Tool"
-		}
-		return name
-	}
-}
-
-// ToolInvocationLabel returns a compact user-facing label for a tool call.
-func ToolInvocationLabel(name string, args map[string]any) string {
-	displayName := ToolDisplayName(name)
-	for _, key := range []string{"query", "url", "command", "path", "name"} {
-		if value, ok := displayStringArg(args, key); ok {
-			if IsShellToolName(name) && key == "command" {
-				value = truncateDisplayRunes(value, maxToolInvocationCommandRunes)
-			}
-			return fmt.Sprintf("%s(%s)", displayName, strconv.Quote(value))
-		}
-	}
-	if len(args) == 0 {
-		return displayName
-	}
-	return fmt.Sprintf("%s(%s)", displayName, formatDisplayArgs(args))
-}
-
-// IsShellToolName reports whether name identifies a platform shell tool.
-func IsShellToolName(name string) bool {
-	return name == "bash" || name == "powershell"
-}
-
-func displayStringArg(args map[string]any, key string) (string, bool) {
-	value, ok := args[key].(string)
-	if !ok || strings.TrimSpace(value) == "" {
-		return "", false
-	}
-	return value, true
-}
-
-func truncateDisplayRunes(value string, limit int) string {
-	runes := []rune(value)
-	if limit <= 0 || len(runes) <= limit {
-		return value
-	}
-	return string(runes[:limit]) + "..."
-}
-
-func formatDisplayArgs(args map[string]any) string {
-	keys := make([]string, 0, len(args))
-	for key := range args {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-
-	parts := make([]string, 0, len(keys))
-	for _, key := range keys {
-		value := fmt.Sprintf("%v", args[key])
-		value = truncateDisplayRunes(value, 100)
-		parts = append(parts, fmt.Sprintf("%s=%s", key, strconv.Quote(value)))
-	}
-	return strings.Join(parts, ", ")
-}

agent/tool_display_test.go

@@ -1,33 +0,0 @@
-package agent
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestToolInvocationLabelTruncatesLongBashCommand(t *testing.T) {
-	command := strings.Repeat("a", 101)
-	label := ToolInvocationLabel("bash", map[string]any{"command": command})
-	want := `Bash("` + strings.Repeat("a", 100) + `...")`
-	if label != want {
-		t.Fatalf("label = %q, want %q", label, want)
-	}
-}
-
-func TestToolInvocationLabelCountsRunes(t *testing.T) {
-	command := strings.Repeat("界", 101)
-	label := ToolInvocationLabel("bash", map[string]any{"command": command})
-	want := `Bash("` + strings.Repeat("界", 100) + `...")`
-	if label != want {
-		t.Fatalf("label = %q, want %q", label, want)
-	}
-}
-
-func TestToolInvocationLabelTruncatesLongPowerShellCommand(t *testing.T) {
-	command := strings.Repeat("a", 101)
-	label := ToolInvocationLabel("powershell", map[string]any{"command": command})
-	want := `PowerShell("` + strings.Repeat("a", 100) + `...")`
-	if label != want {
-		t.Fatalf("label = %q, want %q", label, want)
-	}
-}

agent/tools/bash.go

@@ -1,201 +0,0 @@
-package tools
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-)
-
-const (
-	bashTimeout        = 3 * time.Minute
-	maxBashOutputBytes = 60_000
-)
-
-type Bash struct{}
-
-func NewBash() *Bash {
-	return &Bash{}
-}
-
-func (b *Bash) Name() string {
-	return shellToolName()
-}
-
-func (b *Bash) Description() string {
-	return shellToolDescription()
-}
-
-func (b *Bash) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("command", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: shellCommandDescription(),
-	})
-	return api.ToolFunction{
-		Name:        b.Name(),
-		Description: b.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"command"},
-		},
-	}
-}
-
-func (b *Bash) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (b *Bash) Execute(ctx context.Context, toolCtx agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	command, ok := args["command"].(string)
-	if !ok || strings.TrimSpace(command) == "" {
-		return agent.ToolResult{}, fmt.Errorf("command parameter is required")
-	}
-
-	ctx, cancel := context.WithTimeout(ctx, bashTimeout)
-	defer cancel()
-
-	cwdFile, err := os.CreateTemp("", "ollama-agent-cwd-*")
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	cwdPath := cwdFile.Name()
-	_ = cwdFile.Close()
-	defer os.Remove(cwdPath)
-
-	cmd := newBashCommand(ctx, command, cwdPath)
-	cmd.Cancel = func() error {
-		return killBashCommand(cmd)
-	}
-	if toolCtx.WorkingDir != "" {
-		cmd.Dir = toolCtx.WorkingDir
-	}
-
-	var stdout, stderr boundedOutput
-	stdout.Limit = maxBashOutputBytes
-	stderr.Limit = maxBashOutputBytes
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	err = runBashCommand(cmd)
-	finalWorkingDir := readFinalWorkingDir(cwdPath)
-
-	var sb strings.Builder
-	if stdout.Len() > 0 {
-		sb.WriteString(stdout.String("stdout"))
-	}
-	if stderr.Len() > 0 {
-		if sb.Len() > 0 {
-			sb.WriteString("\n")
-		}
-		sb.WriteString("stderr:\n")
-		sb.WriteString(stderr.String("stderr"))
-	}
-
-	if err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
-			return agent.ToolResult{Content: sb.String() + "\n\nError: command timed out after " + bashTimeout.String(), WorkingDir: finalWorkingDir}, nil
-		}
-		if ctx.Err() == context.Canceled {
-			return agent.ToolResult{Content: sb.String() + "\n\nError: command was canceled", WorkingDir: finalWorkingDir}, nil
-		}
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return agent.ToolResult{Content: sb.String() + fmt.Sprintf("\n\nExit code: %d", exitErr.ExitCode()), WorkingDir: finalWorkingDir}, nil
-		}
-		return agent.ToolResult{Content: sb.String(), WorkingDir: finalWorkingDir}, fmt.Errorf("executing command: %w", err)
-	}
-
-	if sb.Len() == 0 {
-		return agent.ToolResult{Content: "(no output)", WorkingDir: finalWorkingDir}, nil
-	}
-	return agent.ToolResult{Content: sb.String(), WorkingDir: finalWorkingDir}, nil
-}
-
-func readFinalWorkingDir(path string) string {
-	content, err := os.ReadFile(path)
-	if err != nil {
-		return ""
-	}
-	workingDir := strings.TrimPrefix(string(content), "\ufeff")
-	workingDir = strings.TrimSpace(workingDir)
-	if workingDir == "" {
-		return ""
-	}
-	workingDir = normalizeBashWorkingDir(workingDir)
-	info, err := os.Stat(workingDir)
-	if err != nil || !info.IsDir() {
-		return ""
-	}
-	return workingDir
-}
-
-func normalizeBashWorkingDir(workingDir string) string {
-	if runtime.GOOS == "windows" && len(workingDir) >= 3 && workingDir[0] == '/' && workingDir[2] == '/' && isASCIIAlpha(workingDir[1]) {
-		workingDir = strings.ToUpper(string(workingDir[1])) + ":" + workingDir[2:]
-	}
-	workingDir = filepath.Clean(filepath.FromSlash(workingDir))
-	if runtime.GOOS == "windows" && len(workingDir) >= 2 && workingDir[1] == ':' && isASCIIAlpha(workingDir[0]) {
-		workingDir = strings.ToUpper(string(workingDir[0])) + workingDir[1:]
-	}
-	return workingDir
-}
-
-func isASCIIAlpha(b byte) bool {
-	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
-}
-
-func shellQuote(value string) string {
-	return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'"
-}
-
-type boundedOutput struct {
-	Limit   int
-	buf     strings.Builder
-	omitted int
-}
-
-func (b *boundedOutput) Write(p []byte) (int, error) {
-	if b.Limit <= 0 {
-		b.omitted += len(p)
-		return len(p), nil
-	}
-	remaining := b.Limit - b.buf.Len()
-	if remaining <= 0 {
-		b.omitted += len(p)
-		return len(p), nil
-	}
-	if len(p) <= remaining {
-		b.buf.Write(p)
-		return len(p), nil
-	}
-	b.buf.Write(p[:remaining])
-	b.omitted += len(p) - remaining
-	return len(p), nil
-}
-
-func (b *boundedOutput) Len() int {
-	return b.buf.Len() + b.omitted
-}
-
-func (b *boundedOutput) String(label string) string {
-	content := b.buf.String()
-	if b.omitted == 0 {
-		return content
-	}
-	return content + fmt.Sprintf("\n\n[%s truncated: omitted ~%d tokens]", label, approximateTokensFromBytes(b.omitted))
-}
-
-func approximateTokensFromBytes(n int) int {
-	if n <= 0 {
-		return 0
-	}
-	return max(1, (n+3)/4)
-}

agent/tools/bash_test.go

@@ -1,128 +0,0 @@
-package tools
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/ollama/ollama/agent"
-)
-
-func TestBashReportsFinalWorkingDir(t *testing.T) {
-	root := t.TempDir()
-	subdir := filepath.Join(root, "sub")
-	if err := os.Mkdir(subdir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewBash().Execute(context.Background(), agent.ToolContext{WorkingDir: root}, map[string]any{
-		"command": shellTestCommand("cd sub && pwd", "Set-Location sub; Get-Location"),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	wantDir, err := filepath.EvalSymlinks(subdir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.WorkingDir != wantDir {
-		t.Fatalf("working dir = %q, want %q", result.WorkingDir, wantDir)
-	}
-	if !strings.Contains(result.Content, "sub") {
-		t.Fatalf("content = %q, want pwd output", result.Content)
-	}
-}
-
-func TestBashBoundsOutputWhileRunning(t *testing.T) {
-	result, err := NewBash().Execute(context.Background(), agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
-		"command": shellTestCommand("yes x | head -c 70000", "[Console]::Out.Write(('x' * 70000))"),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "[stdout truncated: omitted ~") || !strings.Contains(result.Content, " tokens]") {
-		t.Fatalf("content = %q, want stdout truncation marker", result.Content)
-	}
-	if count, want := strings.Count(result.Content, "x"), shellTestCapturedXCount(); count != want {
-		t.Fatalf("captured x count = %d, want %d", count, want)
-	}
-	if len(result.Content) > maxBashOutputBytes+200 {
-		t.Fatalf("content length = %d, want bounded output", len(result.Content))
-	}
-}
-
-func TestBashReportsCanceledCommand(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	result, err := NewBash().Execute(ctx, agent.ToolContext{WorkingDir: t.TempDir()}, map[string]any{
-		"command": shellTestCommand("sleep 10", "Start-Sleep -Seconds 10"),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "Error: command was canceled") {
-		t.Fatalf("content = %q, want canceled message", result.Content)
-	}
-	if strings.Contains(result.Content, "Exit code: -1") {
-		t.Fatalf("content = %q, should not mask cancellation as exit code", result.Content)
-	}
-}
-
-func shellTestCommand(unix, windows string) string {
-	if runtime.GOOS == "windows" {
-		return windows
-	}
-	return unix
-}
-
-func shellTestCapturedXCount() int {
-	if runtime.GOOS == "windows" {
-		return maxBashOutputBytes
-	}
-	return maxBashOutputBytes / 2
-}
-
-func TestReadFinalWorkingDirRejectsInvalidPaths(t *testing.T) {
-	dir := t.TempDir()
-	cwdFile := filepath.Join(dir, "cwd")
-	notDir := filepath.Join(dir, "file.txt")
-	if err := os.WriteFile(notDir, []byte("not a dir"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := os.WriteFile(cwdFile, []byte(notDir+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if got := readFinalWorkingDir(cwdFile); got != "" {
-		t.Fatalf("regular file cwd = %q, want empty", got)
-	}
-
-	if err := os.WriteFile(cwdFile, []byte(filepath.Join(dir, "missing")+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if got := readFinalWorkingDir(cwdFile); got != "" {
-		t.Fatalf("missing cwd = %q, want empty", got)
-	}
-
-	if err := os.WriteFile(cwdFile, []byte(dir+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if got := readFinalWorkingDir(cwdFile); got != dir {
-		t.Fatalf("directory cwd = %q, want %q", got, dir)
-	}
-}
-
-func TestNormalizeBashWorkingDirWindowsDriveLetter(t *testing.T) {
-	if runtime.GOOS != "windows" {
-		t.Skip("windows path normalization")
-	}
-	got := normalizeBashWorkingDir("/c/Users/jdoe/project")
-	want := filepath.Clean(`C:\Users\jdoe\project`)
-	if got != want {
-		t.Fatalf("working dir = %q, want %q", got, want)
-	}
-}

agent/tools/bash_unix.go

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

agent/tools/bash_unix_test.go

@@ -1,16 +0,0 @@
-//go:build !windows
-
-package tools
-
-import (
-	"os/exec"
-	"testing"
-)
-
-func TestConfigureBashCommandSetsProcessGroup(t *testing.T) {
-	cmd := exec.Command("bash", "-c", "true")
-	configureBashCommand(cmd)
-	if cmd.SysProcAttr == nil || !cmd.SysProcAttr.Setpgid {
-		t.Fatalf("configureBashCommand should start bash in a new process group")
-	}
-}

agent/tools/bash_windows.go

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

agent/tools/file.go

@@ -1,577 +0,0 @@
-package tools
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-)
-
-const (
-	maxReadBytes = 200000
-)
-
-type Read struct{}
-
-func NewRead() *Read {
-	return &Read{}
-}
-
-func (r *Read) Name() string {
-	return "read"
-}
-
-func (r *Read) Description() string {
-	return "Read a text file from the current working directory."
-}
-
-func (r *Read) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("path", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Path to the file to read, relative to the working directory.",
-	})
-	props.Set("start_line", api.ToolProperty{
-		Type:        api.PropertyType{"integer"},
-		Description: "Optional 1-based line to start reading from.",
-	})
-	props.Set("end_line", api.ToolProperty{
-		Type:        api.PropertyType{"integer"},
-		Description: "Optional 1-based inclusive line to stop reading at.",
-	})
-	props.Set("line_count", api.ToolProperty{
-		Type:        api.PropertyType{"integer"},
-		Description: "Optional maximum number of lines to read, starting at start_line or line 1.",
-	})
-	props.Set("line_range", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: `Optional 1-based inclusive range like "10-40", "10:40", "10..40", "10-", or "10".`,
-	})
-	return api.ToolFunction{
-		Name:        r.Name(),
-		Description: r.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"path"},
-		},
-	}
-}
-
-func (r *Read) Execute(ctx context.Context, toolCtx agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	path, ok := args["path"].(string)
-	if !ok || strings.TrimSpace(path) == "" {
-		return agent.ToolResult{}, fmt.Errorf("path parameter is required")
-	}
-
-	file, info, err := openRegularFile(toolCtx.WorkingDir, path)
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	defer file.Close()
-
-	selection, err := readSelectionFromArgs(args)
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	if !selection.enabled && info.Size() > maxReadBytes {
-		return agent.ToolResult{}, fmt.Errorf("%s is too large to read (%d bytes)", path, info.Size())
-	}
-
-	select {
-	case <-ctx.Done():
-		return agent.ToolResult{}, ctx.Err()
-	default:
-	}
-
-	var content string
-	if selection.enabled {
-		content, err = readLineSelection(file, selection)
-	} else {
-		var contentBytes []byte
-		contentBytes, err = io.ReadAll(file)
-		content = string(contentBytes)
-	}
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	return agent.ToolResult{Content: content}, nil
-}
-
-type Edit struct{}
-
-func NewEdit() *Edit {
-	return &Edit{}
-}
-
-func (e *Edit) Name() string {
-	return "edit"
-}
-
-func (e *Edit) Description() string {
-	return "Edit a text file in the current working directory by replacing exact text."
-}
-
-func (e *Edit) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("path", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Path to the file to edit, relative to the working directory.",
-	})
-	props.Set("old_text", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Exact text to replace.",
-	})
-	props.Set("new_text", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Replacement text.",
-	})
-	props.Set("replace_all", api.ToolProperty{
-		Type:        api.PropertyType{"boolean"},
-		Description: "Replace every occurrence. Defaults to false and requires old_text to match exactly once.",
-	})
-	return api.ToolFunction{
-		Name:        e.Name(),
-		Description: e.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"path", "old_text", "new_text"},
-		},
-	}
-}
-
-func (e *Edit) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (e *Edit) Execute(ctx context.Context, toolCtx agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	path, ok := args["path"].(string)
-	if !ok || strings.TrimSpace(path) == "" {
-		return agent.ToolResult{}, fmt.Errorf("path parameter is required")
-	}
-
-	oldText, ok := args["old_text"].(string)
-	if !ok || oldText == "" {
-		return agent.ToolResult{}, fmt.Errorf("old_text parameter is required")
-	}
-
-	newText, ok := args["new_text"].(string)
-	if !ok {
-		return agent.ToolResult{}, fmt.Errorf("new_text parameter is required")
-	}
-
-	replaceAll, _ := args["replace_all"].(bool)
-
-	if err := rejectFinalSymlink(toolCtx.WorkingDir, path); err != nil {
-		return agent.ToolResult{}, err
-	}
-
-	file, info, err := openRegularFile(toolCtx.WorkingDir, path)
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	if info.Size() > maxReadBytes {
-		file.Close()
-		return agent.ToolResult{}, fmt.Errorf("%s is too large to edit (%d bytes)", path, info.Size())
-	}
-
-	select {
-	case <-ctx.Done():
-		file.Close()
-		return agent.ToolResult{}, ctx.Err()
-	default:
-	}
-
-	contentBytes, err := io.ReadAll(file)
-	if closeErr := file.Close(); err == nil && closeErr != nil {
-		err = closeErr
-	}
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	content := string(contentBytes)
-	matches := strings.Count(content, oldText)
-	if matches == 0 {
-		return agent.ToolResult{}, fmt.Errorf("old_text was not found in %s", path)
-	}
-	if matches > 1 && !replaceAll {
-		return agent.ToolResult{}, fmt.Errorf("old_text matched %d times in %s; set replace_all to true to replace every match", matches, path)
-	}
-
-	var updated string
-	if replaceAll {
-		updated = strings.ReplaceAll(content, oldText, newText)
-	} else {
-		updated = strings.Replace(content, oldText, newText, 1)
-	}
-	if len(updated) > maxReadBytes {
-		return agent.ToolResult{}, fmt.Errorf("edited content is too large (%d bytes)", len(updated))
-	}
-
-	if err := writeFileAtomic(toolCtx.WorkingDir, path, []byte(updated), info.Mode().Perm()); err != nil {
-		return agent.ToolResult{}, err
-	}
-
-	return agent.ToolResult{Content: fmt.Sprintf("Updated %s (%d replacement%s).", path, matches, plural(matches))}, nil
-}
-
-func cleanRelativePath(path string) (string, error) {
-	path = strings.TrimSpace(path)
-	if path == "" {
-		return "", fmt.Errorf("path parameter is required")
-	}
-	if filepath.IsAbs(path) {
-		return "", fmt.Errorf("absolute paths are not allowed")
-	}
-	cleaned := filepath.Clean(path)
-	if cleaned == "." || cleaned == ".." || strings.HasPrefix(cleaned, ".."+string(os.PathSeparator)) {
-		return "", fmt.Errorf("path escapes working directory")
-	}
-	return cleaned, nil
-}
-
-func openRegularFile(workingDir, path string) (*os.File, os.FileInfo, error) {
-	rel, err := cleanRelativePath(path)
-	if err != nil {
-		return nil, nil, err
-	}
-	root, err := openWorkingRoot(workingDir)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer root.Close()
-
-	file, err := root.Open(rel)
-	if err != nil {
-		return nil, nil, rootPathError(err)
-	}
-	info, err := file.Stat()
-	if err != nil {
-		file.Close()
-		return nil, nil, err
-	}
-	if info.IsDir() {
-		file.Close()
-		return nil, nil, fmt.Errorf("%s is a directory", path)
-	}
-	return file, info, nil
-}
-
-func writeFileAtomic(workingDir, path string, data []byte, perm os.FileMode) error {
-	rel, err := cleanRelativePath(path)
-	if err != nil {
-		return err
-	}
-	root, err := openWorkingRoot(workingDir)
-	if err != nil {
-		return err
-	}
-	defer root.Close()
-	if err := rejectRootFinalSymlink(root, rel, path); err != nil {
-		return err
-	}
-
-	parent, name := filepath.Split(rel)
-	tmpBase := fmt.Sprintf(".%s.ollama-tmp-%d", name, os.Getpid())
-	for i := 0; ; i++ {
-		candidateName := tmpBase
-		if i > 0 {
-			candidateName = fmt.Sprintf("%s-%d", tmpBase, i)
-		}
-		candidate := filepath.Join(parent, candidateName)
-		file, err := root.OpenFile(candidate, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
-		if os.IsExist(err) {
-			continue
-		}
-		if err != nil {
-			return rootPathError(err)
-		}
-		writeErr := writeAllAndSync(file, data)
-		closeErr := file.Close()
-		if writeErr != nil || closeErr != nil {
-			_ = root.Remove(candidate)
-			if writeErr != nil {
-				return writeErr
-			}
-			return closeErr
-		}
-		if err := root.Rename(candidate, rel); err != nil {
-			_ = root.Remove(candidate)
-			return rootPathError(err)
-		}
-		return nil
-	}
-}
-
-func rejectFinalSymlink(workingDir, path string) error {
-	rel, err := cleanRelativePath(path)
-	if err != nil {
-		return err
-	}
-	root, err := openWorkingRoot(workingDir)
-	if err != nil {
-		return err
-	}
-	defer root.Close()
-	return rejectRootFinalSymlink(root, rel, path)
-}
-
-func rejectRootFinalSymlink(root *os.Root, rel, path string) error {
-	info, err := root.Lstat(rel)
-	if err != nil {
-		return rootPathError(err)
-	}
-	if info.Mode()&os.ModeSymlink != 0 {
-		return fmt.Errorf("%s is a symlink; edit the target file directly", path)
-	}
-	return nil
-}
-
-func rootPathError(err error) error {
-	if err != nil && strings.Contains(err.Error(), "path escapes") {
-		return fmt.Errorf("path escapes working directory")
-	}
-	return err
-}
-
-func openWorkingRoot(workingDir string) (*os.Root, error) {
-	base, err := workingDirAbs(workingDir)
-	if err != nil {
-		return nil, err
-	}
-	return os.OpenRoot(base)
-}
-
-func writeAllAndSync(file *os.File, data []byte) error {
-	if _, err := file.Write(data); err != nil {
-		return err
-	}
-	return file.Sync()
-}
-
-func workingDirAbs(workingDir string) (string, error) {
-	base := workingDir
-	if base == "" {
-		var err error
-		base, err = os.Getwd()
-		if err != nil {
-			return "", err
-		}
-	}
-	return canonicalPath(base)
-}
-
-func canonicalPath(path string) (string, error) {
-	abs, err := filepath.Abs(path)
-	if err != nil {
-		return "", err
-	}
-	resolved, err := filepath.EvalSymlinks(abs)
-	if err == nil {
-		return resolved, nil
-	}
-	return abs, nil
-}
-
-type readSelection struct {
-	enabled bool
-	start   int
-	end     int
-}
-
-func readSelectionFromArgs(args map[string]any) (readSelection, error) {
-	selection := readSelection{start: 1}
-	var startSet, endSet bool
-
-	for _, key := range []string{"line_range", "range", "lines"} {
-		if lineRange, ok := stringReadArg(args, key); ok {
-			start, end, err := parseLineRange(lineRange)
-			if err != nil {
-				return readSelection{}, err
-			}
-			selection.enabled = true
-			if start > 0 {
-				selection.start = start
-				startSet = true
-			}
-			if end > 0 {
-				selection.end = end
-				endSet = true
-			}
-			break
-		}
-	}
-
-	if start, ok, err := intReadArg(args, "start_line"); err != nil {
-		return readSelection{}, err
-	} else if ok {
-		selection.enabled = true
-		selection.start = start
-		startSet = true
-	}
-	if end, ok, err := intReadArg(args, "end_line"); err != nil {
-		return readSelection{}, err
-	} else if ok {
-		selection.enabled = true
-		selection.end = end
-		endSet = true
-	}
-
-	lineCount, countSet, err := readLineCountArg(args)
-	if err != nil {
-		return readSelection{}, err
-	}
-	if countSet {
-		selection.enabled = true
-		if !startSet {
-			selection.start = 1
-		}
-		if !endSet {
-			selection.end = selection.start + lineCount - 1
-		}
-	}
-
-	if !selection.enabled {
-		return selection, nil
-	}
-	if selection.start < 1 {
-		return readSelection{}, fmt.Errorf("start_line must be greater than 0")
-	}
-	if selection.end > 0 && selection.end < selection.start {
-		return readSelection{}, fmt.Errorf("end_line must be greater than or equal to start_line")
-	}
-	return selection, nil
-}
-
-func readLineCountArg(args map[string]any) (int, bool, error) {
-	for _, key := range []string{"line_count", "num_lines"} {
-		value, ok, err := intReadArg(args, key)
-		if err != nil || ok {
-			if ok && value < 1 {
-				return 0, false, fmt.Errorf("%s must be greater than 0", key)
-			}
-			return value, ok, err
-		}
-	}
-	return 0, false, nil
-}
-
-func parseLineRange(value string) (int, int, error) {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return 0, 0, nil
-	}
-	value = strings.TrimPrefix(value, "lines")
-	value = strings.TrimPrefix(value, "line")
-	value = strings.TrimSpace(value)
-
-	for _, sep := range []string{"..", ":", ","} {
-		value = strings.ReplaceAll(value, sep, "-")
-	}
-	parts := strings.Split(value, "-")
-	if len(parts) > 2 {
-		return 0, 0, fmt.Errorf("line_range must look like 10-40, 10:40, 10..40, 10-, or 10")
-	}
-
-	start, end := 0, 0
-	var err error
-	if strings.TrimSpace(parts[0]) != "" {
-		start, err = strconv.Atoi(strings.TrimSpace(parts[0]))
-		if err != nil || start < 1 {
-			return 0, 0, fmt.Errorf("line_range start must be a positive line number")
-		}
-	}
-	if len(parts) == 1 {
-		return start, start, nil
-	}
-	if strings.TrimSpace(parts[1]) != "" {
-		end, err = strconv.Atoi(strings.TrimSpace(parts[1]))
-		if err != nil || end < 1 {
-			return 0, 0, fmt.Errorf("line_range end must be a positive line number")
-		}
-	}
-	if start == 0 && end == 0 {
-		return 0, 0, fmt.Errorf("line_range must include at least one line number")
-	}
-	if start == 0 {
-		start = 1
-	}
-	if end > 0 && end < start {
-		return 0, 0, fmt.Errorf("line_range end must be greater than or equal to start")
-	}
-	return start, end, nil
-}
-
-func readLineSelection(file *os.File, selection readSelection) (string, error) {
-	reader := bufio.NewReader(file)
-	var b strings.Builder
-	for lineNo := 1; ; lineNo++ {
-		line, err := reader.ReadString('\n')
-		if lineNo >= selection.start && (selection.end == 0 || lineNo <= selection.end) {
-			if b.Len()+len(line) > maxReadBytes {
-				return "", fmt.Errorf("selected content is too large (%d byte limit)", maxReadBytes)
-			}
-			b.WriteString(line)
-		}
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return "", err
-		}
-		if selection.end > 0 && lineNo >= selection.end {
-			break
-		}
-	}
-	return b.String(), nil
-}
-
-func stringReadArg(args map[string]any, key string) (string, bool) {
-	value, ok := args[key].(string)
-	return value, ok && strings.TrimSpace(value) != ""
-}
-
-func intReadArg(args map[string]any, key string) (int, bool, error) {
-	value, ok := args[key]
-	if !ok {
-		return 0, false, nil
-	}
-	switch v := value.(type) {
-	case int:
-		return v, true, nil
-	case int64:
-		return int(v), true, nil
-	case float64:
-		if v != float64(int(v)) {
-			return 0, true, fmt.Errorf("%s must be a whole number", key)
-		}
-		return int(v), true, nil
-	case string:
-		v = strings.TrimSpace(v)
-		if v == "" {
-			return 0, false, nil
-		}
-		n, err := strconv.Atoi(v)
-		if err != nil {
-			return 0, true, fmt.Errorf("%s must be a whole number", key)
-		}
-		return n, true, nil
-	default:
-		return 0, true, fmt.Errorf("%s must be a whole number", key)
-	}
-}
-
-func plural(n int) string {
-	if n == 1 {
-		return ""
-	}
-	return "s"
-}

agent/tools/file_test.go

@@ -1,255 +0,0 @@
-package tools
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/ollama/ollama/agent"
-)
-
-func TestEditReplacesUniqueText(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("hello world\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewEdit().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":     "note.txt",
-		"old_text": "hello",
-		"new_text": "hi",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "Updated note.txt") {
-		t.Fatalf("result = %q", result.Content)
-	}
-
-	content, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "hi world\n" {
-		t.Fatalf("content = %q", content)
-	}
-}
-
-func TestEditRequiresUniqueMatchByDefault(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "note.txt")
-	if err := os.WriteFile(path, []byte("same same\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := NewEdit().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":     "note.txt",
-		"old_text": "same",
-		"new_text": "other",
-	})
-	if err == nil {
-		t.Fatal("expected ambiguous edit to fail")
-	}
-	if !strings.Contains(err.Error(), "matched 2 times") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditRejectsEscapingPath(t *testing.T) {
-	dir := t.TempDir()
-	_, err := NewEdit().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":     "../outside.txt",
-		"old_text": "old",
-		"new_text": "new",
-	})
-	if err == nil {
-		t.Fatal("expected escaping path to fail")
-	}
-	if !strings.Contains(err.Error(), "path escapes working directory") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestEditRejectsSymlinkEscape(t *testing.T) {
-	dir := t.TempDir()
-	outside := t.TempDir()
-	if err := os.WriteFile(filepath.Join(outside, "note.txt"), []byte("old\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join(dir, "link")); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-
-	_, err := NewEdit().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":     filepath.Join("link", "note.txt"),
-		"old_text": "old",
-		"new_text": "new",
-	})
-	if err == nil {
-		t.Fatal("expected symlink escape to fail")
-	}
-	if !strings.Contains(err.Error(), "path escapes working directory") {
-		t.Fatalf("err = %v", err)
-	}
-
-	content, err := os.ReadFile(filepath.Join(outside, "note.txt"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "old\n" {
-		t.Fatalf("outside content changed to %q", content)
-	}
-}
-
-func TestEditRejectsFinalSymlink(t *testing.T) {
-	dir := t.TempDir()
-	target := filepath.Join(dir, "target.txt")
-	if err := os.WriteFile(target, []byte("old\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	link := filepath.Join(dir, "link.txt")
-	if err := os.Symlink("target.txt", link); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-
-	_, err := NewEdit().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":     "link.txt",
-		"old_text": "old",
-		"new_text": "new",
-	})
-	if err == nil {
-		t.Fatal("expected final symlink edit to fail")
-	}
-	if !strings.Contains(err.Error(), "is a symlink") {
-		t.Fatalf("err = %v", err)
-	}
-	content, err := os.ReadFile(target)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "old\n" {
-		t.Fatalf("target content changed to %q", content)
-	}
-	info, err := os.Lstat(link)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if info.Mode()&os.ModeSymlink == 0 {
-		t.Fatalf("link mode = %v, want symlink", info.Mode())
-	}
-}
-
-func TestReadRejectsParentOutsideCurrentWorkingDir(t *testing.T) {
-	root := t.TempDir()
-	subdir := filepath.Join(root, "sub")
-	if err := os.Mkdir(subdir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "note.txt"), []byte("hello"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := NewRead().Execute(context.Background(), agent.ToolContext{WorkingDir: subdir}, map[string]any{
-		"path": "../note.txt",
-	})
-	if err == nil {
-		t.Fatal("expected parent path to fail")
-	}
-	if !strings.Contains(err.Error(), "path escapes working directory") {
-		t.Fatalf("err = %v", err)
-	}
-}
-
-func TestReadDefaultsToEntireFile(t *testing.T) {
-	dir := t.TempDir()
-	content := "one\ntwo\nthree\n"
-	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewRead().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path": "note.txt",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Content != content {
-		t.Fatalf("content = %q", result.Content)
-	}
-}
-
-func TestReadLineRange(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\nthree\nfour\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewRead().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":       "note.txt",
-		"line_range": "2-3",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Content != "two\nthree\n" {
-		t.Fatalf("content = %q", result.Content)
-	}
-}
-
-func TestReadLinesAliasAsRange(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\nthree\nfour\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewRead().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":  "note.txt",
-		"lines": "2-3",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Content != "two\nthree\n" {
-		t.Fatalf("content = %q", result.Content)
-	}
-}
-
-func TestReadLineCountFromStartLine(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\nthree\nfour\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewRead().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":       "note.txt",
-		"start_line": 3,
-		"line_count": 2,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Content != "three\nfour\n" {
-		t.Fatalf("content = %q", result.Content)
-	}
-}
-
-func TestReadRejectsInvalidLineRange(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "note.txt"), []byte("one\ntwo\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := NewRead().Execute(context.Background(), agent.ToolContext{WorkingDir: dir}, map[string]any{
-		"path":       "note.txt",
-		"line_range": "4-2",
-	})
-	if err == nil {
-		t.Fatal("expected invalid range to fail")
-	}
-	if !strings.Contains(err.Error(), "line_range end") {
-		t.Fatalf("err = %v", err)
-	}
-}

agent/tools/skill.go

@@ -1,137 +0,0 @@
-package tools
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/agent/skills"
-	"github.com/ollama/ollama/api"
-)
-
-type Skill struct {
-	catalog *skills.Catalog
-}
-
-func NewSkill(catalog *skills.Catalog) *Skill {
-	return &Skill{catalog: catalog}
-}
-
-func (s *Skill) Name() string {
-	return "skill"
-}
-
-func (s *Skill) Description() string {
-	return "Load the full SKILL.md instructions for an installed agent skill by name."
-}
-
-func (s *Skill) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("name", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "Name of the skill to load.",
-	})
-	return api.ToolFunction{
-		Name:        s.Name(),
-		Description: s.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Required:   []string{"name"},
-			Properties: props,
-		},
-	}
-}
-
-func (s *Skill) Execute(_ context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	name, _ := args["name"].(string)
-	name = skills.NormalizeName(name)
-	if name == "" {
-		return agent.ToolResult{}, fmt.Errorf("name parameter is required")
-	}
-	if s.catalog == nil || s.catalog.Empty() {
-		return agent.ToolResult{}, fmt.Errorf("no skills are installed")
-	}
-
-	skill, ok := s.catalog.Find(name)
-	if !ok {
-		return agent.ToolResult{}, fmt.Errorf("unknown skill: %s", name)
-	}
-	content, err := SkillResultContent(skill)
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-	return agent.ToolResult{Content: content}, nil
-}
-
-func ManualSkillMessages(skill skills.Skill, request string, ordinal int) ([]api.Message, error) {
-	content, err := SkillResultContent(skill)
-	if err != nil {
-		return nil, err
-	}
-
-	args := api.NewToolCallFunctionArguments()
-	args.Set("name", skill.Name)
-	callID := manualSkillToolCallID(skill.Name, ordinal)
-
-	userContent := strings.TrimSpace(request)
-	if userContent == "" {
-		userContent = fmt.Sprintf("Use the %s skill.", skill.Name)
-	}
-
-	return []api.Message{
-		{Role: "user", Content: userContent},
-		{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{{
-				ID: callID,
-				Function: api.ToolCallFunction{
-					Name:      "skill",
-					Arguments: args,
-				},
-			}},
-		},
-		{Role: "tool", ToolName: "skill", ToolCallID: callID, Content: content},
-	}, nil
-}
-
-func SkillResultContent(skill skills.Skill) (string, error) {
-	content, err := skill.Read()
-	if err != nil {
-		return "", err
-	}
-
-	var b strings.Builder
-	b.WriteString("Loaded skill: ")
-	b.WriteString(skill.Name)
-	b.WriteByte('\n')
-	b.WriteString("Skill directory: ")
-	b.WriteString(skill.Dir)
-	b.WriteString("\nResolve relative file references from the skill directory.\n\n")
-	b.WriteString(content)
-	return b.String(), nil
-}
-
-func manualSkillToolCallID(skillName string, ordinal int) string {
-	name := strings.Trim(strings.Map(func(r rune) rune {
-		switch {
-		case r >= 'a' && r <= 'z':
-			return r
-		case r >= 'A' && r <= 'Z':
-			return r
-		case r >= '0' && r <= '9':
-			return r
-		case r == '-' || r == '_':
-			return r
-		default:
-			return '-'
-		}
-	}, skillName), "-")
-	if name == "" {
-		name = "skill"
-	}
-	if ordinal <= 0 {
-		return "manual-skill-" + name
-	}
-	return fmt.Sprintf("manual-skill-%d-%s", ordinal, name)
-}

agent/tools/skill_test.go

@@ -1,81 +0,0 @@
-package tools
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/agent/skills"
-)
-
-func TestSkillToolLoadsSkill(t *testing.T) {
-	dir := t.TempDir()
-	skillDir := filepath.Join(dir, "go-code")
-	if err := os.MkdirAll(skillDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(skillDir, skills.SkillFile), []byte("---\nname: go-code\ndescription: Write Go code.\n---\n\n# Go Code\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	catalog, err := skills.Load(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	result, err := NewSkill(catalog).Execute(context.Background(), agent.ToolContext{}, map[string]any{"name": "go-code"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "Loaded skill: go-code") || !strings.Contains(result.Content, "# Go Code") {
-		t.Fatalf("content = %q", result.Content)
-	}
-}
-
-func TestManualSkillMessagesUseToolCallShape(t *testing.T) {
-	dir := t.TempDir()
-	skillDir := filepath.Join(dir, "go-code")
-	if err := os.MkdirAll(skillDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(skillDir, skills.SkillFile), []byte("---\nname: go-code\ndescription: Write Go code.\n---\n\n# Go Code\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	catalog, err := skills.Load(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	skill, ok := catalog.Find("go-code")
-	if !ok {
-		t.Fatal("skill not found")
-	}
-
-	messages, err := ManualSkillMessages(skill, "write a test", 7)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(messages) != 3 {
-		t.Fatalf("messages = %d, want 3", len(messages))
-	}
-	if messages[0].Role != "user" || messages[0].Content != "write a test" {
-		t.Fatalf("user message = %#v", messages[0])
-	}
-	if messages[1].Role != "assistant" || len(messages[1].ToolCalls) != 1 {
-		t.Fatalf("assistant tool call = %#v", messages[1])
-	}
-	call := messages[1].ToolCalls[0]
-	if call.ID != "manual-skill-7-go-code" || call.Function.Name != "skill" {
-		t.Fatalf("tool call = %#v", call)
-	}
-	if name, _ := call.Function.Arguments.Get("name"); name != "go-code" {
-		t.Fatalf("tool args = %s", call.Function.Arguments.String())
-	}
-	if messages[2].Role != "tool" || messages[2].ToolName != "skill" || messages[2].ToolCallID != call.ID {
-		t.Fatalf("tool result metadata = %#v", messages[2])
-	}
-	if !strings.Contains(messages[2].Content, "Loaded skill: go-code") || !strings.Contains(messages[2].Content, "# Go Code") {
-		t.Fatalf("tool result = %q", messages[2].Content)
-	}
-}

agent/tools/web.go

@@ -1,195 +0,0 @@
-package tools
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-)
-
-var (
-	ErrWebSearchAuthRequired = errors.New("web search requires authentication")
-	ErrWebFetchAuthRequired  = errors.New("web fetch requires authentication")
-)
-
-const (
-	maxWebFetchContentRunes = 60_000
-	webSearchTimeout        = 15 * time.Second
-	webFetchTimeout         = 30 * time.Second
-)
-
-type WebSearch struct{}
-
-func NewWebSearch() *WebSearch {
-	return &WebSearch{}
-}
-
-func (w *WebSearch) Name() string {
-	return "web_search"
-}
-
-func (w *WebSearch) Description() string {
-	return "Search the web for current information that may not be in the model's training data."
-}
-
-func (w *WebSearch) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("query", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The search query to look up on the web.",
-	})
-	return api.ToolFunction{
-		Name:        w.Name(),
-		Description: w.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"query"},
-		},
-	}
-}
-
-func (w *WebSearch) Execute(ctx context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	if internalcloud.Disabled() {
-		return agent.ToolResult{}, errors.New(internalcloud.DisabledError("web search is unavailable"))
-	}
-	query, ok := args["query"].(string)
-	if !ok || strings.TrimSpace(query) == "" {
-		return agent.ToolResult{}, fmt.Errorf("query parameter is required")
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-
-	ctx, cancel := context.WithTimeout(ctx, webSearchTimeout)
-	defer cancel()
-
-	searchResp, err := client.WebSearchExperimental(ctx, &api.WebSearchRequest{Query: query, MaxResults: 5})
-	if err != nil {
-		var authErr api.AuthorizationError
-		if errors.As(err, &authErr) {
-			return agent.ToolResult{}, ErrWebSearchAuthRequired
-		}
-		return agent.ToolResult{}, err
-	}
-	if len(searchResp.Results) == 0 {
-		return agent.ToolResult{Content: "No results found for query: " + query}, nil
-	}
-
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("Search results for: %s\n\n", query))
-	for i, result := range searchResp.Results {
-		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, result.Title))
-		sb.WriteString(fmt.Sprintf("   URL: %s\n", result.URL))
-		if result.Content != "" {
-			content := []rune(result.Content)
-			if len(content) > 300 {
-				content = append(content[:300], []rune("...")...)
-			}
-			sb.WriteString(fmt.Sprintf("   %s\n", string(content)))
-		}
-		sb.WriteByte('\n')
-	}
-	return agent.ToolResult{Content: sb.String()}, nil
-}
-
-type WebFetch struct{}
-
-func NewWebFetch() *WebFetch {
-	return &WebFetch{}
-}
-
-func (w *WebFetch) Name() string {
-	return "web_fetch"
-}
-
-func (w *WebFetch) Description() string {
-	return "Fetch and extract text content from a web page."
-}
-
-func (w *WebFetch) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("url", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The URL to fetch and extract content from.",
-	})
-	return api.ToolFunction{
-		Name:        w.Name(),
-		Description: w.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"url"},
-		},
-	}
-}
-
-func (w *WebFetch) Execute(ctx context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	if internalcloud.Disabled() {
-		return agent.ToolResult{}, errors.New(internalcloud.DisabledError("web fetch is unavailable"))
-	}
-	urlStr, ok := args["url"].(string)
-	if !ok || strings.TrimSpace(urlStr) == "" {
-		return agent.ToolResult{}, fmt.Errorf("url parameter is required")
-	}
-	if _, err := url.Parse(urlStr); err != nil {
-		return agent.ToolResult{}, fmt.Errorf("invalid URL: %w", err)
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-
-	ctx, cancel := context.WithTimeout(ctx, webFetchTimeout)
-	defer cancel()
-
-	fetchResp, err := client.WebFetchExperimental(ctx, &api.WebFetchRequest{URL: urlStr})
-	if err != nil {
-		var authErr api.AuthorizationError
-		if errors.As(err, &authErr) {
-			return agent.ToolResult{}, ErrWebFetchAuthRequired
-		}
-		return agent.ToolResult{}, err
-	}
-
-	var sb strings.Builder
-	if fetchResp.Title != "" {
-		sb.WriteString(fmt.Sprintf("Title: %s\n\n", fetchResp.Title))
-	}
-	if fetchResp.Content != "" {
-		sb.WriteString("Content:\n")
-		sb.WriteString(truncateWebFetchContent(fetchResp.Content))
-	} else {
-		sb.WriteString("No content could be extracted from the page.")
-	}
-	return agent.ToolResult{Content: sb.String()}, nil
-}
-
-func truncateWebFetchContent(content string) string {
-	runes := []rune(content)
-	if len(runes) <= maxWebFetchContentRunes {
-		return content
-	}
-	omitted := len(runes) - maxWebFetchContentRunes
-	return string(runes[:maxWebFetchContentRunes]) + fmt.Sprintf(
-		"\n\n[tool output truncated: showing first ~%d tokens; omitted ~%d tokens. Use a narrower request or search query if more detail is needed.]",
-		approximateToolTokensFromRunes(maxWebFetchContentRunes),
-		approximateToolTokensFromRunes(omitted),
-	)
-}
-
-func approximateToolTokensFromRunes(n int) int {
-	if n <= 0 {
-		return 0
-	}
-	return max(1, (n+3)/4)
-}

agent/tools/web_test.go

@@ -1,59 +0,0 @@
-package tools
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	coreagent "github.com/ollama/ollama/agent"
-	"github.com/ollama/ollama/api"
-)
-
-func TestWebToolsDoNotRequireApproval(t *testing.T) {
-	if coreagent.ToolRequiresApproval(NewWebSearch(), map[string]any{"query": "ollama"}) {
-		t.Fatal("web search should not require approval")
-	}
-	if coreagent.ToolRequiresApproval(NewWebFetch(), map[string]any{"url": "https://ollama.com"}) {
-		t.Fatal("web fetch should not require approval")
-	}
-}
-
-func TestWebFetchBoundsContentBeforeReturning(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/api/experimental/web_fetch" {
-			t.Fatalf("path = %q, want /api/experimental/web_fetch", r.URL.Path)
-		}
-		var req api.WebFetchRequest
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			t.Fatal(err)
-		}
-		if req.URL != "https://ollama.com" {
-			t.Fatalf("request URL = %q, want https://ollama.com", req.URL)
-		}
-		if err := json.NewEncoder(w).Encode(api.WebFetchResponse{
-			Title:   "Ollama",
-			Content: strings.Repeat("x", maxWebFetchContentRunes+25),
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}))
-	defer ts.Close()
-	t.Setenv("OLLAMA_HOST", ts.URL)
-
-	result, err := NewWebFetch().Execute(t.Context(), coreagent.ToolContext{}, map[string]any{
-		"url": "https://ollama.com",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "[tool output truncated: showing first ~") ||
-		!strings.Contains(result.Content, "omitted ~7 tokens") ||
-		!strings.Contains(result.Content, "Use a narrower request or search query") {
-		t.Fatalf("content missing truncation marker: %q", result.Content)
-	}
-	if count := strings.Count(result.Content, "x"); count != maxWebFetchContentRunes {
-		t.Fatalf("captured content count = %d, want %d", count, maxWebFetchContentRunes)
-	}
-}

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

@@ -10,7 +10,7 @@
 // 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
+// [in the GitHub repository]: https://github.com/ollama/ollama/tree/main/examples
 package api
 
 import (
@@ -24,10 +24,7 @@ import (
 	"net/http"
 	"net/url"
 	"runtime"
-	"strconv"
-	"time"
 
-	"github.com/ollama/ollama/auth"
 	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/format"
 	"github.com/ollama/ollama/version"
@@ -45,12 +42,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)
@@ -85,14 +76,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 +97,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 +106,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 +129,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 +143,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 +152,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 +164,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 errors.New(errorResponse.Error)
+		}
+
+		if response.StatusCode >= http.StatusBadRequest {
 			return StatusError{
 				StatusCode:   response.StatusCode,
 				Status:       response.Status,
@@ -250,19 +184,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
 }
 
@@ -351,7 +277,7 @@ 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
+// [Modelfile]: https://github.com/ollama/ollama/blob/main/docs/modelfile.md
 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
@@ -372,16 +298,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
@@ -462,51 +378,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,13 +1,6 @@
 package api
 
 import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
 	"testing"
 )
 
@@ -50,399 +43,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 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

@@ -11,39 +11,12 @@ 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 }`,
@@ -52,7 +25,7 @@ func TestKeepAliveParsingFromJSON(t *testing.T) {
 		{
 			name: "Positive Float",
 			req:  `{ "keep_alive": 42.5 }`,
-			exp:  &Duration{42500 * time.Millisecond},
+			exp:  &Duration{42 * time.Second},
 		},
 		{
 			name: "Positive Integer String",
@@ -161,7 +134,7 @@ func TestUseMmapParsingFromJSON(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			var oMap map[string]any
+			var oMap map[string]interface{}
 			err := json.Unmarshal([]byte(test.req), &oMap)
 			require.NoError(t, err)
 			opts := DefaultOptions()
@@ -172,47 +145,6 @@ func TestUseMmapParsingFromJSON(t *testing.T) {
 	}
 }
 
-func TestMainGPUParsingFromJSON(t *testing.T) {
-	tests := []struct {
-		name    string
-		req     string
-		wantGPU *int
-	}{
-		{
-			name: "Undefined",
-			req:  `{}`,
-		},
-		{
-			name:    "Zero",
-			req:     `{ "main_gpu": 0 }`,
-			wantGPU: testIntPtr(0),
-		},
-		{
-			name:    "Nonzero",
-			req:     `{ "main_gpu": 1 }`,
-			wantGPU: testIntPtr(1),
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			var oMap map[string]any
-			err := json.Unmarshal([]byte(test.req), &oMap)
-			require.NoError(t, err)
-
-			opts := DefaultOptions()
-			err = opts.FromMap(oMap)
-			require.NoError(t, err)
-
-			if test.wantGPU == nil {
-				assert.Nil(t, opts.MainGPU)
-			} else if assert.NotNil(t, opts.MainGPU) {
-				assert.Equal(t, *test.wantGPU, *opts.MainGPU)
-			}
-		})
-	}
-}
-
 func TestUseMmapFormatParams(t *testing.T) {
 	tr := true
 	fa := false
@@ -277,12 +209,6 @@ func TestUseMmapFormatParams(t *testing.T) {
 	}
 }
 
-func TestMainGPUFormatParams(t *testing.T) {
-	resp, err := FormatParams(map[string][]string{"main_gpu": {"0"}})
-	require.NoError(t, err)
-	assert.Equal(t, int64(0), resp["main_gpu"])
-}
-
 func TestMessage_UnmarshalJSON(t *testing.T) {
 	tests := []struct {
 		input    string
@@ -305,664 +231,3 @@ func TestMessage_UnmarshalJSON(t *testing.T) {
 		}
 	}
 }
-
-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 @@
 ollama.syso
-*.crt
-*.exe
-/app/app
-/app/squirrel
-ollama
-*cover*
-.vscode
-.env
-.DS_Store
-.claude

app/README.md

@@ -1,97 +1,22 @@
-# Ollama for macOS and Windows
+# Ollama App
 
-## Download
+## Linux
 
-- [macOS](https://github.com/ollama/app/releases/download/latest/Ollama.dmg)
-- [Windows](https://github.com/ollama/app/releases/download/latest/OllamaSetup.exe)
+TODO
 
-## Development
+## MacOS
 
-### Desktop App
+TODO
 
-```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/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/AppDelegate.h

@@ -1,7 +0,0 @@
-#import <Cocoa/Cocoa.h>
-
-@interface AppDelegate : NSObject <NSApplicationDelegate>
-
-- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
-
-@end

app/cmd/app/app.go

@@ -1,507 +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)
-		if checkAndHandleExistingInstance(urlSchemeRequest) {
-			// The function will exit if it successfully sends to another instance
-			// If we reach here, we're the first/only instance
-		} else {
-			// No existing instance found, handle the URL scheme in this instance
-			go func() {
-				handleURLSchemeInCurrentInstance(urlSchemeRequest)
-			}()
-		}
-	}
-
-	// 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{}
-	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 != "" {
-		go func() {
-			handleURLSchemeInCurrentInstance(urlSchemeRequest)
-		}()
-	} else {
-		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)
-		}
-	}()
-
-	osRun(cancel, hasCompletedFirstRun, startHidden)
-
-	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 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 {
-				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")
-		showWindow(wv.webview.Window())
-		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) {
-	isConnect, err := parseURLScheme(urlSchemeRequest)
-	if err != nil {
-		slog.Error("failed to parse URL scheme request", "url", urlSchemeRequest, "error", err)
-		return
-	}
-
-	if isConnect {
-		handleConnectURLScheme()
-	} else {
-		if wv.webview != nil {
-			showWindow(wv.webview.Window())
-		}
-	}
-}

app/cmd/app/app_darwin.go

@@ -1,262 +0,0 @@
-//go:build windows || darwin
-
-package main
-
-// #cgo CFLAGS: -x objective-c
-// #cgo LDFLAGS: -framework Webkit -framework Cocoa -framework LocalAuthentication -framework ServiceManagement
-// #include "app_darwin.h"
-// #include "../../updater/updater_darwin.h"
-// typedef const char cchar_t;
-import "C"
-
-import (
-	"log/slog"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-	"unsafe"
-
-	"github.com/ollama/ollama/app/updater"
-	"github.com/ollama/ollama/app/version"
-)
-
-var ollamaPath = func() string {
-	if updater.BundlePath != "" {
-		return filepath.Join(updater.BundlePath, "Contents", "Resources", "ollama")
-	}
-
-	pwd, err := os.Getwd()
-	if err != nil {
-		slog.Warn("failed to get pwd", "error", err)
-		return ""
-	}
-	return filepath.Join(pwd, "ollama")
-}()
-
-var (
-	isApp           = updater.BundlePath != ""
-	appLogPath      = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "app.log")
-	launchAgentPath = filepath.Join(os.Getenv("HOME"), "Library", "LaunchAgents", "com.ollama.ollama.plist")
-)
-
-// TODO(jmorganca): pre-create the window and pass
-// it to the webview instead of using the internal one
-//
-//export StartUI
-func StartUI(path *C.cchar_t) {
-	p := C.GoString(path)
-	wv.Run(p)
-	styleWindow(wv.webview.Window())
-	C.setWindowDelegate(wv.webview.Window())
-}
-
-//export ShowUI
-func ShowUI() {
-	// If webview is already running, just show the window
-	if wv.IsRunning() && wv.webview != nil {
-		showWindow(wv.webview.Window())
-	} else {
-		root := C.CString("/")
-		defer C.free(unsafe.Pointer(root))
-		StartUI(root)
-	}
-}
-
-//export StopUI
-func StopUI() {
-	wv.Terminate()
-}
-
-//export StartUpdate
-func StartUpdate() {
-	if err := updater.DoUpgrade(true); err != nil {
-		slog.Error("upgrade failed", "error", err)
-		return
-	}
-	slog.Debug("launching new version...")
-	// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
-	LaunchNewApp()
-	// not reached if upgrade works, the new app will kill this process
-}
-
-//export darwinStartHiddenTasks
-func darwinStartHiddenTasks() {
-	startHiddenTasks()
-}
-
-func init() {
-	// Temporary code to mimic Squirrel ShipIt behavior
-	if len(os.Args) > 2 {
-		if os.Args[1] == "___launch___" {
-			path := strings.TrimPrefix(os.Args[2], "file://")
-			slog.Info("Ollama binary called as ShipIt - launching", "app", path)
-			appName := C.CString(path)
-			defer C.free(unsafe.Pointer(appName))
-			C.launchApp(appName)
-			slog.Info("other instance has been launched")
-			time.Sleep(5 * time.Second)
-			slog.Info("exiting with zero status")
-			os.Exit(0)
-		}
-	}
-}
-
-// maybeMoveAndRestart checks if we should relocate
-// and returns true if we did and should immediately exit
-func maybeMoveAndRestart() appMove {
-	if updater.BundlePath == "" {
-		// Typically developer mode with 'go run ./cmd/app'
-		return CannotMove
-	}
-	// Respect users intent if they chose "keep" vs. "replace" when dragging to Applications
-	if strings.HasPrefix(updater.BundlePath, strings.TrimSuffix(updater.SystemWidePath, filepath.Ext(updater.SystemWidePath))) {
-		return AlreadyMoved
-	}
-
-	// Ask to move to applications directory
-	status := (appMove)(C.askToMoveToApplications())
-	if status == MoveCompleted {
-		// Double check
-		if _, err := os.Stat(updater.SystemWidePath); err != nil {
-			slog.Warn("stat failure after move", "path", updater.SystemWidePath, "error", err)
-			return MoveError
-		}
-	}
-	return status
-}
-
-// handleExistingInstance handles existing instances on macOS
-func handleExistingInstance(_ bool) {
-	C.killOtherInstances()
-}
-
-func installSymlink() {
-	if !isApp {
-		return
-	}
-	cliPath := C.CString(ollamaPath)
-	defer C.free(unsafe.Pointer(cliPath))
-
-	// Check the users path first
-	cmd, _ := exec.LookPath("ollama")
-	if cmd != "" {
-		resolved, err := os.Readlink(cmd)
-		if err == nil {
-			tmp, err := filepath.Abs(resolved)
-			if err == nil {
-				resolved = tmp
-			}
-		} else {
-			resolved = cmd
-		}
-		if resolved == ollamaPath {
-			slog.Info("ollama already in users PATH", "cli", cmd)
-			return
-		}
-	}
-
-	code := C.installSymlink(cliPath)
-	if code != 0 {
-		slog.Error("Failed to install symlink")
-	}
-}
-
-func UpdateAvailable(ver string) error {
-	slog.Debug("update detected, adjusting menu")
-	// TODO (jmorganca): find a better check for development mode than checking the bundle path
-	if updater.BundlePath != "" {
-		C.updateAvailable()
-	}
-	return nil
-}
-
-func osRun(_ func(), hasCompletedFirstRun, startHidden bool) {
-	registerLaunchAgent(hasCompletedFirstRun)
-
-	// Run the native macOS app
-	// Note: this will block until the app is closed
-	slog.Debug("starting native darwin event loop")
-	C.run(C._Bool(hasCompletedFirstRun), C._Bool(startHidden))
-}
-
-func quit() {
-	C.quit()
-}
-
-func LaunchNewApp() {
-	appName := C.CString(updater.BundlePath)
-	defer C.free(unsafe.Pointer(appName))
-	C.launchApp(appName)
-}
-
-func registerLaunchAgent(hasCompletedFirstRun bool) {
-	// Remove any stale Login Item registrations
-	C.unregisterSelfFromLoginItem()
-
-	C.registerSelfAsLoginItem(C._Bool(hasCompletedFirstRun))
-}
-
-func logStartup() {
-	appPath := updater.BundlePath
-	if appPath == updater.SystemWidePath {
-		// Detect sandboxed scenario
-		exe, err := os.Executable()
-		if err == nil {
-			p := filepath.Dir(exe)
-			if filepath.Base(p) == "MacOS" {
-				p = filepath.Dir(filepath.Dir(p))
-				if p != appPath {
-					slog.Info("starting sandboxed Ollama", "app", appPath, "sandbox", p)
-					return
-				}
-			}
-		}
-	}
-	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
-}
-
-func hideWindow(ptr unsafe.Pointer) {
-	C.hideWindow(C.uintptr_t(uintptr(ptr)))
-}
-
-func showWindow(ptr unsafe.Pointer) {
-	C.showWindow(C.uintptr_t(uintptr(ptr)))
-}
-
-func styleWindow(ptr unsafe.Pointer) {
-	C.styleWindow(C.uintptr_t(uintptr(ptr)))
-}
-
-func runInBackground() {
-	cmd := exec.Command(filepath.Join(updater.BundlePath, "Contents", "MacOS", "Ollama"), "hidden")
-	if cmd != nil {
-		err := cmd.Run()
-		if err != nil {
-			slog.Error("failed to run Ollama", "bundlePath", updater.BundlePath, "error", err)
-			os.Exit(1)
-		}
-	} else {
-		slog.Error("failed to start Ollama in background", "bundlePath", updater.BundlePath)
-		os.Exit(1)
-	}
-}
-
-func drag(ptr unsafe.Pointer) {
-	C.drag(C.uintptr_t(uintptr(ptr)))
-}
-
-func doubleClick(ptr unsafe.Pointer) {
-	C.doubleClick(C.uintptr_t(uintptr(ptr)))
-}
-
-//export handleConnectURL
-func handleConnectURL() {
-	handleConnectURLScheme()
-}
-
-// checkAndHandleExistingInstance is not needed on non-Windows platforms
-func checkAndHandleExistingInstance(_ string) bool {
-	return false
-}

app/cmd/app/app_darwin.h

@@ -1,43 +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 firstTimeRun, bool startHidden);
-void killOtherInstances();
-enum AppMove askToMoveToApplications();
-int createSymlinkWithAuthorization();
-int installSymlink(const char *cliPath);
-extern void Restart();
-// extern void Quit();
-void StartUI(const char *path);
-void ShowUI();
-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 drag(uintptr_t wndPtr);
-void doubleClick(uintptr_t wndPtr);
-void handleConnectURL();

app/cmd/app/app_windows.go

@@ -1,448 +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() {
-	if wv.webview != nil {
-		showWindow(wv.webview.Window())
-	} else {
-		wv.Run("/")
-	}
-}
-
-func (*appCallbacks) UITerminate() {
-	wv.Terminate()
-}
-
-func (*appCallbacks) UIRunning() bool {
-	return wv.IsRunning()
-}
-
-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 {
-		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) {
-	isConnect, err := parseURLScheme(urlScheme)
-	if err != nil {
-		slog.Error("failed to parse URL scheme request", "url", urlScheme, "error", err)
-		return
-	}
-
-	if isConnect {
-		handleConnectURLScheme()
-	} else {
-		if wv.webview != nil {
-			showWindow(wv.webview.Window())
-		}
-	}
-}
-
-func UpdateAvailable(ver string) error {
-	if app.t == nil {
-		slog.Debug("tray not yet initialized, skipping update notification")
-		return nil
-	}
-	return app.t.UpdateAvailable(ver)
-}
-
-func osRun(shutdown func(), hasCompletedFirstRun, startHidden bool) {
-	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
-			}
-		}
-	}
-	if startHidden {
-		startHiddenTasks()
-	} else {
-		ptr := wv.Run("/")
-
-		// 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 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) bool {
-	if urlSchemeRequest == "" {
-		return false
-	}
-
-	// Try to send URL to existing instance using wintray messaging
-	if wintray.CheckAndSendToExistingInstance(urlSchemeRequest) {
-		os.Exit(0)
-		return true
-	}
-
-	// No existing instance, we'll handle it ourselves
-	return false
-}

app/cmd/app/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,528 +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"
-	"time"
-	"unsafe"
-
-	"github.com/ollama/ollama/app/dialog"
-	"github.com/ollama/ollama/app/store"
-	"github.com/ollama/ollama/app/webview"
-)
-
-type Webview struct {
-	port    int
-	token   string
-	webview webview.WebView
-	mutex   sync.Mutex
-
-	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 += `
-				// Fix scrollbar styling for Edge WebView2 on Windows only
-				function updateScrollbarStyles() {
-					const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
-					const existingStyle = document.getElementById('scrollbar-style');
-					if (existingStyle) existingStyle.remove();
-					
-					const style = document.createElement('style');
-					style.id = 'scrollbar-style';
-					
-					if (isDark) {
-						style.textContent = ` + "`" + `
-							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
-							::-webkit-scrollbar-track { background: #1a1a1a !important; }
-							::-webkit-scrollbar-thumb { background: #404040 !important; border-radius: 6px !important; }
-							::-webkit-scrollbar-thumb:hover { background: #505050 !important; }
-							::-webkit-scrollbar-corner { background: #1a1a1a !important; }
-							::-webkit-scrollbar-button { 
-								background: transparent !important;
-								border: none !important;
-								width: 0px !important;
-								height: 0px !important;
-								margin: 0 !important;
-								padding: 0 !important;
-							}
-							::-webkit-scrollbar-button:vertical:start:decrement {
-								background: transparent !important;
-								height: 0px !important;
-							}
-							::-webkit-scrollbar-button:vertical:end:increment {
-								background: transparent !important;
-								height: 0px !important;
-							}
-							::-webkit-scrollbar-button:horizontal:start:decrement {
-								background: transparent !important;
-								width: 0px !important;
-							}
-							::-webkit-scrollbar-button:horizontal:end:increment {
-								background: transparent !important;
-								width: 0px !important;
-							}
-						` + "`" + `;
-					} else {
-						style.textContent = ` + "`" + `
-							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
-							::-webkit-scrollbar-track { background: #f0f0f0 !important; }
-							::-webkit-scrollbar-thumb { background: #c0c0c0 !important; border-radius: 6px !important; }
-							::-webkit-scrollbar-thumb:hover { background: #a0a0a0 !important; }
-							::-webkit-scrollbar-corner { background: #f0f0f0 !important; }
-							::-webkit-scrollbar-button { 
-								background: transparent !important;
-								border: none !important;
-								width: 0px !important;
-								height: 0px !important;
-								margin: 0 !important;
-								padding: 0 !important;
-							}
-							::-webkit-scrollbar-button:vertical:start:decrement {
-								background: transparent !important;
-								height: 0px !important;
-							}
-							::-webkit-scrollbar-button:vertical:end:increment {
-								background: transparent !important;
-								height: 0px !important;
-							}
-							::-webkit-scrollbar-button:horizontal:start:decrement {
-								background: transparent !important;
-								width: 0px !important;
-							}
-							::-webkit-scrollbar-button:horizontal:end:increment {
-								background: transparent !important;
-								width: 0px !important;
-							}
-						` + "`" + `;
-					}
-					document.head.appendChild(style);
-				}
-				
-				window.addEventListener('load', updateScrollbarStyles);
-				window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', updateScrollbarStyles);
-			`
-		}
-		// on windows make ctrl+n open new chat
-		// 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 += `
-			window.OLLAMA_WEBSEARCH = true;
-		`
-
-		wv.Init(init)
-
-		// Add keyboard handler for zoom
-		wv.Init(`
-			window.addEventListener('keydown', function(e) {
-				// 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("close", func() {
-			hideWindow(wv.Window())
-		})
-
-		// 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")
-			}()
-		}
-
-		if w.Store != nil {
-			width, height, err := w.Store.WindowSize()
-			if err != nil {
-				slog.Error("failed to get window size", "error", err)
-			}
-			if width > 0 && height > 0 {
-				wv.SetSize(width, height, webview.HintNone)
-			} else {
-				wv.SetSize(800, 600, webview.HintNone)
-			}
-		}
-		wv.SetSize(800, 600, 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.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) 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

@@ -1,51 +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>CFBundleDisplayName</key>
-    <string>Ollama</string>
-    <key>CFBundleExecutable</key>
-    <string>Ollama</string>
-    <key>CFBundleIconFile</key>
-    <string>icon.icns</string>
-    <key>CFBundleIdentifier</key>
-    <string>com.electron.ollama</string>
-    <key>CFBundleInfoDictionaryVersion</key>
-    <string>6.0</string>
-    <key>CFBundleName</key>
-    <string>Ollama</string>
-    <key>CFBundlePackageType</key>
-    <string>APPL</string>
-    <key>CFBundleShortVersionString</key>
-    <string>0.0.0</string>
-    <key>CFBundleVersion</key>
-    <string>0.0.0</string>
-    <key>DTCompiler</key>
-    <string>com.apple.compilers.llvm.clang.1_0</string>
-    <key>DTSDKBuild</key>
-    <string>22E245</string>
-    <key>DTSDKName</key>
-    <string>macosx14.0</string>
-    <key>DTXcode</key>
-    <string>1431</string>
-    <key>DTXcodeBuild</key>
-    <string>14E300c</string>
-    <key>LSApplicationCategoryType</key>
-    <string>public.app-category.developer-tools</string>
-    <key>LSMinimumSystemVersion</key>
-    <string>14.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/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_nonwindows.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package lifecycle
+
+import "errors"
+
+func GetStarted() error {
+	return errors.New("not implemented")
+}

app/lifecycle/getstarted_windows.go

@@ -0,0 +1,43 @@
+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/lifecycle.go

@@ -0,0 +1,94 @@
+package lifecycle
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"log/slog"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/tray"
+	"github.com/ollama/ollama/envconfig"
+)
+
+func Run() {
+	InitLogging()
+	slog.Info("app config", "env", envconfig.Values())
+
+	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 := DoUpgrade(cancel, done)
+				if err != nil {
+					slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
+				}
+			case <-callbacks.ShowLogs:
+				ShowLogs()
+			case <-callbacks.DoFirstUse:
+				err := GetStarted()
+				if err != nil {
+					slog.Warn(fmt.Sprintf("Failed to launch getting started shell: %s", err))
+				}
+			}
+		}
+	}()
+
+	// Are we first use?
+	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)
+	} else {
+		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
+		}
+	}
+
+	StartBackgroundUpdaterChecker(ctx, t.UpdateAvailable)
+
+	t.Run()
+	cancel()
+	slog.Info("Waiting for ollama server to shutdown...")
+	if done != nil {
+		<-done
+	}
+	slog.Info("Ollama app exiting")
+}