Update readme.md

Signed-off-by: Matt Williams <m@technovangelist.com>

.dockerignore

@@ -1,11 +1,9 @@
 .vscode
 ollama
 app
-macapp
 dist
-build
+scripts
+llm/llama.cpp/ggml
+llm/llama.cpp/gguf
 .env
 .cache
-test_data
-.git
-

.gitattributes

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

.github/ISSUE_TEMPLATE/10_bug_report.yml

@@ -1,68 +0,0 @@
-name: Bug report
-labels: [bug]
-description: Something isn't working right.
-body:
-  - type: textarea
-    id: description
-    attributes:
-      label: What is the issue?
-      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:
-      label: OS
-      description: Which operating system are you using?
-      multiple: true
-      options:
-        - Linux
-        - macOS
-        - Windows
-        - Docker
-        - WSL2
-    validations:
-      required: false
-  - type: dropdown
-    id: gpu
-    attributes:
-      label: GPU
-      description: Which GPU are you using?
-      multiple: true
-      options:
-        - Nvidia
-        - AMD
-        - Intel
-        - Apple
-        - Other
-    validations:
-      required: false
-  - type: dropdown
-    id: cpu
-    attributes:
-      label: CPU
-      description: Which CPU are you using?
-      multiple: true
-      options:
-        - Intel
-        - AMD
-        - Apple
-        - Other
-    validations:
-      required: false
-  - type: input
-    id: version
-    attributes:
-      label: Ollama version
-      description: What version of Ollama are you using? (`ollama --version`)
-      placeholder: e.g., 0.1.32
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/20_feature_request.md

@@ -1,6 +0,0 @@
----
-name: Feature request
-about: Request a new feature
-labels: feature request
----
-

.github/ISSUE_TEMPLATE/30_model_request.md

@@ -1,5 +0,0 @@
----
-name: Model request
-about: Request support for a new model to be added to Ollama
-labels: model request
----

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Help
-    url: https://discord.com/invite/ollama
-    about: Please join our Discord server for help using Ollama
-  - name: Troubleshooting
-    url: https://github.com/ollama/ollama/blob/main/docs/faq.md#faq
-    about: See the FAQ for common issues and solutions

.github/workflows/latest.yaml

@@ -1,24 +0,0 @@
-name: latest
-
-on:
-  release:
-    types: [released]
-
-jobs:
-  update-latest:
-    environment: release
-    runs-on: linux
-    steps:
-      - uses: actions/checkout@v4
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ vars.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
-      - name: Tag images as latest
-        env:
-          PUSH: "1"
-        shell: bash
-        run: |
-          export "VERSION=${GITHUB_REF_NAME#v}"
-          ./scripts/tag_latest.sh

.github/workflows/release.yaml

@@ -1,776 +0,0 @@
-name: release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-env:
-  CGO_CFLAGS: '-O3'
-  CGO_CXXFLAGS: '-O3'
-
-jobs:
-  setup-environment:
-    runs-on: ubuntu-latest
-    environment: release
-    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
-        run: |
-          echo GOFLAGS="'-ldflags=-w -s \"-X=github.com/ollama/ollama/version.Version=${GITHUB_REF_NAME#v}\" \"-X=github.com/ollama/ollama/server.mode=release\"'" | tee -a $GITHUB_OUTPUT
-          echo VERSION="${GITHUB_REF_NAME#v}" | tee -a $GITHUB_OUTPUT
-          echo vendorsha=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION) | tee -a $GITHUB_OUTPUT
-
-  darwin-build:
-    runs-on: macos-26-xlarge
-    environment: release
-    needs: setup-environment
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
-      APPLE_IDENTITY: ${{ secrets.APPLE_IDENTITY }}
-      APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-      APPLE_TEAM_ID: ${{ vars.APPLE_TEAM_ID }}
-      APPLE_ID: ${{ vars.APPLE_ID }}
-      MACOS_SIGNING_KEY: ${{ secrets.MACOS_SIGNING_KEY }}
-      MACOS_SIGNING_KEY_PASSWORD: ${{ secrets.MACOS_SIGNING_KEY_PASSWORD }}
-      DEVELOPER_DIR: /Applications/Xcode_26.4.1.app/Contents/Developer
-      CGO_CFLAGS: '-mmacosx-version-min=14.0 -O3'
-      CGO_CXXFLAGS: '-mmacosx-version-min=14.0 -O3'
-      CGO_LDFLAGS: '-mmacosx-version-min=14.0 -O3'
-    steps:
-      - uses: actions/checkout@v4
-      - name: Select Xcode 26.4.1
-        shell: bash
-        run: |
-          set -euo pipefail
-          if [ ! -d "${DEVELOPER_DIR}" ]; then
-            echo "Missing ${DEVELOPER_DIR}"
-            ls -1 /Applications | grep '^Xcode' || true
-            exit 1
-          fi
-
-          sudo xcode-select -s "${DEVELOPER_DIR}"
-          sw_vers
-          xcodebuild -version
-          xcrun --sdk macosx --show-sdk-version
-          xcrun --find metal
-      - run: |
-          echo $MACOS_SIGNING_KEY | base64 --decode > certificate.p12
-          security create-keychain -p password build.keychain
-          security default-keychain -s build.keychain
-          security unlock-keychain -p password build.keychain
-          security import certificate.p12 -k build.keychain -P $MACOS_SIGNING_KEY_PASSWORD -T /usr/bin/codesign
-          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k password build.keychain
-          security set-keychain-settings -lut 3600 build.keychain
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          cache-dependency-path: |
-            go.sum
-            LLAMA_CPP_VERSION
-            MLX_VERSION
-            MLX_C_VERSION
-      - run: |
-          ./scripts/build_darwin.sh
-      - name: Log build results
-        run: |
-          ls -l dist/
-      - uses: actions/upload-artifact@v4
-        with:
-          name: bundles-darwin
-          path: |
-            dist/*.tgz
-            dist/*.tar.zst
-            dist/*.zip
-            dist/*.dmg
-
-  windows-depends:
-    needs: setup-environment
-    strategy:
-      matrix:
-        os: [windows]
-        arch: [amd64]
-        preset: ['CPU']
-        build-steps: ['cpu cpuArm64']
-        include:
-          - os: windows
-            arch: amd64
-            preset: 'CUDA 12'
-            build-steps: cuda12
-            install: https://developer.download.nvidia.com/compute/cuda/12.8.0/local_installers/cuda_12.8.0_571.96_windows.exe
-            cuda-components:
-              - '"cudart"'
-              - '"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
-          - os: windows
-            arch: amd64
-            preset: 'MLX CUDA 13'
-            build-steps: mlxCuda13
-            build-parallel: '16'
-            cmake-cuda-flags: '-t 6'
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
-    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
-    environment: release
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
-    steps:
-      - if: startsWith(matrix.preset, 'MLX ')
-        name: Increase pagefile to 200 GB
-        uses: al-cheb/configure-pagefile-action@v1.5
-        with:
-          minimum-size: 16GB
-          maximum-size: 200GB
-          disk-root: "D:"
-      - name: Install system dependencies
-        run: |
-          choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: matrix.preset == 'CPU'
-        name: Install Windows ARM64 cross compiler
-        run: |
-          Invoke-WebRequest -Uri "https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-x86_64.zip" -OutFile "${{ runner.temp }}\llvm-mingw-ucrt.zip"
-          Expand-Archive -Path ${{ runner.temp }}\llvm-mingw-ucrt.zip -DestinationPath "C:\Program Files\"
-          $installPath=(Resolve-Path -Path "C:\Program Files\llvm-mingw-*-ucrt-x86_64").path
-          if (!(Test-Path "$installPath\bin\aarch64-w64-mingw32-gcc.exe")) {
-            throw "llvm-mingw x86_64 package is missing the aarch64 cross compiler"
-          }
-      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan') || startsWith(matrix.preset, 'MLX ')
-        id: cache-install
-        uses: actions/cache/restore@v4
-        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: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'MLX ')
-        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 ${{ 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: startsWith(matrix.preset, 'MLX ')
-        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
-      - 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
-          OLLAMA_BUILD_PARALLEL: ${{ matrix.build-parallel || '' }}
-          OLLAMA_CMAKE_CUDA_FLAGS: ${{ matrix.cmake-cuda-flags || '' }}
-      - name: Log build results
-        run: |
-          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
-      - if: matrix.preset == 'CPU'
-        name: Verify Windows CPU payloads
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/windows-amd64/lib/ollama/llama-server.exe \
-            dist/windows-arm64/lib/ollama/llama-server.exe
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: depends-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}
-          path: dist\*
-
-  windows-build:
-    runs-on: windows
-    environment: release
-    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"
-      - run: |
-          ./scripts/build_windows ollama ollamaArm64 app appArm64
-      - name: Verify Windows build payloads
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/windows-amd64/ollama.exe \
-            dist/windows-arm64/ollama.exe
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - 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\*
-
-  windows-app:
-    runs-on: windows
-    environment: release
-    needs: [setup-environment, windows-build, windows-depends]
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
-      KEY_CONTAINER: ${{ vars.KEY_CONTAINER }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: google-github-actions/auth@v2
-        with:
-          project_id: ollama
-          credentials_json: ${{ secrets.GOOGLE_SIGNING_CREDENTIALS }}
-      - run: |
-          $ErrorActionPreference = "Stop"
-          Invoke-WebRequest -Uri "https://go.microsoft.com/fwlink/p/?LinkId=323507" -OutFile "${{ runner.temp }}\sdksetup.exe"
-          Start-Process "${{ runner.temp }}\sdksetup.exe" -ArgumentList @("/q") -NoNewWindow -Wait
-
-          Invoke-WebRequest -Uri "https://github.com/GoogleCloudPlatform/kms-integrations/releases/download/cng-v1.0/kmscng-1.0-windows-amd64.zip" -OutFile "${{ runner.temp }}\plugin.zip"
-          Expand-Archive -Path "${{ runner.temp }}\plugin.zip" -DestinationPath "${{ runner.temp }}\plugin\"
-          & "${{ runner.temp }}\plugin\*\kmscng.msi" /quiet
-
-          echo "${{ vars.OLLAMA_CERT }}" >ollama_inc.crt
-      - 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: Log dist contents after download
-        run: |
-          gci -path .\dist -recurse
-      - name: Verify Windows package inputs
-        shell: bash
-        run: |
-          set -euo pipefail
-          for payload in \
-            dist/windows-amd64/ollama.exe \
-            dist/windows-amd64/lib/ollama/llama-server.exe \
-            dist/windows-arm64/ollama.exe \
-            dist/windows-arm64/lib/ollama/llama-server.exe
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - run: |
-          ./scripts/build_windows.ps1 deps sign installer zip
-      - name: Log contents after build
-        run: |
-          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
-      - uses: actions/upload-artifact@v4
-        with:
-          name: bundles-windows
-          path: |
-            dist/*.zip
-            dist/*.ps1
-            dist/OllamaSetup.exe
-
-  linux-depends:
-    strategy:
-      matrix:
-        include:
-          - arch: amd64
-            target: llama-server-cpu
-          - arch: amd64
-            target: llama-server-cuda_v12
-          - arch: amd64
-            target: llama-server-cuda_v13
-          - arch: amd64
-            target: mlx
-          - arch: amd64
-            target: llama-server-rocm_v7_2
-          - arch: amd64
-            target: llama-server-vulkan
-          - arch: arm64
-            target: llama-server-cpu
-          - arch: arm64
-            target: llama-server-cuda_v12
-          - arch: arm64
-            target: llama-server-cuda_v13
-          - arch: arm64
-            target: jetpack-5
-          - arch: arm64
-            target: jetpack-6
-    runs-on: ${{ matrix.arch == 'arm64' && 'linux-arm64' || 'linux' }}
-    environment: release
-    needs: setup-environment
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
-        with:
-          username: ${{ vars.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
-      - if: matrix.target == 'mlx'
-        name: Increase Linux swap to 200 GB
-        shell: bash
-        run: |
-          set -e
-          SWAP_PATH=/swapfile-mlx
-          SWAP_SIZE_GB=200
-          if [ -f "$SWAP_PATH" ]; then
-              sudo swapoff "$SWAP_PATH" 2>/dev/null || true
-              sudo rm -f "$SWAP_PATH"
-          fi
-          if ! sudo fallocate -l ${SWAP_SIZE_GB}G "$SWAP_PATH" 2>/dev/null; then
-              echo "fallocate unsupported, falling back to dd"
-              sudo dd if=/dev/zero of="$SWAP_PATH" bs=1M count=$((SWAP_SIZE_GB * 1024))
-          fi
-          sudo chmod 600 "$SWAP_PATH"
-          sudo mkswap "$SWAP_PATH"
-          sudo swapon "$SWAP_PATH"
-          swapon --show
-          free -h
-      - uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: linux/${{ matrix.arch }}
-          target: ${{ matrix.target }}
-          provenance: false
-          sbom: false
-          build-args: |
-            GOFLAGS=${{ env.GOFLAGS }}
-            CGO_CFLAGS=${{ env.CGO_CFLAGS }}
-            CGO_CXXFLAGS=${{ env.CGO_CXXFLAGS }}
-            OLLAMA_MLX_BUILD_JOBS=16
-            OLLAMA_MLX_NVCC_THREADS=6
-            APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-            APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
-          cache-from: |
-            type=registry,ref=ollama/release:cache-${{ matrix.arch }}-${{ matrix.target }}
-            type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-          cache-to: type=registry,ref=ollama/release:cache-${{ matrix.arch }}-${{ matrix.target }},mode=max
-
-  # Build each Docker variant (OS, arch, and flavor) separately. Using QEMU is unreliable and slower.
-  # Heavy stages were pre-built by linux-depends; this job is cache-hit-only for those layers
-  # and just assembles, runs the Go build, pushes the final image, and extracts release bundles.
-  docker-build-push:
-    strategy:
-      matrix:
-        include:
-          - os: linux
-            arch: arm64
-            archive-target: archive
-            build-args: |
-              CGO_CFLAGS
-              CGO_CXXFLAGS
-              GOFLAGS
-              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-              APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
-              OLLAMA_MLX_BUILD_JOBS=16
-              OLLAMA_MLX_NVCC_THREADS=6
-            cache-from: |
-              type=registry,ref=ollama/release:cache-arm64-llama-server-cpu
-              type=registry,ref=ollama/release:cache-arm64-llama-server-cuda_v12
-              type=registry,ref=ollama/release:cache-arm64-llama-server-cuda_v13
-              type=registry,ref=ollama/release:cache-arm64-jetpack-5
-              type=registry,ref=ollama/release:cache-arm64-jetpack-6
-              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-          - os: linux
-            arch: amd64
-            archive-target: archive
-            build-args: |
-              CGO_CFLAGS
-              CGO_CXXFLAGS
-              GOFLAGS
-              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-              APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
-              OLLAMA_MLX_BUILD_JOBS=16
-              OLLAMA_MLX_NVCC_THREADS=6
-            cache-from: |
-              type=registry,ref=ollama/release:cache-amd64-llama-server-cpu
-              type=registry,ref=ollama/release:cache-amd64-llama-server-cuda_v12
-              type=registry,ref=ollama/release:cache-amd64-llama-server-cuda_v13
-              type=registry,ref=ollama/release:cache-amd64-mlx
-              type=registry,ref=ollama/release:cache-amd64-llama-server-rocm_v7_2
-              type=registry,ref=ollama/release:cache-amd64-llama-server-vulkan
-              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-          - os: linux
-            arch: amd64
-            suffix: '-rocm'
-            archive-target: image-archive
-            build-args: |
-              CGO_CFLAGS
-              CGO_CXXFLAGS
-              GOFLAGS
-              FLAVOR=rocm
-              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-              APT_PORTS_MIRROR=http://azure.ports.ubuntu.com/ubuntu-ports
-              OLLAMA_MLX_BUILD_JOBS=16
-              OLLAMA_MLX_NVCC_THREADS=6
-            cache-from: |
-              type=registry,ref=ollama/release:cache-amd64-llama-server-cpu
-              type=registry,ref=ollama/release:cache-amd64-llama-server-rocm_v7_2
-              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
-    environment: release
-    needs: [setup-environment, linux-depends]
-    env:
-      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
-        with:
-          username: ${{ vars.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
-      - id: build-push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: ${{ matrix.os }}/${{ matrix.arch }}
-          provenance: false
-          sbom: false
-          build-args: ${{ matrix.build-args }}
-          outputs: type=image,name=${{ vars.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
-          cache-from: ${{ matrix.cache-from }}
-          cache-to: type=inline
-      - run: |
-          mkdir -p ${{ matrix.os }}-${{ matrix.arch }}
-          echo "${{ steps.build-push.outputs.digest }}" >${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}.txt
-        working-directory: ${{ runner.temp }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: digest-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}
-          path: |
-            ${{ runner.temp }}/${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}.txt
-      - uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: ${{ matrix.os }}/${{ matrix.arch }}
-          target: ${{ matrix.archive-target }}
-          provenance: false
-          sbom: false
-          build-args: ${{ matrix.build-args }}
-          outputs: type=local,dest=dist/${{ matrix.os }}-${{ matrix.arch }}
-          cache-from: ${{ matrix.cache-from }}
-      - name: Deduplicate CUDA libraries
-        run: |
-          ./scripts/deduplicate_cuda_libs.sh dist/${{ matrix.os }}-${{ matrix.arch }}
-      - name: Verify Linux build payloads
-        shell: bash
-        run: |
-          set -euo pipefail
-          base="dist/${{ matrix.os }}-${{ matrix.arch }}"
-          for payload in \
-            "$base/bin/ollama" \
-            "$base/lib/ollama/llama-server"
-          do
-            [ -f "$payload" ] || { echo "missing $payload"; exit 1; }
-          done
-      - run: |
-          for COMPONENT in bin/* lib/ollama/*; do
-            case "$COMPONENT" in
-              bin/ollama*)               echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/*.so*)          echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/llama-server*|lib/ollama/llama-quantize*)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/cuda_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/vulkan*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/mlx*)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-mlx.tar.in ;;
-              lib/ollama/include*)       echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-mlx.tar.in ;;
-              lib/ollama/cuda_jetpack5)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack5.tar.in ;;
-              lib/ollama/cuda_jetpack6)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack6.tar.in ;;
-              lib/ollama/rocm_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-rocm.tar.in ;;
-            esac
-          done
-        working-directory: dist/${{ matrix.os }}-${{ matrix.arch }}
-      - if: matrix.suffix == '-rocm'
-        run: rm -f dist/${{ matrix.os }}-${{ matrix.arch }}/ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in
-      - run: |
-          echo "Manifests"
-          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in ; do
-            echo $ARCHIVE
-            cat $ARCHIVE
-          done
-      - run: |
-          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in; do
-            tar c -C dist/${{ matrix.os }}-${{ matrix.arch }} -T $ARCHIVE --owner 0 --group 0 | zstd -19 -T0 >$(basename ${ARCHIVE//.*/}.tar.zst) &
-          done
-          wait
-      - uses: actions/upload-artifact@v4
-        with:
-          name: bundles-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.suffix }}
-          path: |
-            *.tar.zst
-
-  # Merge Docker images for the same flavor into a single multi-arch manifest
-  docker-merge-push:
-    strategy:
-      matrix:
-        suffix: ['', '-rocm']
-    runs-on: linux
-    environment: release
-    needs: [docker-build-push]
-    steps:
-      - uses: docker/login-action@v3
-        with:
-          username: ${{ vars.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
-      - id: metadata
-        uses: docker/metadata-action@v4
-        with:
-          flavor: |
-            latest=false
-            suffix=${{ matrix.suffix }}
-          images: |
-            ${{ vars.DOCKER_REPO }}
-          tags: |
-            type=ref,enable=true,priority=600,prefix=pr-,event=pr
-            type=semver,pattern={{version}}
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: digest-*
-          path: ${{ runner.temp }}
-          merge-multiple: true
-      - run: |
-          docker buildx imagetools create $(echo '${{ steps.metadata.outputs.json }}' | jq -cr '.tags | map("-t", .) | join(" ")') $(cat *-${{ matrix.suffix }}.txt | xargs printf '${{ vars.DOCKER_REPO }}@%s ')
-          docker buildx imagetools inspect ${{ vars.DOCKER_REPO }}:${{ steps.metadata.outputs.version }}
-        working-directory: ${{ runner.temp }}
-
-  # Final release process
-  release:
-    runs-on: ubuntu-latest
-    environment: release
-    needs: [darwin-build, windows-app, docker-build-push]
-    permissions:
-      contents: write
-    env:
-      GH_TOKEN: ${{ github.token }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: bundles-*
-          path: dist
-          merge-multiple: true
-      - name: Log dist contents
-        run: |
-          ls -l dist/
-      - name: Copy install scripts to dist
-        run: |
-          cp scripts/install.sh dist/install.sh
-      - name: Verify release artifacts
-        run: |
-          required=(
-            dist/OllamaSetup.exe
-            dist/install.ps1
-            dist/install.sh
-            dist/ollama-windows-amd64.zip
-            dist/ollama-windows-arm64.zip
-          )
-          for payload in "${required[@]}"; do
-            if [ ! -f "$payload" ]; then
-              echo "::error::Missing expected release artifact: $payload"
-              exit 1
-            fi
-          done
-      - name: Generate checksum file
-        run: find . -type f -not -name 'sha256sum.txt' | xargs sha256sum | tee sha256sum.txt
-        working-directory: dist
-      - name: Create or update Release for tag
-        run: |
-          RELEASE_VERSION="$(echo ${GITHUB_REF_NAME} | cut -f1 -d-)"
-          echo "Looking for existing release for ${RELEASE_VERSION}"
-          OLD_TAG=$(gh release ls --json name,tagName | jq -r ".[] | select(.name == \"${RELEASE_VERSION}\") | .tagName")
-          if [ -n "$OLD_TAG" ]; then
-            echo "Updating release ${RELEASE_VERSION} to point to new tag ${GITHUB_REF_NAME}"
-            gh release edit ${OLD_TAG} --tag ${GITHUB_REF_NAME}
-          else
-            echo "Creating new release ${RELEASE_VERSION} pointing to tag ${GITHUB_REF_NAME}"
-            gh release create ${GITHUB_REF_NAME} \
-              --title ${RELEASE_VERSION} \
-              --draft \
-              --generate-notes \
-              --prerelease
-          fi
-      - name: Upload release artifacts
-        run: |
-          pids=()
-          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.tar.zst dist/*.exe dist/*.dmg dist/*.ps1 dist/*.sh ; do
-            echo "Uploading $payload"
-            gh release upload ${GITHUB_REF_NAME} $payload --clobber &
-            pids+=($!)
-            sleep 1
-          done
-          echo "Waiting for uploads to complete"
-          failed=0
-          for pid in "${pids[@]}"; do
-            if ! wait $pid; then
-              echo "::error::Upload failed (pid $pid)"
-              failed=1
-            fi
-          done
-          if [ $failed -ne 0 ]; then
-            echo "One or more uploads failed"
-            exit 1
-          fi
-          echo "done"

.github/workflows/test-install.yaml

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

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

@@ -1,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,420 +0,0 @@
-name: test
-
-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.
-  #
-  # For non-PR pushes, concurrency.group needs to be unique for every distinct
-  # CI run we want to have happen. Use run_id, which in practice means all
-  # non-PR CI runs will be allowed to run without preempting each other.
-  group: ${{ github.workflow }}-$${{ github.pull_request.number || github.run_id }}
-  cancel-in-progress: true
-
-on:
-  pull_request:
-    paths:
-      - '**/*'
-      - '!docs/**'
-      - '!README.md'
-
-jobs:
-  changes:
-    runs-on: ubuntu-latest
-    outputs:
-      changed: ${{ steps.changes.outputs.changed }}
-      app_changed: ${{ steps.changes.outputs.app_changed }}
-      enginehash: ${{ steps.changes.outputs.enginehash }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - id: changes
-        run: |
-          changed() {
-            local BASE=${{ github.event.pull_request.base.sha }}
-            local HEAD=${{ github.event.pull_request.head.sha }}
-            local MERGE_BASE=$(git merge-base $BASE $HEAD)
-            git diff-tree -r --no-commit-id --name-only "$MERGE_BASE" "$HEAD" \
-              | xargs python3 -c "import sys; from pathlib import Path; print(any(Path(x).match(glob) for x in sys.argv[1:] for glob in '$*'.split(' ')))"
-          }
-
-          echo changed=$(changed \
-            'CMakeLists.txt' \
-            'CMakePresets.json' \
-            'cmake/**' \
-            'cmake/**/*' \
-            'llama/server/**/*' \
-            'llama/compat/**/*' \
-            'LLAMA_CPP_VERSION' \
-            'MLX_VERSION' \
-            'MLX_C_VERSION' \
-            'llama/llama.cpp/**/*' \
-            'ml/backend/ggml/ggml/**/*' \
-            'x/imagegen/mlx/**' \
-            'x/imagegen/mlx/**/*' \
-            '.github/**/*') | tee -a $GITHUB_OUTPUT
-          echo app_changed=$(changed 'app/**' 'app/**/*') | tee -a $GITHUB_OUTPUT
-          echo enginehash=$(cat LLAMA_CPP_VERSION)-$(cat MLX_VERSION)-$(cat MLX_C_VERSION) | tee -a $GITHUB_OUTPUT
-
-  patches:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Verify patches apply cleanly
-        shell: bash
-        run: |
-          cmake -S llama/server -B "$RUNNER_TEMP/llama-server-patch-check" \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DBUILD_SHARED_LIBS=ON \
-            -DGGML_BACKEND_DL=ON \
-            -DGGML_NATIVE=OFF \
-            -DGGML_OPENMP=OFF \
-            -DGGML_CPU_ALL_VARIANTS=ON \
-            -DOLLAMA_RUNNER_DIR=
-
-  linux:
-    needs: [changes]
-    if: needs.changes.outputs.changed == 'True'
-    strategy:
-      matrix:
-        include:
-          - preset: CPU
-            superbuild_target: ollama-local
-            superbuild_dir: build/local-superbuild
-            superbuild_args: ''
-            expected_payload: lib/ollama/llama-server
-            install-go: true
-          - preset: CUDA
-            container: nvidia/cuda:13.0.0-devel-ubuntu22.04
-            superbuild_target: ollama-llama-server-cuda_v13
-            superbuild_dir: build/local-superbuild-cuda_v13
-            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=87'
-            expected_payload: lib/ollama/cuda_v13/libggml-cuda.so
-          - preset: ROCm
-            container: rocm/dev-ubuntu-22.04:7.2.1
-            extra-packages: rocm-libs
-            superbuild_target: ollama-llama-server-rocm_v7_2
-            superbuild_dir: build/local-superbuild-rocm_v7_2
-            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=rocm_v7_2 -DAMDGPU_TARGETS=gfx1010 -DCMAKE_PREFIX_PATH=/opt/rocm'
-            expected_payload: lib/ollama/rocm_v7_2/libggml-hip.so
-          - preset: Vulkan
-            container: ubuntu:22.04
-            extra-packages: >
-              mesa-vulkan-drivers vulkan-tools
-              libvulkan1 libvulkan-dev
-              vulkan-sdk spirv-headers cmake ccache g++ make
-            superbuild_target: ollama-llama-server-vulkan
-            superbuild_dir: build/local-superbuild-vulkan
-            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=vulkan'
-            expected_payload: lib/ollama/vulkan/libggml-vulkan.so
-          - preset: 'MLX CUDA 13'
-            container: nvidia/cuda:13.0.0-devel-ubuntu22.04
-            extra-packages: libcudnn9-dev-cuda-13 libopenblas-dev liblapack-dev liblapacke-dev git curl
-            superbuild_target: ollama-mlx-cuda_v13
-            superbuild_dir: build/local-superbuild-mlx-cuda_v13
-            superbuild_args: '-DOLLAMA_MLX_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=87 -DMLX_CUDA_ARCHITECTURES=80-virtual -DBLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu -DLAPACK_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu'
-            expected_payload: lib/ollama/mlx_cuda_v13/libmlx.so
-            install-go: true
-    runs-on: linux
-    container: ${{ matrix.container }}
-    steps:
-      - uses: actions/checkout@v4
-      - run: |
-          [ -n "${{ matrix.container }}" ] || sudo=sudo
-          $sudo apt-get update
-          # Add LunarG Vulkan SDK apt repo for Ubuntu 22.04
-          if [ "${{ matrix.preset }}" = "Vulkan" ]; then
-            $sudo apt-get install -y --no-install-recommends wget gnupg ca-certificates software-properties-common
-            wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | $sudo gpg --dearmor -o /usr/share/keyrings/lunarg-archive-keyring.gpg
-            # Use signed-by to bind the repo to the installed keyring to avoid NO_PUBKEY
-            echo "deb [signed-by=/usr/share/keyrings/lunarg-archive-keyring.gpg]  https://packages.lunarg.com/vulkan/1.4.313 jammy main" | $sudo tee /etc/apt/sources.list.d/lunarg-vulkan-1.4.313-jammy.list > /dev/null
-            $sudo apt-get update
-          fi
-          $sudo apt-get install -y cmake ccache curl git ${{ matrix.extra-packages }}
-          # Use a current CMake for upstream llama.cpp and Vulkan dependency discovery.
-          curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.31.2/cmake-3.31.2-linux-$(uname -m).tar.gz | $sudo tar xz -C /usr/local --strip-components 1
-          # Export VULKAN_SDK if provided by LunarG package (defensive)
-          if [ -d "/usr/lib/x86_64-linux-gnu/vulkan" ] && [ "${{ matrix.preset }}" = "Vulkan" ]; then
-            echo "VULKAN_SDK=/usr" >> $GITHUB_ENV
-          fi
-        env:
-          DEBIAN_FRONTEND: noninteractive
-      - if: matrix.install-go
-        name: Install Go
-        run: |
-          [ -n "${{ matrix.container }}" ] || sudo=sudo
-          GO_VERSION=$(awk '/^go / { print $2 }' go.mod)
-          curl -fsSL "https://golang.org/dl/go${GO_VERSION}.linux-$(dpkg --print-architecture).tar.gz" | $sudo tar xz -C /usr/local
-          echo "/usr/local/go/bin" >> $GITHUB_PATH
-      - uses: actions/cache@v4
-        with:
-          path: /github/home/.cache/ccache
-          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.enginehash }}
-      - name: Build native superbuild
-        if: matrix.superbuild_target
-        run: |
-          cmake -S . -B "${{ matrix.superbuild_dir }}" ${{ matrix.superbuild_args }}
-          CMAKE_BUILD_PARALLEL_LEVEL=$(nproc) cmake --build "${{ matrix.superbuild_dir }}" --target "${{ matrix.superbuild_target }}" -- -l $(nproc)
-          test -e "${{ matrix.superbuild_dir }}/${{ matrix.expected_payload }}"
-      - name: Verify local superbuild install
-        if: matrix.superbuild_target == 'ollama-local'
-        run: |
-          ./ollama --version
-          "${{ matrix.superbuild_dir }}/lib/ollama/llama-server" --version
-          test -x "${{ matrix.superbuild_dir }}/lib/ollama/llama-quantize"
-          cmake --install "${{ matrix.superbuild_dir }}" --component ollama-local --prefix "$RUNNER_TEMP/ollama-local"
-          "$RUNNER_TEMP/ollama-local/bin/ollama" --version
-          "$RUNNER_TEMP/ollama-local/lib/ollama/llama-server" --version
-          test -x "$RUNNER_TEMP/ollama-local/lib/ollama/llama-quantize"
-  windows:
-    needs: [changes]
-    if: needs.changes.outputs.changed == 'True'
-    strategy:
-      matrix:
-        include:
-          - preset: CPU
-            superbuild_target: ollama-local
-            superbuild_dir: build\local-superbuild
-            superbuild_args: ''
-            expected_payload: lib\ollama\llama-server.exe
-          - preset: CUDA
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            superbuild_target: ollama-llama-server-cuda_v13
-            superbuild_dir: build\local-superbuild-cuda_v13
-            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=80'
-            expected_payload: lib\ollama\cuda_v13\ggml-cuda.dll
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
-          - preset: ROCm
-            install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-26.Q1-Win11-For-HIP.exe
-            rocm-version: '7.1'
-            superbuild_target: ollama-llama-server-rocm_v7_1
-            superbuild_dir: build\local-superbuild-rocm_v7_1
-            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=rocm_v7_1 -DAMDGPU_TARGETS=gfx1010'
-            expected_payload: lib\ollama\rocm_v7_1\ggml-hip.dll
-          - preset: Vulkan
-            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
-            superbuild_target: ollama-llama-server-vulkan
-            superbuild_dir: build\local-superbuild-vulkan
-            superbuild_args: '-DOLLAMA_LLAMA_BACKENDS=vulkan'
-            expected_payload: lib\ollama\vulkan\ggml-vulkan.dll
-          - preset: 'MLX CUDA 13'
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            superbuild_target: ollama-mlx-cuda_v13
-            superbuild_dir: build\local-superbuild-mlx-cuda_v13
-            superbuild_args: '-DOLLAMA_MLX_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=80 -DMLX_CUDA_ARCHITECTURES=80-virtual'
-            expected_payload: lib\ollama\mlx_cuda_v13\mlx.dll
-            install-go: true
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
-    runs-on: windows
-    steps:
-      - run: |
-          choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan' || matrix.preset == 'MLX CUDA 13'
-        id: cache-install
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
-            C:\Program Files\AMD\ROCm
-            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'MLX CUDA 13'
-        name: Install CUDA ${{ matrix.cuda-version }}
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            $subpackages = @(${{ join(matrix.cuda-components, ', ') }}) | Foreach-Object {"${_}_${{ matrix.cuda-version }}"}
-            Start-Process -FilePath .\install.exe -ArgumentList (@("-s") + $subpackages) -NoNewWindow -Wait
-          }
-
-          $cudaPath = (Resolve-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\*").path
-          echo "$cudaPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-      - if: matrix.preset == 'ROCm'
-        name: Install ROCm ${{ matrix.rocm-version }}
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            Start-Process -FilePath .\install.exe -ArgumentList '-install' -NoNewWindow -Wait
-          }
-
-          $hipPath = (Resolve-Path "C:\Program Files\AMD\ROCm\*").path
-          echo "$hipPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo "CC=$hipPath\bin\clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CXX=$hipPath\bin\clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "HIPCXX=$hipPath\bin\clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "HIP_PLATFORM=amd" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CMAKE_PREFIX_PATH=$hipPath" | Out-File -FilePath $env:GITHUB_ENV -Append
-      - if: matrix.preset == 'Vulkan'
-        name: Install Vulkan ${{ matrix.rocm-version }}
-        run: |
-          $ErrorActionPreference = "Stop"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
-            Start-Process -FilePath .\install.exe -ArgumentList "-c","--am","--al","in" -NoNewWindow -Wait
-          }
-
-          $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
-          $vulkanRuntime = Join-Path $vulkanPath "Helpers\VulkanRT.exe"
-          if (Test-Path $vulkanRuntime) {
-            Start-Process -FilePath $vulkanRuntime -ArgumentList "/s" -NoNewWindow -Wait
-          }
-          echo "$vulkanPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo "VULKAN_SDK=$vulkanPath" >> $env:GITHUB_ENV
-      - if: matrix.preset == 'MLX CUDA 13'
-        name: Install cuDNN for MLX
-        run: |
-          $ErrorActionPreference = "Stop"
-          $cudnnRoot = "C:\Program Files\NVIDIA\CUDNN"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.cudnn-install }}" -OutFile "cudnn.zip"
-            Expand-Archive -Path cudnn.zip -DestinationPath cudnn-extracted
-            $cudnnDir = (Get-ChildItem -Path cudnn-extracted -Directory)[0].FullName
-            New-Item -ItemType Directory -Force -Path $cudnnRoot
-            Copy-Item -Path "$cudnnDir\*" -Destination "$cudnnRoot\" -Recurse
-          }
-
-          echo "CUDNN_ROOT_DIR=$cudnnRoot" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_INCLUDE_PATH=$cudnnRoot\include" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_LIBRARY_PATH=$cudnnRoot\lib\x64" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "$cudnnRoot\bin\x64" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-      - if: ${{ !cancelled() && steps.cache-install.outputs.cache-hit != 'true' }}
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
-            C:\Program Files\AMD\ROCm
-            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - uses: actions/checkout@v4
-      - if: matrix.superbuild_target == 'ollama-local' || matrix.install-go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: 'go.mod'
-      - uses: actions/cache@v4
-        with:
-          path: ${{ github.workspace }}\.ccache
-          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.enginehash }}
-      - name: Build native superbuild
-        if: matrix.superbuild_target
-        run: |
-          $ErrorActionPreference = "Stop"
-          Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
-          Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
-          cmake -S . -B "${{ matrix.superbuild_dir }}" ${{ matrix.superbuild_args }}
-          $env:CMAKE_BUILD_PARALLEL_LEVEL = [Environment]::ProcessorCount
-          cmake --build "${{ matrix.superbuild_dir }}" --target "${{ matrix.superbuild_target }}" -- -l $([Environment]::ProcessorCount)
-          if (!(Test-Path "${{ matrix.superbuild_dir }}\${{ matrix.expected_payload }}")) {
-            throw "missing ${{ matrix.expected_payload }}"
-          }
-        env:
-          CMAKE_GENERATOR: Ninja
-      - name: Verify local superbuild install
-        if: matrix.superbuild_target == 'ollama-local'
-        run: |
-          $ErrorActionPreference = "Stop"
-          & ".\ollama.exe" --version
-          & "${{ matrix.superbuild_dir }}\lib\ollama\llama-server.exe" --version
-          if (!(Test-Path "${{ matrix.superbuild_dir }}\lib\ollama\llama-quantize.exe")) {
-            throw "missing llama-quantize.exe"
-          }
-          $installPrefix = Join-Path $env:RUNNER_TEMP "ollama-local"
-          cmake --install "${{ matrix.superbuild_dir }}" --component ollama-local --prefix "$installPrefix"
-          & "$installPrefix\bin\ollama.exe" --version
-          & "$installPrefix\lib\ollama\llama-server.exe" --version
-          if (!(Test-Path "$installPrefix\lib\ollama\llama-quantize.exe")) {
-            throw "missing installed llama-quantize.exe"
-          }
-  go_mod_tidy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: check that 'go mod tidy' is clean
-        run: go mod tidy --diff || (echo "Please run 'go mod tidy'." && exit 1)
-
-  test:
-    needs: [changes]
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    env:
-      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
-        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') }}
-        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 ./...
-
-      - 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
-        with:
-          only-new-issues: true

.gitignore

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

.gitmodules

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

.golangci.yaml

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

.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

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

Dockerfile

@@ -1,319 +1,23 @@
-# vim: filetype=dockerfile
+FROM nvidia/cuda:11.8.0-devel-ubuntu22.04
 
-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
-
-#
-# GPU toolchain stages — provide compilers for llama-server GPU builds
-#
-
-FROM base AS cpu-deps
-RUN dnf install -y gcc-toolset-11-gcc gcc-toolset-11-gcc-c++
-ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
-
-FROM base AS cuda-12-deps
-ARG CUDA12VERSION=12.8
-RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
-ENV PATH=/usr/local/cuda-12/bin:$PATH
-
-FROM base AS cuda-13-deps
-ARG CUDA13VERSION=13.0
-RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
-ENV PATH=/usr/local/cuda-13/bin:$PATH
-
-FROM base AS rocm-7-deps
-ENV PATH=/opt/rocm/llvm/bin:/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:$PATH
-
-FROM base AS vulkan-deps
-ARG VULKANVERSION
-RUN ln -s /usr/bin/python3 /usr/bin/python \
-    && wget https://sdk.lunarg.com/sdk/download/${VULKANVERSION}/linux/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz -O /tmp/vulkansdk.tar.xz \
-    && tar xvf /tmp/vulkansdk.tar.xz -C /tmp \
-    && /tmp/${VULKANVERSION}/vulkansdk -j 8 vulkan-headers \
-    && /tmp/${VULKANVERSION}/vulkansdk -j 8 spirv-headers \
-    && /tmp/${VULKANVERSION}/vulkansdk -j 8 shaderc \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/include/* /usr/local/include/ \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/lib/* /usr/local/lib \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/share/* /usr/local/share/ \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/bin/* /usr/local/bin/ \
-    && rm -rf /tmp/${VULKANVERSION} /tmp/vulkansdk.tar.xz
-ENV VULKAN_SDK=/usr/local
-
-#
-# llama-server stages — rebuild when LLAMA_CPP_VERSION, llama/server/, or llama/compat/ changes.
-#
-# CPU stage: llama-server + ggml-base + ggml-cpu variants → lib/ollama/
-# GPU stages: GPU backend .so only → lib/ollama/<variant>/
-#
-
-FROM cpu-deps AS llama-server-cpu
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset cpu \
-        && cmake --build build/llama-server-cpu -- -l $(nproc) \
-        && cmake --install build/llama-server-cpu --component llama-server --strip \
-        && for lib in \
-            /usr/lib64/libgomp.so* \
-            /usr/lib64/libomp.so* \
-            /opt/rh/gcc-toolset-11/root/usr/lib64/libgomp.so* \
-            /opt/rh/gcc-toolset-11/root/usr/lib64/libomp.so*; do \
-                [ -e "$lib" ] && cp -a "$lib" dist/lib/ollama/ || true; \
-            done
-
-FROM scratch AS publish-llama-server-cpu
-COPY --from=llama-server-cpu dist/lib/ollama /lib/ollama/
-
-FROM cuda-12-deps AS llama-server-cuda_v12
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_v12_linux \
-        && cmake --build build/llama-server-cuda_v12 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_v12 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_v12
-COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
-
-FROM cuda-13-deps AS llama-server-cuda_v13
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_v13_linux \
-        && cmake --build build/llama-server-cuda_v13 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_v13 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_v13
-COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
-
-FROM rocm-7-deps AS llama-server-rocm_v7_2
-ENV CC=clang CXX=clang++
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset rocm_v7_2_linux \
-        && cmake --build build/llama-server-rocm_v7_2 -- -l $(nproc) \
-        && cmake --install build/llama-server-rocm_v7_2 --component llama-server --strip
-RUN rm -f dist/lib/ollama/rocm_v7_2/rocblas/library/*gfx90[06]*
-
-FROM scratch AS publish-llama-server-rocm_v7_2
-COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama/
-
-FROM vulkan-deps AS llama-server-vulkan
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset vulkan \
-        && cmake --build build/llama-server-vulkan -- -l $(nproc) \
-        && cmake --install build/llama-server-vulkan --component llama-server --strip
-
-FROM scratch AS publish-llama-server-vulkan
-COPY --from=llama-server-vulkan dist/lib/ollama /lib/ollama/
-
-#
-# JetPack stages — self-contained with their own base images
-#
-
-FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK5VERSION} AS jetpack-5
-ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache git unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_jetpack5 \
-        && cmake --build build/llama-server-cuda_jetpack5 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_jetpack5 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_jetpack5
-COPY --from=jetpack-5 dist/lib/ollama /lib/ollama/
-
-FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK6VERSION} AS jetpack-6
-ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache git unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
-COPY LLAMA_CPP_VERSION .
-COPY llama/server llama/server
-COPY llama/compat llama/compat
-RUN --mount=type=cache,target=/root/.ccache \
-    cmake -S llama/server --preset llama_cuda_jetpack6 \
-        && cmake --build build/llama-server-cuda_jetpack6 -- -l $(nproc) \
-        && cmake --install build/llama-server-cuda_jetpack6 --component llama-server --strip
-
-FROM scratch AS publish-llama-server-cuda_jetpack6
-COPY --from=jetpack-6 dist/lib/ollama /lib/ollama/
-
-#
-# MLX stage
-#
-
-FROM base AS mlx
-ARG CUDA13VERSION=13.0
-ARG OLLAMA_MLX_BUILD_JOBS=
-ARG OLLAMA_MLX_NVCC_THREADS=2
-ARG MLX_CUDA_RAM_MB=
-RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-} \
-    && dnf install -y openblas-devel lapack-devel \
-    && dnf install -y libcudnn9-cuda-13 libcudnn9-devel-cuda-13 \
-    && 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
-COPY . .
+ARG TARGETARCH
 ARG GOFLAGS="'-ldflags=-w -s'"
-ENV CGO_ENABLED=1
-ARG CGO_CFLAGS
-ARG CGO_CXXFLAGS
-ENV CGO_CFLAGS="${CGO_CFLAGS}"
-ENV CGO_CXXFLAGS="${CGO_CXXFLAGS}"
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    go build -trimpath -buildmode=pie -o /bin/ollama .
 
-FROM scratch AS publish-go
-COPY --from=build /bin/ollama /bin/ollama
+WORKDIR /go/src/github.com/jmorganca/ollama
+RUN apt-get update && apt-get install -y git build-essential cmake
+ADD https://dl.google.com/go/go1.21.3.linux-$TARGETARCH.tar.gz /tmp/go1.21.3.tar.gz
+RUN mkdir -p /usr/local && tar xz -C /usr/local </tmp/go1.21.3.tar.gz
 
-#
-# Assembly stages — combine llama-server variants + GPU runtime libs
-#
+COPY . .
+ENV GOARCH=$TARGETARCH
+ENV GOFLAGS=$GOFLAGS
+RUN /usr/local/go/bin/go generate ./... \
+    && /usr/local/go/bin/go build .
 
-FROM --platform=linux/amd64 scratch AS amd64
-COPY --from=llama-server-cpu      dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-vulkan   dist/lib/ollama /lib/ollama/
-COPY --from=mlx     /go/src/github.com/ollama/ollama/dist/lib/ollama /lib/ollama/
-
-FROM --platform=linux/arm64 scratch AS arm64
-COPY --from=llama-server-cpu dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-cuda_v12 dist/lib/ollama /lib/ollama/
-COPY --from=llama-server-cuda_v13 dist/lib/ollama /lib/ollama/
-COPY --from=jetpack-5 dist/lib/ollama/ /lib/ollama/
-COPY --from=jetpack-6 dist/lib/ollama/ /lib/ollama/
-
-FROM scratch AS rocm
-COPY --from=llama-server-cpu  dist/lib/ollama /lib/ollama
-COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama
-
-FROM --platform=linux/amd64 scratch AS amd64-archive
-COPY --from=amd64 /lib/ollama /lib/ollama/
-COPY --from=llama-server-rocm_v7_2 dist/lib/ollama /lib/ollama/
-
-FROM --platform=linux/arm64 scratch AS arm64-archive
-COPY --from=arm64 /lib/ollama /lib/ollama/
-
-FROM ${TARGETARCH}-archive AS archive
-COPY --from=build /bin/ollama /bin/ollama
-
-FROM ${FLAVOR} AS image-archive
-COPY --from=build /bin/ollama /bin/ollama
-
-FROM ubuntu:24.04
-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
-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
+FROM ubuntu:22.04
+RUN apt-get update && apt-get install -y ca-certificates
+COPY --from=0 /go/src/github.com/jmorganca/ollama/ollama /bin/ollama
 EXPOSE 11434
+ENV OLLAMA_HOST 0.0.0.0
 ENTRYPOINT ["/bin/ollama"]
 CMD ["serve"]

Dockerfile.build

@@ -0,0 +1,31 @@
+# centos7 amd64 dependencies
+FROM --platform=linux/amd64 nvidia/cuda:11.3.1-devel-centos7 AS base-amd64
+RUN yum install -y https://repo.ius.io/ius-release-el7.rpm centos-release-scl && \
+    yum update -y && \
+    yum install -y devtoolset-10-gcc devtoolset-10-gcc-c++ git236 wget
+RUN wget "https://github.com/Kitware/CMake/releases/download/v3.27.6/cmake-3.27.6-linux-x86_64.sh" -O cmake-installer.sh && chmod +x cmake-installer.sh && ./cmake-installer.sh --skip-license --prefix=/usr/local
+ENV PATH /opt/rh/devtoolset-10/root/usr/bin:$PATH
+
+# centos8 arm64 dependencies
+FROM --platform=linux/arm64 nvidia/cuda-arm64:11.3.1-devel-centos8 AS base-arm64
+RUN sed -i -e 's/mirrorlist/#mirrorlist/g' -e 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+RUN yum install -y git cmake
+
+FROM base-${TARGETARCH}
+ARG TARGETARCH
+ARG GOFLAGS="'-ldflags -w -s'"
+
+# install go
+ADD https://dl.google.com/go/go1.21.3.linux-$TARGETARCH.tar.gz /tmp/go1.21.3.tar.gz
+RUN mkdir -p /usr/local && tar xz -C /usr/local </tmp/go1.21.3.tar.gz
+
+# build the final binary
+WORKDIR /go/src/github.com/jmorganca/ollama
+COPY . .
+
+ENV GOOS=linux
+ENV GOARCH=$TARGETARCH
+ENV GOFLAGS=$GOFLAGS
+
+RUN /usr/local/go/bin/go generate ./... && \
+    /usr/local/go/bin/go build .

LLAMA_CPP_VERSION

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

MLX_C_VERSION

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

MLX_VERSION

@@ -1 +0,0 @@
-de7b4ed986b6d6f55b8ace5e73c24d1ca0bea89b

README.md

@@ -1,356 +1,282 @@
-<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">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" height="200px" srcset="https://github.com/jmorganca/ollama/assets/3325447/56ea1849-1284-4645-8970-956de6e51c3c">
+    <img alt="logo" height="200px" src="https://github.com/jmorganca/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7">
+  </picture>
+</div>
 
 # Ollama
 
-Start building with open models.
+[![Discord](https://dcbadge.vercel.app/api/server/ollama?style=flat&compact=true)](https://discord.gg/ollama)
 
-## Download
+Get up and running with large language models locally.
 
 ### macOS
 
-```shell
-curl -fsSL https://ollama.com/install.sh | sh
-```
-
-or [download manually](https://ollama.com/download/Ollama.dmg)
+[Download](https://ollama.ai/download/Ollama-darwin.zip)
 
 ### Windows
 
-```shell
-irm https://ollama.com/install.ps1 | iex
+Coming soon!
+
+### Linux & WSL2
+
+```
+curl https://ollama.ai/install.sh | sh
 ```
 
-or [download manually](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/jmorganca/ollama/blob/main/docs/linux.md)
 
 ### Docker
 
 The official [Ollama Docker image](https://hub.docker.com/r/ollama/ollama) `ollama/ollama` is available on Docker Hub.
 
-### Libraries
+## Quickstart
 
-- [ollama-python](https://github.com/ollama/ollama-python)
-- [ollama-js](https://github.com/ollama/ollama-js)
-
-### Community
-
-- [Discord](https://discord.gg/ollama)
-- [𝕏 (Twitter)](https://x.com/ollama)
-- [Reddit](https://reddit.com/r/ollama)
-
-## Get started
+To run and chat with [Llama 2](https://ollama.ai/library/llama2):
 
 ```
-ollama
+ollama run llama2
 ```
 
-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 open-source models available on [ollama.ai/library](https://ollama.ai/library 'ollama model library')
 
-To launch a specific integration:
+Here are some example open-source models that can be downloaded:
+
+| Model              | Parameters | Size  | Download                       |
+| ------------------ | ---------- | ----- | ------------------------------ |
+| Neural Chat        | 7B         | 4.1GB | `ollama run neural-chat`       |
+| Starling           | 7B         | 4.1GB | `ollama run starling-lm`       |
+| Mistral            | 7B         | 4.1GB | `ollama run mistral`           |
+| Llama 2            | 7B         | 3.8GB | `ollama run llama2`            |
+| Code Llama         | 7B         | 3.8GB | `ollama run codellama`         |
+| Llama 2 Uncensored | 7B         | 3.8GB | `ollama run llama2-uncensored` |
+| Llama 2 13B        | 13B        | 7.3GB | `ollama run llama2:13b`        |
+| Llama 2 70B        | 70B        | 39GB  | `ollama run llama2:70b`        |
+| Orca Mini          | 3B         | 1.9GB | `ollama run orca-mini`         |
+| Vicuna             | 7B         | 3.8GB | `ollama run vicuna`            |
+
+> Note: You should have at least 8 GB of RAM to run the 3B models, 16 GB to run the 7B models, and 32 GB to run the 13B models.
+
+## Customize your own 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 `llama2` model:
 
 ```
-ollama launch claude
+ollama pull llama2
 ```
 
-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 llama2
+
+# set the temperature to 1 [higher is more creative, lower is more coherent]
+PARAMETER temperature 1
+
+# set the system prompt
+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.
+
+### Pull a model
+
+```
+ollama pull llama2
+```
+
+> This command can also be used to update a local model. Only the diff will be pulled.
+
+### Remove a model
+
+```
+ollama rm llama2
+```
+
+### Copy a model
+
+```
+ollama cp llama2 my-llama2
+```
+
+### 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.
+```
+
+### Pass in prompt as arguments
+
+```
+$ ollama run llama2 "Summarize this file: $(cat README.md)"
+ Ollama is a lightweight, extensible framework for building and running language models on the local machine. It provides a simple API for creating, running, and managing models, as well as a library of pre-built models that can be easily used in a variety of applications.
+```
+
+### List models on your computer
+
+```
+ollama list
+```
+
+### Start Ollama
+
+`ollama serve` is used when you want to start ollama without running the desktop application.
+
+## Building
+
+Install `cmake` and `go`:
+
+```
+brew install cmake go
+```
+
+Then generate dependencies and build:
+
+```
+go generate ./...
+go build .
+```
+
+Next, start the server:
+
+```
+./ollama serve
+```
+
+Finally, in a separate shell, run a model:
+
+```
+./ollama run llama2
+```
 
 ## REST API
 
 Ollama has a REST API for running and managing models.
+For example, to generate text from a model:
 
 ```
-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": "llama2",
+  "prompt":"Why is the sky blue?"
 }'
 ```
 
-See the [API documentation](https://docs.ollama.com/api) for all endpoints.
-
-### Python
-
-```
-pip install ollama
-```
-
-```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.
+### Mobile
 
-### Chat Interfaces
+- [Mobile Artificial Intelligence Distribution](https://github.com/MaidFoundation/Maid) (Maid)
 
-#### Web
+### Web & Desktop
 
-- [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
+- [HTML UI](https://github.com/rtcfirefly/ollama-ui)
+- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama)
+- [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)
+- [Web UI](https://github.com/ollama-webui/ollama-webui)
+- [Ollamac](https://github.com/kevinhermawan/Ollamac)
+- [big-AGI](https://github.com/enricoros/big-agi/blob/main/docs/config-ollama.md)
+- [Cheshire Cat assistant framework](https://github.com/cheshire-cat-ai/core)
+- [Amica](https://github.com/semperai/amica)
 
-#### Desktop
+### Terminal
 
-- [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
+- [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)
+- [ogpt.nvim](https://github.com/huynle/ogpt.nvim)
+- [gptel Emacs client](https://github.com/karthink/gptel)
+- [Oatmeal](https://github.com/dustinblackman/oatmeal)
 
-#### Mobile
-
-- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) - One-click Ollama on Android
-
-> SwiftChat, Enchanted, Maid, Ollama App, Reins, and ConfiChat listed above also support mobile platforms.
-
-### Code Editors & Development
-
-- [Cline](https://github.com/cline/cline) - VS Code extension for multi-file/whole-repo coding
-- [Continue](https://github.com/continuedev/continue) - Open-source AI code assistant for any IDE
-- [Void](https://github.com/voideditor/void) - Open source AI code editor, Cursor alternative
-- [Copilot for Obsidian](https://github.com/logancyang/obsidian-copilot) - AI assistant for Obsidian
-- [twinny](https://github.com/rjmacarthy/twinny) - Copilot and Copilot chat alternative
-- [gptel Emacs client](https://github.com/karthink/gptel) - LLM client for Emacs
-- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) - Use Ollama as GitHub Copilot
-- [Obsidian Local GPT](https://github.com/pfrankov/obsidian-local-gpt) - Local AI for Obsidian
-- [Ellama Emacs client](https://github.com/s-kostyaev/ellama) - LLM tool for Emacs
-- [orbiton](https://github.com/xyproto/orbiton) - Config-free text editor with Ollama tab completion
-- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) - Sublime Text 4 AI assistant
-- [VT Code](https://github.com/vinhnx/vtcode) - Rust-based terminal coding agent with Tree-sitter
-- [QodeAssist](https://github.com/Palm1r/QodeAssist) - AI coding assistant for Qt Creator
-- [AI Toolkit for VS Code](https://aka.ms/ai-tooklit/ollama-docs) - Microsoft-official VS Code extension
-- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama) - Natural language interface for computers
-
-### Libraries & SDKs
-
-- [LiteLLM](https://github.com/BerriAI/litellm) - Unified API for 100+ LLM providers
-- [Semantic Kernel](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama) - Microsoft AI orchestration SDK
-- [LangChain4j](https://github.com/langchain4j/langchain4j) - Java LangChain ([example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java))
-- [LangChainGo](https://github.com/tmc/langchaingo/) - Go LangChain ([example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example))
-- [Spring AI](https://github.com/spring-projects/spring-ai) - Spring framework AI support ([docs](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html))
-- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
-- [Ollama for Ruby](https://github.com/crmne/ruby_llm) - Ruby LLM library
-- [any-llm](https://github.com/mozilla-ai/any-llm) - Unified LLM interface by Mozilla
-- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp) - .NET SDK
-- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) - Rust LangChain ([example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs))
-- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) - Java agent framework ([example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama))
-- [Elixir LangChain](https://github.com/brainlid/langchain) - Elixir LangChain
-- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs) - Rust SDK
-- [LangChain for .NET](https://github.com/tryAGI/LangChain) - .NET LangChain ([example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs))
-- [chromem-go](https://github.com/philippgille/chromem-go) - Go vector database with Ollama embeddings ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
-- [LangChainDart](https://github.com/davidmigloz/langchain_dart) - Dart LangChain
-- [LlmTornado](https://github.com/lofcz/llmtornado) - Unified C# interface for multiple inference APIs
-- [Ollama4j for Java](https://github.com/ollama4j/ollama4j) - Java SDK
-- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel) - Laravel integration
-- [Ollama for Swift](https://github.com/mattt/ollama-swift) - Swift SDK
-- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama) - Data framework for LLM apps
-- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md) - AI pipeline framework
-- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama) - Google AI framework
-- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp) - C++ SDK
-- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) - Julia LLM toolkit ([example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama))
-- [Ollama for R - rollama](https://github.com/JBGruber/rollama) - R SDK
-- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama) - AI gateway
-- [Testcontainers](https://testcontainers.com/modules/ollama/) - Container-based testing
-- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama) - PHP AI framework
-
-### Frameworks & Agents
-
-- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) - Autonomous AI agent platform
-- [crewAI](https://github.com/crewAIInc/crewAI) - Multi-agent orchestration framework
-- [Strands Agents](https://github.com/strands-agents/sdk-python) - Model-driven agent building by AWS
-- [Cheshire Cat](https://github.com/cheshire-cat-ai/core) - AI assistant framework
-- [any-agent](https://github.com/mozilla-ai/any-agent) - Unified agent framework interface by Mozilla
-- [Stakpak](https://github.com/stakpak/agent) - Open source DevOps agent
-- [Hexabot](https://github.com/hexastack/hexabot) - Conversational AI builder
-- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) - Multi-agent orchestration ([docs](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama))
-
-### RAG & Knowledge Bases
-
-- [RAGFlow](https://github.com/infiniflow/ragflow) - RAG engine based on deep document understanding
-- [R2R](https://github.com/SciPhi-AI/R2R) - Open-source RAG engine
-- [MaxKB](https://github.com/1Panel-dev/MaxKB/) - Ready-to-use RAG chatbot
-- [Minima](https://github.com/dmayboroda/minima) - On-premises or fully local RAG
-- [Chipper](https://github.com/TilmanGriesel/chipper) - AI interface with Haystack RAG
-- [ARGO](https://github.com/xark-argo/argo) - RAG and deep research on Mac/Windows/Linux
-- [Archyve](https://github.com/nickthecook/archyve) - RAG-enabling document library
-- [Casibase](https://casibase.org) - AI knowledge base with RAG and SSO
-- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) - Native client with RAG and multi-agent automation
-
-### Bots & Messaging
-
-- [LangBot](https://github.com/RockChinQ/LangBot) - Multi-platform messaging bots with agents and RAG
-- [AstrBot](https://github.com/Soulter/AstrBot/) - Multi-platform chatbot with RAG and plugins
-- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) - TypeScript Discord bot
-- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram) - Telegram bot
-- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) - Telegram bot for roleplay
-
-### Terminal & CLI
-
-- [aichat](https://github.com/sigoden/aichat) - All-in-one LLM CLI with Shell Assistant, RAG, and AI tools
-- [oterm](https://github.com/ggozad/oterm) - Terminal client for Ollama
-- [gollama](https://github.com/sammcj/gollama) - Go-based model manager for Ollama
-- [tlm](https://github.com/yusufcanb/tlm) - Local shell copilot
-- [tenere](https://github.com/pythops/tenere) - TUI for LLMs
-- [ParLlama](https://github.com/paulrobello/parllama) - TUI for Ollama
-- [llm-ollama](https://github.com/taketwo/llm-ollama) - Plugin for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/)
-- [ShellOracle](https://github.com/djcopley/ShellOracle) - Shell command suggestions
-- [LLM-X](https://github.com/mrdjohnson/llm-x) - Progressive web app for LLMs
-- [cmdh](https://github.com/pgibler/cmdh) - Natural language to shell commands
-- [VT](https://github.com/vinhnx/vt.ai) - Minimal multimodal AI chat app
-
-### Productivity & Apps
-
-- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) - AI collaborative workspace, self-hostable Notion alternative
-- [Screenpipe](https://github.com/mediar-ai/screenpipe) - 24/7 screen and mic recording with AI-powered search
-- [Vibe](https://github.com/thewh1teagle/vibe) - Transcribe and analyze meetings
-- [Page Assist](https://github.com/n4ze3m/page-assist) - Chrome extension for AI-powered browsing
-- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) - Private, on-device browser AI assistant
-- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server) - Security proxy for Ollama
-- [1Panel](https://github.com/1Panel-dev/1Panel/) - Web-based Linux server management
-- [Writeopia](https://github.com/Writeopia/Writeopia) - Text editor with Ollama integration
-- [QA-Pilot](https://github.com/reid41/QA-Pilot) - GitHub code repository understanding
-- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama) - Ollama in Raycast
-- [Painting Droid](https://github.com/mateuszmigas/painting-droid) - Painting app with AI integrations
-- [Serene Pub](https://github.com/doolijb/serene-pub) - AI roleplaying app
-- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) - Document management with Ollama workflows
-- [TagSpaces](https://www.tagspaces.org) - File management with [AI tagging](https://docs.tagspaces.org/ai/)
-
-### Observability & Monitoring
-
-- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) - Debug, evaluate, and monitor LLM applications
-- [OpenLIT](https://github.com/openlit/openlit) - OpenTelemetry-native monitoring for Ollama and GPUs
-- [Lunary](https://lunary.ai/docs/integrations/ollama) - LLM observability with analytics and PII masking
-- [Langfuse](https://langfuse.com/docs/integrations/ollama) - Open source LLM observability
-- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) - AI observability and evaluation for agents
-- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) - Open source LLM observability
-
-### Database & Embeddings
-
-- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database ([guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md))
-- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) - Connect Ollama with 200+ data platforms
-- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) - Embeddable vector database for Go ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
-- [Kangaroo](https://github.com/dbkangaroo/kangaroo) - AI-powered SQL client
-
-### Infrastructure & Deployment
-
-#### Cloud
-
-- [Google Cloud](https://cloud.google.com/run/docs/tutorials/gpu-gemma2-with-ollama)
-- [Fly.io](https://fly.io/docs/python/do-more/add-ollama/)
-- [Koyeb](https://www.koyeb.com/deploy/ollama)
-- [Harbor](https://github.com/av/harbor) - Containerized LLM toolkit with Ollama as default backend
-
-#### Package Managers
+### Package managers
 
 - [Pacman](https://archlinux.org/packages/extra/x86_64/ollama/)
-- [Homebrew](https://formulae.brew.sh/formula/ollama)
-- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
-- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
-- [Gentoo](https://github.com/gentoo/guru/tree/master/app-misc/ollama)
-- [Flox](https://flox.dev/blog/ollama-part-one)
-- [Guix channel](https://codeberg.org/tusharhero/ollama-guix)
+
+### Libraries
+
+- [LangChain](https://python.langchain.com/docs/integrations/llms/ollama) and [LangChain.js](https://js.langchain.com/docs/modules/model_io/models/llms/integrations/ollama) with [example](https://js.langchain.com/docs/use_cases/question_answering/local_retrieval_qa)
+- [LangChainGo](https://github.com/tmc/langchaingo/) with [example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example)
+- [LlamaIndex](https://gpt-index.readthedocs.io/en/stable/examples/llm/ollama.html)
+- [LiteLLM](https://github.com/BerriAI/litellm)
+- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp)
+- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs)
+- [Ollama4j for Java](https://github.com/amithkoujalgi/ollama4j)
+- [ModelFusion Typescript Library](https://modelfusion.dev/integration/model-provider/ollama)
+- [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
+- [Ollama for Dart](https://github.com/breitburg/dart-ollama)
+- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel)
+
+### Mobile
+
+- [Maid](https://github.com/danemadsen/Maid) (Mobile Artificial Intelligence Distribution)
+
+### Extensions & Plugins
+
+- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)
+- [Discollama](https://github.com/mxyng/discollama) (Discord bot inside the Ollama discord channel)
+- [Continue](https://github.com/continuedev/continue)
+- [Obsidian Ollama plugin](https://github.com/hinterdupfinger/obsidian-ollama)
+- [Logseq Ollama plugin](https://github.com/omagdy7/ollama-logseq)
+- [Dagger Chatbot](https://github.com/samalba/dagger-chatbot)
+- [Discord AI Bot](https://github.com/mekb-turtle/discord-ai-bot)
+- [Hass Ollama Conversation](https://github.com/ej52/hass-ollama-conversation)
+- [Rivet plugin](https://github.com/abrenneke/rivet-plugin-ollama)
+- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using Ollama)
+- [Obsidian BMO Chatbot plugin](https://github.com/longy2k/obsidian-bmo-chatbot)

SECURITY.md

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

agent/approval.go

@@ -1,209 +0,0 @@
-package agent
-
-import (
-	"context"
-	"strings"
-	"sync"
-)
-
-type ApprovalRequest struct {
-	WorkingDir string
-	Calls      []ApprovalToolCall
-}
-
-func (r *ApprovalRequest) AddToolCall(id, name string, args map[string]any) {
-	r.Calls = append(r.Calls, ApprovalToolCall{
-		ToolCallID:    id,
-		ToolName:      name,
-		Args:          args,
-		ApprovalScope: toolApprovalScope(name, args),
-	})
-}
-
-type ApprovalToolCall struct {
-	ToolCallID    string
-	ToolName      string
-	Args          map[string]any
-	ApprovalScope string
-}
-
-type Approval struct {
-	Allow       bool
-	AllowAll    bool
-	AllowScopes []string
-	Reason      string
-}
-
-type ApprovalPrompter interface {
-	PromptApproval(context.Context, ApprovalRequest) (Approval, error)
-}
-
-type ApprovalState struct {
-	mu       sync.RWMutex
-	allowAll bool
-	scopes   map[string]bool
-}
-
-func (s *ApprovalState) Set(allowAll bool, scopes map[string]bool) {
-	if s == nil {
-		return
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.allowAll = allowAll
-	s.scopes = cloneApprovalScopes(scopes)
-}
-
-func (s *ApprovalState) SetAllowAll(allowAll bool) {
-	if s == nil {
-		return
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.allowAll = allowAll
-}
-
-func (s *ApprovalState) AllowAll() bool {
-	if s == nil {
-		return false
-	}
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.allowAll
-}
-
-func (s *ApprovalState) Allows(scope string) bool {
-	if s == nil {
-		return false
-	}
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.allowAll || s.scopes[scope]
-}
-
-func (s *ApprovalState) Apply(result *Approval) {
-	if s == nil || result == nil {
-		return
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if result.AllowAll {
-		result.Allow = true
-		s.allowAll = true
-	}
-	if len(result.AllowScopes) > 0 {
-		result.Allow = true
-		if s.scopes == nil {
-			s.scopes = make(map[string]bool, len(result.AllowScopes))
-		}
-		for _, scope := range result.AllowScopes {
-			scope = strings.TrimSpace(scope)
-			if scope != "" {
-				s.scopes[scope] = true
-			}
-		}
-	}
-}
-
-func (s *ApprovalState) AllowScopes(scopes []string) {
-	if s == nil {
-		return
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.scopes == nil {
-		s.scopes = make(map[string]bool, len(scopes))
-	}
-	for _, scope := range scopes {
-		scope = strings.TrimSpace(scope)
-		if scope != "" {
-			s.scopes[scope] = true
-		}
-	}
-}
-
-func cloneApprovalScopes(src map[string]bool) map[string]bool {
-	if len(src) == 0 {
-		return nil
-	}
-	dst := make(map[string]bool, len(src))
-	for scope, allowed := range src {
-		if allowed {
-			dst[scope] = true
-		}
-	}
-	return dst
-}
-
-func (s *Session) needsApproval(tool Tool, name string, args map[string]any) bool {
-	return ToolRequiresApproval(tool, args) && !s.allows(toolApprovalScope(name, args))
-}
-
-// allows reports whether scope is permitted by the session's accumulated approval state.
-func (s *Session) allows(scope string) bool {
-	if s == nil || s.ApprovalState == nil {
-		return false
-	}
-	return s.ApprovalState.Allows(scope)
-}
-
-// applyApproval merges an approval result into the session's state and marks
-// the result as allowed when scopes or allow-all were granted. It mutates
-// result.Allow so the caller can branch on the effective decision.
-func (s *Session) applyApproval(result *Approval) {
-	if s == nil || result == nil {
-		return
-	}
-	if s.ApprovalState == nil {
-		s.ApprovalState = &ApprovalState{}
-	}
-	s.ApprovalState.Apply(result)
-}
-
-func (s *Session) authorizeToolCalls(ctx context.Context, req ApprovalRequest) (Approval, error) {
-	if s == nil || len(req.Calls) == 0 || (s.ApprovalState != nil && s.ApprovalState.AllowAll()) {
-		return Approval{Allow: true}, nil
-	}
-	if s.ApprovalPrompter == nil {
-		return Approval{
-			Reason: "Tool execution requires approval, but no approval prompter is available.",
-		}, nil
-	}
-
-	result, err := s.ApprovalPrompter.PromptApproval(ctx, req)
-	if err != nil {
-		return Approval{}, err
-	}
-	s.applyApproval(&result)
-	return result, nil
-}
-
-// toolApprovalScope returns the approval scope key for a tool invocation.
-//
-// For shell tools (bash/powershell) the scope is "<tool>\x00<command>": the
-// exact, trimmed command byte string. "Always allow this command" therefore
-// matches ONLY that precise string — any whitespace, quoting, or casing
-// variant, or any command that is a superset of the approved one, will
-// re-prompt. The NUL separator is safe because a shell command string cannot
-// contain a literal NUL. For all other tools the scope is the tool name.
-func toolApprovalScope(toolName string, args map[string]any) string {
-	toolName = strings.TrimSpace(toolName)
-	if isShellApprovalTool(toolName) {
-		if command, ok := stringArg(args, "command"); ok {
-			command = strings.TrimSpace(command)
-			if command != "" {
-				return toolName + "\x00" + command
-			}
-		}
-	}
-	return toolName
-}
-
-func isShellApprovalTool(name string) bool {
-	return name == "bash" || name == "powershell"
-}
-
-func stringArg(args map[string]any, key string) (string, bool) {
-	value, ok := args[key].(string)
-	return value, ok
-}

agent/approval_test.go

@@ -1,55 +0,0 @@
-package agent
-
-import "testing"
-
-func TestApprovalRequestScopesShellCommandsToExactCommand(t *testing.T) {
-	req := ApprovalRequest{}
-	req.AddToolCall("call-1", "bash", map[string]any{"command": " pwd "})
-	req.AddToolCall("call-2", "powershell", map[string]any{"command": "Get-ChildItem"})
-	req.AddToolCall("call-3", "edit", map[string]any{"path": "README.md"})
-
-	tests := []struct {
-		index int
-		want  string
-	}{
-		{index: 0, want: "bash\x00pwd"},
-		{index: 1, want: "powershell\x00Get-ChildItem"},
-		{index: 2, want: "edit"},
-	}
-	for _, tt := range tests {
-		if got := req.Calls[tt.index].ApprovalScope; got != tt.want {
-			t.Fatalf("call %d approval scope = %q, want %q", tt.index, got, tt.want)
-		}
-	}
-}
-
-func TestSessionApplyApprovalScopes(t *testing.T) {
-	session := &Session{}
-	result := Approval{AllowScopes: []string{"edit", "bash\x00pwd", " "}}
-
-	session.applyApproval(&result)
-
-	if !result.Allow {
-		t.Fatal("scoped approval should allow the current request")
-	}
-	if !session.allows("edit") || !session.allows("bash\x00pwd") {
-		t.Fatal("scoped approval was not saved")
-	}
-	if session.allows("bash") || session.allows("bash\x00ls") {
-		t.Fatal("shell approval was too broad")
-	}
-	if session.ApprovalState.AllowAll() {
-		t.Fatal("allow all = true, want false for scoped approval")
-	}
-}
-
-func TestSessionApplyApprovalAllowAll(t *testing.T) {
-	session := &Session{}
-	result := Approval{AllowAll: true}
-
-	session.applyApproval(&result)
-
-	if !result.Allow || !session.allows("anything") {
-		t.Fatalf("allow all = %v result = %#v, want allow all", session.ApprovalState.AllowAll(), result)
-	}
-}

agent/compactor.go

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

agent/compactor_test.go

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

agent/events.go

@@ -1,79 +0,0 @@
-package agent
-
-import (
-	"context"
-
-	"github.com/ollama/ollama/api"
-)
-
-type EventType string
-
-const (
-	EventMessageDelta       EventType = "message_delta"
-	EventThinkingDelta      EventType = "thinking_delta"
-	EventToolCallDetected   EventType = "tool_call_detected"
-	EventToolStarted        EventType = "tool_started"
-	EventToolFinished       EventType = "tool_finished"
-	EventCompactionStarted  EventType = "compaction_started"
-	EventCompactionProgress EventType = "compaction_progress"
-	EventCompacted          EventType = "compacted"
-	EventCompactionSkipped  EventType = "compaction_skipped"
-	EventRunFinished        EventType = "run_finished"
-	EventError              EventType = "error"
-)
-
-type Event struct {
-	Type       EventType      `json:"type"`
-	RunID      string         `json:"runId,omitempty"`
-	ChatID     string         `json:"chatId,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"`
-	Error      string         `json:"error,omitempty"`
-}
-
-type EventSink interface {
-	Emit(Event) error
-}
-
-type EventSinkFunc func(Event) error
-
-func (fn EventSinkFunc) Emit(event Event) error {
-	if fn == nil {
-		return nil
-	}
-	return fn(event)
-}
-
-func (s *Session) emit(event Event) error {
-	if s == nil {
-		return nil
-	}
-	var firstErr error
-	for _, sink := range s.EventSinks {
-		if sink == nil {
-			continue
-		}
-		if err := sink.Emit(event); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	return firstErr
-}
-
-func (s *Session) emitIgnoringCanceled(ctx context.Context, event Event) error {
-	err := s.emit(event)
-	if err != nil && ctx != nil && ctx.Err() != nil {
-		//nolint:nilerr // Event sinks may close during cancellation; cancellation is not a user-facing emit failure.
-		return nil
-	}
-	return err
-}

agent/registry.go

@@ -1,97 +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 (r *Registry) Register(tool Tool) {
-	if r == nil || tool == nil {
-		return
-	}
-	if r.tools == nil {
-		r.tools = make(map[string]Tool)
-	}
-	r.tools[tool.Name()] = tool
-}
-
-func (r *Registry) Get(name string) (Tool, bool) {
-	if r == nil {
-		return nil, false
-	}
-	tool, ok := r.tools[name]
-	return tool, ok
-}
-
-func (r *Registry) Names() []string {
-	if r == nil {
-		return nil
-	}
-	names := make([]string, 0, len(r.tools))
-	for name := range r.tools {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return names
-}
-
-func (r *Registry) Tools() api.Tools {
-	if r == nil {
-		return nil
-	}
-	names := r.Names()
-	apiTools := make(api.Tools, 0, len(names))
-	for _, name := range names {
-		tool := r.tools[name]
-		apiTools = append(apiTools, api.Tool{
-			Type:     "function",
-			Function: tool.Schema(),
-		})
-	}
-	return apiTools
-}
-
-func (r *Registry) Execute(ctx context.Context, toolCtx ToolContext, call api.ToolCall) (ToolResult, error) {
-	tool, ok := r.Get(call.Function.Name)
-	if !ok {
-		return ToolResult{}, fmt.Errorf("unknown tool: %s", call.Function.Name)
-	}
-	return tool.Execute(ctx, toolCtx, call.Function.Arguments.ToMap())
-}
-
-func ToolRequiresApproval(tool Tool, args map[string]any) bool {
-	if tool == nil {
-		return false
-	}
-	if t, ok := tool.(ApprovalRequired); ok {
-		return t.RequiresApproval(args)
-	}
-	return false
-}

agent/session.go

@@ -1,1023 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/google/uuid"
-
-	"github.com/ollama/ollama/api"
-)
-
-type ChatClient interface {
-	Chat(context.Context, *api.ChatRequest, api.ChatResponseFunc) error
-}
-
-type Session struct {
-	Client           ChatClient
-	EventSinks       []EventSink
-	Tools            *Registry
-	DisableTools     bool
-	ApprovalPrompter ApprovalPrompter
-	ApprovalState    *ApprovalState
-	WorkingDir       string
-	Compactor        Compactor
-}
-
-type RunOptions struct {
-	ChatID       string
-	Model        string
-	SystemPrompt string
-	Messages     []api.Message
-	NewMessages  []api.Message
-	Format       string
-	Options      map[string]any
-	Think        *api.ThinkValue
-	KeepAlive    *api.Duration
-	// MaxToolRounds limits consecutive model/tool cycles.
-	// Zero uses the default guard; negative disables the guard for tests or
-	// special callers.
-	MaxToolRounds int
-}
-
-type RunResult struct {
-	Messages   []api.Message
-	Latest     api.ChatResponse
-	WorkingDir string
-}
-
-const (
-	defaultMaxToolRounds              = 100
-	maxToolResultRunes                = 60000
-	smallContextToolResultRunes       = 6000
-	tinyContextToolResultRunes        = 3200
-	smallContextToolResultTokenWindow = 8192
-	tinyContextToolResultTokenWindow  = 4096
-	toolTruncationMarkerReserveTokens = 64
-	toolOutputFullOmissionPrefix      = "[tool output truncated: output omitted because the context is full;"
-)
-
-type toolOutputOverflow struct {
-	toolName   string
-	toolCallID string
-	content    string
-}
-
-type toolBatchResult struct {
-	messages  []api.Message
-	stop      toolExecutionStop
-	overflows []toolOutputOverflow
-}
-
-type toolExecutionStop string
-
-const (
-	toolExecutionDenied   toolExecutionStop = "denied"
-	toolExecutionCanceled toolExecutionStop = "canceled"
-)
-
-const toolExecutionDisabledMessage = "Tool execution disabled."
-
-type runPhase int
-
-const (
-	runPhaseModel runPhase = iota
-	runPhaseTools
-	runPhaseCompact
-	runPhaseDone
-)
-
-type runState struct {
-	runID string
-	opts  RunOptions
-
-	phase runPhase
-
-	messages []api.Message
-	latest   api.ChatResponse
-
-	assistant        api.Message
-	pendingToolCalls []api.ToolCall
-	canceled         bool
-
-	toolBatch *toolBatchResult
-
-	consecutiveModelErrors int
-	toolRounds             int
-	maxToolRounds          int
-	compactionSkipNotified bool
-
-	finish runFinish
-}
-
-type runFinish struct {
-	status         string
-	ignoreCanceled bool
-	err            error
-}
-
-func (st *runState) finishDone() {
-	st.finish = runFinish{status: "done"}
-	st.phase = runPhaseDone
-}
-
-func (st *runState) finishDenied() {
-	st.finish = runFinish{status: "denied"}
-	st.phase = runPhaseDone
-}
-
-func (st *runState) finishCanceled() {
-	st.finish = runFinish{status: "canceled", ignoreCanceled: true}
-	st.phase = runPhaseDone
-}
-
-func (st *runState) finishError(err error) {
-	st.finish = runFinish{err: err}
-	st.phase = runPhaseDone
-}
-
-func (s *Session) Run(ctx context.Context, opts RunOptions) (*RunResult, error) {
-	if s == nil {
-		return nil, errors.New("nil session")
-	}
-	if s.Client == nil {
-		return nil, errors.New("agent session requires a chat client")
-	}
-	if opts.Model == "" {
-		return nil, errors.New("agent session requires a model")
-	}
-	if s.ApprovalState == nil {
-		s.ApprovalState = &ApprovalState{}
-	}
-	runID := uuid.NewString()
-	messages := make([]api.Message, 0, len(opts.Messages)+len(opts.NewMessages))
-	for _, msg := range opts.Messages {
-		messages = append(messages, sanitizeMessageForRun(msg))
-	}
-	for _, msg := range opts.NewMessages {
-		msg = sanitizeMessageForRun(msg)
-		messages = append(messages, msg)
-	}
-
-	if err := s.checkPreflightPromptBudget(opts, messages); err != nil {
-		s.emit(Event{Type: EventError, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Error: err.Error()})
-		return nil, err
-	}
-
-	st := runState{
-		runID:         runID,
-		opts:          opts,
-		phase:         runPhaseModel,
-		messages:      messages,
-		maxToolRounds: resolvedMaxToolRounds(opts.MaxToolRounds),
-	}
-	for {
-		switch st.phase {
-		case runPhaseModel:
-			if err := s.runModelStep(ctx, &st); err != nil {
-				return nil, err
-			}
-		case runPhaseTools:
-			if err := s.runToolStep(ctx, &st); err != nil {
-				return nil, err
-			}
-		case runPhaseCompact:
-			if err := s.runCompactionStep(ctx, &st); err != nil {
-				return &RunResult{Messages: st.messages, Latest: st.latest, WorkingDir: s.WorkingDir}, err
-			}
-		case runPhaseDone:
-			return s.finishRun(ctx, &st)
-		}
-	}
-}
-
-func (s *Session) runModelStep(ctx context.Context, st *runState) error {
-	opts := st.opts
-
-	assistant, pendingToolCalls, canceled, err := s.chatRound(ctx, st.runID, opts, st.messages, &st.latest)
-	if err != nil {
-		var statusErr api.StatusError
-		if errors.As(err, &statusErr) && statusErr.StatusCode >= 500 && st.consecutiveModelErrors < 2 {
-			st.consecutiveModelErrors++
-			st.messages = append(st.messages, api.Message{
-				Role:    "user",
-				Content: fmt.Sprintf("Your previous response caused an error: %s\n\nPlease try again with a valid response.", statusErr.ErrorMessage),
-			})
-			return nil
-		}
-		s.emit(Event{Type: EventError, RunID: st.runID, ChatID: opts.ChatID, Model: opts.Model, Error: err.Error()})
-		return err
-	}
-	st.consecutiveModelErrors = 0
-	st.assistant = assistant
-	st.pendingToolCalls = pendingToolCalls
-	st.canceled = canceled
-
-	if !messageEmpty(assistant) {
-		st.messages = append(st.messages, assistant)
-	}
-
-	if len(pendingToolCalls) == 0 {
-		st.toolBatch = nil
-		st.phase = runPhaseCompact
-		return nil
-	}
-
-	if canceled {
-		skipped, skipErr := s.skipToolCalls(ctx, st.runID, opts, pendingToolCalls, "Tool execution skipped because the run was canceled.")
-		if skipErr != nil {
-			s.emit(Event{Type: EventError, RunID: st.runID, ChatID: opts.ChatID, Model: opts.Model, Error: skipErr.Error()})
-			return skipErr
-		}
-		st.messages = append(st.messages, skipped...)
-		st.finishCanceled()
-		return nil
-	}
-
-	if s.DisableTools {
-		batch, skipErr := s.disabledToolCalls(ctx, st.runID, opts, st.messages, pendingToolCalls)
-		if skipErr != nil {
-			s.emit(Event{Type: EventError, RunID: st.runID, ChatID: opts.ChatID, Model: opts.Model, Error: skipErr.Error()})
-			return skipErr
-		}
-		st.messages = append(st.messages, batch.messages...)
-		st.toolBatch = &batch
-		st.phase = runPhaseCompact
-		return nil
-	}
-
-	if s.Tools == nil {
-		st.finishDone()
-		return nil
-	}
-
-	if st.maxToolRounds >= 0 && st.toolRounds >= st.maxToolRounds {
-		content := fmt.Sprintf("Tool execution skipped because the max tool-round limit of %d was reached. Send another message to continue.", st.maxToolRounds)
-		toolMessages, skipErr := s.skipToolCalls(ctx, st.runID, opts, pendingToolCalls, content)
-		if skipErr != nil {
-			s.emit(Event{Type: EventError, RunID: st.runID, ChatID: opts.ChatID, Model: opts.Model, Error: skipErr.Error()})
-			return skipErr
-		}
-		st.messages = append(st.messages, toolMessages...)
-		err := fmt.Errorf("tool round limit reached after %d rounds; send another message to continue", st.maxToolRounds)
-		s.emit(Event{Type: EventError, RunID: st.runID, ChatID: opts.ChatID, Model: opts.Model, Error: err.Error()})
-		st.finishError(err)
-		return nil
-	}
-
-	st.phase = runPhaseTools
-	return nil
-}
-
-func (s *Session) runToolStep(ctx context.Context, st *runState) error {
-	batch, err := s.executeToolCalls(ctx, st.runID, st.opts, st.messages, st.pendingToolCalls)
-	if err != nil {
-		s.emit(Event{Type: EventError, RunID: st.runID, ChatID: st.opts.ChatID, Model: st.opts.Model, Error: err.Error()})
-		return err
-	}
-
-	st.messages = append(st.messages, batch.messages...)
-	st.toolBatch = &batch
-	st.phase = runPhaseCompact
-	return nil
-}
-
-func (s *Session) runCompactionStep(ctx context.Context, st *runState) error {
-	opts := st.opts
-	var err error
-	if st.toolBatch != nil && len(st.toolBatch.overflows) > 0 {
-		st.messages, st.compactionSkipNotified, err = s.compactForToolOutputOverflow(ctx, st.runID, opts, st.messages, st.latest, st.assistant, st.toolBatch.messages, st.toolBatch.overflows, st.compactionSkipNotified)
-	} else {
-		st.messages, st.compactionSkipNotified, err = s.maybeCompact(ctx, st.runID, opts, st.messages, st.latest, st.compactionSkipNotified)
-	}
-	if err != nil {
-		s.emit(Event{Type: EventError, RunID: st.runID, ChatID: opts.ChatID, Model: opts.Model, Error: err.Error()})
-		return err
-	}
-
-	if st.toolBatch == nil {
-		if st.canceled {
-			st.finishCanceled()
-		} else {
-			st.finishDone()
-		}
-		return nil
-	}
-
-	switch st.toolBatch.stop {
-	case toolExecutionDenied:
-		st.finishDenied()
-	case toolExecutionCanceled:
-		st.finishCanceled()
-	default:
-		st.toolRounds++
-		st.assistant = api.Message{}
-		st.pendingToolCalls = nil
-		st.toolBatch = nil
-		st.phase = runPhaseModel
-	}
-	return nil
-}
-
-func (s *Session) finishRun(ctx context.Context, st *runState) (*RunResult, error) {
-	if st.finish.status != "" {
-		event := Event{Type: EventRunFinished, RunID: st.runID, ChatID: st.opts.ChatID, Model: st.opts.Model, Status: st.finish.status}
-		var err error
-		if st.finish.ignoreCanceled {
-			err = s.emitIgnoringCanceled(ctx, event)
-		} else {
-			err = s.emit(event)
-		}
-		if err != nil {
-			return nil, err
-		}
-	}
-	return &RunResult{Messages: st.messages, Latest: st.latest, WorkingDir: s.WorkingDir}, st.finish.err
-}
-
-func (s *Session) chatRound(ctx context.Context, runID string, opts RunOptions, messages []api.Message, latest *api.ChatResponse) (api.Message, []api.ToolCall, bool, error) {
-	var tools api.Tools
-	if !s.DisableTools {
-		tools = s.availableTools()
-	}
-	req := buildChatRequest(opts, messages, tools)
-
-	assistant := api.Message{Role: "assistant"}
-	var pendingToolCalls []api.ToolCall
-
-	err := s.Client.Chat(ctx, &req, func(response api.ChatResponse) error {
-		if response.Message.Role != "" {
-			assistant.Role = response.Message.Role
-		}
-
-		if response.Message.Content == "" && response.Message.Thinking == "" && len(response.Message.ToolCalls) == 0 {
-			*latest = response
-			return nil
-		}
-
-		if response.Message.Thinking != "" {
-			assistant.Thinking += response.Message.Thinking
-			if err := s.emit(Event{Type: EventThinkingDelta, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Thinking: response.Message.Thinking}); err != nil {
-				return err
-			}
-		}
-
-		if response.Message.Content != "" {
-			assistant.Content += response.Message.Content
-			if err := s.emit(Event{Type: EventMessageDelta, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Content: response.Message.Content}); err != nil {
-				return err
-			}
-		}
-
-		if len(response.Message.ToolCalls) > 0 {
-			assistant.ToolCalls = append(assistant.ToolCalls, response.Message.ToolCalls...)
-			pendingToolCalls = append(pendingToolCalls, response.Message.ToolCalls...)
-			if err := s.emit(Event{Type: EventToolCallDetected, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, ToolCalls: response.Message.ToolCalls}); err != nil {
-				return err
-			}
-		}
-
-		*latest = response
-		return nil
-	})
-	if err != nil {
-		if isContextCanceledError(ctx, err) {
-			return assistant, pendingToolCalls, true, nil
-		}
-		return assistant, pendingToolCalls, false, err
-	}
-
-	return assistant, pendingToolCalls, false, nil
-}
-
-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...)
-	}
-
-	format := opts.Format
-	if format == "json" {
-		format = `"` + format + `"`
-	}
-
-	req := api.ChatRequest{
-		Model:    opts.Model,
-		Messages: requestMessages,
-		Format:   json.RawMessage(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 (s *Session) executeToolCalls(ctx context.Context, runID string, opts RunOptions, messages []api.Message, calls []api.ToolCall) (toolBatchResult, error) {
-	batch := toolBatchResult{
-		messages: make([]api.Message, 0, len(calls)),
-	}
-	projectedMessages := append([]api.Message(nil), messages...)
-
-	type plannedToolCall struct {
-		call       api.ToolCall
-		tool       Tool
-		toolName   string
-		args       map[string]any
-		workingDir string
-	}
-	plans := make([]plannedToolCall, 0, len(calls))
-	batchWorkingDir := s.currentWorkingDir()
-	approvalReq := ApprovalRequest{WorkingDir: batchWorkingDir}
-	for _, call := range calls {
-		toolName := call.Function.Name
-		args := call.Function.Arguments.ToMap()
-		tool, ok := s.Tools.Get(toolName)
-		plans = append(plans, plannedToolCall{
-			call:       call,
-			tool:       tool,
-			toolName:   toolName,
-			args:       args,
-			workingDir: batchWorkingDir,
-		})
-		if ok && s.needsApproval(tool, toolName, args) {
-			approvalReq.AddToolCall(call.ID, toolName, args)
-		}
-	}
-
-	if len(approvalReq.Calls) > 0 {
-		approvalResult, err := s.authorizeToolCalls(ctx, approvalReq)
-		if err != nil {
-			if ctx.Err() != nil {
-				skipped, skipErr := s.skipToolCalls(ctx, runID, opts, calls, "Tool execution skipped because the run was canceled.")
-				if skipErr != nil {
-					return toolBatchResult{}, skipErr
-				}
-				batch.messages = append(batch.messages, skipped...)
-				batch.stop = toolExecutionCanceled
-				return batch, nil
-			}
-			return toolBatchResult{}, err
-		}
-		if !approvalResult.Allow {
-			content := approvalResult.Reason
-			if content == "" {
-				content = "Tool execution denied."
-			}
-			for _, plan := range plans {
-				msg := s.toolMessageForContext(plan.toolName, plan.call.ID, content, opts, projectedMessages)
-				batch.messages = append(batch.messages, msg)
-				projectedMessages = append(projectedMessages, msg)
-				deniedContent := msg.Content
-				if emitErr := s.emit(Event{Type: EventToolFinished, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "denied", ToolCallID: plan.call.ID, ToolName: plan.toolName, Args: plan.args, Content: deniedContent, Error: deniedContent}); emitErr != nil {
-					return toolBatchResult{}, emitErr
-				}
-			}
-			batch.stop = toolExecutionDenied
-			return batch, nil
-		}
-	}
-
-	for i, plan := range plans {
-		call := plan.call
-		toolName := plan.toolName
-		args := plan.args
-		if ctx.Err() != nil {
-			skipped, skipErr := s.skipToolCalls(ctx, runID, opts, calls[i:], "Tool execution skipped because the run was canceled.")
-			if skipErr != nil {
-				return toolBatchResult{}, skipErr
-			}
-			batch.messages = append(batch.messages, skipped...)
-			batch.stop = toolExecutionCanceled
-			return batch, nil
-		}
-		if plan.tool == nil {
-			content := fmt.Sprintf("Error: unknown tool: %s", toolName)
-			msg := s.toolMessageForContext(toolName, call.ID, content, opts, projectedMessages)
-			batch.messages = append(batch.messages, msg)
-			projectedMessages = append(projectedMessages, msg)
-			content = msg.Content
-			if toolOutputFullyOmitted(content) {
-				batch.overflows = append(batch.overflows, toolOutputOverflow{toolName: toolName, toolCallID: call.ID, content: fmt.Sprintf("Error: unknown tool: %s", toolName)})
-			}
-			if emitErr := s.emit(Event{Type: EventToolFinished, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "failed", ToolCallID: call.ID, ToolName: toolName, Args: args, Content: content, Error: fmt.Sprintf("unknown tool: %s", toolName)}); emitErr != nil {
-				return toolBatchResult{}, emitErr
-			}
-			continue
-		}
-
-		if err := s.emit(Event{Type: EventToolStarted, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "running", ToolCallID: call.ID, ToolName: toolName, WorkingDir: plan.workingDir, Args: args}); err != nil {
-			return toolBatchResult{}, err
-		}
-
-		result, err := s.Tools.Execute(ctx, ToolContext{WorkingDir: plan.workingDir}, call)
-		if err != nil {
-			rawContent := fmt.Sprintf("Error: %v", err)
-			msg := s.toolMessageForContext(toolName, call.ID, rawContent, opts, projectedMessages)
-			batch.messages = append(batch.messages, msg)
-			projectedMessages = append(projectedMessages, msg)
-			content := msg.Content
-			if toolOutputFullyOmitted(content) {
-				batch.overflows = append(batch.overflows, toolOutputOverflow{toolName: toolName, toolCallID: call.ID, content: rawContent})
-			}
-			if emitErr := s.emitIgnoringCanceled(ctx, Event{Type: EventToolFinished, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "failed", ToolCallID: call.ID, ToolName: toolName, Args: args, Content: content, Error: err.Error()}); emitErr != nil {
-				return toolBatchResult{}, emitErr
-			}
-			if ctx.Err() != nil {
-				skipped, skipErr := s.skipToolCalls(ctx, runID, opts, calls[i+1:], "Tool execution skipped because the run was canceled.")
-				if skipErr != nil {
-					return toolBatchResult{}, skipErr
-				}
-				batch.messages = append(batch.messages, skipped...)
-				batch.stop = toolExecutionCanceled
-				return batch, nil
-			}
-			continue
-		}
-
-		eventWorkingDir := plan.workingDir
-		if s.applyToolWorkingDir(result.WorkingDir) {
-			eventWorkingDir = s.WorkingDir
-		}
-		rawContent := result.Content
-
-		msg := s.toolMessageForContext(toolName, call.ID, rawContent, opts, projectedMessages)
-		batch.messages = append(batch.messages, msg)
-		projectedMessages = append(projectedMessages, msg)
-		content := msg.Content
-
-		if toolOutputFullyOmitted(content) {
-			batch.overflows = append(batch.overflows, toolOutputOverflow{toolName: toolName, toolCallID: call.ID, content: rawContent})
-		}
-		if err := s.emitIgnoringCanceled(ctx, Event{Type: EventToolFinished, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "done", ToolCallID: call.ID, ToolName: toolName, WorkingDir: eventWorkingDir, Args: args, Content: content}); err != nil {
-			return toolBatchResult{}, err
-		}
-		if ctx.Err() != nil {
-			skipped, skipErr := s.skipToolCalls(ctx, runID, opts, calls[i+1:], "Tool execution skipped because the run was canceled.")
-			if skipErr != nil {
-				return toolBatchResult{}, skipErr
-			}
-			batch.messages = append(batch.messages, skipped...)
-			batch.stop = toolExecutionCanceled
-			return batch, nil
-		}
-	}
-	return batch, nil
-}
-
-func (s *Session) disabledToolCalls(ctx context.Context, runID string, opts RunOptions, messages []api.Message, calls []api.ToolCall) (toolBatchResult, error) {
-	batch := toolBatchResult{
-		messages: make([]api.Message, 0, len(calls)),
-	}
-	projectedMessages := append([]api.Message(nil), messages...)
-	for _, call := range calls {
-		toolName := call.Function.Name
-		args := call.Function.Arguments.ToMap()
-		msg := s.toolMessageForContext(toolName, call.ID, toolExecutionDisabledMessage, opts, projectedMessages)
-		batch.messages = append(batch.messages, msg)
-		projectedMessages = append(projectedMessages, msg)
-		if emitErr := s.emitIgnoringCanceled(ctx, Event{Type: EventToolFinished, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "disabled", ToolCallID: call.ID, ToolName: toolName, Args: args, Content: msg.Content, Error: msg.Content}); emitErr != nil {
-			return toolBatchResult{}, emitErr
-		}
-	}
-	return batch, nil
-}
-
-func (s *Session) skipToolCalls(ctx context.Context, runID string, opts RunOptions, calls []api.ToolCall, content string) ([]api.Message, error) {
-	toolMessages := make([]api.Message, 0, len(calls))
-	for _, call := range calls {
-		toolName := call.Function.Name
-		args := call.Function.Arguments.ToMap()
-		msg := toolMessage(toolName, call.ID, content)
-		toolMessages = append(toolMessages, msg)
-		if emitErr := s.emitIgnoringCanceled(ctx, Event{Type: EventToolFinished, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Status: "skipped", ToolCallID: call.ID, ToolName: toolName, Args: args, Content: msg.Content, Error: msg.Content}); emitErr != nil {
-			return nil, emitErr
-		}
-	}
-	return toolMessages, nil
-}
-
-func (s *Session) currentWorkingDir() string {
-	if s.WorkingDir != "" {
-		return s.WorkingDir
-	}
-	wd, err := os.Getwd()
-	if err != nil {
-		return ""
-	}
-	s.WorkingDir = wd
-	return s.WorkingDir
-}
-
-func (s *Session) applyToolWorkingDir(next string) bool {
-	next = strings.TrimSpace(next)
-	if next == "" {
-		return false
-	}
-	current := s.currentWorkingDir()
-	nextAbs, err := canonicalSessionPath(next)
-	if err != nil {
-		return false
-	}
-	if current == nextAbs {
-		return false
-	}
-	s.WorkingDir = nextAbs
-	return true
-}
-
-func canonicalSessionPath(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 isContextCanceledError(ctx context.Context, err error) bool {
-	if err == nil {
-		return false
-	}
-	if errors.Is(err, context.Canceled) {
-		return true
-	}
-	return ctx != nil && errors.Is(ctx.Err(), context.Canceled) && strings.Contains(err.Error(), "context canceled")
-}
-
-func (s *Session) maybeCompact(ctx context.Context, runID string, opts RunOptions, messages []api.Message, latest api.ChatResponse, skipNotified bool) ([]api.Message, bool, error) {
-	if s.Compactor == nil {
-		return messages, skipNotified, nil
-	}
-	req := s.compactionRequest(runID, opts, messages, latest)
-	trigger := s.autoCompactionTrigger(req)
-	if trigger != "" {
-		s.emitCompactionStarted(runID, opts, trigger)
-	}
-	result, err := s.Compactor.MaybeCompact(ctx, req)
-	if err != nil {
-		if result.Due && !skipNotified {
-			if trigger == "" {
-				trigger = "error"
-			}
-			s.emitCompactionSkipped(runID, opts, trigger, result.Reason)
-			skipNotified = true
-		}
-		return messages, skipNotified, nil
-	}
-	if !result.Compacted {
-		if result.Due && !skipNotified {
-			if trigger == "" {
-				trigger = "due"
-			}
-			s.emitCompactionSkipped(runID, opts, trigger, result.Reason)
-			skipNotified = true
-		}
-		return messages, skipNotified, nil
-	}
-	s.emitCompacted(runID, opts, result.Messages, trigger, result.Summary)
-	if err := s.checkPostCompactionPromptBudget(opts, result.Messages); err != nil {
-		return result.Messages, skipNotified, err
-	}
-	return result.Messages, skipNotified, nil
-}
-
-func (s *Session) compactForToolOutputOverflow(ctx context.Context, runID string, opts RunOptions, messages []api.Message, latest api.ChatResponse, assistant api.Message, toolMessages []api.Message, overflows []toolOutputOverflow, skipNotified bool) ([]api.Message, bool, error) {
-	if s.Compactor == nil {
-		return messages, skipNotified, nil
-	}
-
-	keepUserTurns := 0
-	req := s.compactionRequest(runID, opts, messages, latest)
-	req.Force = true
-	req.KeepUserTurns = &keepUserTurns
-	s.emitCompactionStarted(runID, opts, "tool_output")
-
-	result, err := s.Compactor.MaybeCompact(ctx, req)
-	if err != nil {
-		if result.Due && !skipNotified {
-			s.emitCompactionSkipped(runID, opts, "tool_output", result.Reason)
-			skipNotified = true
-		}
-		return messages, skipNotified, nil
-	}
-	if !result.Compacted {
-		if result.Due && !skipNotified {
-			s.emitCompactionSkipped(runID, opts, "tool_output", result.Reason)
-			skipNotified = true
-		}
-		return messages, skipNotified, nil
-	}
-
-	overflowByID := make(map[string]toolOutputOverflow, len(overflows))
-	for _, overflow := range overflows {
-		overflowByID[overflow.toolCallID] = overflow
-	}
-
-	compacted := append([]api.Message(nil), result.Messages...)
-	if !messageEmpty(assistant) {
-		compacted = append(compacted, assistant)
-	}
-
-	for _, msg := range toolMessages {
-		content := msg.Content
-		toolName := msg.ToolName
-		if overflow, ok := overflowByID[msg.ToolCallID]; ok {
-			content = overflow.content
-			if overflow.toolName != "" {
-				toolName = overflow.toolName
-			}
-		}
-		refit := s.toolMessageForPostCompactionContext(toolName, msg.ToolCallID, content, opts, compacted)
-		compacted = append(compacted, refit)
-	}
-
-	s.emitCompacted(runID, opts, compacted, "tool_output", result.Summary)
-	if err := s.checkPostCompactionPromptBudget(opts, compacted); err != nil {
-		return compacted, skipNotified, err
-	}
-	return compacted, skipNotified, nil
-}
-
-func (s *Session) compactionRequest(runID string, opts RunOptions, messages []api.Message, latest api.ChatResponse) CompactionRequest {
-	return CompactionRequest{
-		ChatID:       opts.ChatID,
-		Model:        opts.Model,
-		SystemPrompt: opts.SystemPrompt,
-		Messages:     messages,
-		Tools:        s.availableTools(),
-		Format:       opts.Format,
-		Latest:       latest,
-		Options:      opts.Options,
-		KeepAlive:    opts.KeepAlive,
-		Think:        opts.Think,
-		ContinueTask: true,
-		Progress: func(progress CompactionProgress) {
-			_ = s.emit(Event{Type: EventCompactionProgress, RunID: runID, ChatID: opts.ChatID, Model: opts.Model, Tokens: progress.Tokens})
-		},
-	}
-}
-
-func (s *Session) emitCompactionStarted(runID string, opts RunOptions, status string) {
-	_ = s.emit(Event{
-		Type:   EventCompactionStarted,
-		RunID:  runID,
-		ChatID: opts.ChatID,
-		Model:  opts.Model,
-		Status: status,
-	})
-}
-
-func (s *Session) emitCompactionSkipped(runID string, opts RunOptions, status, reason string) {
-	_ = s.emit(Event{
-		Type:    EventCompactionSkipped,
-		RunID:   runID,
-		ChatID:  opts.ChatID,
-		Model:   opts.Model,
-		Status:  status,
-		Content: CompactionSkippedMessage(reason),
-	})
-}
-
-func (s *Session) emitCompacted(runID string, opts RunOptions, messages []api.Message, status, summary string) {
-	_ = s.emit(Event{
-		Type:     EventCompacted,
-		RunID:    runID,
-		ChatID:   opts.ChatID,
-		Model:    opts.Model,
-		Status:   status,
-		Content:  summary,
-		Messages: messages,
-	})
-}
-
-func (s *Session) autoCompactionTrigger(req CompactionRequest) string {
-	if compactor, ok := s.Compactor.(*SimpleCompactor); ok && compactor != nil {
-		if req.Force {
-			return "force"
-		}
-		contextWindow := compactor.contextWindowTokens(req.Options)
-		threshold := int(float64(contextWindow) * compactor.threshold())
-		if threshold <= 0 {
-			return ""
-		}
-		if req.Latest.PromptEvalCount > 0 && req.Latest.PromptEvalCount >= threshold {
-			return "prompt_eval"
-		}
-		if estimateCompactionRequestTokens(req) >= threshold {
-			return "estimate"
-		}
-	}
-	return ""
-}
-
-func CompactionSkippedMessage(reason string) string {
-	reason = strings.TrimSpace(reason)
-	if reason == "" {
-		reason = "compaction could not run"
-	}
-	return reason
-}
-
-func resolvedMaxToolRounds(value int) int {
-	if value == 0 {
-		return defaultMaxToolRounds
-	}
-	return value
-}
-
-func (s *Session) toolMessageForContext(toolName, toolCallID, content string, opts RunOptions, messages []api.Message) api.Message {
-	maxRunes := maxToolResultRunes
-	if limit := smallContextToolResultLimitRunes(s.contextWindowTokens(opts)); limit > 0 {
-		maxRunes = min(maxRunes, limit)
-	}
-
-	msg := toolMessageWithLimit(toolName, toolCallID, content, maxRunes)
-	threshold := s.compactionThresholdTokens(opts)
-	if threshold <= 0 {
-		return msg
-	}
-
-	projected := append(append([]api.Message(nil), messages...), msg)
-	projectedTokens := s.estimateRunPromptTokens(opts, projected)
-	if projectedTokens < threshold {
-		return msg
-	}
-
-	baseTokens := s.estimateRunPromptTokens(opts, messages)
-	overheadTokens := estimateMessagesTokens([]api.Message{{
-		Role:       "tool",
-		ToolName:   toolName,
-		ToolCallID: toolCallID,
-	}})
-	// Keep oversized tool output below the compaction threshold before it is
-	// appended to history. This is especially important for <=8k contexts: the
-	// next step must still have enough room to compact and continue the same
-	// user request instead of asking the user to prompt again.
-	availableRunes := (threshold - baseTokens - overheadTokens - toolTruncationMarkerReserveTokens) * 4
-	maxRunes = min(maxRunes, max(0, availableRunes))
-	msg.Content = truncateToolResultContentTo(content, maxRunes)
-	return msg
-}
-
-func (s *Session) toolMessageForPostCompactionContext(toolName, toolCallID, content string, opts RunOptions, messages []api.Message) api.Message {
-	maxRunes := maxToolResultRunes
-	if limit := smallContextToolResultLimitRunes(s.contextWindowTokens(opts)); limit > 0 {
-		maxRunes = min(maxRunes, limit)
-	}
-
-	contextWindow := s.contextWindowTokens(opts)
-	if contextWindow <= 0 {
-		return toolMessageWithLimit(toolName, toolCallID, content, maxRunes)
-	}
-
-	baseTokens := s.estimateRunPromptTokens(opts, messages)
-	overheadTokens := estimateMessagesTokens([]api.Message{{
-		Role:       "tool",
-		ToolName:   toolName,
-		ToolCallID: toolCallID,
-	}})
-	availableRunes := (contextWindow - baseTokens - overheadTokens - toolTruncationMarkerReserveTokens) * 4
-	maxRunes = min(maxRunes, max(0, availableRunes))
-	return toolMessageWithLimit(toolName, toolCallID, content, maxRunes)
-}
-
-func toolMessageWithLimit(toolName, toolCallID, content string, maxRunes int) api.Message {
-	return api.Message{
-		Role:       "tool",
-		Content:    truncateToolResultContentTo(content, maxRunes),
-		ToolName:   toolName,
-		ToolCallID: toolCallID,
-	}
-}
-
-func smallContextToolResultLimitRunes(contextWindow int) int {
-	switch {
-	case contextWindow > 0 && contextWindow <= tinyContextToolResultTokenWindow:
-		return tinyContextToolResultRunes
-	case contextWindow > 0 && contextWindow <= smallContextToolResultTokenWindow:
-		return smallContextToolResultRunes
-	default:
-		return 0
-	}
-}
-
-func (s *Session) availableTools() api.Tools {
-	if s == nil || s.Tools == nil {
-		return nil
-	}
-	return s.Tools.Tools()
-}
-
-func (s *Session) compactionThresholdTokens(opts RunOptions) int {
-	contextWindow := s.contextWindowTokens(opts)
-	if contextWindow <= 0 {
-		return 0
-	}
-
-	configuredThreshold := 0.0
-	if compactor, ok := s.Compactor.(*SimpleCompactor); ok && compactor != nil {
-		configuredThreshold = compactor.Options.Threshold
-	}
-
-	threshold := int(float64(contextWindow) * ResolveCompactionThreshold(configuredThreshold))
-	if threshold <= 0 {
-		return 0
-	}
-	return threshold
-}
-
-func (s *Session) contextWindowTokens(opts RunOptions) int {
-	if s.Compactor == nil {
-		return 0
-	}
-
-	configuredWindow := 0
-	if compactor, ok := s.Compactor.(*SimpleCompactor); ok && compactor != nil {
-		configuredWindow = compactor.Options.ContextWindowTokens
-	}
-
-	return ResolveContextWindowTokens(opts.Options, configuredWindow)
-}
-
-func toolMessage(toolName, toolCallID, content string) api.Message {
-	return toolMessageWithLimit(toolName, toolCallID, content, maxToolResultRunes)
-}
-
-func sanitizeMessageForRun(msg api.Message) api.Message {
-	if msg.Role == "tool" {
-		msg.Content = truncateToolResultContent(msg.Content)
-	}
-	return msg
-}
-
-func sanitizeMessagesForRequest(messages []api.Message) []api.Message {
-	if len(messages) == 0 {
-		return nil
-	}
-	sanitized := make([]api.Message, len(messages))
-	for i, msg := range messages {
-		sanitized[i] = sanitizeMessageForRequest(msg)
-	}
-	return sanitized
-}
-
-func sanitizeMessageForRequest(msg api.Message) api.Message {
-	return sanitizeMessageForRun(msg)
-}
-
-func truncateToolResultContent(content string) string {
-	return truncateToolResultContentTo(content, maxToolResultRunes)
-}
-
-func truncateToolResultContentTo(content string, maxRunes int) string {
-	if maxRunes <= 0 {
-		return fmt.Sprintf("%s omitted ~%d tokens. Use a narrower command, line range, or search query if more detail is needed.]", toolOutputFullOmissionPrefix, approximateTokensFromRunes(len([]rune(content))))
-	}
-	if len(content) <= maxRunes {
-		return content
-	}
-	runes := []rune(content)
-	if len(runes) <= maxRunes {
-		return content
-	}
-	head := maxRunes * 3 / 4
-	tail := maxRunes - head
-	omitted := len(runes) - head - tail
-	marker := fmt.Sprintf(
-		"\n\n[tool output truncated: showing first ~%d tokens and last ~%d tokens; omitted ~%d tokens. Use a narrower command, line range, or search query if more detail is needed.]\n\n",
-		approximateTokensFromRunes(head),
-		approximateTokensFromRunes(tail),
-		approximateTokensFromRunes(omitted),
-	)
-	return string(runes[:head]) + marker + string(runes[len(runes)-tail:])
-}
-
-func toolOutputFullyOmitted(content string) bool {
-	return strings.HasPrefix(content, toolOutputFullOmissionPrefix)
-}
-
-func approximateTokensFromRunes(n int) int {
-	if n <= 0 {
-		return 0
-	}
-	return max(1, (n+3)/4)
-}
-
-func messageEmpty(msg api.Message) bool {
-	return msg.Content == "" && msg.Thinking == "" && len(msg.ToolCalls) == 0
-}

agent/session_test.go

@@ -1,2188 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/ollama/ollama/api"
-)
-
-type fakeClient struct {
-	calls     int
-	responses [][]api.ChatResponse
-	requests  []*api.ChatRequest
-	err       error
-}
-
-func (c *fakeClient) Chat(ctx context.Context, req *api.ChatRequest, fn api.ChatResponseFunc) error {
-	c.requests = append(c.requests, req)
-	if c.calls >= len(c.responses) {
-		return nil
-	}
-	responses := c.responses[c.calls]
-	c.calls++
-	for _, response := range responses {
-		if err := fn(response); err != nil {
-			return err
-		}
-	}
-	return c.err
-}
-
-type staticTool struct{}
-
-type approvalTestTool struct {
-	called *bool
-}
-
-type namedApprovalTestTool struct {
-	name string
-}
-
-type cwdTestTool struct{}
-
-type largeTool struct{}
-
-type preTruncatedTool struct{}
-
-type cancelingTool struct {
-	cancel context.CancelFunc
-}
-
-type cancelAfterToolCallClient struct {
-	cancel context.CancelFunc
-}
-
-type recordingCompactor struct {
-	requests []CompactionRequest
-}
-
-type oversizedCompactor struct {
-	requests []CompactionRequest
-}
-
-type recordingEventSink struct {
-	events []Event
-}
-
-func (s *recordingEventSink) Emit(event Event) error {
-	s.events = append(s.events, event)
-	return nil
-}
-
-func hasEventType(events []Event, eventType EventType) bool {
-	for _, event := range events {
-		if event.Type == eventType {
-			return true
-		}
-	}
-	return false
-}
-
-func hasEventWithTokens(events []Event, eventType EventType, tokens int) bool {
-	for _, event := range events {
-		if event.Type == eventType && event.Tokens == tokens {
-			return true
-		}
-	}
-	return false
-}
-
-func TestSessionEmitsToAllSinksAfterError(t *testing.T) {
-	errSink := EventSinkFunc(func(Event) error {
-		return errors.New("sink failed")
-	})
-	events := &recordingEventSink{}
-	session := &Session{EventSinks: []EventSink{errSink, events}}
-
-	err := session.emit(Event{Type: EventRunFinished})
-	if err == nil {
-		t.Fatal("emit should return the first sink error")
-	}
-	if !hasEventType(events.events, EventRunFinished) {
-		t.Fatalf("later sink did not receive event after earlier error: %#v", events.events)
-	}
-}
-
-func (c cancelAfterToolCallClient) Chat(ctx context.Context, req *api.ChatRequest, fn api.ChatResponseFunc) error {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "skip me")
-	if err := fn(api.ChatResponse{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-		ID: "call-1",
-		Function: api.ToolCallFunction{
-			Name:      "echo_tool",
-			Arguments: args,
-		},
-	}}}}); err != nil {
-		return err
-	}
-	c.cancel()
-	return context.Canceled
-}
-
-func (c *recordingCompactor) MaybeCompact(_ context.Context, req CompactionRequest) (CompactionResult, error) {
-	c.requests = append(c.requests, req)
-	result := CompactionResult{Messages: req.Messages, Due: true}
-	if len(req.Messages) > 0 && req.Messages[len(req.Messages)-1].Role == "tool" {
-		result.Messages = CompactionSummaryMessages("tool result summarized", false)
-		result.Compacted = true
-		result.Summary = "tool result summarized"
-	}
-	return result, nil
-}
-
-func (c *oversizedCompactor) MaybeCompact(_ context.Context, req CompactionRequest) (CompactionResult, error) {
-	c.requests = append(c.requests, req)
-	summary := strings.Repeat("oversized summary ", 300)
-	return CompactionResult{
-		Messages:  CompactionSummaryMessages(summary, req.ContinueTask),
-		Compacted: true,
-		Due:       true,
-		Summary:   summary,
-	}, nil
-}
-
-type recordingApprovalPrompter struct {
-	requests []ApprovalRequest
-	results  []Approval
-}
-
-func approvalStateForTest(allowAll bool, scopes map[string]bool) *ApprovalState {
-	state := &ApprovalState{}
-	state.Set(allowAll, scopes)
-	return state
-}
-
-func (staticTool) Name() string {
-	return "echo_tool"
-}
-
-func (staticTool) Description() string {
-	return "echoes a value"
-}
-
-func (staticTool) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("value", api.ToolProperty{Type: api.PropertyType{"string"}})
-	return api.ToolFunction{
-		Name:        "echo_tool",
-		Description: "echoes a value",
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-		},
-	}
-}
-
-func (staticTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
-	return ToolResult{Content: "tool says hello"}, nil
-}
-
-func (largeTool) Name() string {
-	return "large_tool"
-}
-
-func (largeTool) Description() string {
-	return "returns a large result"
-}
-
-func (largeTool) Schema() api.ToolFunction {
-	return api.ToolFunction{
-		Name:        "large_tool",
-		Description: "returns a large result",
-		Parameters: api.ToolFunctionParameters{
-			Type: "object",
-		},
-	}
-}
-
-func (largeTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
-	return ToolResult{Content: strings.Repeat("x", maxToolResultRunes+100)}, nil
-}
-
-func (preTruncatedTool) Name() string {
-	return "pre_truncated_tool"
-}
-
-func (preTruncatedTool) Description() string {
-	return "returns a large result that is already marked as truncated"
-}
-
-func (preTruncatedTool) Schema() api.ToolFunction {
-	return api.ToolFunction{
-		Name:        "pre_truncated_tool",
-		Description: "returns a large result that is already marked as truncated",
-		Parameters: api.ToolFunctionParameters{
-			Type: "object",
-		},
-	}
-}
-
-func (preTruncatedTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
-	content := strings.Repeat("x", smallContextToolResultRunes) +
-		"\n\n[tool output truncated: showing first ~1500 tokens; omitted ~999 tokens. Use a narrower command, line range, or search query if more detail is needed.]\n\n" +
-		strings.Repeat("y", smallContextToolResultRunes)
-	return ToolResult{Content: content}, nil
-}
-
-func (t cancelingTool) Name() string {
-	return "cancel_tool"
-}
-
-func (t cancelingTool) Description() string {
-	return "cancels while running"
-}
-
-func (t cancelingTool) Schema() api.ToolFunction {
-	return api.ToolFunction{
-		Name:        t.Name(),
-		Description: t.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type: "object",
-		},
-	}
-}
-
-func (t cancelingTool) Execute(ctx context.Context, _ ToolContext, _ map[string]any) (ToolResult, error) {
-	t.cancel()
-	<-ctx.Done()
-	return ToolResult{}, ctx.Err()
-}
-
-func (t approvalTestTool) Name() string {
-	return "approval_tool"
-}
-
-func (t approvalTestTool) Description() string {
-	return "requires approval"
-}
-
-func (t approvalTestTool) Schema() api.ToolFunction {
-	return api.ToolFunction{
-		Name:        "approval_tool",
-		Description: "requires approval",
-		Parameters: api.ToolFunctionParameters{
-			Type: "object",
-		},
-	}
-}
-
-func (t approvalTestTool) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (t approvalTestTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
-	if t.called != nil {
-		*t.called = true
-	}
-	return ToolResult{Content: "approved"}, nil
-}
-
-func (t namedApprovalTestTool) Name() string {
-	return t.name
-}
-
-func (t namedApprovalTestTool) Description() string {
-	return "requires approval"
-}
-
-func (t namedApprovalTestTool) Schema() api.ToolFunction {
-	return api.ToolFunction{
-		Name:        t.name,
-		Description: "requires approval",
-		Parameters: api.ToolFunctionParameters{
-			Type: "object",
-		},
-	}
-}
-
-func (t namedApprovalTestTool) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (t namedApprovalTestTool) Execute(context.Context, ToolContext, map[string]any) (ToolResult, error) {
-	return ToolResult{Content: "approved"}, nil
-}
-
-func (p *recordingApprovalPrompter) PromptApproval(_ context.Context, req ApprovalRequest) (Approval, error) {
-	p.requests = append(p.requests, req)
-	if len(p.results) == 0 {
-		return Approval{Allow: true}, nil
-	}
-	result := p.results[0]
-	p.results = p.results[1:]
-	return result, nil
-}
-
-func (cwdTestTool) Name() string {
-	return "cwd_tool"
-}
-
-func (cwdTestTool) Description() string {
-	return "tests cwd state"
-}
-
-func (cwdTestTool) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("mode", api.ToolProperty{Type: api.PropertyType{"string"}})
-	props.Set("path", api.ToolProperty{Type: api.PropertyType{"string"}})
-	return api.ToolFunction{
-		Name:        "cwd_tool",
-		Description: "tests cwd state",
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-		},
-	}
-}
-
-func (cwdTestTool) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (cwdTestTool) Execute(_ context.Context, toolCtx ToolContext, args map[string]any) (ToolResult, error) {
-	switch args["mode"] {
-	case "set":
-		path, _ := args["path"].(string)
-		return ToolResult{Content: "changed", WorkingDir: filepath.Join(toolCtx.WorkingDir, path)}, nil
-	case "escape":
-		return ToolResult{Content: "escaped", WorkingDir: filepath.Dir(toolCtx.WorkingDir)}, nil
-	default:
-		return ToolResult{Content: toolCtx.WorkingDir}, nil
-	}
-}
-
-func TestSessionRunsToolLoop(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "hello")
-
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "echo_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-
-	registry := &Registry{}
-	registry.Register(staticTool{})
-
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if client.calls != 2 {
-		t.Fatalf("client calls = %d, want 2", client.calls)
-	}
-	if len(result.Messages) != 4 {
-		t.Fatalf("messages = %d, want 4", len(result.Messages))
-	}
-	if result.Messages[2].Role != "tool" || result.Messages[2].Content != "tool says hello" {
-		t.Fatalf("tool message = %#v", result.Messages[2])
-	}
-	if len(client.requests[0].Tools) != 1 {
-		t.Fatalf("first request tools = %d, want 1", len(client.requests[0].Tools))
-	}
-	if len(client.requests[1].Messages) != 3 {
-		t.Fatalf("second request messages = %d, want 3", len(client.requests[1].Messages))
-	}
-}
-
-func TestSessionAddsSystemPromptOnlyToRequest(t *testing.T) {
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	session := &Session{Client: client}
-
-	_, err := session.Run(context.Background(), RunOptions{
-		ChatID:       "chat-1",
-		Model:        "model",
-		SystemPrompt: "available context: go-code",
-		NewMessages:  []api.Message{{Role: "user", Content: "hello"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(client.requests) != 1 {
-		t.Fatalf("requests = %d, want 1", len(client.requests))
-	}
-	reqMessages := client.requests[0].Messages
-	if len(reqMessages) != 2 || reqMessages[0].Role != "system" || reqMessages[0].Content != "available context: go-code" {
-		t.Fatalf("request messages = %#v", reqMessages)
-	}
-}
-
-func TestSessionChatRequestMatchesRunRequest(t *testing.T) {
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	session := &Session{Client: client, Tools: registry}
-	opts := RunOptions{
-		ChatID:       "chat-1",
-		Model:        "model",
-		SystemPrompt: "available context: go-code",
-		NewMessages:  []api.Message{{Role: "user", Content: "hello"}},
-		Format:       "json",
-		Options:      map[string]any{"temperature": 0.5},
-	}
-
-	want := buildChatRequest(opts, opts.NewMessages, registry.Tools())
-	_, err := session.Run(context.Background(), opts)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(client.requests) != 1 {
-		t.Fatalf("requests = %d, want 1", len(client.requests))
-	}
-	gotJSON, err := json.Marshal(client.requests[0])
-	if err != nil {
-		t.Fatal(err)
-	}
-	wantJSON, err := json.Marshal(want)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(gotJSON) != string(wantJSON) {
-		t.Fatalf("ChatRequest mismatch\ngot:  %s\nwant: %s", gotJSON, wantJSON)
-	}
-}
-
-func TestSessionAccumulatesStreamingAssistantMessage(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "hello")
-	responses := make([]api.ChatResponse, 0, 100)
-	var wantContent, wantThinking string
-	for range 99 {
-		wantContent += "x"
-		wantThinking += "t"
-		responses = append(responses, api.ChatResponse{
-			Message: api.Message{Role: "assistant", Content: "x", Thinking: "t"},
-		})
-	}
-	toolCall := api.ToolCall{
-		ID: "call-1",
-		Function: api.ToolCallFunction{
-			Name:      "echo_tool",
-			Arguments: args,
-		},
-	}
-	responses = append(responses, api.ChatResponse{
-		Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{toolCall}},
-	})
-
-	session := &Session{
-		Client: &fakeClient{responses: [][]api.ChatResponse{responses}},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "stream"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(result.Messages) != 2 || result.Messages[1].Content != wantContent || result.Messages[1].Thinking != wantThinking || len(result.Messages[1].ToolCalls) != 1 {
-		t.Fatalf("result messages = %#v", result.Messages)
-	}
-}
-
-func TestSessionRequestHistoryKeepsThinkingAndServerToolCallIDs(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "hello")
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", Thinking: "private chain"}},
-				{Message: api.Message{Role: "assistant", Content: "I'll check."}},
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "volatile-random-id",
-					Function: api.ToolCallFunction{
-						Name:      "echo_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(client.requests) != 2 {
-		t.Fatalf("requests = %d, want 2", len(client.requests))
-	}
-
-	secondRequestMessages := client.requests[1].Messages
-	if len(secondRequestMessages) != 3 {
-		t.Fatalf("second request messages = %#v", secondRequestMessages)
-	}
-	assistant := secondRequestMessages[1]
-	if assistant.Role != "assistant" {
-		t.Fatalf("second request assistant = %#v", assistant)
-	}
-	if assistant.Thinking != "private chain" {
-		t.Fatalf("assistant thinking = %q, want preserved", assistant.Thinking)
-	}
-	if len(assistant.ToolCalls) != 1 || assistant.ToolCalls[0].ID != "volatile-random-id" {
-		t.Fatalf("assistant tool calls = %#v", assistant.ToolCalls)
-	}
-	tool := secondRequestMessages[2]
-	if tool.Role != "tool" || tool.ToolCallID != "volatile-random-id" {
-		t.Fatalf("tool result message = %#v", tool)
-	}
-	if len(result.Messages) < 3 || result.Messages[1].Thinking != "private chain" {
-		t.Fatalf("visible result messages lost thinking: %#v", result.Messages)
-	}
-}
-
-func TestSessionKeepsPartialStreamOnCancellation(t *testing.T) {
-	session := &Session{
-		Client: &fakeClient{
-			responses: [][]api.ChatResponse{{
-				{Message: api.Message{Role: "assistant", Content: "partial "}},
-				{Message: api.Message{Role: "assistant", Content: "answer"}},
-			}},
-			err: context.Canceled,
-		},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "cancel"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Messages) != 2 || result.Messages[1].Content != "partial answer" {
-		t.Fatalf("result messages = %#v", result.Messages)
-	}
-}
-
-func TestSessionCancellationKeepsPartialResultWhenUISinkCancels(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	trace := &recordingEventSink{}
-	session := &Session{
-		Client: &fakeClient{
-			responses: [][]api.ChatResponse{{
-				{Message: api.Message{Role: "assistant", Content: "partial"}},
-			}},
-			err: context.Canceled,
-		},
-		EventSinks: []EventSink{
-			EventSinkFunc(func(event Event) error {
-				if event.Type == EventRunFinished {
-					return context.Canceled
-				}
-				return nil
-			}),
-			trace,
-		},
-	}
-
-	result, err := session.Run(ctx, RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "cancel"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result == nil || len(result.Messages) != 2 || result.Messages[1].Content != "partial" {
-		t.Fatalf("result messages = %#v, want partial assistant result", result)
-	}
-	if !hasEventType(trace.events, EventRunFinished) {
-		t.Fatalf("trace sink did not receive run finished event: %#v", trace.events)
-	}
-}
-
-func TestSessionTreatsHTTPContextCanceledStringAsCancellation(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	client := &fakeClient{err: errors.New(`Post "http://127.0.0.1:11434/api/chat": context canceled`)}
-	session := &Session{Client: client}
-
-	result, err := session.Run(ctx, RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "hello"}},
-	})
-	if err != nil {
-		t.Fatalf("Run returned error for canceled HTTP request: %v", err)
-	}
-	if result == nil {
-		t.Fatal("Run returned nil result")
-	}
-	if len(result.Messages) != 1 || result.Messages[0].Content != "hello" {
-		t.Fatalf("messages = %#v, want original user message only", result.Messages)
-	}
-}
-
-func TestSessionDisabledToolsOmitToolsAndReturnsDisabledResults(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "hello")
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "echo_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "tools are off"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	events := &recordingEventSink{}
-	session := &Session{
-		Client:       client,
-		EventSinks:   []EventSink{events},
-		Tools:        registry,
-		DisableTools: true,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(client.requests) != 2 {
-		t.Fatalf("requests = %d, want 2", len(client.requests))
-	}
-	if got := len(client.requests[0].Tools); got != 0 {
-		t.Fatalf("advertised tools = %d, want 0", got)
-	}
-	secondMessages := client.requests[1].Messages
-	if len(secondMessages) != 3 {
-		t.Fatalf("second request messages = %#v", secondMessages)
-	}
-	if secondMessages[2].Role != "tool" || secondMessages[2].ToolCallID != "call-1" || secondMessages[2].Content != toolExecutionDisabledMessage {
-		t.Fatalf("disabled tool message = %#v", secondMessages[2])
-	}
-	if len(result.Messages) != 4 || result.Messages[2].Content != toolExecutionDisabledMessage {
-		t.Fatalf("result messages = %#v", result.Messages)
-	}
-	var sawDetected, sawDisabled bool
-	for _, event := range events.events {
-		if event.Type == EventToolCallDetected {
-			sawDetected = true
-		}
-		if event.Type == EventToolFinished && event.Status == "disabled" && event.Content == toolExecutionDisabledMessage {
-			sawDisabled = true
-		}
-	}
-	if !sawDetected || !sawDisabled {
-		t.Fatalf("events missing detected/disabled: %#v", events.events)
-	}
-}
-
-func TestSessionCancellationAfterToolCallAppendsSkippedToolMessage(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	session := &Session{
-		Client:        cancelAfterToolCallClient{cancel: cancel},
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	result, err := session.Run(ctx, RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "cancel after tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Messages) != 3 {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-	if len(result.Messages[1].ToolCalls) != 1 {
-		t.Fatalf("assistant tool calls = %#v", result.Messages[1])
-	}
-	if result.Messages[2].Role != "tool" || result.Messages[2].ToolCallID != "call-1" {
-		t.Fatalf("skipped tool message = %#v", result.Messages[2])
-	}
-	if !strings.Contains(result.Messages[2].Content, "run was canceled") {
-		t.Fatalf("skipped content = %q", result.Messages[2].Content)
-	}
-}
-
-func TestSessionCancellationDuringToolExecutionAppendsToolMessage(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	events := &recordingEventSink{}
-	registry := &Registry{}
-	registry.Register(cancelingTool{cancel: cancel})
-	client := &fakeClient{responses: [][]api.ChatResponse{{
-		{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-			ID: "call-1",
-			Function: api.ToolCallFunction{
-				Name: "cancel_tool",
-			},
-		}}}},
-	}}}
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		EventSinks:    []EventSink{events},
-	}
-
-	result, err := session.Run(ctx, RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "cancel during tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Messages) != 3 {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-	if result.Messages[2].Role != "tool" || result.Messages[2].ToolCallID != "call-1" {
-		t.Fatalf("tool message = %#v", result.Messages[2])
-	}
-	if !strings.Contains(result.Messages[2].Content, "context canceled") {
-		t.Fatalf("tool content = %q", result.Messages[2].Content)
-	}
-	var finished *Event
-	for i := range events.events {
-		if events.events[i].Type == EventRunFinished {
-			finished = &events.events[i]
-		}
-	}
-	if finished == nil {
-		t.Fatalf("run finished event missing: %#v", events.events)
-	}
-	if finished.Status != "canceled" {
-		t.Fatalf("run status = %q, want canceled", finished.Status)
-	}
-}
-
-func TestSessionToolLoopAllowsRoundsUnderDefaultCap(t *testing.T) {
-	responses := make([][]api.ChatResponse, 0, 26)
-	for i := range 25 {
-		args := api.NewToolCallFunctionArguments()
-		args.Set("value", "hello")
-		responses = append(responses, []api.ChatResponse{{
-			Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-				ID: "call-" + string(rune('a'+i)),
-				Function: api.ToolCallFunction{
-					Name:      "echo_tool",
-					Arguments: args,
-				},
-			}}},
-		}})
-	}
-	responses = append(responses, []api.ChatResponse{{
-		Message: api.Message{Role: "assistant", Content: "done"},
-	}})
-
-	client := &fakeClient{responses: responses}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	if _, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "keep going"}},
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if client.calls != 26 {
-		t.Fatalf("client calls = %d, want 26", client.calls)
-	}
-}
-
-func TestSessionToolRoundLimitAppendsSkippedToolMessages(t *testing.T) {
-	firstArgs := api.NewToolCallFunctionArguments()
-	firstArgs.Set("value", "first")
-	secondArgs := api.NewToolCallFunctionArguments()
-	secondArgs.Set("value", "second")
-	thirdArgs := api.NewToolCallFunctionArguments()
-	thirdArgs.Set("value", "third")
-
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "echo_tool",
-						Arguments: firstArgs,
-					},
-				}}},
-			}},
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{
-					{
-						ID: "call-2",
-						Function: api.ToolCallFunction{
-							Name:      "echo_tool",
-							Arguments: secondArgs,
-						},
-					},
-					{
-						ID: "call-3",
-						Function: api.ToolCallFunction{
-							Name:      "echo_tool",
-							Arguments: thirdArgs,
-						},
-					},
-				}},
-			}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:        "chat-1",
-		Model:         "model",
-		NewMessages:   []api.Message{{Role: "user", Content: "hit cap"}},
-		MaxToolRounds: 1,
-	})
-	if err == nil || !strings.Contains(err.Error(), "tool round limit reached after 1 rounds") {
-		t.Fatalf("error = %v, want tool-round limit", err)
-	}
-	if result == nil {
-		t.Fatal("expected partial result with skipped tool messages")
-	}
-	if len(result.Messages) != 6 {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-	for i, wantID := range []string{"call-2", "call-3"} {
-		msg := result.Messages[4+i]
-		if msg.Role != "tool" || msg.ToolCallID != wantID {
-			t.Fatalf("skipped tool %d = %#v", i, msg)
-		}
-		if !strings.Contains(msg.Content, "max tool-round limit of 1") {
-			t.Fatalf("skipped content = %q", msg.Content)
-		}
-	}
-}
-
-func TestSessionToolLoopStopsAtDefaultRoundCap(t *testing.T) {
-	responses := make([][]api.ChatResponse, 0, defaultMaxToolRounds+1)
-	for range defaultMaxToolRounds + 1 {
-		args := api.NewToolCallFunctionArguments()
-		args.Set("value", "hello")
-		responses = append(responses, []api.ChatResponse{{
-			Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-				ID: "call",
-				Function: api.ToolCallFunction{
-					Name:      "echo_tool",
-					Arguments: args,
-				},
-			}}},
-		}})
-	}
-
-	client := &fakeClient{responses: responses}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	_, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "keep going"}},
-	})
-	if err == nil || !strings.Contains(err.Error(), "tool round limit reached after 100 rounds") {
-		t.Fatalf("error = %v, want default tool round limit", err)
-	}
-	if client.calls != defaultMaxToolRounds+1 {
-		t.Fatalf("client calls = %d, want %d", client.calls, defaultMaxToolRounds+1)
-	}
-}
-
-func TestSessionToolLoopNegativeLimitIsUnlimited(t *testing.T) {
-	responses := make([][]api.ChatResponse, 0, defaultMaxToolRounds+2)
-	for range defaultMaxToolRounds + 1 {
-		args := api.NewToolCallFunctionArguments()
-		args.Set("value", "hello")
-		responses = append(responses, []api.ChatResponse{{
-			Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-				ID: "call",
-				Function: api.ToolCallFunction{
-					Name:      "echo_tool",
-					Arguments: args,
-				},
-			}}},
-		}})
-	}
-	responses = append(responses, []api.ChatResponse{{
-		Message: api.Message{Role: "assistant", Content: "done"},
-	}})
-
-	client := &fakeClient{responses: responses}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	if _, err := session.Run(context.Background(), RunOptions{
-		Model:         "model",
-		NewMessages:   []api.Message{{Role: "user", Content: "keep going"}},
-		MaxToolRounds: -1,
-	}); err != nil {
-		t.Fatal(err)
-	}
-	if client.calls != defaultMaxToolRounds+2 {
-		t.Fatalf("client calls = %d, want %d", client.calls, defaultMaxToolRounds+2)
-	}
-}
-
-func TestSessionTruncatesLargeToolResultsBeforeHistory(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "large_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(largeTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Messages) < 3 {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-	content := result.Messages[2].Content
-	if !strings.Contains(content, "[tool output truncated: showing first ~") ||
-		!strings.Contains(content, "omitted ~25 tokens") ||
-		!strings.Contains(content, "Use a narrower command, line range, or search query") {
-		t.Fatalf("tool content missing truncation marker: %q", content)
-	}
-	if strings.Count(content, "x") != maxToolResultRunes {
-		t.Fatalf("truncated content x count = %d, want %d", strings.Count(content, "x"), maxToolResultRunes)
-	}
-	requestContent := client.requests[1].Messages[2].Content
-	if !strings.Contains(requestContent, "[tool output truncated: showing first ~") {
-		t.Fatalf("second model request did not use capped tool content: %q", requestContent)
-	}
-	if strings.Count(requestContent, "x") > maxToolResultRunes {
-		t.Fatalf("request tool content x count = %d, want at most %d", strings.Count(requestContent, "x"), maxToolResultRunes)
-	}
-}
-
-func TestSessionSmallContextUsesLowerToolResultPreviewCap(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "large_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(largeTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor: &SimpleCompactor{Client: nil, Options: CompactionOptions{
-			ContextWindowTokens: smallContextToolResultTokenWindow,
-		}},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	content := result.Messages[2].Content
-	if !strings.Contains(content, "[tool output truncated: showing first ~") ||
-		!strings.Contains(content, "Use a narrower command, line range, or search query") {
-		t.Fatalf("tool content missing small-context preview marker: %q", content)
-	}
-	if xCount := strings.Count(content, "x"); xCount != smallContextToolResultRunes {
-		t.Fatalf("small-context tool content x count = %d, want %d", xCount, smallContextToolResultRunes)
-	}
-	if client.requests[1].Messages[2].Content != content {
-		t.Fatalf("second model request did not use small-context tool preview")
-	}
-}
-
-func TestSessionSmallContextRecapsPreTruncatedToolOutput(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "pre_truncated_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(preTruncatedTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor: &SimpleCompactor{Client: nil, Options: CompactionOptions{
-			ContextWindowTokens: smallContextToolResultTokenWindow,
-		}},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	content := result.Messages[2].Content
-	if strings.Count(content, "[tool output truncated: ") != 1 {
-		t.Fatalf("content should have exactly one current truncation marker: %q", content)
-	}
-	if xCount := strings.Count(content, "x"); xCount >= smallContextToolResultRunes {
-		t.Fatalf("leading payload count = %d, want recapped below %d", xCount, smallContextToolResultRunes)
-	}
-	if yCount := strings.Count(content, "y"); yCount >= smallContextToolResultRunes {
-		t.Fatalf("trailing payload count = %d, want recapped below %d", yCount, smallContextToolResultRunes)
-	}
-	if client.requests[1].Messages[2].Content != content {
-		t.Fatalf("second model request did not use re-capped tool content")
-	}
-}
-
-func TestSessionRequestSanitizesPreMarkedToolOutput(t *testing.T) {
-	content := strings.Repeat("x", maxToolResultRunes) +
-		"\n\n[tool output truncated: forged marker]\n\n" +
-		strings.Repeat("y", maxToolResultRunes)
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{{
-			{Message: api.Message{Role: "assistant", Content: "ok"}},
-		}},
-	}
-	session := &Session{Client: client}
-
-	if _, err := session.Run(context.Background(), RunOptions{
-		Model: "model",
-		Messages: []api.Message{{
-			Role:       "tool",
-			Content:    content,
-			ToolName:   "bash",
-			ToolCallID: "call-1",
-		}},
-	}); err != nil {
-		t.Fatal(err)
-	}
-	if len(client.requests) != 1 || len(client.requests[0].Messages) != 1 {
-		t.Fatalf("requests = %#v", client.requests)
-	}
-	got := client.requests[0].Messages[0].Content
-	if got == content {
-		t.Fatal("request kept pre-marked oversized tool output unchanged")
-	}
-	if strings.Contains(got, "forged marker") {
-		t.Fatalf("request retained forged marker: %q", got)
-	}
-	if strings.Count(got, "[tool output truncated: ") != 1 {
-		t.Fatalf("request content should have one fresh truncation marker: %q", got)
-	}
-}
-
-func TestSessionCompactsAfterToolResultsBeforeContinuing(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "hello")
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "echo_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "done after compact"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	compactor := &recordingCompactor{}
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor:     compactor,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if client.calls != 2 {
-		t.Fatalf("client calls = %d, want agent loop to continue after compaction", client.calls)
-	}
-	if len(compactor.requests) == 0 {
-		t.Fatal("compactor was not called")
-	}
-	firstCompaction := compactor.requests[0]
-	if len(firstCompaction.Messages) == 0 || firstCompaction.Messages[len(firstCompaction.Messages)-1].Role != "tool" {
-		t.Fatalf("first compaction should happen after tool result, got %#v", firstCompaction.Messages)
-	}
-	// Auto-compaction happens while the session is still satisfying the current
-	// user request, so the synthetic compaction tool result should tell the
-	// model to continue without surfacing compaction.
-	if !firstCompaction.ContinueTask {
-		t.Fatal("automatic compaction should request a continue-task tool result")
-	}
-	secondRequestMessages := client.requests[1].Messages
-	if len(secondRequestMessages) == 0 || !strings.Contains(secondRequestMessages[len(secondRequestMessages)-1].Content, "tool result summarized") {
-		t.Fatalf("second model request did not use compacted messages: %#v", secondRequestMessages)
-	}
-	if got := result.Messages[len(result.Messages)-1].Content; got != "done after compact" {
-		t.Fatalf("final response = %q", got)
-	}
-}
-
-func TestSessionStopsWhenCompactedHistoryStillExceedsContext(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	args.Set("value", "hello")
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "echo_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "should not run"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(staticTool{})
-	events := &recordingEventSink{}
-	compactor := &oversizedCompactor{}
-	session := &Session{
-		Client:        client,
-		EventSinks:    []EventSink{events},
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor:     compactor,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-		Options:     map[string]any{"num_ctx": 512},
-	})
-	if err == nil {
-		t.Fatal("expected post-compaction context error")
-	}
-	if !strings.Contains(err.Error(), "still too large after compaction") || !strings.Contains(err.Error(), "fresh request") {
-		t.Fatalf("error = %q, want actionable post-compaction guidance", err.Error())
-	}
-	if result == nil {
-		t.Fatal("expected partial result with compacted messages")
-	}
-	if client.calls != 1 || len(client.requests) != 1 {
-		t.Fatalf("client calls = %d requests = %d, want no request after oversized compaction", client.calls, len(client.requests))
-	}
-	if len(compactor.requests) != 1 {
-		t.Fatalf("compactor requests = %d, want 1", len(compactor.requests))
-	}
-	if !hasEventType(events.events, EventCompacted) {
-		t.Fatalf("events missing compacted event: %#v", events.events)
-	}
-	if !hasEventType(events.events, EventError) {
-		t.Fatalf("events missing post-compaction error: %#v", events.events)
-	}
-	if len(result.Messages) == 0 || !strings.Contains(result.Messages[len(result.Messages)-1].Content, "Conversation summary:") {
-		t.Fatalf("result should retain compacted summary messages: %#v", result.Messages)
-	}
-}
-
-func TestSessionContextCapsToolResultBeforeCompaction(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "large_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(largeTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor: &SimpleCompactor{Client: nil, Options: CompactionOptions{
-			ContextWindowTokens: 100,
-			Threshold:           0.8,
-		}},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	content := result.Messages[2].Content
-	if !strings.Contains(content, "[tool output truncated: ") ||
-		!strings.Contains(content, "Use a narrower command, line range, or search query") {
-		t.Fatalf("tool content missing truncation marker: %q", content)
-	}
-	if xCount := strings.Count(content, "x"); xCount >= maxToolResultRunes {
-		t.Fatalf("context-capped content x count = %d, want less than hard cap", xCount)
-	}
-	if client.requests[1].Messages[2].Content != content {
-		t.Fatalf("second model request did not use context-capped tool content")
-	}
-}
-
-func TestSessionCompactsThenReattachesFullyOmittedToolResult(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "large_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "older history summarized"}}},
-			{{Message: api.Message{Role: "assistant", Content: "done with result"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(largeTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor: &SimpleCompactor{Client: client, Options: CompactionOptions{
-			ContextWindowTokens: smallContextToolResultTokenWindow,
-			Threshold:           0.45,
-		}},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		Messages:    []api.Message{{Role: "user", Content: strings.Repeat("history ", 2000)}},
-		NewMessages: []api.Message{{Role: "user", Content: "use a large tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if client.calls != 3 {
-		t.Fatalf("client calls = %d, want model, compaction, model", client.calls)
-	}
-	if len(client.requests) != 3 {
-		t.Fatalf("requests = %d, want 3", len(client.requests))
-	}
-
-	nextRequestMessages := client.requests[2].Messages
-	if len(nextRequestMessages) != 4 {
-		t.Fatalf("next model request messages = %#v, want summary pair plus tool call/result", nextRequestMessages)
-	}
-	if nextRequestMessages[0].Role != "assistant" || len(nextRequestMessages[0].ToolCalls) != 1 || nextRequestMessages[0].ToolCalls[0].Function.Name != CompactionToolName {
-		t.Fatalf("first message should be compaction summary tool call: %#v", nextRequestMessages[0])
-	}
-	if nextRequestMessages[1].Role != "tool" || nextRequestMessages[1].ToolName != CompactionToolName || !strings.Contains(nextRequestMessages[1].Content, "older history summarized") {
-		t.Fatalf("second message should be compaction summary result: %#v", nextRequestMessages[1])
-	}
-	if nextRequestMessages[2].Role != "assistant" || len(nextRequestMessages[2].ToolCalls) != 1 || nextRequestMessages[2].ToolCalls[0].ID != "call-1" {
-		t.Fatalf("third message should be original assistant tool call: %#v", nextRequestMessages[2])
-	}
-	toolResult := nextRequestMessages[3]
-	if toolResult.Role != "tool" || toolResult.ToolName != "large_tool" || toolResult.ToolCallID != "call-1" {
-		t.Fatalf("fourth message should be reattached large tool result: %#v", toolResult)
-	}
-	if toolOutputFullyOmitted(toolResult.Content) {
-		t.Fatalf("tool result should be re-fitted after compaction, got full omission marker: %q", toolResult.Content)
-	}
-	if !strings.Contains(toolResult.Content, "[tool output truncated: showing first ~") {
-		t.Fatalf("tool result should still be bounded after compaction: %q", toolResult.Content)
-	}
-	if strings.Count(toolResult.Content, "x") != smallContextToolResultRunes {
-		t.Fatalf("tool result x count = %d, want %d", strings.Count(toolResult.Content, "x"), smallContextToolResultRunes)
-	}
-	if got := result.Messages[len(result.Messages)-1].Content; got != "done with result" {
-		t.Fatalf("final response = %q", got)
-	}
-}
-
-func TestSessionEmitsAutoCompactionActivityEvents(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{{
-				Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "large_tool",
-						Arguments: args,
-					},
-				}}},
-			}},
-			{{Message: api.Message{Role: "assistant", Content: "summary"}, Metrics: api.Metrics{EvalCount: 7}}},
-			{{Message: api.Message{Role: "assistant", Content: "done"}}},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(largeTool{})
-	events := &recordingEventSink{}
-	session := &Session{
-		Client:        client,
-		EventSinks:    []EventSink{events},
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		Compactor: &SimpleCompactor{Client: client, Options: CompactionOptions{
-			ContextWindowTokens: 300,
-			Threshold:           0.3,
-		}},
-	}
-
-	if _, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if !hasEventType(events.events, EventCompactionStarted) {
-		t.Fatalf("events missing compaction start: %#v", events.events)
-	}
-	if !hasEventWithTokens(events.events, EventCompactionProgress, 7) {
-		t.Fatalf("events missing compaction progress tokens: %#v", events.events)
-	}
-	if !hasEventType(events.events, EventCompacted) {
-		t.Fatalf("events missing compacted event: %#v", events.events)
-	}
-}
-
-func TestSessionTruncatesSeededToolMessagesBeforeHistory(t *testing.T) {
-	largeContent := strings.Repeat("x", maxToolResultRunes+100)
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{{
-			{Message: api.Message{Role: "assistant", Content: "done"}},
-		}},
-	}
-	session := &Session{
-		Client: client,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID: "chat-1",
-		Model:  "model",
-		NewMessages: []api.Message{
-			{Role: "user", Content: "use seeded tool"},
-			{Role: "tool", ToolName: "example_tool", ToolCallID: "call-1", Content: largeContent},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(result.Messages) < 2 {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-	content := result.Messages[1].Content
-	if !strings.Contains(content, "[tool output truncated: showing first ~") ||
-		!strings.Contains(content, "omitted ~25 tokens") {
-		t.Fatalf("seeded tool content missing truncation marker: %q", content)
-	}
-	requestContent := client.requests[0].Messages[1].Content
-	if !strings.Contains(requestContent, "[tool output truncated: showing first ~") {
-		t.Fatalf("model request did not use capped seeded tool content: %q", requestContent)
-	}
-	if strings.Count(requestContent, "x") > maxToolResultRunes {
-		t.Fatalf("request seeded tool content x count = %d, want at most %d", strings.Count(requestContent, "x"), maxToolResultRunes)
-	}
-}
-
-func TestSessionPreflightRejectsOversizedFirstRequest(t *testing.T) {
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{{
-			{Message: api.Message{Role: "assistant", Content: "should not run"}},
-		}},
-	}
-	events := &recordingEventSink{}
-	session := &Session{
-		Client:     client,
-		EventSinks: []EventSink{events},
-		Compactor: &SimpleCompactor{Client: nil, Options: CompactionOptions{
-			ContextWindowTokens: 128,
-		}},
-	}
-
-	_, err := session.Run(context.Background(), RunOptions{
-		ChatID:       "chat-1",
-		Model:        "model",
-		SystemPrompt: strings.Repeat("system instructions ", 200),
-		NewMessages:  []api.Message{{Role: "user", Content: "hello"}},
-	})
-	if err == nil {
-		t.Fatal("expected preflight context error")
-	}
-	if !strings.Contains(err.Error(), "Reduce the system prompt or message history") || !strings.Contains(err.Error(), "compact the conversation") {
-		t.Fatalf("error = %q, want actionable prompt guidance", err.Error())
-	}
-	if len(client.requests) != 0 {
-		t.Fatalf("chat requests = %d, want none before preflight passes", len(client.requests))
-	}
-	if !hasEventType(events.events, EventError) {
-		t.Fatalf("events missing error: %#v", events.events)
-	}
-}
-
-func TestSessionPreflightIgnoresRawImageBytes(t *testing.T) {
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{{
-			{Message: api.Message{Role: "assistant", Content: "image received"}},
-		}},
-	}
-	session := &Session{
-		Client: client,
-		Compactor: &SimpleCompactor{Client: nil, Options: CompactionOptions{
-			ContextWindowTokens: 128,
-		}},
-	}
-
-	image := make(api.ImageData, 64*1024)
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID: "chat-1",
-		Model:  "model",
-		NewMessages: []api.Message{{
-			Role:    "user",
-			Content: "describe this image",
-			Images:  []api.ImageData{image},
-		}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(client.requests) != 1 {
-		t.Fatalf("chat requests = %d, want 1", len(client.requests))
-	}
-	if got := client.requests[0].Messages[0].Images; len(got) != 1 || len(got[0]) != len(image) {
-		t.Fatalf("request images = %#v, want original image payload", got)
-	}
-	if len(result.Messages) == 0 || result.Messages[len(result.Messages)-1].Content != "image received" {
-		t.Fatalf("result messages = %#v", result.Messages)
-	}
-}
-
-func TestSessionFreezesBatchToolWorkingDirAfterApproval(t *testing.T) {
-	root := t.TempDir()
-	if err := os.Mkdir(filepath.Join(root, "sub"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	setArgs := api.NewToolCallFunctionArguments()
-	setArgs.Set("mode", "set")
-	setArgs.Set("path", "sub")
-	echoArgs := api.NewToolCallFunctionArguments()
-	echoArgs.Set("mode", "echo")
-
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{
-					{
-						ID: "call-1",
-						Function: api.ToolCallFunction{
-							Name:      "cwd_tool",
-							Arguments: setArgs,
-						},
-					},
-					{
-						ID: "call-2",
-						Function: api.ToolCallFunction{
-							Name:      "cwd_tool",
-							Arguments: echoArgs,
-						},
-					},
-				}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(cwdTestTool{})
-	prompter := &recordingApprovalPrompter{results: []Approval{{Allow: true}}}
-	session := &Session{
-		Client:           client,
-		Tools:            registry,
-		ApprovalPrompter: prompter,
-		WorkingDir:       root,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use cwd"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	want, err := filepath.EvalSymlinks(filepath.Join(root, "sub"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	approvedRoot := root
-	if len(prompter.requests) != 1 {
-		t.Fatalf("approval requests = %d, want 1", len(prompter.requests))
-	}
-	if prompter.requests[0].WorkingDir != approvedRoot {
-		t.Fatalf("approval cwd = %q, want %q", prompter.requests[0].WorkingDir, approvedRoot)
-	}
-	if session.WorkingDir != want {
-		t.Fatalf("session cwd = %q, want %q", session.WorkingDir, want)
-	}
-	if result.WorkingDir != want {
-		t.Fatalf("result cwd = %q, want %q", result.WorkingDir, want)
-	}
-	if result.Messages[2].Content != "changed" {
-		t.Fatalf("cwd change tool content = %q, want unchanged output", result.Messages[2].Content)
-	}
-	if result.Messages[3].Content != approvedRoot {
-		t.Fatalf("second tool saw cwd %q, want approved cwd %q", result.Messages[3].Content, approvedRoot)
-	}
-}
-
-func TestSessionAllowsToolWorkingDirOutsideInitialDir(t *testing.T) {
-	root := t.TempDir()
-	escapeArgs := api.NewToolCallFunctionArguments()
-	escapeArgs.Set("mode", "escape")
-	echoArgs := api.NewToolCallFunctionArguments()
-	echoArgs.Set("mode", "echo")
-
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{
-					{
-						ID: "call-1",
-						Function: api.ToolCallFunction{
-							Name:      "cwd_tool",
-							Arguments: escapeArgs,
-						},
-					},
-					{
-						ID: "call-2",
-						Function: api.ToolCallFunction{
-							Name:      "cwd_tool",
-							Arguments: echoArgs,
-						},
-					},
-				}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(cwdTestTool{})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-		WorkingDir:    root,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use cwd"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	want, err := filepath.EvalSymlinks(filepath.Dir(root))
-	if err != nil {
-		t.Fatal(err)
-	}
-	approvedRoot := root
-	if session.WorkingDir != want {
-		t.Fatalf("session cwd = %q, want %q", session.WorkingDir, want)
-	}
-	if result.Messages[2].Content != "escaped" {
-		t.Fatalf("escape tool content = %q, want unchanged output", result.Messages[2].Content)
-	}
-	if result.Messages[3].Content != approvedRoot {
-		t.Fatalf("second tool saw cwd %q, want original cwd %q", result.Messages[3].Content, approvedRoot)
-	}
-}
-
-func TestSessionDeniesWithoutApprovalPrompter(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	echoArgs := api.NewToolCallFunctionArguments()
-	echoArgs.Set("value", "should not run")
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{
-					{
-						ID: "call-1",
-						Function: api.ToolCallFunction{
-							Name:      "approval_tool",
-							Arguments: args,
-						},
-					},
-					{
-						ID: "call-2",
-						Function: api.ToolCallFunction{
-							Name:      "echo_tool",
-							Arguments: echoArgs,
-						},
-					},
-				}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-	called := false
-	registry := &Registry{}
-	registry.Register(approvalTestTool{called: &called})
-	registry.Register(staticTool{})
-	session := &Session{
-		Client: client,
-		Tools:  registry,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		ChatID:      "chat-1",
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if called {
-		t.Fatal("tool executed despite denied approval")
-	}
-	if client.calls != 1 {
-		t.Fatalf("client calls = %d, want 1 after denial", client.calls)
-	}
-	if len(result.Messages) != 4 {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-	if result.Messages[2].Role != "tool" || result.Messages[2].ToolCallID != "call-1" {
-		t.Fatalf("denial tool message = %#v", result.Messages[2])
-	}
-	if result.Messages[2].Content == "" || result.Messages[2].Content == "approved" || result.Messages[2].Content == "tool says hello" {
-		t.Fatalf("tool denial content = %q", result.Messages[2].Content)
-	}
-	if result.Messages[3].Role != "tool" || result.Messages[3].ToolCallID != "call-2" {
-		t.Fatalf("second denial tool message = %#v", result.Messages[3])
-	}
-	if result.Messages[3].Content == "" || result.Messages[3].Content == "tool says hello" {
-		t.Fatalf("second denial content = %q", result.Messages[3].Content)
-	}
-}
-
-func TestSessionPromptsOnceForApprovalBatch(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{
-					{
-						ID: "call-1",
-						Function: api.ToolCallFunction{
-							Name:      "approval_tool",
-							Arguments: args,
-						},
-					},
-					{
-						ID: "call-2",
-						Function: api.ToolCallFunction{
-							Name:      "approval_tool",
-							Arguments: args,
-						},
-					},
-				}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-	called := false
-	registry := &Registry{}
-	registry.Register(approvalTestTool{called: &called})
-	prompter := &recordingApprovalPrompter{
-		results: []Approval{{Reason: "denied"}},
-	}
-	session := &Session{
-		Client:           client,
-		Tools:            registry,
-		ApprovalPrompter: prompter,
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use tools"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(prompter.requests) != 1 {
-		t.Fatalf("approval prompts = %d, want 1", len(prompter.requests))
-	}
-	if len(prompter.requests[0].Calls) != 2 {
-		t.Fatalf("approval calls = %#v, want both tool calls", prompter.requests[0].Calls)
-	}
-	if called {
-		t.Fatal("tool ran despite denied approval")
-	}
-	if client.calls != 1 {
-		t.Fatalf("client calls = %d, want 1 after denial", client.calls)
-	}
-	if len(result.Messages) != 4 || result.Messages[2].Role != "tool" || result.Messages[3].Role != "tool" {
-		t.Fatalf("messages = %#v", result.Messages)
-	}
-}
-
-func TestSessionRunsFullApprovedToolBatchBeforeNextModelStep(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{
-					{
-						ID: "call-1",
-						Function: api.ToolCallFunction{
-							Name:      "approval_tool",
-							Arguments: args,
-						},
-					},
-					{
-						ID: "call-2",
-						Function: api.ToolCallFunction{
-							Name:      "approval_tool",
-							Arguments: args,
-						},
-					},
-				}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(approvalTestTool{})
-	prompter := &recordingApprovalPrompter{
-		results: []Approval{{Allow: true}},
-	}
-	events := &recordingEventSink{}
-	session := &Session{
-		Client:           client,
-		Tools:            registry,
-		ApprovalPrompter: prompter,
-		EventSinks:       []EventSink{events},
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use tools"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if client.calls != 2 {
-		t.Fatalf("client calls = %d, want second model step only after tool batch", client.calls)
-	}
-	if len(result.Messages) != 5 {
-		t.Fatalf("messages = %#v, want user, assistant tool calls, two tool results, final assistant", result.Messages)
-	}
-	if result.Messages[2].Role != "tool" || result.Messages[2].ToolCallID != "call-1" {
-		t.Fatalf("first tool result = %#v", result.Messages[2])
-	}
-	if result.Messages[3].Role != "tool" || result.Messages[3].ToolCallID != "call-2" {
-		t.Fatalf("second tool result = %#v", result.Messages[3])
-	}
-	if result.Messages[4].Role != "assistant" || result.Messages[4].Content != "done" {
-		t.Fatalf("final assistant = %#v", result.Messages[4])
-	}
-
-	var finishedBeforeDelta []string
-	for _, event := range events.events {
-		if event.Type == EventMessageDelta && event.Content == "done" {
-			break
-		}
-		if event.Type == EventToolFinished {
-			finishedBeforeDelta = append(finishedBeforeDelta, event.ToolCallID)
-		}
-	}
-	if strings.Join(finishedBeforeDelta, ",") != "call-1,call-2" {
-		t.Fatalf("tool finishes before final model delta = %#v, want full batch before model", finishedBeforeDelta)
-	}
-}
-
-func TestSessionAllowAllApprovalSkipsFuturePrompts(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "approval_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-2",
-					Function: api.ToolCallFunction{
-						Name:      "approval_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done again"}},
-			},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(approvalTestTool{})
-	prompter := &recordingApprovalPrompter{
-		results: []Approval{{AllowAll: true}},
-	}
-	session := &Session{
-		Client:           client,
-		Tools:            registry,
-		ApprovalPrompter: prompter,
-	}
-
-	for range 2 {
-		if _, err := session.Run(context.Background(), RunOptions{
-			Model:       "model",
-			NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if !session.ApprovalState.AllowAll() {
-		t.Fatal("session did not remember allow all")
-	}
-	if len(prompter.requests) != 1 {
-		t.Fatalf("approval prompts = %d, want 1", len(prompter.requests))
-	}
-}
-
-func TestSessionAllowToolApprovalSkipsFuturePromptForSameTool(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "approval_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-2",
-					Function: api.ToolCallFunction{
-						Name:      "approval_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done again"}},
-			},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(approvalTestTool{})
-	prompter := &recordingApprovalPrompter{
-		results: []Approval{{AllowScopes: []string{"approval_tool"}}},
-	}
-	session := &Session{
-		Client:           client,
-		Tools:            registry,
-		ApprovalPrompter: prompter,
-	}
-
-	for range 2 {
-		if _, err := session.Run(context.Background(), RunOptions{
-			Model:       "model",
-			NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if session.ApprovalState.AllowAll() {
-		t.Fatal("allowing one tool enabled full access")
-	}
-	if !session.ApprovalState.Allows("approval_tool") {
-		t.Fatal("approval_tool scope was not saved")
-	}
-	if len(prompter.requests) != 1 {
-		t.Fatalf("approval prompts = %d, want 1", len(prompter.requests))
-	}
-}
-
-func TestSessionAllowShellApprovalScopesToExactCommand(t *testing.T) {
-	pwdArgs := api.NewToolCallFunctionArguments()
-	pwdArgs.Set("command", "pwd")
-	lsArgs := api.NewToolCallFunctionArguments()
-	lsArgs.Set("command", "ls")
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "bash",
-						Arguments: pwdArgs,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-2",
-					Function: api.ToolCallFunction{
-						Name:      "bash",
-						Arguments: pwdArgs,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done again"}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-3",
-					Function: api.ToolCallFunction{
-						Name:      "bash",
-						Arguments: lsArgs,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done finally"}},
-			},
-		},
-	}
-	registry := &Registry{}
-	registry.Register(namedApprovalTestTool{name: "bash"})
-	prompter := &recordingApprovalPrompter{
-		results: []Approval{
-			{AllowScopes: []string{toolApprovalScope("bash", map[string]any{"command": "pwd"})}},
-			{Allow: true},
-		},
-	}
-	session := &Session{
-		Client:           client,
-		Tools:            registry,
-		ApprovalPrompter: prompter,
-	}
-
-	for range 3 {
-		if _, err := session.Run(context.Background(), RunOptions{
-			Model:       "model",
-			NewMessages: []api.Message{{Role: "user", Content: "use a command"}},
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if !session.ApprovalState.Allows("bash\x00pwd") {
-		t.Fatal("pwd command scope was not saved")
-	}
-	if session.ApprovalState.Allows("bash") || session.ApprovalState.Allows("bash\x00ls") {
-		t.Fatal("shell approval was too broad")
-	}
-	if len(prompter.requests) != 2 {
-		t.Fatalf("approval prompts = %d, want first pwd and later ls", len(prompter.requests))
-	}
-	if got := prompter.requests[0].Calls[0].ApprovalScope; got != "bash\x00pwd" {
-		t.Fatalf("first approval scope = %q, want pwd command scope", got)
-	}
-	if got := prompter.requests[1].Calls[0].ApprovalScope; got != "bash\x00ls" {
-		t.Fatalf("second approval scope = %q, want ls command scope", got)
-	}
-}
-
-func TestSessionAllowAllToolsExecutesApprovalTool(t *testing.T) {
-	args := api.NewToolCallFunctionArguments()
-	client := &fakeClient{
-		responses: [][]api.ChatResponse{
-			{
-				{Message: api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
-					ID: "call-1",
-					Function: api.ToolCallFunction{
-						Name:      "approval_tool",
-						Arguments: args,
-					},
-				}}}},
-			},
-			{
-				{Message: api.Message{Role: "assistant", Content: "done"}},
-			},
-		},
-	}
-	called := false
-	registry := &Registry{}
-	registry.Register(approvalTestTool{called: &called})
-	session := &Session{
-		Client:        client,
-		Tools:         registry,
-		ApprovalState: approvalStateForTest(true, nil),
-	}
-
-	result, err := session.Run(context.Background(), RunOptions{
-		Model:       "model",
-		NewMessages: []api.Message{{Role: "user", Content: "use a tool"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !called {
-		t.Fatal("tool did not execute")
-	}
-	if result.Messages[2].Content != "approved" {
-		t.Fatalf("tool content = %q, want approved", result.Messages[2].Content)
-	}
-}

agent/tools/bash.go

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

agent/tools/bash_test.go

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

agent/tools/bash_unix.go

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

agent/tools/bash_unix_test.go

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

agent/tools/bash_windows.go

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

agent/tools/bash_windows_test.go

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

agent/tools/file.go

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

agent/tools/file_test.go

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

agent/tools/file_unix_test.go

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

agent/tools/web.go

@@ -1,199 +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 (w *WebSearch) Name() string {
-	return "web_search"
-}
-
-func (w *WebSearch) Description() string {
-	return "Search the web for current information that may not be in the model's training data."
-}
-
-func (w *WebSearch) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("query", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The search query to look up on the web.",
-	})
-	return api.ToolFunction{
-		Name:        w.Name(),
-		Description: w.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"query"},
-		},
-	}
-}
-
-func (w *WebSearch) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (w *WebSearch) Execute(ctx context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	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{}, fmt.Errorf("%w: %s", ErrWebSearchAuthRequired, authErr)
-		}
-		return agent.ToolResult{}, err
-	}
-	if len(searchResp.Results) == 0 {
-		return agent.ToolResult{Content: "No results found for query: " + query}, nil
-	}
-
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("Search results for: %s\n\n", query))
-	for i, result := range searchResp.Results {
-		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, result.Title))
-		sb.WriteString(fmt.Sprintf("   URL: %s\n", result.URL))
-		if result.Content != "" {
-			content := []rune(result.Content)
-			if len(content) > 300 {
-				content = append(content[:300], []rune("...")...)
-			}
-			sb.WriteString(fmt.Sprintf("   %s\n", string(content)))
-		}
-		sb.WriteByte('\n')
-	}
-	return agent.ToolResult{Content: sb.String()}, nil
-}
-
-type WebFetch struct{}
-
-func (w *WebFetch) Name() string {
-	return "web_fetch"
-}
-
-func (w *WebFetch) Description() string {
-	return "Fetch and extract text content from a web page."
-}
-
-func (w *WebFetch) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("url", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The URL to fetch and extract content from.",
-	})
-	return api.ToolFunction{
-		Name:        w.Name(),
-		Description: w.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"url"},
-		},
-	}
-}
-
-func (w *WebFetch) RequiresApproval(map[string]any) bool {
-	return true
-}
-
-func (w *WebFetch) Execute(ctx context.Context, _ agent.ToolContext, args map[string]any) (agent.ToolResult, error) {
-	if internalcloud.Disabled() {
-		return agent.ToolResult{}, errors.New(internalcloud.DisabledError("web fetch is unavailable"))
-	}
-	urlStr, ok := args["url"].(string)
-	if !ok || strings.TrimSpace(urlStr) == "" {
-		return agent.ToolResult{}, fmt.Errorf("url parameter is required")
-	}
-	parsed, err := url.Parse(urlStr)
-	if err != nil {
-		return agent.ToolResult{}, fmt.Errorf("invalid URL: %w", err)
-	}
-	if scheme := strings.ToLower(parsed.Scheme); scheme != "http" && scheme != "https" {
-		return agent.ToolResult{}, fmt.Errorf("unsupported URL scheme %q: only http and https are allowed", parsed.Scheme)
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return agent.ToolResult{}, err
-	}
-
-	ctx, cancel := context.WithTimeout(ctx, webFetchTimeout)
-	defer cancel()
-
-	fetchResp, err := client.WebFetchExperimental(ctx, &api.WebFetchRequest{URL: urlStr})
-	if err != nil {
-		var authErr api.AuthorizationError
-		if errors.As(err, &authErr) {
-			return agent.ToolResult{}, fmt.Errorf("%w: %s", ErrWebFetchAuthRequired, authErr)
-		}
-		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,88 +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 TestWebToolsRequireApproval(t *testing.T) {
-	if !coreagent.ToolRequiresApproval((&WebSearch{}), map[string]any{"query": "ollama"}) {
-		t.Fatal("web search should require approval")
-	}
-	if !coreagent.ToolRequiresApproval((&WebFetch{}), map[string]any{"url": "https://ollama.com"}) {
-		t.Fatal("web fetch should require approval")
-	}
-}
-
-func TestWebFetchRejectsUnsupportedScheme(t *testing.T) {
-	tests := []struct {
-		name    string
-		url     string
-		wantErr bool
-	}{
-		{name: "file scheme", url: "file:///etc/passwd", wantErr: true},
-		{name: "data scheme", url: "data:text/plain,secret", wantErr: true},
-		{name: "ftp scheme", url: "ftp://example.com/secret", wantErr: true},
-		{name: "http allowed", url: "http://example.com", wantErr: false},
-		{name: "https allowed", url: "https://example.com", wantErr: false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := (&WebFetch{}).Execute(t.Context(), coreagent.ToolContext{}, map[string]any{"url": tt.url})
-			if tt.wantErr && err == nil {
-				t.Fatal("expected unsupported scheme to be rejected")
-			}
-			// For allowed schemes we expect an error only from the missing
-			// server/auth path, not from scheme validation. The http/https
-			// cases reach the client and may fail on connection/auth; we only
-			// assert that the error is NOT a scheme error.
-			if !tt.wantErr && err != nil && strings.Contains(err.Error(), "unsupported URL scheme") {
-				t.Fatalf("http/https rejected as unsupported: %v", err)
-			}
-		})
-	}
-}
-
-func TestWebFetchBoundsContentBeforeReturning(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/api/experimental/web_fetch" {
-			t.Fatalf("path = %q, want /api/experimental/web_fetch", r.URL.Path)
-		}
-		var req api.WebFetchRequest
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			t.Fatal(err)
-		}
-		if req.URL != "https://ollama.com" {
-			t.Fatalf("request URL = %q, want https://ollama.com", req.URL)
-		}
-		if err := json.NewEncoder(w).Encode(api.WebFetchResponse{
-			Title:   "Ollama",
-			Content: strings.Repeat("x", maxWebFetchContentRunes+25),
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}))
-	defer ts.Close()
-	t.Setenv("OLLAMA_HOST", ts.URL)
-
-	result, err := (&WebFetch{}).Execute(t.Context(), coreagent.ToolContext{}, map[string]any{
-		"url": "https://ollama.com",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(result.Content, "[tool output truncated: showing first ~") ||
-		!strings.Contains(result.Content, "omitted ~7 tokens") ||
-		!strings.Contains(result.Content, "Use a narrower request or search query") {
-		t.Fatalf("content missing truncation marker: %q", result.Content)
-	}
-	if count := strings.Count(result.Content, "x"); count != maxWebFetchContentRunes {
-		t.Fatalf("captured content count = %d, want %d", count, maxWebFetchContentRunes)
-	}
-}

anthropic/anthropic.go

@@ -1,1267 +0,0 @@
-package anthropic
-
-import (
-	"bytes"
-	"context"
-	"crypto/rand"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/auth"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-	"github.com/ollama/ollama/logutil"
-)
-
-// Error types matching Anthropic API
-type Error struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-}
-
-type ErrorResponse struct {
-	Type      string `json:"type"` // always "error"
-	Error     Error  `json:"error"`
-	RequestID string `json:"request_id,omitempty"`
-}
-
-// NewError creates a new ErrorResponse with the appropriate error type based on HTTP status code
-func NewError(code int, message string) ErrorResponse {
-	var etype string
-	switch code {
-	case http.StatusBadRequest:
-		etype = "invalid_request_error"
-	case http.StatusUnauthorized:
-		etype = "authentication_error"
-	case http.StatusForbidden:
-		etype = "permission_error"
-	case http.StatusNotFound:
-		etype = "not_found_error"
-	case http.StatusTooManyRequests:
-		etype = "rate_limit_error"
-	case http.StatusServiceUnavailable, 529:
-		etype = "overloaded_error"
-	default:
-		etype = "api_error"
-	}
-
-	return ErrorResponse{
-		Type:      "error",
-		Error:     Error{Type: etype, Message: message},
-		RequestID: generateID("req"),
-	}
-}
-
-// Request types
-
-// MessagesRequest represents an Anthropic Messages API request
-type MessagesRequest struct {
-	Model         string          `json:"model"`
-	MaxTokens     int             `json:"max_tokens"`
-	Messages      []MessageParam  `json:"messages"`
-	System        any             `json:"system,omitempty"` // string or []map[string]any (JSON-decoded ContentBlock)
-	Stream        bool            `json:"stream,omitempty"`
-	Temperature   *float64        `json:"temperature,omitempty"`
-	TopP          *float64        `json:"top_p,omitempty"`
-	TopK          *int            `json:"top_k,omitempty"`
-	StopSequences []string        `json:"stop_sequences,omitempty"`
-	Tools         []Tool          `json:"tools,omitempty"`
-	ToolChoice    *ToolChoice     `json:"tool_choice,omitempty"`
-	Thinking      *ThinkingConfig `json:"thinking,omitempty"`
-	Metadata      *Metadata       `json:"metadata,omitempty"`
-	OutputConfig  *OutputConfig   `json:"output_config,omitempty"`
-}
-
-type OutputConfig struct {
-	Effort string `json:"effort,omitempty"`
-}
-
-// MessageParam represents a message in the request
-type MessageParam struct {
-	Role    string         `json:"role"`    // "user" or "assistant"
-	Content []ContentBlock `json:"content"` // always []ContentBlock; plain strings are normalized on unmarshal
-}
-
-func (m *MessageParam) UnmarshalJSON(data []byte) error {
-	var raw struct {
-		Role    string          `json:"role"`
-		Content json.RawMessage `json:"content"`
-	}
-	if err := json.Unmarshal(data, &raw); err != nil {
-		return err
-	}
-	m.Role = raw.Role
-
-	var s string
-	if err := json.Unmarshal(raw.Content, &s); err == nil {
-		m.Content = []ContentBlock{{Type: "text", Text: &s}}
-		return nil
-	}
-
-	return json.Unmarshal(raw.Content, &m.Content)
-}
-
-// ContentBlock represents a content block in a message.
-// Text and Thinking use pointers so they serialize as the field being present (even if empty)
-// only when set, which is required for SDK streaming accumulation.
-type ContentBlock struct {
-	Type string `json:"type"` // text, image, tool_use, tool_result, thinking, server_tool_use, web_search_tool_result
-
-	// For text blocks - pointer so field only appears when set (SDK requires it for accumulation)
-	Text *string `json:"text,omitempty"`
-
-	// For text blocks with citations
-	Citations []Citation `json:"citations,omitempty"`
-
-	// For image blocks
-	Source *ImageSource `json:"source,omitempty"`
-
-	// For tool_use and server_tool_use blocks
-	ID    string                        `json:"id,omitempty"`
-	Name  string                        `json:"name,omitempty"`
-	Input api.ToolCallFunctionArguments `json:"input,omitzero"`
-
-	// For tool_result and web_search_tool_result blocks
-	ToolUseID string `json:"tool_use_id,omitempty"`
-	Content   any    `json:"content,omitempty"` // string, []ContentBlock, []WebSearchResult, or WebSearchToolResultError
-	IsError   bool   `json:"is_error,omitempty"`
-
-	// For thinking blocks - pointer so field only appears when set (SDK requires it for accumulation)
-	Thinking  *string `json:"thinking,omitempty"`
-	Signature string  `json:"signature,omitempty"`
-}
-
-// Citation represents a citation in a text block
-type Citation struct {
-	Type           string `json:"type"` // "web_search_result_location"
-	URL            string `json:"url"`
-	Title          string `json:"title"`
-	EncryptedIndex string `json:"encrypted_index,omitempty"`
-	CitedText      string `json:"cited_text,omitempty"`
-}
-
-// WebSearchResult represents a single web search result
-type WebSearchResult struct {
-	Type             string `json:"type"` // "web_search_result"
-	URL              string `json:"url"`
-	Title            string `json:"title"`
-	EncryptedContent string `json:"encrypted_content,omitempty"`
-	PageAge          string `json:"page_age,omitempty"`
-}
-
-// WebSearchToolResultError represents an error from web search
-type WebSearchToolResultError struct {
-	Type      string `json:"type"` // "web_search_tool_result_error"
-	ErrorCode string `json:"error_code"`
-}
-
-// ImageSource represents the source of an image
-type ImageSource struct {
-	Type      string `json:"type"` // "base64"
-	MediaType string `json:"media_type,omitempty"`
-	Data      string `json:"data,omitempty"`
-	URL       string `json:"url,omitempty"`
-}
-
-// Tool represents a tool definition
-type Tool struct {
-	Type        string          `json:"type,omitempty"` // "custom" for user-defined tools, or "web_search_20250305" for web search
-	Name        string          `json:"name"`
-	Description string          `json:"description,omitempty"`
-	InputSchema json.RawMessage `json:"input_schema,omitempty"`
-
-	// Web search specific fields
-	MaxUses int `json:"max_uses,omitempty"`
-}
-
-// ToolChoice controls how the model uses tools
-type ToolChoice struct {
-	Type                   string `json:"type"` // "auto", "any", "tool", "none"
-	Name                   string `json:"name,omitempty"`
-	DisableParallelToolUse bool   `json:"disable_parallel_tool_use,omitempty"`
-}
-
-// ThinkingConfig controls extended thinking
-type ThinkingConfig struct {
-	Type         string `json:"type"` // "enabled" or "disabled"
-	BudgetTokens int    `json:"budget_tokens,omitempty"`
-}
-
-// Metadata for the request
-type Metadata struct {
-	UserID string `json:"user_id,omitempty"`
-}
-
-// Response types
-
-// MessagesResponse represents an Anthropic Messages API response
-type MessagesResponse struct {
-	ID           string         `json:"id"`
-	Type         string         `json:"type"` // "message"
-	Role         string         `json:"role"` // "assistant"
-	Model        string         `json:"model"`
-	Content      []ContentBlock `json:"content"`
-	StopReason   string         `json:"stop_reason,omitempty"`
-	StopSequence string         `json:"stop_sequence,omitempty"`
-	Usage        Usage          `json:"usage"`
-}
-
-// Usage contains token usage information
-type Usage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-}
-
-// Streaming event types
-
-// MessageStartEvent is sent at the start of streaming
-type MessageStartEvent struct {
-	Type    string           `json:"type"` // "message_start"
-	Message MessagesResponse `json:"message"`
-}
-
-// ContentBlockStartEvent signals the start of a content block
-type ContentBlockStartEvent struct {
-	Type         string       `json:"type"` // "content_block_start"
-	Index        int          `json:"index"`
-	ContentBlock ContentBlock `json:"content_block"`
-}
-
-// ContentBlockDeltaEvent contains incremental content updates
-type ContentBlockDeltaEvent struct {
-	Type  string `json:"type"` // "content_block_delta"
-	Index int    `json:"index"`
-	Delta Delta  `json:"delta"`
-}
-
-// Delta represents an incremental update
-type Delta struct {
-	Type        string `json:"type"` // "text_delta", "input_json_delta", "thinking_delta", "signature_delta"
-	Text        string `json:"text,omitempty"`
-	PartialJSON string `json:"partial_json,omitempty"`
-	Thinking    string `json:"thinking,omitempty"`
-	Signature   string `json:"signature,omitempty"`
-}
-
-// ContentBlockStopEvent signals the end of a content block
-type ContentBlockStopEvent struct {
-	Type  string `json:"type"` // "content_block_stop"
-	Index int    `json:"index"`
-}
-
-// MessageDeltaEvent contains updates to the message
-type MessageDeltaEvent struct {
-	Type  string       `json:"type"` // "message_delta"
-	Delta MessageDelta `json:"delta"`
-	Usage DeltaUsage   `json:"usage"`
-}
-
-// MessageDelta contains stop information
-type MessageDelta struct {
-	StopReason   string `json:"stop_reason,omitempty"`
-	StopSequence string `json:"stop_sequence,omitempty"`
-}
-
-// DeltaUsage contains cumulative token usage
-type DeltaUsage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-}
-
-// MessageStopEvent signals the end of the message
-type MessageStopEvent struct {
-	Type string `json:"type"` // "message_stop"
-}
-
-// PingEvent is a keepalive event
-type PingEvent struct {
-	Type string `json:"type"` // "ping"
-}
-
-// StreamErrorEvent is an error during streaming
-type StreamErrorEvent struct {
-	Type  string `json:"type"` // "error"
-	Error Error  `json:"error"`
-}
-
-// FromMessagesRequest converts an Anthropic MessagesRequest to an Ollama api.ChatRequest
-func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
-	logutil.Trace("anthropic: converting request", "req", TraceMessagesRequest(r))
-
-	var messages []api.Message
-
-	if r.System != nil {
-		switch sys := r.System.(type) {
-		case string:
-			if sys != "" {
-				messages = append(messages, api.Message{Role: "system", Content: sys})
-			}
-		case []any:
-			// System can be an array of content blocks
-			var content strings.Builder
-			for _, block := range sys {
-				if blockMap, ok := block.(map[string]any); ok {
-					if blockMap["type"] == "text" {
-						if text, ok := blockMap["text"].(string); ok {
-							content.WriteString(text)
-						}
-					}
-				}
-			}
-			if content.Len() > 0 {
-				messages = append(messages, api.Message{Role: "system", Content: content.String()})
-			}
-		}
-	}
-
-	for i, msg := range r.Messages {
-		converted, err := convertMessage(msg)
-		if err != nil {
-			logutil.Trace("anthropic: message conversion failed", "index", i, "role", msg.Role, "err", err)
-			return nil, err
-		}
-		messages = append(messages, converted...)
-	}
-
-	options := make(map[string]any)
-
-	options["num_predict"] = r.MaxTokens
-
-	if r.Temperature != nil {
-		options["temperature"] = *r.Temperature
-	}
-
-	if r.TopP != nil {
-		options["top_p"] = *r.TopP
-	}
-
-	if r.TopK != nil {
-		options["top_k"] = *r.TopK
-	}
-
-	if len(r.StopSequences) > 0 {
-		options["stop"] = r.StopSequences
-	}
-
-	var tools api.Tools
-	hasBuiltinWebSearch := false
-	for _, t := range r.Tools {
-		if strings.HasPrefix(t.Type, "web_search") {
-			hasBuiltinWebSearch = true
-			break
-		}
-	}
-
-	for _, t := range r.Tools {
-		// Anthropic built-in web_search maps to Ollama function name "web_search".
-		// If a user-defined tool also uses that name in the same request, drop the
-		// user-defined one to avoid ambiguous tool-call routing.
-		if hasBuiltinWebSearch && !strings.HasPrefix(t.Type, "web_search") && t.Name == "web_search" {
-			logutil.Trace("anthropic: dropping colliding custom web_search tool", "tool", TraceTool(t))
-			continue
-		}
-
-		tool, _, err := convertTool(t)
-		if err != nil {
-			return nil, err
-		}
-		tools = append(tools, tool)
-	}
-
-	var think *api.ThinkValue
-	normalizedEffort := ""
-	if r.OutputConfig != nil {
-		normalizedEffort = strings.ToLower(strings.TrimSpace(r.OutputConfig.Effort))
-		if normalizedEffort == "xhigh" {
-			normalizedEffort = "high"
-		}
-	}
-
-	if r.Thinking != nil && r.Thinking.Type == "enabled" {
-		think = &api.ThinkValue{Value: true}
-	}
-	if r.Thinking != nil && r.Thinking.Type == "disabled" {
-		think = &api.ThinkValue{Value: false}
-	}
-	if think == nil && r.OutputConfig != nil {
-		switch normalizedEffort {
-		case "high", "medium", "low", "max":
-			think = &api.ThinkValue{Value: normalizedEffort}
-		}
-	}
-
-	stream := r.Stream
-	convertedRequest := &api.ChatRequest{
-		Model:    r.Model,
-		Messages: messages,
-		Options:  options,
-		Stream:   &stream,
-		Tools:    tools,
-		Think:    think,
-	}
-	logutil.Trace("anthropic: converted request", "req", TraceChatRequest(convertedRequest))
-
-	return convertedRequest, nil
-}
-
-// convertMessage converts an Anthropic MessageParam to Ollama api.Message(s)
-func convertMessage(msg MessageParam) ([]api.Message, error) {
-	var messages []api.Message
-	role := strings.ToLower(msg.Role)
-
-	var textContent strings.Builder
-	var images []api.ImageData
-	var toolCalls []api.ToolCall
-	var thinking string
-	var toolResults []api.Message
-	textBlocks := 0
-	imageBlocks := 0
-	toolUseBlocks := 0
-	toolResultBlocks := 0
-	serverToolUseBlocks := 0
-	webSearchToolResultBlocks := 0
-	thinkingBlocks := 0
-	unknownBlocks := 0
-
-	for _, block := range msg.Content {
-		switch block.Type {
-		case "text":
-			textBlocks++
-			if block.Text != nil {
-				textContent.WriteString(*block.Text)
-			}
-
-		case "image":
-			imageBlocks++
-			if block.Source == nil {
-				logutil.Trace("anthropic: invalid image source", "role", role)
-				return nil, errors.New("invalid image source")
-			}
-
-			decoded, err := resolveImageSource(block.Source)
-			if err != nil {
-				logutil.Trace("anthropic: unsupported image source", "role", role, "source_type", block.Source.Type, "error", err)
-				return nil, err
-			}
-			images = append(images, decoded)
-
-		case "tool_use":
-			toolUseBlocks++
-			if block.ID == "" {
-				logutil.Trace("anthropic: tool_use block missing id", "role", role)
-				return nil, errors.New("tool_use block missing required 'id' field")
-			}
-			if block.Name == "" {
-				logutil.Trace("anthropic: tool_use block missing name", "role", role)
-				return nil, errors.New("tool_use block missing required 'name' field")
-			}
-			toolCalls = append(toolCalls, api.ToolCall{
-				ID: block.ID,
-				Function: api.ToolCallFunction{
-					Name:      block.Name,
-					Arguments: block.Input,
-				},
-			})
-
-		case "tool_result":
-			toolResultBlocks++
-			resultContent, resultImages, err := convertToolResultContent(block.Content)
-			if err != nil {
-				logutil.Trace("anthropic: invalid tool_result content", "role", role, "error", err)
-				return nil, err
-			}
-
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    resultContent,
-				Images:     resultImages,
-				ToolCallID: block.ToolUseID,
-			})
-
-		case "thinking":
-			thinkingBlocks++
-			if block.Thinking != nil {
-				thinking = *block.Thinking
-			}
-
-		case "server_tool_use":
-			serverToolUseBlocks++
-			toolCalls = append(toolCalls, api.ToolCall{
-				ID: block.ID,
-				Function: api.ToolCallFunction{
-					Name:      block.Name,
-					Arguments: block.Input,
-				},
-			})
-
-		case "web_search_tool_result":
-			webSearchToolResultBlocks++
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    formatWebSearchToolResultContent(block.Content),
-				ToolCallID: block.ToolUseID,
-			})
-		default:
-			unknownBlocks++
-		}
-	}
-
-	if role == "user" && len(toolResults) > 0 {
-		messages = append(messages, toolResults...)
-	}
-
-	if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
-		m := api.Message{
-			Role:      role,
-			Content:   textContent.String(),
-			Images:    images,
-			ToolCalls: toolCalls,
-			Thinking:  thinking,
-		}
-		messages = append(messages, m)
-	}
-
-	// Add tool results as separate messages.
-	if role != "user" || len(toolResults) == 0 {
-		messages = append(messages, toolResults...)
-	}
-	logutil.Trace("anthropic: converted block message",
-		"role", role,
-		"blocks", len(msg.Content),
-		"text", textBlocks,
-		"image", imageBlocks,
-		"tool_use", toolUseBlocks,
-		"tool_result", toolResultBlocks,
-		"server_tool_use", serverToolUseBlocks,
-		"web_search_result", webSearchToolResultBlocks,
-		"thinking", thinkingBlocks,
-		"unknown", unknownBlocks,
-		"messages", TraceAPIMessages(messages),
-	)
-
-	return messages, nil
-}
-
-func formatWebSearchToolResultContent(content any) string {
-	switch c := content.(type) {
-	case string:
-		return c
-	case []WebSearchResult:
-		var resultContent strings.Builder
-		for _, item := range c {
-			if item.Type != "web_search_result" {
-				continue
-			}
-			fmt.Fprintf(&resultContent, "- %s: %s\n", item.Title, item.URL)
-		}
-		return resultContent.String()
-	case []any:
-		var resultContent strings.Builder
-		for _, item := range c {
-			itemMap, ok := item.(map[string]any)
-			if !ok {
-				continue
-			}
-			switch itemMap["type"] {
-			case "web_search_result":
-				title, _ := itemMap["title"].(string)
-				url, _ := itemMap["url"].(string)
-				fmt.Fprintf(&resultContent, "- %s: %s\n", title, url)
-			case "web_search_tool_result_error":
-				errorCode, _ := itemMap["error_code"].(string)
-				if errorCode == "" {
-					return "web_search_tool_result_error"
-				}
-				return "web_search_tool_result_error: " + errorCode
-			}
-		}
-		return resultContent.String()
-	case map[string]any:
-		if c["type"] == "web_search_tool_result_error" {
-			errorCode, _ := c["error_code"].(string)
-			if errorCode == "" {
-				return "web_search_tool_result_error"
-			}
-			return "web_search_tool_result_error: " + errorCode
-		}
-		data, err := json.Marshal(c)
-		if err != nil {
-			return ""
-		}
-		return string(data)
-	case WebSearchToolResultError:
-		if c.ErrorCode == "" {
-			return "web_search_tool_result_error"
-		}
-		return "web_search_tool_result_error: " + c.ErrorCode
-	default:
-		data, err := json.Marshal(c)
-		if err != nil {
-			return ""
-		}
-		return string(data)
-	}
-}
-
-// convertTool converts an Anthropic Tool to an Ollama api.Tool, returning true if it's a server tool
-func convertTool(t Tool) (api.Tool, bool, error) {
-	if strings.HasPrefix(t.Type, "web_search") {
-		props := api.NewToolPropertiesMap()
-		props.Set("query", api.ToolProperty{
-			Type:        api.PropertyType{"string"},
-			Description: "The search query to look up on the web",
-		})
-		return api.Tool{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name:        "web_search",
-				Description: "Search the web for current information. Use this to find up-to-date information about any topic.",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Required:   []string{"query"},
-					Properties: props,
-				},
-			},
-		}, true, nil
-	}
-
-	var params api.ToolFunctionParameters
-	if len(t.InputSchema) > 0 {
-		if err := json.Unmarshal(t.InputSchema, &params); err != nil {
-			logutil.Trace("anthropic: invalid tool schema", "tool", t.Name, "err", err)
-			return api.Tool{}, false, fmt.Errorf("invalid input_schema for tool %q: %w", t.Name, err)
-		}
-	}
-
-	return api.Tool{
-		Type: "function",
-		Function: api.ToolFunction{
-			Name:        t.Name,
-			Description: t.Description,
-			Parameters:  params,
-		},
-	}, false, nil
-}
-
-// ToMessagesResponse converts an Ollama api.ChatResponse to an Anthropic MessagesResponse
-func ToMessagesResponse(id string, r api.ChatResponse) MessagesResponse {
-	var content []ContentBlock
-
-	if r.Message.Thinking != "" {
-		content = append(content, ContentBlock{
-			Type:     "thinking",
-			Thinking: ptr(r.Message.Thinking),
-		})
-	}
-
-	if r.Message.Content != "" {
-		content = append(content, ContentBlock{
-			Type: "text",
-			Text: ptr(r.Message.Content),
-		})
-	}
-
-	for _, tc := range r.Message.ToolCalls {
-		content = append(content, ContentBlock{
-			Type:  "tool_use",
-			ID:    tc.ID,
-			Name:  tc.Function.Name,
-			Input: tc.Function.Arguments,
-		})
-	}
-
-	stopReason := mapStopReason(r.DoneReason, len(r.Message.ToolCalls) > 0)
-
-	return MessagesResponse{
-		ID:         id,
-		Type:       "message",
-		Role:       "assistant",
-		Model:      r.Model,
-		Content:    content,
-		StopReason: stopReason,
-		Usage: Usage{
-			InputTokens:  r.Metrics.PromptEvalCount,
-			OutputTokens: r.Metrics.EvalCount,
-		},
-	}
-}
-
-// mapStopReason converts Ollama done_reason to Anthropic stop_reason
-func mapStopReason(reason string, hasToolCalls bool) string {
-	if hasToolCalls {
-		return "tool_use"
-	}
-
-	switch reason {
-	case "stop":
-		return "end_turn"
-	case "length":
-		return "max_tokens"
-	default:
-		if reason != "" {
-			return "stop_sequence"
-		}
-		return ""
-	}
-}
-
-// StreamConverter manages state for converting Ollama streaming responses to Anthropic format
-type StreamConverter struct {
-	ID                   string
-	Model                string
-	firstWrite           bool
-	contentIndex         int
-	inputTokens          int
-	outputTokens         int
-	estimatedInputTokens int // Estimated tokens from request (used when actual metrics are 0)
-	thinkingStarted      bool
-	thinkingDone         bool
-	textStarted          bool
-	toolCallsSent        map[string]bool
-}
-
-func NewStreamConverter(id, model string, estimatedInputTokens int) *StreamConverter {
-	return &StreamConverter{
-		ID:                   id,
-		Model:                model,
-		firstWrite:           true,
-		estimatedInputTokens: estimatedInputTokens,
-		toolCallsSent:        make(map[string]bool),
-	}
-}
-
-// StreamEvent represents a streaming event to be sent to the client
-type StreamEvent struct {
-	Event string
-	Data  any
-}
-
-// Process converts an Ollama ChatResponse to Anthropic streaming events
-func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
-	var events []StreamEvent
-
-	if c.firstWrite {
-		c.firstWrite = false
-		// Use actual metrics if available, otherwise use estimate
-		c.inputTokens = r.Metrics.PromptEvalCount
-		if c.inputTokens == 0 && c.estimatedInputTokens > 0 {
-			c.inputTokens = c.estimatedInputTokens
-		}
-
-		events = append(events, StreamEvent{
-			Event: "message_start",
-			Data: MessageStartEvent{
-				Type: "message_start",
-				Message: MessagesResponse{
-					ID:      c.ID,
-					Type:    "message",
-					Role:    "assistant",
-					Model:   c.Model,
-					Content: []ContentBlock{},
-					Usage: Usage{
-						InputTokens:  c.inputTokens,
-						OutputTokens: 0,
-					},
-				},
-			},
-		})
-	}
-
-	if r.Message.Thinking != "" && !c.thinkingDone {
-		if !c.thinkingStarted {
-			c.thinkingStarted = true
-			events = append(events, StreamEvent{
-				Event: "content_block_start",
-				Data: ContentBlockStartEvent{
-					Type:  "content_block_start",
-					Index: c.contentIndex,
-					ContentBlock: ContentBlock{
-						Type:     "thinking",
-						Thinking: ptr(""),
-					},
-				},
-			})
-		}
-
-		events = append(events, StreamEvent{
-			Event: "content_block_delta",
-			Data: ContentBlockDeltaEvent{
-				Type:  "content_block_delta",
-				Index: c.contentIndex,
-				Delta: Delta{
-					Type:     "thinking_delta",
-					Thinking: r.Message.Thinking,
-				},
-			},
-		})
-	}
-
-	if r.Message.Content != "" {
-		if c.thinkingStarted && !c.thinkingDone {
-			c.thinkingDone = true
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-		}
-
-		if !c.textStarted {
-			c.textStarted = true
-			events = append(events, StreamEvent{
-				Event: "content_block_start",
-				Data: ContentBlockStartEvent{
-					Type:  "content_block_start",
-					Index: c.contentIndex,
-					ContentBlock: ContentBlock{
-						Type: "text",
-						Text: ptr(""),
-					},
-				},
-			})
-		}
-
-		events = append(events, StreamEvent{
-			Event: "content_block_delta",
-			Data: ContentBlockDeltaEvent{
-				Type:  "content_block_delta",
-				Index: c.contentIndex,
-				Delta: Delta{
-					Type: "text_delta",
-					Text: r.Message.Content,
-				},
-			},
-		})
-	}
-
-	for _, tc := range r.Message.ToolCalls {
-		if c.toolCallsSent[tc.ID] {
-			continue
-		}
-
-		// Close thinking block if still open (thinking → tool_use without text in between)
-		if c.thinkingStarted && !c.thinkingDone {
-			c.thinkingDone = true
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-		}
-
-		if c.textStarted {
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-			c.textStarted = false
-		}
-
-		argsJSON, err := json.Marshal(tc.Function.Arguments)
-		if err != nil {
-			slog.Error("failed to marshal tool arguments", "error", err, "tool_id", tc.ID)
-			continue
-		}
-		events = append(events, StreamEvent{
-			Event: "content_block_start",
-			Data: ContentBlockStartEvent{
-				Type:  "content_block_start",
-				Index: c.contentIndex,
-				ContentBlock: ContentBlock{
-					Type:  "tool_use",
-					ID:    tc.ID,
-					Name:  tc.Function.Name,
-					Input: api.NewToolCallFunctionArguments(),
-				},
-			},
-		})
-
-		events = append(events, StreamEvent{
-			Event: "content_block_delta",
-			Data: ContentBlockDeltaEvent{
-				Type:  "content_block_delta",
-				Index: c.contentIndex,
-				Delta: Delta{
-					Type:        "input_json_delta",
-					PartialJSON: string(argsJSON),
-				},
-			},
-		})
-
-		events = append(events, StreamEvent{
-			Event: "content_block_stop",
-			Data: ContentBlockStopEvent{
-				Type:  "content_block_stop",
-				Index: c.contentIndex,
-			},
-		})
-
-		c.toolCallsSent[tc.ID] = true
-		c.contentIndex++
-	}
-
-	if r.Done {
-		if c.textStarted {
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-		} else if c.thinkingStarted && !c.thinkingDone {
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-		}
-
-		c.inputTokens = r.Metrics.PromptEvalCount
-		c.outputTokens = r.Metrics.EvalCount
-		stopReason := mapStopReason(r.DoneReason, len(c.toolCallsSent) > 0)
-
-		events = append(events, StreamEvent{
-			Event: "message_delta",
-			Data: MessageDeltaEvent{
-				Type: "message_delta",
-				Delta: MessageDelta{
-					StopReason: stopReason,
-				},
-				Usage: DeltaUsage{
-					InputTokens:  c.inputTokens,
-					OutputTokens: c.outputTokens,
-				},
-			},
-		})
-
-		events = append(events, StreamEvent{
-			Event: "message_stop",
-			Data: MessageStopEvent{
-				Type: "message_stop",
-			},
-		})
-	}
-
-	return events
-}
-
-// generateID generates a unique ID with the given prefix using crypto/rand
-func generateID(prefix string) string {
-	b := make([]byte, 12)
-	if _, err := rand.Read(b); err != nil {
-		// Fallback to time-based ID if crypto/rand fails
-		return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
-	}
-	return fmt.Sprintf("%s_%x", prefix, b)
-}
-
-// GenerateMessageID generates a unique message ID
-func GenerateMessageID() string {
-	return generateID("msg")
-}
-
-func resolveImageSource(source *ImageSource) (api.ImageData, error) {
-	if source.Type != "base64" {
-		return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", source.Type)
-	}
-
-	decoded, err := base64.StdEncoding.DecodeString(source.Data)
-	if err != nil {
-		return nil, fmt.Errorf("invalid base64 image data: %w", err)
-	}
-
-	return decoded, nil
-}
-
-func convertToolResultContent(content any) (string, []api.ImageData, error) {
-	switch c := content.(type) {
-	case nil:
-		return "", nil, nil
-	case string:
-		return c, nil, nil
-	case []any:
-		var text strings.Builder
-		var images []api.ImageData
-
-		for _, cb := range c {
-			cbMap, ok := cb.(map[string]any)
-			if !ok {
-				continue
-			}
-
-			switch cbMap["type"] {
-			case "text":
-				if t, ok := cbMap["text"].(string); ok {
-					text.WriteString(t)
-				}
-			case "image":
-				rawSource, ok := cbMap["source"].(map[string]any)
-				if !ok {
-					return "", nil, errors.New("invalid tool_result image source")
-				}
-
-				var source ImageSource
-				if rawType, ok := rawSource["type"].(string); ok {
-					source.Type = rawType
-				}
-				if rawMediaType, ok := rawSource["media_type"].(string); ok {
-					source.MediaType = rawMediaType
-				}
-				if rawData, ok := rawSource["data"].(string); ok {
-					source.Data = rawData
-				}
-
-				img, err := resolveImageSource(&source)
-				if err != nil {
-					return "", nil, err
-				}
-				images = append(images, img)
-			}
-		}
-
-		return text.String(), images, nil
-	default:
-		return "", nil, nil
-	}
-}
-
-// ptr returns a pointer to the given string value
-func ptr(s string) *string {
-	return &s
-}
-
-// CountTokensRequest represents an Anthropic count_tokens request
-type CountTokensRequest struct {
-	Model    string          `json:"model"`
-	Messages []MessageParam  `json:"messages"`
-	System   any             `json:"system,omitempty"`
-	Tools    []Tool          `json:"tools,omitempty"`
-	Thinking *ThinkingConfig `json:"thinking,omitempty"`
-}
-
-// EstimateInputTokens estimates input tokens from a MessagesRequest (reuses CountTokensRequest logic)
-func EstimateInputTokens(req MessagesRequest) int {
-	return estimateTokens(CountTokensRequest{
-		Model:    req.Model,
-		Messages: req.Messages,
-		System:   req.System,
-		Tools:    req.Tools,
-		Thinking: req.Thinking,
-	})
-}
-
-// CountTokensResponse represents an Anthropic count_tokens response
-type CountTokensResponse struct {
-	InputTokens int `json:"input_tokens"`
-}
-
-// estimateTokens returns a rough estimate of tokens (len/4).
-// TODO: Replace with actual tokenization via Tokenize API for accuracy.
-// Current len/4 heuristic is a rough approximation (~4 chars/token average).
-func estimateTokens(req CountTokensRequest) int {
-	var totalLen int
-
-	// Count system prompt
-	totalLen += countAnyContent(req.System)
-
-	for _, msg := range req.Messages {
-		// Count role (always present)
-		totalLen += len(msg.Role)
-		// Count content
-		totalLen += countAnyContent(msg.Content)
-	}
-
-	for _, tool := range req.Tools {
-		totalLen += len(tool.Name) + len(tool.Description) + len(tool.InputSchema)
-	}
-
-	// Return len/4 as rough token estimate, minimum 1 if there's any content
-	tokens := totalLen / 4
-	if tokens == 0 && (len(req.Messages) > 0 || req.System != nil) {
-		tokens = 1
-	}
-	return tokens
-}
-
-func countAnyContent(content any) int {
-	if content == nil {
-		return 0
-	}
-
-	switch c := content.(type) {
-	case string:
-		return len(c)
-	case []ContentBlock:
-		total := 0
-		for _, block := range c {
-			total += countContentBlock(block)
-		}
-		return total
-	case []any:
-		total := 0
-		for _, item := range c {
-			data, err := json.Marshal(item)
-			if err != nil {
-				continue
-			}
-			var block ContentBlock
-			if err := json.Unmarshal(data, &block); err == nil {
-				total += countContentBlock(block)
-			}
-		}
-		return total
-	default:
-		if data, err := json.Marshal(content); err == nil {
-			return len(data)
-		}
-		return 0
-	}
-}
-
-func countContentBlock(block ContentBlock) int {
-	total := 0
-	if block.Text != nil {
-		total += len(*block.Text)
-	}
-	if block.Thinking != nil {
-		total += len(*block.Thinking)
-	}
-	if block.Type == "tool_use" || block.Type == "tool_result" {
-		if data, err := json.Marshal(block); err == nil {
-			total += len(data)
-		}
-	}
-	return total
-}
-
-// OllamaWebSearchRequest represents a request to the Ollama web search API
-type OllamaWebSearchRequest struct {
-	Query      string `json:"query"`
-	MaxResults int    `json:"max_results,omitempty"`
-}
-
-// OllamaWebSearchResult represents a single search result from Ollama API
-type OllamaWebSearchResult struct {
-	Title   string `json:"title"`
-	URL     string `json:"url"`
-	Content string `json:"content"`
-}
-
-// OllamaWebSearchResponse represents the response from the Ollama web search API
-type OllamaWebSearchResponse struct {
-	Results []OllamaWebSearchResult `json:"results"`
-}
-
-var WebSearchEndpoint = "https://ollama.com/api/web_search"
-
-func WebSearch(ctx context.Context, query string, maxResults int) (*OllamaWebSearchResponse, error) {
-	if internalcloud.Disabled() {
-		logutil.TraceContext(ctx, "anthropic: web search blocked", "reason", "cloud_disabled")
-		return nil, errors.New(internalcloud.DisabledError("web search is unavailable"))
-	}
-
-	if maxResults <= 0 {
-		maxResults = 5
-	}
-	if maxResults > 10 {
-		maxResults = 10
-	}
-
-	reqBody := OllamaWebSearchRequest{
-		Query:      query,
-		MaxResults: maxResults,
-	}
-
-	body, err := json.Marshal(reqBody)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal web search request: %w", err)
-	}
-
-	searchURL, err := url.Parse(WebSearchEndpoint)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse web search URL: %w", err)
-	}
-	logutil.TraceContext(ctx, "anthropic: web search request",
-		"query", TraceTruncateString(query),
-		"max_results", maxResults,
-		"url", searchURL.String(),
-	)
-
-	q := searchURL.Query()
-	q.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
-	searchURL.RawQuery = q.Encode()
-
-	signature := ""
-	if strings.EqualFold(searchURL.Hostname(), "ollama.com") {
-		challenge := fmt.Sprintf("%s,%s", http.MethodPost, searchURL.RequestURI())
-		signature, err = auth.Sign(ctx, []byte(challenge))
-		if err != nil {
-			return nil, fmt.Errorf("failed to sign web search request: %w", err)
-		}
-	}
-	logutil.TraceContext(ctx, "anthropic: web search auth", "signed", signature != "")
-
-	req, err := http.NewRequestWithContext(ctx, "POST", searchURL.String(), bytes.NewReader(body))
-	if err != nil {
-		return nil, fmt.Errorf("failed to create web search request: %w", err)
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	if signature != "" {
-		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("web search request failed: %w", err)
-	}
-	defer resp.Body.Close()
-	logutil.TraceContext(ctx, "anthropic: web search response", "status", resp.StatusCode)
-
-	if resp.StatusCode != http.StatusOK {
-		respBody, _ := io.ReadAll(resp.Body)
-		return nil, fmt.Errorf("web search returned status %d: %s", resp.StatusCode, string(respBody))
-	}
-
-	var searchResp OllamaWebSearchResponse
-	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
-		return nil, fmt.Errorf("failed to decode web search response: %w", err)
-	}
-	logutil.TraceContext(ctx, "anthropic: web search results", "count", len(searchResp.Results))
-
-	return &searchResp, nil
-}
-
-func ConvertOllamaToAnthropicResults(ollamaResults *OllamaWebSearchResponse) []WebSearchResult {
-	var results []WebSearchResult
-	for _, r := range ollamaResults.Results {
-		results = append(results, WebSearchResult{
-			Type:  "web_search_result",
-			URL:   r.URL,
-			Title: r.Title,
-		})
-	}
-	return results
-}

anthropic/anthropic_test.go

@@ -1,1907 +0,0 @@
-package anthropic
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-
-	"github.com/ollama/ollama/api"
-)
-
-const (
-	testImage = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
-)
-
-// textContent is a convenience for constructing []ContentBlock with a single text block in tests.
-func textContent(s string) []ContentBlock {
-	return []ContentBlock{{Type: "text", Text: &s}}
-}
-
-// makeArgs creates ToolCallFunctionArguments from key-value pairs (convenience function for tests)
-func makeArgs(kvs ...any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for i := 0; i < len(kvs)-1; i += 2 {
-		args.Set(kvs[i].(string), kvs[i+1])
-	}
-	return args
-}
-
-func TestFromMessagesRequest_Basic(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Model != "test-model" {
-		t.Errorf("expected model 'test-model', got %q", result.Model)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Role != "user" || result.Messages[0].Content != "Hello" {
-		t.Errorf("unexpected message: %+v", result.Messages[0])
-	}
-
-	if numPredict, ok := result.Options["num_predict"].(int); !ok || numPredict != 1024 {
-		t.Errorf("expected num_predict 1024, got %v", result.Options["num_predict"])
-	}
-}
-
-func TestFromMessagesRequest_WithSystemPrompt(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		System:    "You are a helpful assistant.",
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Role != "system" || result.Messages[0].Content != "You are a helpful assistant." {
-		t.Errorf("unexpected system message: %+v", result.Messages[0])
-	}
-}
-
-func TestFromMessagesRequest_WithSystemPromptArray(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		System: []any{
-			map[string]any{"type": "text", "text": "You are helpful."},
-			map[string]any{"type": "text", "text": " Be concise."},
-		},
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Content != "You are helpful. Be concise." {
-		t.Errorf("unexpected system message content: %q", result.Messages[0].Content)
-	}
-}
-
-func TestFromMessagesRequest_WithOptions(t *testing.T) {
-	temp := 0.7
-	topP := 0.9
-	topK := 40
-	req := MessagesRequest{
-		Model:         "test-model",
-		MaxTokens:     2048,
-		Messages:      []MessageParam{{Role: "user", Content: textContent("Hello")}},
-		Temperature:   &temp,
-		TopP:          &topP,
-		TopK:          &topK,
-		StopSequences: []string{"\n", "END"},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Options["temperature"] != 0.7 {
-		t.Errorf("expected temperature 0.7, got %v", result.Options["temperature"])
-	}
-	if result.Options["top_p"] != 0.9 {
-		t.Errorf("expected top_p 0.9, got %v", result.Options["top_p"])
-	}
-	if result.Options["top_k"] != 40 {
-		t.Errorf("expected top_k 40, got %v", result.Options["top_k"])
-	}
-	if diff := cmp.Diff([]string{"\n", "END"}, result.Options["stop"]); diff != "" {
-		t.Errorf("stop sequences mismatch: %s", diff)
-	}
-}
-
-func TestFromMessagesRequest_WithImage(t *testing.T) {
-	imgData, _ := base64.StdEncoding.DecodeString(testImage)
-
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "user",
-				Content: []ContentBlock{
-					{Type: "text", Text: ptr("What's in this image?")},
-					{
-						Type: "image",
-						Source: &ImageSource{
-							Type:      "base64",
-							MediaType: "image/png",
-							Data:      testImage,
-						},
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Content != "What's in this image?" {
-		t.Errorf("expected content 'What's in this image?', got %q", result.Messages[0].Content)
-	}
-
-	if len(result.Messages[0].Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(result.Messages[0].Images))
-	}
-
-	if string(result.Messages[0].Images[0]) != string(imgData) {
-		t.Error("image data mismatch")
-	}
-}
-
-func TestFromMessagesRequest_WithToolUse(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("What's the weather in Paris?")},
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:  "tool_use",
-						ID:    "call_123",
-						Name:  "get_weather",
-						Input: makeArgs("location", "Paris"),
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	if len(result.Messages[1].ToolCalls) != 1 {
-		t.Fatalf("expected 1 tool call, got %d", len(result.Messages[1].ToolCalls))
-	}
-
-	tc := result.Messages[1].ToolCalls[0]
-	if tc.ID != "call_123" {
-		t.Errorf("expected tool call ID 'call_123', got %q", tc.ID)
-	}
-	if tc.Function.Name != "get_weather" {
-		t.Errorf("expected tool name 'get_weather', got %q", tc.Function.Name)
-	}
-}
-
-func TestFromMessagesRequest_WithToolResult(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_123",
-						Content:   "The weather in Paris is sunny, 22°C",
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	msg := result.Messages[0]
-	if msg.Role != "tool" {
-		t.Errorf("expected role 'tool', got %q", msg.Role)
-	}
-	if msg.ToolCallID != "call_123" {
-		t.Errorf("expected tool_call_id 'call_123', got %q", msg.ToolCallID)
-	}
-	if msg.Content != "The weather in Paris is sunny, 22°C" {
-		t.Errorf("unexpected content: %q", msg.Content)
-	}
-}
-
-func TestFromMessagesRequest_WithToolResultImage(t *testing.T) {
-	imgData, _ := base64.StdEncoding.DecodeString(testImage)
-
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_img",
-						Content: []any{
-							map[string]any{"type": "text", "text": "Attached image"},
-							map[string]any{
-								"type": "image",
-								"source": map[string]any{
-									"type":       "base64",
-									"media_type": "image/png",
-									"data":       testImage,
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	msg := result.Messages[0]
-	if msg.Role != "tool" {
-		t.Errorf("expected role 'tool', got %q", msg.Role)
-	}
-	if msg.ToolCallID != "call_img" {
-		t.Errorf("expected tool_call_id 'call_img', got %q", msg.ToolCallID)
-	}
-	if msg.Content != "Attached image" {
-		t.Errorf("unexpected content: %q", msg.Content)
-	}
-	if len(msg.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(msg.Images))
-	}
-	if string(msg.Images[0]) != string(imgData) {
-		t.Error("image data mismatch")
-	}
-}
-
-func TestFromMessagesRequest_WithToolResultFollowedByUserText(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:  "tool_use",
-						ID:    "call_read",
-						Name:  "Read",
-						Input: makeArgs("file_path", "/Users/hoyyeva/Desktop/aaa.png"),
-					},
-				},
-			},
-			{
-				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_read",
-						Content:   "Read image (311.5KB)",
-					},
-					{
-						Type: "text",
-						Text: ptr("Please describe it."),
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 3 {
-		t.Fatalf("expected 3 messages, got %d", len(result.Messages))
-	}
-
-	if result.Messages[1].Role != "tool" {
-		t.Fatalf("expected second message to be tool, got %q", result.Messages[1].Role)
-	}
-	if result.Messages[1].ToolCallID != "call_read" {
-		t.Fatalf("expected tool_call_id 'call_read', got %q", result.Messages[1].ToolCallID)
-	}
-	if result.Messages[2].Role != "user" {
-		t.Fatalf("expected third message to be user, got %q", result.Messages[2].Role)
-	}
-	if result.Messages[2].Content != "Please describe it." {
-		t.Fatalf("unexpected user content: %q", result.Messages[2].Content)
-	}
-}
-
-func TestFromMessagesRequest_WithOutputConfigEffort(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "high",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set from output_config.effort")
-	}
-
-	if got := result.Think.String(); got != "high" {
-		t.Fatalf("expected think level 'high', got %q", got)
-	}
-}
-
-func TestFromMessagesRequest_WithOutputConfigEffortXHighMapsToHigh(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "xhigh",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set from output_config.effort")
-	}
-
-	if got := result.Think.String(); got != "high" {
-		t.Fatalf("expected think level 'high' for xhigh effort, got %q", got)
-	}
-}
-
-func TestFromMessagesRequest_ThinkingDisabledOverridesOutputConfigEffort(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		Thinking: &ThinkingConfig{
-			Type: "disabled",
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "high",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set")
-	}
-
-	if got := result.Think.Value; got != false {
-		t.Fatalf("expected think=false when thinking is disabled, got %v", got)
-	}
-}
-
-func TestFromMessagesRequest_ThinkingAdaptiveUsesOutputConfigEffort(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		Thinking: &ThinkingConfig{
-			Type: "adaptive",
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "high",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set from output_config.effort")
-	}
-
-	if got := result.Think.String(); got != "high" {
-		t.Fatalf("expected think level 'high' for adaptive thinking, got %q", got)
-	}
-}
-
-func TestFromMessagesRequest_WithTools(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
-		Tools: []Tool{
-			{
-				Name:        "get_weather",
-				Description: "Get current weather",
-				InputSchema: json.RawMessage(`{"type":"object","properties":{"location":{"type":"string"}},"required":["location"]}`),
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Tools) != 1 {
-		t.Fatalf("expected 1 tool, got %d", len(result.Tools))
-	}
-
-	tool := result.Tools[0]
-	if tool.Type != "function" {
-		t.Errorf("expected type 'function', got %q", tool.Type)
-	}
-	if tool.Function.Name != "get_weather" {
-		t.Errorf("expected name 'get_weather', got %q", tool.Function.Name)
-	}
-	if tool.Function.Description != "Get current weather" {
-		t.Errorf("expected description 'Get current weather', got %q", tool.Function.Description)
-	}
-}
-
-func TestFromMessagesRequest_DropsCustomWebSearchWhenBuiltinPresent(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
-		Tools: []Tool{
-			{
-				Type: "web_search_20250305",
-				Name: "web_search",
-			},
-			{
-				Type:        "custom",
-				Name:        "web_search",
-				Description: "User-defined web search that should be dropped",
-				InputSchema: json.RawMessage(`{"type":"invalid"}`),
-			},
-			{
-				Type:        "custom",
-				Name:        "get_weather",
-				Description: "Get current weather",
-				InputSchema: json.RawMessage(`{"type":"object","properties":{"location":{"type":"string"}},"required":["location"]}`),
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Tools) != 2 {
-		t.Fatalf("expected 2 tools after dropping custom web_search, got %d", len(result.Tools))
-	}
-	if result.Tools[0].Function.Name != "web_search" {
-		t.Fatalf("expected first tool to be built-in web_search, got %q", result.Tools[0].Function.Name)
-	}
-	if result.Tools[1].Function.Name != "get_weather" {
-		t.Fatalf("expected second tool to be get_weather, got %q", result.Tools[1].Function.Name)
-	}
-}
-
-func TestFromMessagesRequest_KeepsCustomWebSearchWhenBuiltinAbsent(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
-		Tools: []Tool{
-			{
-				Type:        "custom",
-				Name:        "web_search",
-				Description: "User-defined web search",
-				InputSchema: json.RawMessage(`{"type":"object","properties":{"query":{"type":"string"}},"required":["query"]}`),
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Tools) != 1 {
-		t.Fatalf("expected 1 custom tool, got %d", len(result.Tools))
-	}
-	if result.Tools[0].Function.Name != "web_search" {
-		t.Fatalf("expected custom tool name web_search, got %q", result.Tools[0].Function.Name)
-	}
-	if result.Tools[0].Function.Description != "User-defined web search" {
-		t.Fatalf("expected custom description preserved, got %q", result.Tools[0].Function.Description)
-	}
-}
-
-func TestFromMessagesRequest_WithThinking(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
-		Thinking:  &ThinkingConfig{Type: "enabled", BudgetTokens: 1000},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected Think to be set")
-	}
-	if v, ok := result.Think.Value.(bool); !ok || !v {
-		t.Errorf("expected Think.Value to be true, got %v", result.Think.Value)
-	}
-}
-
-func TestFromMessagesRequest_ThinkingOnlyBlock(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:     "thinking",
-						Thinking: ptr("Let me think about this..."),
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	assistantMsg := result.Messages[1]
-	if assistantMsg.Thinking != "Let me think about this..." {
-		t.Errorf("expected thinking content, got %q", assistantMsg.Thinking)
-	}
-}
-
-func TestFromMessagesRequest_ToolUseMissingID(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type: "tool_use",
-						Name: "get_weather",
-					},
-				},
-			},
-		},
-	}
-
-	_, err := FromMessagesRequest(req)
-	if err == nil {
-		t.Fatal("expected error for missing tool_use id")
-	}
-	if err.Error() != "tool_use block missing required 'id' field" {
-		t.Errorf("unexpected error message: %v", err)
-	}
-}
-
-func TestFromMessagesRequest_ToolUseMissingName(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type: "tool_use",
-						ID:   "call_123",
-					},
-				},
-			},
-		},
-	}
-
-	_, err := FromMessagesRequest(req)
-	if err == nil {
-		t.Fatal("expected error for missing tool_use name")
-	}
-	if err.Error() != "tool_use block missing required 'name' field" {
-		t.Errorf("unexpected error message: %v", err)
-	}
-}
-
-func TestFromMessagesRequest_InvalidToolSchema(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
-		Tools: []Tool{
-			{
-				Name:        "bad_tool",
-				InputSchema: json.RawMessage(`{invalid json`),
-			},
-		},
-	}
-
-	_, err := FromMessagesRequest(req)
-	if err == nil {
-		t.Fatal("expected error for invalid tool schema")
-	}
-}
-
-func TestToMessagesResponse_Basic(t *testing.T) {
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:    "assistant",
-			Content: "Hello there!",
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics: api.Metrics{
-			PromptEvalCount: 10,
-			EvalCount:       5,
-		},
-	}
-
-	result := ToMessagesResponse("msg_123", resp)
-
-	if result.ID != "msg_123" {
-		t.Errorf("expected ID 'msg_123', got %q", result.ID)
-	}
-	if result.Type != "message" {
-		t.Errorf("expected type 'message', got %q", result.Type)
-	}
-	if result.Role != "assistant" {
-		t.Errorf("expected role 'assistant', got %q", result.Role)
-	}
-	if len(result.Content) != 1 {
-		t.Fatalf("expected 1 content block, got %d", len(result.Content))
-	}
-	if result.Content[0].Type != "text" || result.Content[0].Text == nil || *result.Content[0].Text != "Hello there!" {
-		t.Errorf("unexpected content: %+v", result.Content[0])
-	}
-	if result.StopReason != "end_turn" {
-		t.Errorf("expected stop_reason 'end_turn', got %q", result.StopReason)
-	}
-	if result.Usage.InputTokens != 10 || result.Usage.OutputTokens != 5 {
-		t.Errorf("unexpected usage: %+v", result.Usage)
-	}
-}
-
-func TestToMessagesResponse_WithToolCalls(t *testing.T) {
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_123",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: makeArgs("location", "Paris"),
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	result := ToMessagesResponse("msg_123", resp)
-
-	if len(result.Content) != 1 {
-		t.Fatalf("expected 1 content block, got %d", len(result.Content))
-	}
-	if result.Content[0].Type != "tool_use" {
-		t.Errorf("expected type 'tool_use', got %q", result.Content[0].Type)
-	}
-	if result.Content[0].ID != "call_123" {
-		t.Errorf("expected ID 'call_123', got %q", result.Content[0].ID)
-	}
-	if result.Content[0].Name != "get_weather" {
-		t.Errorf("expected name 'get_weather', got %q", result.Content[0].Name)
-	}
-	if result.StopReason != "tool_use" {
-		t.Errorf("expected stop_reason 'tool_use', got %q", result.StopReason)
-	}
-}
-
-func TestToMessagesResponse_WithThinking(t *testing.T) {
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:     "assistant",
-			Content:  "The answer is 42.",
-			Thinking: "Let me think about this...",
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	result := ToMessagesResponse("msg_123", resp)
-
-	if len(result.Content) != 2 {
-		t.Fatalf("expected 2 content blocks, got %d", len(result.Content))
-	}
-	if result.Content[0].Type != "thinking" {
-		t.Errorf("expected first block type 'thinking', got %q", result.Content[0].Type)
-	}
-	if result.Content[0].Thinking == nil || *result.Content[0].Thinking != "Let me think about this..." {
-		t.Errorf("unexpected thinking content: %v", result.Content[0].Thinking)
-	}
-	if result.Content[1].Type != "text" {
-		t.Errorf("expected second block type 'text', got %q", result.Content[1].Type)
-	}
-}
-
-func TestMapStopReason(t *testing.T) {
-	tests := []struct {
-		reason       string
-		hasToolCalls bool
-		want         string
-	}{
-		{"stop", false, "end_turn"},
-		{"length", false, "max_tokens"},
-		{"stop", true, "tool_use"},
-		{"other", false, "stop_sequence"},
-		{"", false, ""},
-	}
-
-	for _, tt := range tests {
-		got := mapStopReason(tt.reason, tt.hasToolCalls)
-		if got != tt.want {
-			t.Errorf("mapStopReason(%q, %v) = %q, want %q", tt.reason, tt.hasToolCalls, got, tt.want)
-		}
-	}
-}
-
-func TestNewError(t *testing.T) {
-	tests := []struct {
-		code int
-		want string
-	}{
-		{400, "invalid_request_error"},
-		{401, "authentication_error"},
-		{403, "permission_error"},
-		{404, "not_found_error"},
-		{429, "rate_limit_error"},
-		{500, "api_error"},
-		{503, "overloaded_error"},
-		{529, "overloaded_error"},
-	}
-
-	for _, tt := range tests {
-		result := NewError(tt.code, "test message")
-		if result.Type != "error" {
-			t.Errorf("NewError(%d) type = %q, want 'error'", tt.code, result.Type)
-		}
-		if result.Error.Type != tt.want {
-			t.Errorf("NewError(%d) error.type = %q, want %q", tt.code, result.Error.Type, tt.want)
-		}
-		if result.Error.Message != "test message" {
-			t.Errorf("NewError(%d) message = %q, want 'test message'", tt.code, result.Error.Message)
-		}
-		if result.RequestID == "" {
-			t.Errorf("NewError(%d) request_id should not be empty", tt.code)
-		}
-	}
-}
-
-func TestGenerateMessageID(t *testing.T) {
-	id1 := GenerateMessageID()
-	id2 := GenerateMessageID()
-
-	if id1 == "" {
-		t.Error("GenerateMessageID returned empty string")
-	}
-	if id1 == id2 {
-		t.Error("GenerateMessageID returned duplicate IDs")
-	}
-	if len(id1) < 10 {
-		t.Errorf("GenerateMessageID returned short ID: %q", id1)
-	}
-	if id1[:4] != "msg_" {
-		t.Errorf("GenerateMessageID should start with 'msg_', got %q", id1[:4])
-	}
-}
-
-func TestStreamConverter_Basic(t *testing.T) {
-	conv := NewStreamConverter("msg_123", "test-model", 0)
-
-	// First chunk
-	resp1 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:    "assistant",
-			Content: "Hello",
-		},
-		Metrics: api.Metrics{PromptEvalCount: 10},
-	}
-
-	events1 := conv.Process(resp1)
-	if len(events1) < 3 {
-		t.Fatalf("expected at least 3 events for first chunk, got %d", len(events1))
-	}
-
-	// Should have message_start, content_block_start, content_block_delta
-	if events1[0].Event != "message_start" {
-		t.Errorf("expected first event 'message_start', got %q", events1[0].Event)
-	}
-	if events1[1].Event != "content_block_start" {
-		t.Errorf("expected second event 'content_block_start', got %q", events1[1].Event)
-	}
-	if events1[2].Event != "content_block_delta" {
-		t.Errorf("expected third event 'content_block_delta', got %q", events1[2].Event)
-	}
-
-	// Final chunk
-	resp2 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:    "assistant",
-			Content: " world!",
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics:    api.Metrics{PromptEvalCount: 10, EvalCount: 5},
-	}
-
-	events2 := conv.Process(resp2)
-
-	// Should have content_block_delta, content_block_stop, message_delta, message_stop
-	hasStop := false
-	for _, e := range events2 {
-		if e.Event == "message_delta" {
-			if data, ok := e.Data.(MessageDeltaEvent); ok {
-				if data.Type != "message_delta" {
-					t.Errorf("unexpected data type: %+v", data)
-				}
-
-				if data.Delta.StopReason != "end_turn" {
-					t.Errorf("unexpected stop reason: %+v", data.Delta.StopReason)
-				}
-
-				if data.Usage.InputTokens != 10 || data.Usage.OutputTokens != 5 {
-					t.Errorf("unexpected usage: %+v", data.Usage)
-				}
-			} else {
-				t.Errorf("unexpected data: %+v", e.Data)
-			}
-		}
-
-		if e.Event == "message_stop" {
-			hasStop = true
-		}
-	}
-	if !hasStop {
-		t.Error("expected message_stop event in final chunk")
-	}
-}
-
-func TestStreamConverter_WithToolCalls(t *testing.T) {
-	conv := NewStreamConverter("msg_123", "test-model", 0)
-
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_123",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: makeArgs("location", "Paris"),
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics:    api.Metrics{PromptEvalCount: 10, EvalCount: 5},
-	}
-
-	events := conv.Process(resp)
-
-	hasToolStart := false
-	hasToolDelta := false
-	for _, e := range events {
-		if e.Event == "content_block_start" {
-			if start, ok := e.Data.(ContentBlockStartEvent); ok {
-				if start.ContentBlock.Type == "tool_use" {
-					hasToolStart = true
-				}
-			}
-		}
-		if e.Event == "content_block_delta" {
-			if delta, ok := e.Data.(ContentBlockDeltaEvent); ok {
-				if delta.Delta.Type == "input_json_delta" {
-					hasToolDelta = true
-				}
-			}
-		}
-	}
-
-	if !hasToolStart {
-		t.Error("expected tool_use content_block_start event")
-	}
-	if !hasToolDelta {
-		t.Error("expected input_json_delta event")
-	}
-}
-
-// TestStreamConverter_ThinkingDirectlyFollowedByToolCall verifies that when a
-// model emits a thinking block followed directly by a tool_use block (with no
-// text block in between), the streaming converter correctly closes the thinking
-// block and increments the content index before opening the tool_use block.
-// Previously, the converter reused contentIndex=0 for the tool_use block,
-// which caused "Content block not found" errors in clients. See #14816.
-func TestStreamConverter_ThinkingDirectlyFollowedByToolCall(t *testing.T) {
-	conv := NewStreamConverter("msg_123", "test-model", 0)
-
-	// First chunk: thinking content (no text)
-	resp1 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:     "assistant",
-			Thinking: "I should call the tool.",
-		},
-	}
-	events1 := conv.Process(resp1)
-
-	// Should have: message_start, content_block_start(thinking), content_block_delta(thinking)
-	if len(events1) < 3 {
-		t.Fatalf("expected at least 3 events for thinking chunk, got %d", len(events1))
-	}
-	if events1[0].Event != "message_start" {
-		t.Errorf("expected first event 'message_start', got %q", events1[0].Event)
-	}
-	thinkingStart, ok := events1[1].Data.(ContentBlockStartEvent)
-	if !ok || thinkingStart.ContentBlock.Type != "thinking" {
-		t.Errorf("expected content_block_start(thinking) as second event, got %+v", events1[1])
-	}
-	if thinkingStart.Index != 0 {
-		t.Errorf("expected thinking block at index 0, got %d", thinkingStart.Index)
-	}
-
-	// Second chunk: tool call (no text between thinking and tool)
-	resp2 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_abc",
-					Function: api.ToolCallFunction{
-						Name:      "ask_user",
-						Arguments: makeArgs("question", "cats or dogs?"),
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics:    api.Metrics{PromptEvalCount: 10, EvalCount: 5},
-	}
-	events2 := conv.Process(resp2)
-
-	// Expect: content_block_stop(index=0), content_block_start(tool_use, index=1),
-	//         content_block_delta(input_json_delta, index=1), content_block_stop(index=1),
-	//         message_delta, message_stop
-	var thinkingStop, toolStart, toolDelta, toolStop *StreamEvent
-	for i := range events2 {
-		e := &events2[i]
-		switch e.Event {
-		case "content_block_stop":
-			if stop, ok := e.Data.(ContentBlockStopEvent); ok {
-				if stop.Index == 0 && thinkingStop == nil {
-					thinkingStop = e
-				} else if stop.Index == 1 {
-					toolStop = e
-				}
-			}
-		case "content_block_start":
-			if start, ok := e.Data.(ContentBlockStartEvent); ok && start.ContentBlock.Type == "tool_use" {
-				toolStart = e
-			}
-		case "content_block_delta":
-			if delta, ok := e.Data.(ContentBlockDeltaEvent); ok && delta.Delta.Type == "input_json_delta" {
-				toolDelta = e
-			}
-		}
-	}
-
-	if thinkingStop == nil {
-		t.Error("expected content_block_stop for thinking block (index 0)")
-	}
-	if toolStart == nil {
-		t.Fatal("expected content_block_start for tool_use block")
-	}
-	if start, ok := toolStart.Data.(ContentBlockStartEvent); !ok || start.Index != 1 {
-		t.Errorf("expected tool_use block at index 1, got %+v", toolStart.Data)
-	}
-	if toolDelta == nil {
-		t.Fatal("expected input_json_delta event for tool call")
-	}
-	if delta, ok := toolDelta.Data.(ContentBlockDeltaEvent); !ok || delta.Index != 1 {
-		t.Errorf("expected tool delta at index 1, got %+v", toolDelta.Data)
-	}
-	if toolStop == nil {
-		t.Error("expected content_block_stop for tool_use block (index 1)")
-	}
-}
-
-func TestStreamConverter_ToolCallWithUnmarshalableArgs(t *testing.T) {
-	// Test that unmarshalable arguments (like channels) are handled gracefully
-	// and don't cause a panic or corrupt stream
-	conv := NewStreamConverter("msg_123", "test-model", 0)
-
-	// Create a channel which cannot be JSON marshaled
-	unmarshalable := make(chan int)
-	badArgs := api.NewToolCallFunctionArguments()
-	badArgs.Set("channel", unmarshalable)
-
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_bad",
-					Function: api.ToolCallFunction{
-						Name:      "bad_function",
-						Arguments: badArgs,
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	// Should not panic and should skip the unmarshalable tool call
-	events := conv.Process(resp)
-
-	// Verify no tool_use block was started (since marshal failed before block start)
-	hasToolStart := false
-	for _, e := range events {
-		if e.Event == "content_block_start" {
-			if start, ok := e.Data.(ContentBlockStartEvent); ok {
-				if start.ContentBlock.Type == "tool_use" {
-					hasToolStart = true
-				}
-			}
-		}
-	}
-
-	if hasToolStart {
-		t.Error("expected no tool_use block when arguments cannot be marshaled")
-	}
-}
-
-func TestStreamConverter_MultipleToolCallsWithMixedValidity(t *testing.T) {
-	// Test that valid tool calls still work when mixed with invalid ones
-	conv := NewStreamConverter("msg_123", "test-model", 0)
-
-	unmarshalable := make(chan int)
-	badArgs := api.NewToolCallFunctionArguments()
-	badArgs.Set("channel", unmarshalable)
-
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_good",
-					Function: api.ToolCallFunction{
-						Name:      "good_function",
-						Arguments: makeArgs("location", "Paris"),
-					},
-				},
-				{
-					ID: "call_bad",
-					Function: api.ToolCallFunction{
-						Name:      "bad_function",
-						Arguments: badArgs,
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	events := conv.Process(resp)
-
-	// Count tool_use blocks - should only have 1 (the valid one)
-	toolStartCount := 0
-	toolDeltaCount := 0
-	for _, e := range events {
-		if e.Event == "content_block_start" {
-			if start, ok := e.Data.(ContentBlockStartEvent); ok {
-				if start.ContentBlock.Type == "tool_use" {
-					toolStartCount++
-					if start.ContentBlock.Name != "good_function" {
-						t.Errorf("expected tool name 'good_function', got %q", start.ContentBlock.Name)
-					}
-				}
-			}
-		}
-		if e.Event == "content_block_delta" {
-			if delta, ok := e.Data.(ContentBlockDeltaEvent); ok {
-				if delta.Delta.Type == "input_json_delta" {
-					toolDeltaCount++
-				}
-			}
-		}
-	}
-
-	if toolStartCount != 1 {
-		t.Errorf("expected 1 tool_use block, got %d", toolStartCount)
-	}
-	if toolDeltaCount != 1 {
-		t.Errorf("expected 1 input_json_delta, got %d", toolDeltaCount)
-	}
-}
-
-func TestContentBlockJSON_EmptyFieldsPresent(t *testing.T) {
-	tests := []struct {
-		name     string
-		block    ContentBlock
-		wantKeys []string
-	}{
-		{
-			name: "text block includes empty text field",
-			block: ContentBlock{
-				Type: "text",
-				Text: ptr(""),
-			},
-			wantKeys: []string{"type", "text"},
-		},
-		{
-			name: "thinking block includes empty thinking field",
-			block: ContentBlock{
-				Type:     "thinking",
-				Thinking: ptr(""),
-			},
-			wantKeys: []string{"type", "thinking"},
-		},
-		{
-			name: "text block with content",
-			block: ContentBlock{
-				Type: "text",
-				Text: ptr("hello"),
-			},
-			wantKeys: []string{"type", "text"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			data, err := json.Marshal(tt.block)
-			if err != nil {
-				t.Fatalf("failed to marshal: %v", err)
-			}
-
-			var result map[string]any
-			if err := json.Unmarshal(data, &result); err != nil {
-				t.Fatalf("failed to unmarshal: %v", err)
-			}
-
-			for _, key := range tt.wantKeys {
-				if _, ok := result[key]; !ok {
-					t.Errorf("expected key %q to be present in JSON output, got: %s", key, string(data))
-				}
-			}
-		})
-	}
-}
-
-func TestContentBlockJSON_NonToolBlocksDoNotIncludeInput(t *testing.T) {
-	tests := []struct {
-		name  string
-		block ContentBlock
-	}{
-		{
-			name: "text block",
-			block: ContentBlock{
-				Type: "text",
-				Text: ptr("hello"),
-			},
-		},
-		{
-			name: "thinking block",
-			block: ContentBlock{
-				Type:     "thinking",
-				Thinking: ptr("let me think"),
-			},
-		},
-		{
-			name: "image block",
-			block: ContentBlock{
-				Type: "image",
-				Source: &ImageSource{
-					Type:      "base64",
-					MediaType: "image/png",
-					Data:      testImage,
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			data, err := json.Marshal(tt.block)
-			if err != nil {
-				t.Fatalf("failed to marshal: %v", err)
-			}
-
-			var result map[string]any
-			if err := json.Unmarshal(data, &result); err != nil {
-				t.Fatalf("failed to unmarshal: %v", err)
-			}
-
-			if _, ok := result["input"]; ok {
-				t.Fatalf("unexpected input field in non-tool block JSON: %s", string(data))
-			}
-		})
-	}
-}
-
-func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
-	t.Run("text block start includes empty text", func(t *testing.T) {
-		conv := NewStreamConverter("msg_123", "test-model", 0)
-
-		resp := api.ChatResponse{
-			Model:   "test-model",
-			Message: api.Message{Role: "assistant", Content: "hello"},
-		}
-
-		events := conv.Process(resp)
-
-		var foundTextStart bool
-		for _, e := range events {
-			if e.Event == "content_block_start" {
-				if start, ok := e.Data.(ContentBlockStartEvent); ok {
-					if start.ContentBlock.Type == "text" {
-						foundTextStart = true
-						// Marshal and verify the text field is present
-						data, _ := json.Marshal(start)
-						var result map[string]any
-						if err := json.Unmarshal(data, &result); err != nil {
-							t.Fatalf("failed to unmarshal content_block_start JSON: %v", err)
-						}
-						cb := result["content_block"].(map[string]any)
-						if _, ok := cb["text"]; !ok {
-							t.Error("content_block_start for text should include 'text' field")
-						}
-					}
-				}
-			}
-		}
-
-		if !foundTextStart {
-			t.Error("expected text content_block_start event")
-		}
-	})
-
-	t.Run("thinking block start includes empty thinking", func(t *testing.T) {
-		conv := NewStreamConverter("msg_123", "test-model", 0)
-
-		resp := api.ChatResponse{
-			Model:   "test-model",
-			Message: api.Message{Role: "assistant", Thinking: "let me think..."},
-		}
-
-		events := conv.Process(resp)
-
-		var foundThinkingStart bool
-		for _, e := range events {
-			if e.Event == "content_block_start" {
-				if start, ok := e.Data.(ContentBlockStartEvent); ok {
-					if start.ContentBlock.Type == "thinking" {
-						foundThinkingStart = true
-						data, _ := json.Marshal(start)
-						var result map[string]any
-						json.Unmarshal(data, &result)
-						cb := result["content_block"].(map[string]any)
-						if _, ok := cb["thinking"]; !ok {
-							t.Error("content_block_start for thinking should include 'thinking' field")
-						}
-					}
-				}
-			}
-		}
-
-		if !foundThinkingStart {
-			t.Error("expected thinking content_block_start event")
-		}
-	})
-
-	t.Run("tool_use block start includes empty input object", func(t *testing.T) {
-		conv := NewStreamConverter("msg_123", "test-model", 0)
-
-		resp := api.ChatResponse{
-			Model: "test-model",
-			Message: api.Message{
-				Role: "assistant",
-				ToolCalls: []api.ToolCall{
-					{
-						ID: "call_123",
-						Function: api.ToolCallFunction{
-							Name:      "get_weather",
-							Arguments: makeArgs("location", "Paris"),
-						},
-					},
-				},
-			},
-		}
-
-		events := conv.Process(resp)
-
-		var foundToolStart bool
-		for _, e := range events {
-			if e.Event == "content_block_start" {
-				if start, ok := e.Data.(ContentBlockStartEvent); ok {
-					if start.ContentBlock.Type == "tool_use" {
-						foundToolStart = true
-						if start.ContentBlock.Input.Len() != 0 {
-							t.Errorf("expected empty input object, got len=%d", start.ContentBlock.Input.Len())
-						}
-
-						data, _ := json.Marshal(start)
-						var result map[string]any
-						json.Unmarshal(data, &result)
-						cb := result["content_block"].(map[string]any)
-						input, ok := cb["input"]
-						if !ok {
-							t.Error("content_block_start for tool_use should include 'input' field")
-							continue
-						}
-						inputMap, ok := input.(map[string]any)
-						if !ok {
-							t.Errorf("input field should be an object, got %T", input)
-							continue
-						}
-						if len(inputMap) != 0 {
-							t.Errorf("expected empty input object in content_block_start, got %v", inputMap)
-						}
-					}
-				}
-			}
-		}
-
-		if !foundToolStart {
-			t.Error("expected tool_use content_block_start event")
-		}
-	})
-}
-
-func TestEstimateTokens_SimpleMessage(t *testing.T) {
-	req := CountTokensRequest{
-		Model: "test-model",
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello, world!")},
-		},
-	}
-
-	tokens := estimateTokens(req)
-
-	// "user" (4) + "Hello, world!" (13) = 17 chars / 4 = 4 tokens
-	if tokens < 1 {
-		t.Errorf("expected at least 1 token, got %d", tokens)
-	}
-	// Sanity check: shouldn't be wildly off
-	if tokens > 10 {
-		t.Errorf("expected fewer than 10 tokens for short message, got %d", tokens)
-	}
-}
-
-func TestEstimateTokens_WithSystemPrompt(t *testing.T) {
-	req := CountTokensRequest{
-		Model:  "test-model",
-		System: "You are a helpful assistant.",
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
-		},
-	}
-
-	tokens := estimateTokens(req)
-
-	// System prompt adds to count
-	if tokens < 5 {
-		t.Errorf("expected at least 5 tokens with system prompt, got %d", tokens)
-	}
-}
-
-func TestEstimateTokens_WithTools(t *testing.T) {
-	req := CountTokensRequest{
-		Model: "test-model",
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("What's the weather?")},
-		},
-		Tools: []Tool{
-			{
-				Name:        "get_weather",
-				Description: "Get the current weather for a location",
-				InputSchema: json.RawMessage(`{"type":"object","properties":{"location":{"type":"string"}}}`),
-			},
-		},
-	}
-
-	tokens := estimateTokens(req)
-
-	// Tools add significant content
-	if tokens < 10 {
-		t.Errorf("expected at least 10 tokens with tools, got %d", tokens)
-	}
-}
-
-func TestEstimateTokens_WithThinking(t *testing.T) {
-	req := CountTokensRequest{
-		Model: "test-model",
-		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:     "thinking",
-						Thinking: ptr("Let me think about this carefully..."),
-					},
-					{
-						Type: "text",
-						Text: ptr("Here is my response."),
-					},
-				},
-			},
-		},
-	}
-
-	tokens := estimateTokens(req)
-
-	// Thinking content should be counted
-	if tokens < 10 {
-		t.Errorf("expected at least 10 tokens with thinking content, got %d", tokens)
-	}
-}
-
-func TestEstimateTokens_EmptyContent(t *testing.T) {
-	req := CountTokensRequest{
-		Model:    "test-model",
-		Messages: []MessageParam{},
-	}
-
-	tokens := estimateTokens(req)
-
-	if tokens != 0 {
-		t.Errorf("expected 0 tokens for empty content, got %d", tokens)
-	}
-}
-
-// Web Search Tests
-
-func TestConvertTool_WebSearch(t *testing.T) {
-	tool := Tool{
-		Type:    "web_search_20250305",
-		Name:    "web_search",
-		MaxUses: 5,
-	}
-
-	result, isServerTool, err := convertTool(tool)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if !isServerTool {
-		t.Error("expected isServerTool to be true for web_search tool")
-	}
-
-	if result.Type != "function" {
-		t.Errorf("expected type 'function', got %q", result.Type)
-	}
-
-	if result.Function.Name != "web_search" {
-		t.Errorf("expected name 'web_search', got %q", result.Function.Name)
-	}
-
-	if result.Function.Description == "" {
-		t.Error("expected non-empty description for web_search tool")
-	}
-
-	// Check that query parameter is defined
-	if result.Function.Parameters.Properties == nil {
-		t.Fatal("expected properties to be defined")
-	}
-
-	queryProp, ok := result.Function.Parameters.Properties.Get("query")
-	if !ok {
-		t.Error("expected 'query' property to be defined")
-	}
-
-	if len(queryProp.Type) == 0 || queryProp.Type[0] != "string" {
-		t.Errorf("expected query type to be 'string', got %v", queryProp.Type)
-	}
-}
-
-func TestConvertTool_RegularTool(t *testing.T) {
-	tool := Tool{
-		Type:        "custom",
-		Name:        "get_weather",
-		Description: "Get the weather",
-		InputSchema: json.RawMessage(`{"type":"object","properties":{"location":{"type":"string"}}}`),
-	}
-
-	result, isServerTool, err := convertTool(tool)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if isServerTool {
-		t.Error("expected isServerTool to be false for regular tool")
-	}
-
-	if result.Function.Name != "get_weather" {
-		t.Errorf("expected name 'get_weather', got %q", result.Function.Name)
-	}
-}
-
-func TestConvertMessage_ServerToolUse(t *testing.T) {
-	msg := MessageParam{
-		Role: "assistant",
-		Content: []ContentBlock{
-			{
-				Type:  "server_tool_use",
-				ID:    "srvtoolu_123",
-				Name:  "web_search",
-				Input: makeArgs("query", "test query"),
-			},
-		},
-	}
-
-	messages, err := convertMessage(msg)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(messages))
-	}
-
-	if len(messages[0].ToolCalls) != 1 {
-		t.Fatalf("expected 1 tool call, got %d", len(messages[0].ToolCalls))
-	}
-
-	tc := messages[0].ToolCalls[0]
-	if tc.ID != "srvtoolu_123" {
-		t.Errorf("expected tool call ID 'srvtoolu_123', got %q", tc.ID)
-	}
-
-	if tc.Function.Name != "web_search" {
-		t.Errorf("expected tool name 'web_search', got %q", tc.Function.Name)
-	}
-}
-
-func TestConvertMessage_WebSearchToolResult(t *testing.T) {
-	msg := MessageParam{
-		Role: "user",
-		Content: []ContentBlock{
-			{
-				Type:      "web_search_tool_result",
-				ToolUseID: "srvtoolu_123",
-				Content: []any{
-					map[string]any{
-						"type":  "web_search_result",
-						"title": "Test Result",
-						"url":   "https://example.com",
-					},
-				},
-			},
-		},
-	}
-
-	messages, err := convertMessage(msg)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Should have a tool result message
-	if len(messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(messages))
-	}
-
-	if messages[0].Role != "tool" {
-		t.Errorf("expected role 'tool', got %q", messages[0].Role)
-	}
-
-	if messages[0].ToolCallID != "srvtoolu_123" {
-		t.Errorf("expected tool_call_id 'srvtoolu_123', got %q", messages[0].ToolCallID)
-	}
-
-	if messages[0].Content == "" {
-		t.Error("expected non-empty content from web search results")
-	}
-}
-
-func TestConvertMessage_WebSearchToolResultEmptyStillCreatesToolMessage(t *testing.T) {
-	msg := MessageParam{
-		Role: "user",
-		Content: []ContentBlock{
-			{
-				Type:      "web_search_tool_result",
-				ToolUseID: "srvtoolu_empty",
-				Content:   []any{},
-			},
-		},
-	}
-
-	messages, err := convertMessage(msg)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(messages))
-	}
-	if messages[0].Role != "tool" {
-		t.Fatalf("expected role tool, got %q", messages[0].Role)
-	}
-	if messages[0].ToolCallID != "srvtoolu_empty" {
-		t.Fatalf("expected tool_call_id srvtoolu_empty, got %q", messages[0].ToolCallID)
-	}
-	if messages[0].Content != "" {
-		t.Fatalf("expected empty content for empty web search results, got %q", messages[0].Content)
-	}
-}
-
-func TestConvertMessage_WebSearchToolResultErrorStillCreatesToolMessage(t *testing.T) {
-	msg := MessageParam{
-		Role: "user",
-		Content: []ContentBlock{
-			{
-				Type:      "web_search_tool_result",
-				ToolUseID: "srvtoolu_error",
-				Content: map[string]any{
-					"type":       "web_search_tool_result_error",
-					"error_code": "max_uses_exceeded",
-				},
-			},
-		},
-	}
-
-	messages, err := convertMessage(msg)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(messages))
-	}
-	if messages[0].Role != "tool" {
-		t.Fatalf("expected role tool, got %q", messages[0].Role)
-	}
-	if messages[0].ToolCallID != "srvtoolu_error" {
-		t.Fatalf("expected tool_call_id srvtoolu_error, got %q", messages[0].ToolCallID)
-	}
-	if !strings.Contains(messages[0].Content, "max_uses_exceeded") {
-		t.Fatalf("expected error code in converted tool content, got %q", messages[0].Content)
-	}
-}
-
-func TestConvertOllamaToAnthropicResults(t *testing.T) {
-	ollamaResp := &OllamaWebSearchResponse{
-		Results: []OllamaWebSearchResult{
-			{
-				Title:   "Test Title",
-				URL:     "https://example.com",
-				Content: "Test content",
-			},
-			{
-				Title:   "Another Result",
-				URL:     "https://example.org",
-				Content: "More content",
-			},
-		},
-	}
-
-	results := ConvertOllamaToAnthropicResults(ollamaResp)
-
-	if len(results) != 2 {
-		t.Fatalf("expected 2 results, got %d", len(results))
-	}
-
-	if results[0].Type != "web_search_result" {
-		t.Errorf("expected type 'web_search_result', got %q", results[0].Type)
-	}
-
-	if results[0].Title != "Test Title" {
-		t.Errorf("expected title 'Test Title', got %q", results[0].Title)
-	}
-
-	if results[0].URL != "https://example.com" {
-		t.Errorf("expected URL 'https://example.com', got %q", results[0].URL)
-	}
-}
-
-func TestWebSearchTypes(t *testing.T) {
-	// Test that WebSearchResult serializes correctly
-	result := WebSearchResult{
-		Type:             "web_search_result",
-		URL:              "https://example.com",
-		Title:            "Test",
-		EncryptedContent: "abc123",
-		PageAge:          "2025-01-01",
-	}
-
-	data, err := json.Marshal(result)
-	if err != nil {
-		t.Fatalf("failed to marshal WebSearchResult: %v", err)
-	}
-
-	var unmarshaled WebSearchResult
-	if err := json.Unmarshal(data, &unmarshaled); err != nil {
-		t.Fatalf("failed to unmarshal WebSearchResult: %v", err)
-	}
-
-	if unmarshaled.Type != result.Type {
-		t.Errorf("type mismatch: expected %q, got %q", result.Type, unmarshaled.Type)
-	}
-
-	// Test WebSearchToolResultError
-	errResult := WebSearchToolResultError{
-		Type:      "web_search_tool_result_error",
-		ErrorCode: "max_uses_exceeded",
-	}
-
-	data, err = json.Marshal(errResult)
-	if err != nil {
-		t.Fatalf("failed to marshal WebSearchToolResultError: %v", err)
-	}
-
-	var unmarshaledErr WebSearchToolResultError
-	if err := json.Unmarshal(data, &unmarshaledErr); err != nil {
-		t.Fatalf("failed to unmarshal WebSearchToolResultError: %v", err)
-	}
-
-	if unmarshaledErr.ErrorCode != "max_uses_exceeded" {
-		t.Errorf("error_code mismatch: expected 'max_uses_exceeded', got %q", unmarshaledErr.ErrorCode)
-	}
-}
-
-func TestCitation(t *testing.T) {
-	citation := Citation{
-		Type:           "web_search_result_location",
-		URL:            "https://example.com",
-		Title:          "Example",
-		EncryptedIndex: "enc123",
-		CitedText:      "Some cited text...",
-	}
-
-	data, err := json.Marshal(citation)
-	if err != nil {
-		t.Fatalf("failed to marshal Citation: %v", err)
-	}
-
-	var unmarshaled Citation
-	if err := json.Unmarshal(data, &unmarshaled); err != nil {
-		t.Fatalf("failed to unmarshal Citation: %v", err)
-	}
-
-	if unmarshaled.Type != "web_search_result_location" {
-		t.Errorf("type mismatch: expected 'web_search_result_location', got %q", unmarshaled.Type)
-	}
-
-	if unmarshaled.CitedText != "Some cited text..." {
-		t.Errorf("cited_text mismatch: expected 'Some cited text...', got %q", unmarshaled.CitedText)
-	}
-}

anthropic/trace.go

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

api/client.go

@@ -1,16 +1,3 @@
-// Package api implements the client-side API for code wishing to interact
-// with the ollama service. The methods of the [Client] type correspond to
-// the ollama REST API as described in [the API documentation].
-// The ollama command-line client itself uses this package to interact with
-// the backend service.
-//
-// # Examples
-//
-// Several examples of using this package are available [in the GitHub
-// repository].
-//
-// [the API documentation]: https://github.com/ollama/ollama/blob/main/docs/api.md
-// [in the GitHub repository]: https://github.com/ollama/ollama/tree/main/api/examples
 package api
 
 import (
@@ -21,23 +8,20 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"net/url"
+	"os"
 	"runtime"
-	"strconv"
-	"time"
+	"strings"
 
-	"github.com/ollama/ollama/auth"
-	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/format"
-	"github.com/ollama/ollama/version"
+	"github.com/jmorganca/ollama/format"
+	"github.com/jmorganca/ollama/version"
 )
 
-// Client encapsulates client state for interacting with the ollama
-// service. Use [ClientFromEnvironment] to create new Clients.
 type Client struct {
 	base *url.URL
-	http *http.Client
+	http http.Client
 }
 
 func checkError(resp *http.Response, body []byte) error {
@@ -45,12 +29,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)
@@ -62,35 +40,56 @@ func checkError(resp *http.Response, body []byte) error {
 	return apiError
 }
 
-// ClientFromEnvironment creates a new [Client] using configuration from the
-// environment variable OLLAMA_HOST, which points to the network host and
-// port on which the ollama service is listening. The format of this variable
-// is:
-//
-//	<scheme>://<host>:<port>
-//
-// If the variable is not specified, a default ollama host and port will be
-// used.
 func ClientFromEnvironment() (*Client, error) {
-	return &Client{
-		base: envconfig.Host(),
-		http: http.DefaultClient,
-	}, nil
-}
+	defaultPort := "11434"
 
-func NewClient(base *url.URL, http *http.Client) *Client {
-	return &Client{
-		base: base,
-		http: http,
+	scheme, hostport, ok := strings.Cut(os.Getenv("OLLAMA_HOST"), "://")
+	switch {
+	case !ok:
+		scheme, hostport = "http", os.Getenv("OLLAMA_HOST")
+	case scheme == "http":
+		defaultPort = "80"
+	case scheme == "https":
+		defaultPort = "443"
 	}
-}
 
-func getAuthorizationToken(ctx context.Context, challenge string) (string, error) {
-	token, err := auth.Sign(ctx, []byte(challenge))
+	// trim trailing slashes
+	hostport = strings.TrimRight(hostport, "/")
+
+	host, port, err := net.SplitHostPort(hostport)
 	if err != nil {
-		return "", err
+		host, port = "127.0.0.1", defaultPort
+		if ip := net.ParseIP(strings.Trim(hostport, "[]")); ip != nil {
+			host = ip.String()
+		} else if hostport != "" {
+			host = hostport
+		}
 	}
-	return token, nil
+
+	client := Client{
+		base: &url.URL{
+			Scheme: scheme,
+			Host:   net.JoinHostPort(host, port),
+		},
+	}
+
+	mockRequest, err := http.NewRequest(http.MethodHead, client.base.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	proxyURL, err := http.ProxyFromEnvironment(mockRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	client.http = http.Client{
+		Transport: &http.Transport{
+			Proxy: http.ProxyURL(proxyURL),
+		},
+	}
+
+	return &client, nil
 }
 
 func (c *Client) do(ctx context.Context, method, path string, reqData, respData any) error {
@@ -114,21 +113,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 +122,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 +145,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 +159,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 +168,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 +180,19 @@ func (c *Client) stream(ctx context.Context, method, path string, data any, fn f
 	scanner.Buffer(scanBuf, maxBufferSize)
 	for scanner.Scan() {
 		var errorResponse struct {
-			Error     string `json:"error,omitempty"`
-			SigninURL string `json:"signin_url,omitempty"`
+			Error string `json:"error,omitempty"`
 		}
 
 		bts := scanner.Bytes()
 		if err := json.Unmarshal(bts, &errorResponse); err != nil {
-			if response.StatusCode >= http.StatusBadRequest {
-				return StatusError{
-					StatusCode:   response.StatusCode,
-					Status:       response.Status,
-					ErrorMessage: string(bts),
-				}
-			}
-			return errors.New(string(bts))
+			return fmt.Errorf("unmarshal: %w", err)
 		}
 
-		if response.StatusCode == http.StatusUnauthorized {
-			return AuthorizationError{
-				StatusCode: response.StatusCode,
-				Status:     response.Status,
-				SigninURL:  errorResponse.SigninURL,
-			}
-		} else if response.StatusCode >= http.StatusBadRequest {
+		if errorResponse.Error != "" {
+			return fmt.Errorf(errorResponse.Error)
+		}
+
+		if response.StatusCode >= http.StatusBadRequest {
 			return StatusError{
 				StatusCode:   response.StatusCode,
 				Status:       response.Status,
@@ -250,30 +200,16 @@ 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
 }
 
-// GenerateResponseFunc is a function that [Client.Generate] invokes every time
-// a response is received from the service. If this function returns an error,
-// [Client.Generate] will stop generating and return this error.
 type GenerateResponseFunc func(GenerateResponse) error
 
-// Generate generates a response for a given prompt. The req parameter should
-// be populated with prompt details. fn is called for each response (there may
-// be multiple responses, e.g. in case streaming is enabled).
 func (c *Client) Generate(ctx context.Context, req *GenerateRequest, fn GenerateResponseFunc) error {
 	return c.stream(ctx, http.MethodPost, "/api/generate", req, func(bts []byte) error {
 		var resp GenerateResponse
@@ -285,34 +221,8 @@ func (c *Client) Generate(ctx context.Context, req *GenerateRequest, fn Generate
 	})
 }
 
-// ChatResponseFunc is a function that [Client.Chat] invokes every time
-// a response is received from the service. If this function returns an error,
-// [Client.Chat] will stop generating and return this error.
-type ChatResponseFunc func(ChatResponse) error
-
-// Chat generates the next message in a chat. [ChatRequest] may contain a
-// sequence of messages which can be used to maintain chat history with a model.
-// fn is called for each response (there may be multiple responses, e.g. if case
-// streaming is enabled).
-func (c *Client) Chat(ctx context.Context, req *ChatRequest, fn ChatResponseFunc) error {
-	return c.stream(ctx, http.MethodPost, "/api/chat", req, func(bts []byte) error {
-		var resp ChatResponse
-		if err := json.Unmarshal(bts, &resp); err != nil {
-			return err
-		}
-
-		return fn(resp)
-	})
-}
-
-// PullProgressFunc is a function that [Client.Pull] invokes every time there
-// is progress with a "pull" request sent to the service. If this function
-// returns an error, [Client.Pull] will stop the process and return this error.
 type PullProgressFunc func(ProgressResponse) error
 
-// Pull downloads a model from the ollama library. fn is called each time
-// progress is made on the request and can be used to display a progress bar,
-// etc.
 func (c *Client) Pull(ctx context.Context, req *PullRequest, fn PullProgressFunc) error {
 	return c.stream(ctx, http.MethodPost, "/api/pull", req, func(bts []byte) error {
 		var resp ProgressResponse
@@ -324,14 +234,8 @@ func (c *Client) Pull(ctx context.Context, req *PullRequest, fn PullProgressFunc
 	})
 }
 
-// PushProgressFunc is a function that [Client.Push] invokes when progress is
-// made.
-// It's similar to other progress function types like [PullProgressFunc].
 type PushProgressFunc func(ProgressResponse) error
 
-// Push uploads a model to the model library; requires registering for ollama.ai
-// and adding a public key first. fn is called each time progress is made on
-// the request and can be used to display a progress bar, etc.
 func (c *Client) Push(ctx context.Context, req *PushRequest, fn PushProgressFunc) error {
 	return c.stream(ctx, http.MethodPost, "/api/push", req, func(bts []byte) error {
 		var resp ProgressResponse
@@ -343,15 +247,8 @@ func (c *Client) Push(ctx context.Context, req *PushRequest, fn PushProgressFunc
 	})
 }
 
-// CreateProgressFunc is a function that [Client.Create] invokes when progress
-// is made.
-// It's similar to other progress function types like [PullProgressFunc].
 type CreateProgressFunc func(ProgressResponse) error
 
-// Create creates a model from a [Modelfile]. fn is a progress function that
-// behaves similarly to other methods (see [Client.Pull]).
-//
-// [Modelfile]: https://github.com/ollama/ollama/blob/main/docs/modelfile.mdx
 func (c *Client) Create(ctx context.Context, req *CreateRequest, fn CreateProgressFunc) error {
 	return c.stream(ctx, http.MethodPost, "/api/create", req, func(bts []byte) error {
 		var resp ProgressResponse
@@ -363,7 +260,6 @@ func (c *Client) Create(ctx context.Context, req *CreateRequest, fn CreateProgre
 	})
 }
 
-// List lists models that are available locally.
 func (c *Client) List(ctx context.Context) (*ListResponse, error) {
 	var lr ListResponse
 	if err := c.do(ctx, http.MethodGet, "/api/tags", nil, &lr); err != nil {
@@ -372,27 +268,6 @@ func (c *Client) List(ctx context.Context) (*ListResponse, error) {
 	return &lr, nil
 }
 
-// ModelRecommendationsExperimental lists model recommendations from the local
-// server's experimental recommendations endpoint.
-func (c *Client) ModelRecommendationsExperimental(ctx context.Context) (*ModelRecommendationsResponse, error) {
-	var resp ModelRecommendationsResponse
-	if err := c.do(ctx, http.MethodGet, "/api/experimental/model-recommendations", nil, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-// ListRunning lists running models.
-func (c *Client) ListRunning(ctx context.Context) (*ProcessResponse, error) {
-	var lr ProcessResponse
-	if err := c.do(ctx, http.MethodGet, "/api/ps", nil, &lr); err != nil {
-		return nil, err
-	}
-	return &lr, nil
-}
-
-// Copy copies a model - creating a model with another name from an existing
-// model.
 func (c *Client) Copy(ctx context.Context, req *CopyRequest) error {
 	if err := c.do(ctx, http.MethodPost, "/api/copy", req, nil); err != nil {
 		return err
@@ -400,7 +275,6 @@ func (c *Client) Copy(ctx context.Context, req *CopyRequest) error {
 	return nil
 }
 
-// Delete deletes a model and its data.
 func (c *Client) Delete(ctx context.Context, req *DeleteRequest) error {
 	if err := c.do(ctx, http.MethodDelete, "/api/delete", req, nil); err != nil {
 		return err
@@ -408,7 +282,6 @@ func (c *Client) Delete(ctx context.Context, req *DeleteRequest) error {
 	return nil
 }
 
-// Show obtains model information, including details, modelfile, license etc.
 func (c *Client) Show(ctx context.Context, req *ShowRequest) (*ShowResponse, error) {
 	var resp ShowResponse
 	if err := c.do(ctx, http.MethodPost, "/api/show", req, &resp); err != nil {
@@ -417,8 +290,6 @@ func (c *Client) Show(ctx context.Context, req *ShowRequest) (*ShowResponse, err
 	return &resp, nil
 }
 
-// Heartbeat checks if the server has started and is responsive; if yes, it
-// returns nil, otherwise an error.
 func (c *Client) Heartbeat(ctx context.Context) error {
 	if err := c.do(ctx, http.MethodHead, "/", nil, nil); err != nil {
 		return err
@@ -426,87 +297,17 @@ func (c *Client) Heartbeat(ctx context.Context) error {
 	return nil
 }
 
-// Embed generates embeddings from a model.
-func (c *Client) Embed(ctx context.Context, req *EmbedRequest) (*EmbedResponse, error) {
-	var resp EmbedResponse
-	if err := c.do(ctx, http.MethodPost, "/api/embed", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-// Embeddings generates an embedding from a model.
-func (c *Client) Embeddings(ctx context.Context, req *EmbeddingRequest) (*EmbeddingResponse, error) {
-	var resp EmbeddingResponse
-	if err := c.do(ctx, http.MethodPost, "/api/embeddings", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-// CreateBlob creates a blob from a file on the server. digest is the
-// expected SHA256 digest of the file, and r represents the file.
 func (c *Client) CreateBlob(ctx context.Context, digest string, r io.Reader) error {
-	return c.do(ctx, http.MethodPost, fmt.Sprintf("/api/blobs/%s", digest), r, nil)
-}
+	if err := c.do(ctx, http.MethodHead, fmt.Sprintf("/api/blobs/%s", digest), nil, nil); err != nil {
+		var statusError StatusError
+		if !errors.As(err, &statusError) || statusError.StatusCode != http.StatusNotFound {
+			return err
+		}
 
-// Version returns the Ollama server version as a string.
-func (c *Client) Version(ctx context.Context) (string, error) {
-	var version struct {
-		Version string `json:"version"`
+		if err := c.do(ctx, http.MethodPost, fmt.Sprintf("/api/blobs/%s", digest), r, nil); err != nil {
+			return err
+		}
 	}
 
-	if err := c.do(ctx, http.MethodGet, "/api/version", nil, &version); err != nil {
-		return "", err
-	}
-
-	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
+	return nil
 }

api/client.py

@@ -0,0 +1,284 @@
+import os
+import json
+import requests
+import os
+import hashlib
+import json
+from pathlib import Path
+
+BASE_URL = os.environ.get('OLLAMA_HOST', 'http://localhost:11434')
+
+# Generate a response for a given prompt with a provided model. This is a streaming endpoint, so will be a series of responses.
+# The final response object will include statistics and additional data from the request. Use the callback function to override
+# the default handler.
+def generate(model_name, prompt, system=None, template=None, format="", context=None, options=None, callback=None):
+    try:
+        url = f"{BASE_URL}/api/generate"
+        payload = {
+            "model": model_name, 
+            "prompt": prompt, 
+            "system": system, 
+            "template": template, 
+            "context": context, 
+            "options": options,
+            "format": format,
+        }
+        
+        # Remove keys with None values
+        payload = {k: v for k, v in payload.items() if v is not None}
+        
+        with requests.post(url, json=payload, stream=True) as response:
+            response.raise_for_status()
+            
+            # Creating a variable to hold the context history of the final chunk
+            final_context = None
+            
+            # Variable to hold concatenated response strings if no callback is provided
+            full_response = ""
+
+            # Iterating over the response line by line and displaying the details
+            for line in response.iter_lines():
+                if line:
+                    # Parsing each line (JSON chunk) and extracting the details
+                    chunk = json.loads(line)
+                    
+                    # If a callback function is provided, call it with the chunk
+                    if callback:
+                        callback(chunk)
+                    else:
+                        # If this is not the last chunk, add the "response" field value to full_response and print it
+                        if not chunk.get("done"):
+                            response_piece = chunk.get("response", "")
+                            full_response += response_piece
+                            print(response_piece, end="", flush=True)
+                    
+                    # Check if it's the last chunk (done is true)
+                    if chunk.get("done"):
+                        final_context = chunk.get("context")
+            
+            # Return the full response and the final context
+            return full_response, final_context
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return None, None
+    
+
+# Create a blob file on the server if it doesn't exist.
+def create_blob(digest, file_path):
+    url = f"{BASE_URL}/api/blobs/{digest}"
+
+    # Check if the blob exists
+    response = requests.head(url)
+    if response.status_code != 404:
+        return  # Blob already exists, no need to upload
+    response.raise_for_status()
+
+    # Upload the blob
+    with open(file_path, 'rb') as file_data:
+        requests.post(url, data=file_data)
+
+
+# Create a model from a Modelfile. Use the callback function to override the default handler.
+def create(model_name, filename, callback=None):
+    try:
+        file_path = Path(filename).expanduser().resolve()
+        processed_lines = []
+
+        # Read and process the modelfile
+        with open(file_path, 'r') as f:
+            for line in f:            
+                # Skip empty or whitespace-only lines
+                if not line.strip():
+                    continue
+            
+                command, args = line.split(maxsplit=1)
+
+                if command.upper() in ["FROM", "ADAPTER"]:
+                    path = Path(args.strip()).expanduser()
+
+                    # Check if path is relative and resolve it
+                    if not path.is_absolute():
+                        path = (file_path.parent / path)
+
+                    # Skip if file does not exist for "model", this is handled by the server
+                    if not path.exists():
+                        processed_lines.append(line)
+                        continue
+
+                    # Calculate SHA-256 hash
+                    with open(path, 'rb') as bin_file:
+                        hash = hashlib.sha256()
+                        hash.update(bin_file.read())
+                        blob = f"sha256:{hash.hexdigest()}"
+                
+                    # Add the file to the remote server
+                    create_blob(blob, path)
+
+                    # Replace path with digest in the line
+                    line = f"{command} @{blob}\n"
+
+                processed_lines.append(line)
+
+        # Combine processed lines back into a single string
+        modelfile_content = '\n'.join(processed_lines)
+
+        url = f"{BASE_URL}/api/create"
+        payload = {"name": model_name, "modelfile": modelfile_content}
+
+        # Making a POST request with the stream parameter set to True to handle streaming responses
+        with requests.post(url, json=payload, stream=True) as response:
+            response.raise_for_status()
+            # Iterating over the response line by line and displaying the status
+            for line in response.iter_lines():
+                if line:
+                    chunk = json.loads(line)
+                    if callback:
+                        callback(chunk)
+                    else:
+                        print(f"Status: {chunk.get('status')}")
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+
+# Pull a model from a the model registry. Cancelled pulls are resumed from where they left off, and multiple
+# calls to will share the same download progress. Use the callback function to override the default handler.
+def pull(model_name, insecure=False, callback=None):
+    try:
+        url = f"{BASE_URL}/api/pull"
+        payload = {
+            "name": model_name,
+            "insecure": insecure
+        }
+
+        # Making a POST request with the stream parameter set to True to handle streaming responses
+        with requests.post(url, json=payload, stream=True) as response:
+            response.raise_for_status()
+
+            # Iterating over the response line by line and displaying the details
+            for line in response.iter_lines():
+                if line:
+                    # Parsing each line (JSON chunk) and extracting the details
+                    chunk = json.loads(line)
+
+                    # If a callback function is provided, call it with the chunk
+                    if callback:
+                        callback(chunk)
+                    else:
+                        # Print the status message directly to the console
+                        print(chunk.get('status', ''), end='', flush=True)
+                    
+                    # If there's layer data, you might also want to print that (adjust as necessary)
+                    if 'digest' in chunk:
+                        print(f" - Digest: {chunk['digest']}", end='', flush=True)
+                        print(f" - Total: {chunk['total']}", end='', flush=True)
+                        print(f" - Completed: {chunk['completed']}", end='\n', flush=True)
+                    else:
+                        print()
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+
+# Push a model to the model registry. Use the callback function to override the default handler.
+def push(model_name, insecure=False, callback=None):
+    try:
+        url = f"{BASE_URL}/api/push"
+        payload = {
+            "name": model_name,
+            "insecure": insecure
+        }
+
+        # Making a POST request with the stream parameter set to True to handle streaming responses
+        with requests.post(url, json=payload, stream=True) as response:
+            response.raise_for_status()
+
+            # Iterating over the response line by line and displaying the details
+            for line in response.iter_lines():
+                if line:
+                    # Parsing each line (JSON chunk) and extracting the details
+                    chunk = json.loads(line)
+
+                    # If a callback function is provided, call it with the chunk
+                    if callback:
+                        callback(chunk)
+                    else:
+                        # Print the status message directly to the console
+                        print(chunk.get('status', ''), end='', flush=True)
+                    
+                    # If there's layer data, you might also want to print that (adjust as necessary)
+                    if 'digest' in chunk:
+                        print(f" - Digest: {chunk['digest']}", end='', flush=True)
+                        print(f" - Total: {chunk['total']}", end='', flush=True)
+                        print(f" - Completed: {chunk['completed']}", end='\n', flush=True)
+                    else:
+                        print()
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+
+# List models that are available locally.
+def list():
+    try:
+        response = requests.get(f"{BASE_URL}/api/tags")
+        response.raise_for_status()
+        data = response.json()
+        models = data.get('models', [])
+        return models
+
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return None
+
+# Copy a model. Creates a model with another name from an existing model.
+def copy(source, destination):
+    try:
+        # Create the JSON payload
+        payload = {
+            "source": source,
+            "destination": destination
+        }
+        
+        response = requests.post(f"{BASE_URL}/api/copy", json=payload)
+        response.raise_for_status()
+        
+        # If the request was successful, return a message indicating that the copy was successful
+        return "Copy successful"
+
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return None
+
+# Delete a model and its data.
+def delete(model_name):
+    try:
+        url = f"{BASE_URL}/api/delete"
+        payload = {"name": model_name}
+        response = requests.delete(url, json=payload)
+        response.raise_for_status()
+        return "Delete successful"
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return None
+
+# Show info about a model.
+def show(model_name):
+    try:
+        url = f"{BASE_URL}/api/show"
+        payload = {"name": model_name}
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        
+        # Parse the JSON response and return it
+        data = response.json()
+        return data
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return None
+
+def heartbeat():
+    try:
+        url = f"{BASE_URL}/"
+        response = requests.head(url)
+        response.raise_for_status()
+        return "Ollama is running"
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return "Ollama is not running"

api/client_test.go

@@ -1,15 +1,6 @@
 package api
 
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-)
+import "testing"
 
 func TestClientFromEnvironment(t *testing.T) {
 	type testCase struct {
@@ -50,399 +41,3 @@ func TestClientFromEnvironment(t *testing.T) {
 		})
 	}
 }
-
-// testError represents an internal error type with status code and message
-// this is used since the error response from the server is not a standard error struct
-type testError struct {
-	message    string
-	statusCode int
-	raw        bool // if true, write message as-is instead of JSON encoding
-}
-
-func (e testError) Error() string {
-	return e.message
-}
-
-func TestClientStream(t *testing.T) {
-	testCases := []struct {
-		name      string
-		responses []any
-		wantErr   string
-	}{
-		{
-			name: "immediate error response",
-			responses: []any{
-				testError{
-					message:    "test error message",
-					statusCode: http.StatusBadRequest,
-				},
-			},
-			wantErr: "test error message",
-		},
-		{
-			name: "error after successful chunks, ok response",
-			responses: []any{
-				ChatResponse{Message: Message{Content: "partial response 1"}},
-				ChatResponse{Message: Message{Content: "partial response 2"}},
-				testError{
-					message:    "mid-stream error",
-					statusCode: http.StatusOK,
-				},
-			},
-			wantErr: "mid-stream error",
-		},
-		{
-			name: "http status error takes precedence over general error",
-			responses: []any{
-				testError{
-					message:    "custom error message",
-					statusCode: http.StatusInternalServerError,
-				},
-			},
-			wantErr: "500",
-		},
-		{
-			name: "successful stream completion",
-			responses: []any{
-				ChatResponse{Message: Message{Content: "chunk 1"}},
-				ChatResponse{Message: Message{Content: "chunk 2"}},
-				ChatResponse{
-					Message:    Message{Content: "final chunk"},
-					Done:       true,
-					DoneReason: "stop",
-				},
-			},
-		},
-		{
-			name: "plain text error response",
-			responses: []any{
-				"internal server error",
-			},
-			wantErr: "internal server error",
-		},
-		{
-			name: "HTML error page",
-			responses: []any{
-				"<html><body>404 Not Found</body></html>",
-			},
-			wantErr: "404 Not Found",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				flusher, ok := w.(http.Flusher)
-				if !ok {
-					t.Fatal("expected http.Flusher")
-				}
-
-				w.Header().Set("Content-Type", "application/x-ndjson")
-
-				for _, resp := range tc.responses {
-					if errResp, ok := resp.(testError); ok {
-						w.WriteHeader(errResp.statusCode)
-						err := json.NewEncoder(w).Encode(map[string]string{
-							"error": errResp.message,
-						})
-						if err != nil {
-							t.Fatal("failed to encode error response:", err)
-						}
-						return
-					}
-
-					if str, ok := resp.(string); ok {
-						fmt.Fprintln(w, str)
-						flusher.Flush()
-						continue
-					}
-
-					if err := json.NewEncoder(w).Encode(resp); err != nil {
-						t.Fatalf("failed to encode response: %v", err)
-					}
-					flusher.Flush()
-				}
-			}))
-			defer ts.Close()
-
-			client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
-
-			var receivedChunks []ChatResponse
-			err := client.stream(t.Context(), http.MethodPost, "/v1/chat", nil, func(chunk []byte) error {
-				var resp ChatResponse
-				if err := json.Unmarshal(chunk, &resp); err != nil {
-					return fmt.Errorf("failed to unmarshal chunk: %w", err)
-				}
-				receivedChunks = append(receivedChunks, resp)
-				return nil
-			})
-
-			if tc.wantErr != "" {
-				if err == nil {
-					t.Fatal("expected error but got nil")
-				}
-				if !strings.Contains(err.Error(), tc.wantErr) {
-					t.Errorf("expected error containing %q, got %v", tc.wantErr, err)
-				}
-				return
-			}
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-func TestClientStreamReportsReadErrors(t *testing.T) {
-	client := NewClient(
-		&url.URL{Scheme: "http", Host: "example.com"},
-		&http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
-			body := failingReader{
-				data: []byte(`{"message":{"content":"partial"}}` + "\n"),
-				err:  io.ErrUnexpectedEOF,
-			}
-
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Status:     "200 OK",
-				Body:       io.NopCloser(&body),
-				Header:     make(http.Header),
-			}, nil
-		})},
-	)
-
-	err := client.stream(t.Context(), http.MethodPost, "/api/chat", nil, func([]byte) error {
-		return nil
-	})
-	if err == nil {
-		t.Fatal("expected stream read error")
-	}
-	if !strings.Contains(err.Error(), io.ErrUnexpectedEOF.Error()) {
-		t.Fatalf("expected unexpected EOF, got %v", err)
-	}
-}
-
-func TestClientDo(t *testing.T) {
-	testCases := []struct {
-		name           string
-		response       any
-		wantErr        string
-		wantStatusCode int
-	}{
-		{
-			name: "immediate error response",
-			response: testError{
-				message:    "test error message",
-				statusCode: http.StatusBadRequest,
-			},
-			wantErr:        "test error message",
-			wantStatusCode: http.StatusBadRequest,
-		},
-		{
-			name: "server error response",
-			response: testError{
-				message:    "internal error",
-				statusCode: http.StatusInternalServerError,
-			},
-			wantErr:        "internal error",
-			wantStatusCode: http.StatusInternalServerError,
-		},
-		{
-			name: "successful response",
-			response: struct {
-				ID      string `json:"id"`
-				Success bool   `json:"success"`
-			}{
-				ID:      "msg_123",
-				Success: true,
-			},
-		},
-		{
-			name: "plain text error response",
-			response: testError{
-				message:    "internal server error",
-				statusCode: http.StatusInternalServerError,
-				raw:        true,
-			},
-			wantErr:        "internal server error",
-			wantStatusCode: http.StatusInternalServerError,
-		},
-		{
-			name: "HTML error page",
-			response: testError{
-				message:    "<html><body>404 Not Found</body></html>",
-				statusCode: http.StatusNotFound,
-				raw:        true,
-			},
-			wantErr:        "<html><body>404 Not Found</body></html>",
-			wantStatusCode: http.StatusNotFound,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if errResp, ok := tc.response.(testError); ok {
-					w.WriteHeader(errResp.statusCode)
-					if !errResp.raw {
-						err := json.NewEncoder(w).Encode(map[string]string{
-							"error": errResp.message,
-						})
-						if err != nil {
-							t.Fatal("failed to encode error response:", err)
-						}
-					} else {
-						// Write raw message (simulates non-JSON error responses)
-						fmt.Fprint(w, errResp.message)
-					}
-					return
-				}
-
-				w.Header().Set("Content-Type", "application/json")
-				if err := json.NewEncoder(w).Encode(tc.response); err != nil {
-					t.Fatalf("failed to encode response: %v", err)
-				}
-			}))
-			defer ts.Close()
-
-			client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
-
-			var resp struct {
-				ID      string `json:"id"`
-				Success bool   `json:"success"`
-			}
-			err := client.do(t.Context(), http.MethodPost, "/v1/messages", nil, &resp)
-
-			if tc.wantErr != "" {
-				if err == nil {
-					t.Fatalf("got nil, want error %q", tc.wantErr)
-				}
-				if err.Error() != tc.wantErr {
-					t.Errorf("error message mismatch: got %q, want %q", err.Error(), tc.wantErr)
-				}
-				if tc.wantStatusCode != 0 {
-					if statusErr, ok := err.(StatusError); ok {
-						if statusErr.StatusCode != tc.wantStatusCode {
-							t.Errorf("status code mismatch: got %d, want %d", statusErr.StatusCode, tc.wantStatusCode)
-						}
-					} else {
-						t.Errorf("expected StatusError, got %T", err)
-					}
-				}
-				return
-			}
-
-			if err != nil {
-				t.Fatalf("got error %q, want nil", err)
-			}
-
-			if expectedResp, ok := tc.response.(struct {
-				ID      string `json:"id"`
-				Success bool   `json:"success"`
-			}); ok {
-				if resp.ID != expectedResp.ID {
-					t.Errorf("response ID mismatch: got %q, want %q", resp.ID, expectedResp.ID)
-				}
-				if resp.Success != expectedResp.Success {
-					t.Errorf("response Success mismatch: got %v, want %v", resp.Success, expectedResp.Success)
-				}
-			}
-		})
-	}
-}
-
-func TestClientWebSearchExperimentalUsesLocalRoute(t *testing.T) {
-	var gotPath string
-	var gotMethod string
-	var gotRequest WebSearchRequest
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotPath = r.URL.Path
-		gotMethod = r.Method
-		if err := json.NewDecoder(r.Body).Decode(&gotRequest); err != nil {
-			t.Fatal(err)
-		}
-		if err := json.NewEncoder(w).Encode(WebSearchResponse{
-			Results: []WebSearchResult{{Title: "Ollama", URL: "https://ollama.com", Content: "models"}},
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}))
-	defer ts.Close()
-
-	client := NewClient(&url.URL{Scheme: "http", Host: ts.Listener.Addr().String()}, http.DefaultClient)
-	resp, err := client.WebSearchExperimental(t.Context(), &WebSearchRequest{Query: "ollama", MaxResults: 3})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if gotMethod != http.MethodPost {
-		t.Fatalf("method = %q, want POST", gotMethod)
-	}
-	if gotPath != "/api/experimental/web_search" {
-		t.Fatalf("path = %q, want /api/experimental/web_search", gotPath)
-	}
-	if gotRequest.Query != "ollama" || gotRequest.MaxResults != 3 {
-		t.Fatalf("request = %#v", gotRequest)
-	}
-	if len(resp.Results) != 1 || resp.Results[0].Title != "Ollama" {
-		t.Fatalf("response = %#v", resp)
-	}
-}
-
-func 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/examples/chat/main.go

@@ -1,51 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/ollama/ollama/api"
-)
-
-func main() {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	messages := []api.Message{
-		{
-			Role:    "system",
-			Content: "Provide very brief, concise responses",
-		},
-		{
-			Role:    "user",
-			Content: "Name some unusual animals",
-		},
-		{
-			Role:    "assistant",
-			Content: "Monotreme, platypus, echidna",
-		},
-		{
-			Role:    "user",
-			Content: "which of these is the most dangerous?",
-		},
-	}
-
-	ctx := context.Background()
-	req := &api.ChatRequest{
-		Model:    "llama3.2",
-		Messages: messages,
-	}
-
-	respFunc := func(resp api.ChatResponse) error {
-		fmt.Print(resp.Message.Content)
-		return nil
-	}
-
-	err = client.Chat(ctx, req, respFunc)
-	if err != nil {
-		log.Fatal(err)
-	}
-}

api/examples/generate-streaming/main.go

@@ -1,40 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/ollama/ollama/api"
-)
-
-func main() {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// By default, GenerateRequest is streaming.
-	req := &api.GenerateRequest{
-		Model:  "gemma2",
-		Prompt: "how many planets are there?",
-	}
-
-	ctx := context.Background()
-	respFunc := func(resp api.GenerateResponse) error {
-		// Only print the response here; GenerateResponse has a number of other
-		// interesting fields you want to examine.
-
-		// In streaming mode, responses are partial so we call fmt.Print (and not
-		// Println) in order to avoid spurious newlines being introduced. The
-		// model will insert its own newlines if it wants.
-		fmt.Print(resp.Response)
-		return nil
-	}
-
-	err = client.Generate(ctx, req, respFunc)
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println()
-}

api/examples/generate/main.go

@@ -1,37 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/ollama/ollama/api"
-)
-
-func main() {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	req := &api.GenerateRequest{
-		Model:  "gemma2",
-		Prompt: "how many planets are there?",
-
-		// set streaming to false
-		Stream: new(bool),
-	}
-
-	ctx := context.Background()
-	respFunc := func(resp api.GenerateResponse) error {
-		// Only print the response here; GenerateResponse has a number of other
-		// interesting fields you want to examine.
-		fmt.Println(resp.Response)
-		return nil
-	}
-
-	err = client.Generate(ctx, req, respFunc)
-	if err != nil {
-		log.Fatal(err)
-	}
-}

api/examples/multimodal/main.go

@@ -1,47 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-
-	"github.com/ollama/ollama/api"
-)
-
-func main() {
-	if len(os.Args) <= 1 {
-		log.Fatal("usage: <image name>")
-	}
-
-	imgData, err := os.ReadFile(os.Args[1])
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	req := &api.GenerateRequest{
-		Model:  "llava",
-		Prompt: "describe this image",
-		Images: []api.ImageData{imgData},
-	}
-
-	ctx := context.Background()
-	respFunc := func(resp api.GenerateResponse) error {
-		// In streaming mode, responses are partial so we call fmt.Print (and not
-		// Println) in order to avoid spurious newlines being introduced. The
-		// model will insert its own newlines if it wants.
-		fmt.Print(resp.Response)
-		return nil
-	}
-
-	err = client.Generate(ctx, req, respFunc)
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println()
-}

api/examples/pull-progress/main.go

@@ -1,31 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/ollama/ollama/api"
-)
-
-func main() {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	ctx := context.Background()
-
-	req := &api.PullRequest{
-		Model: "mistral",
-	}
-	progressFunc := func(resp api.ProgressResponse) error {
-		fmt.Printf("Progress: status=%v, total=%v, completed=%v\n", resp.Status, resp.Total, resp.Completed)
-		return nil
-	}
-
-	err = client.Pull(ctx, req, progressFunc)
-	if err != nil {
-		log.Fatal(err)
-	}
-}

api/types.go

@@ -3,23 +3,13 @@ package api
 import (
 	"encoding/json"
 	"fmt"
-	"iter"
-	"log/slog"
 	"math"
 	"os"
 	"reflect"
-	"strconv"
 	"strings"
 	"time"
-
-	"github.com/google/uuid"
-
-	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/internal/orderedmap"
-	"github.com/ollama/ollama/types/model"
 )
 
-// StatusError is an error with an HTTP status code and message.
 type StatusError struct {
 	StatusCode   int
 	Status       string
@@ -40,545 +30,20 @@ func (e StatusError) Error() string {
 	}
 }
 
-type AuthorizationError struct {
-	StatusCode int
-	Status     string
-	SigninURL  string `json:"signin_url"`
-}
-
-func (e AuthorizationError) Error() string {
-	if e.Status != "" {
-		return e.Status
-	}
-	return "something went wrong, please see the ollama server logs for details"
-}
-
-// ImageData represents the raw binary data of an image file.
-type ImageData []byte
-
-// GenerateRequest describes a request sent by [Client.Generate]. While you
-// have to specify the Model and Prompt fields, all the other fields have
-// reasonable defaults for basic uses.
 type GenerateRequest struct {
-	// Model is the model name; it should be a name familiar to Ollama from
-	// the library at https://ollama.com/library
-	Model string `json:"model"`
-
-	// Prompt is the textual prompt to send to the model.
-	Prompt string `json:"prompt"`
-
-	// Suffix is the text that comes after the inserted text.
-	Suffix string `json:"suffix"`
-
-	// System overrides the model's default system message/prompt.
-	System string `json:"system"`
-
-	// Template overrides the model's default prompt template.
+	Model    string `json:"model"`
+	Prompt   string `json:"prompt"`
+	System   string `json:"system"`
 	Template string `json:"template"`
+	Context  []int  `json:"context,omitempty"`
+	Stream   *bool  `json:"stream,omitempty"`
+	Raw      bool   `json:"raw,omitempty"`
+	Format   string `json:"format"`
 
-	// Context is the context parameter returned from a previous call to
-	// [Client.Generate]. It can be used to keep a short conversational memory.
-	Context []int `json:"context,omitempty"`
-
-	// Stream specifies whether the response is streaming; it is true by default.
-	Stream *bool `json:"stream,omitempty"`
-
-	// Raw set to true means that no formatting will be applied to the prompt.
-	Raw bool `json:"raw,omitempty"`
-
-	// Format specifies the format to return a response in.
-	Format json.RawMessage `json:"format,omitempty"`
-
-	// KeepAlive controls how long the model will stay loaded in memory following
-	// this request.
-	KeepAlive *Duration `json:"keep_alive,omitempty"`
-
-	// Images is an optional list of raw image bytes accompanying this
-	// request, for multimodal models.
-	Images []ImageData `json:"images,omitempty"`
-
-	// Options lists model-specific options. For example, temperature can be
-	// set through this field, if the model supports it.
-	Options map[string]any `json:"options"`
-
-	// Think controls whether thinking/reasoning models will think before
-	// responding. Can be a boolean (true/false) or a string ("high", "medium", "low")
-	// for supported models. Needs to be a pointer so we can distinguish between false
-	// (request that thinking _not_ be used) and unset (use the old behavior
-	// before this option was introduced)
-	Think *ThinkValue `json:"think,omitempty"`
-
-	// Truncate is a boolean that, when set to true, truncates the chat history messages
-	// if the rendered prompt exceeds the context length limit.
-	Truncate *bool `json:"truncate,omitempty"`
-
-	// Shift is a boolean that, when set to true, shifts the chat history
-	// when hitting the context length limit instead of erroring.
-	Shift *bool `json:"shift,omitempty"`
-
-	// DebugRenderOnly is a debug option that, when set to true, returns the rendered
-	// template instead of calling the model.
-	DebugRenderOnly bool `json:"_debug_render_only,omitempty"`
-
-	// Logprobs specifies whether to return log probabilities of the output tokens.
-	Logprobs bool `json:"logprobs,omitempty"`
-
-	// TopLogprobs is the number of most likely tokens to return at each token position,
-	// each with an associated log probability. Only applies when Logprobs is true.
-	// Valid values are 0-20. Default is 0 (only return the selected token's logprob).
-	TopLogprobs int `json:"top_logprobs,omitempty"`
-
-	// Experimental: Image generation fields (may change or be removed)
-
-	// Width is the width of the generated image in pixels.
-	// Only used for image generation models.
-	Width int32 `json:"width,omitempty"`
-
-	// Height is the height of the generated image in pixels.
-	// Only used for image generation models.
-	Height int32 `json:"height,omitempty"`
-
-	// Steps is the number of diffusion steps for image generation.
-	// Only used for image generation models.
-	Steps int32 `json:"steps,omitempty"`
+	Options map[string]interface{} `json:"options"`
 }
 
-// ChatRequest describes a request sent by [Client.Chat].
-type ChatRequest struct {
-	// Model is the model name, as in [GenerateRequest].
-	Model string `json:"model"`
-
-	// Messages is the messages of the chat - can be used to keep a chat memory.
-	Messages []Message `json:"messages"`
-
-	// Stream enables streaming of returned responses; true by default.
-	Stream *bool `json:"stream,omitempty"`
-
-	// Format is the format to return the response in (e.g. "json").
-	Format json.RawMessage `json:"format,omitempty"`
-
-	// KeepAlive controls how long the model will stay loaded into memory
-	// following the request.
-	KeepAlive *Duration `json:"keep_alive,omitempty"`
-
-	// Tools is an optional list of tools the model has access to.
-	Tools `json:"tools,omitempty"`
-
-	// Options lists model-specific options.
-	Options map[string]any `json:"options"`
-
-	// Think controls whether thinking/reasoning models will think before
-	// responding. Can be a boolean (true/false) or a string ("high", "medium", "low")
-	// for supported models.
-	Think *ThinkValue `json:"think,omitempty"`
-
-	// Truncate is a boolean that, when set to true, truncates the chat history messages
-	// if the rendered prompt exceeds the context length limit.
-	Truncate *bool `json:"truncate,omitempty"`
-
-	// Shift is a boolean that, when set to true, shifts the chat history
-	// when hitting the context length limit instead of erroring.
-	Shift *bool `json:"shift,omitempty"`
-
-	// DebugRenderOnly is a debug option that, when set to true, returns the rendered
-	// template instead of calling the model.
-	DebugRenderOnly bool `json:"_debug_render_only,omitempty"`
-
-	// Logprobs specifies whether to return log probabilities of the output tokens.
-	Logprobs bool `json:"logprobs,omitempty"`
-
-	// TopLogprobs is the number of most likely tokens to return at each token position,
-	// each with an associated log probability. Only applies when Logprobs is true.
-	// Valid values are 0-20. Default is 0 (only return the selected token's logprob).
-	TopLogprobs int `json:"top_logprobs,omitempty"`
-}
-
-type Tools []Tool
-
-func (t Tools) String() string {
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-func (t Tool) String() string {
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-// Message is a single message in a chat sequence. The message contains the
-// role ("system", "user", or "assistant"), the content and an optional list
-// of images.
-type Message struct {
-	Role    string `json:"role"`
-	Content string `json:"content"`
-	// Thinking contains the text that was inside thinking tags in the
-	// original model output when ChatRequest.Think is enabled.
-	Thinking   string      `json:"thinking,omitempty"`
-	Images     []ImageData `json:"images,omitempty"`
-	ToolCalls  []ToolCall  `json:"tool_calls,omitempty"`
-	ToolName   string      `json:"tool_name,omitempty"`
-	ToolCallID string      `json:"tool_call_id,omitempty"`
-}
-
-func (m *Message) UnmarshalJSON(b []byte) error {
-	type Alias Message
-	var a Alias
-	if err := json.Unmarshal(b, &a); err != nil {
-		return err
-	}
-
-	*m = Message(a)
-	m.Role = strings.ToLower(m.Role)
-	return nil
-}
-
-type ToolCall struct {
-	ID       string           `json:"id,omitempty"`
-	Function ToolCallFunction `json:"function"`
-}
-
-type ToolCallFunction struct {
-	Index     int                       `json:"index"`
-	Name      string                    `json:"name"`
-	Arguments ToolCallFunctionArguments `json:"arguments"`
-}
-
-// ToolCallFunctionArguments holds tool call arguments in insertion order.
-type ToolCallFunctionArguments struct {
-	om *orderedmap.Map[string, any]
-}
-
-// NewToolCallFunctionArguments creates a new empty ToolCallFunctionArguments.
-func NewToolCallFunctionArguments() ToolCallFunctionArguments {
-	return ToolCallFunctionArguments{om: orderedmap.New[string, any]()}
-}
-
-// Get retrieves a value by key.
-func (t *ToolCallFunctionArguments) Get(key string) (any, bool) {
-	if t == nil || t.om == nil {
-		return nil, false
-	}
-	return t.om.Get(key)
-}
-
-// Set sets a key-value pair, preserving insertion order.
-func (t *ToolCallFunctionArguments) Set(key string, value any) {
-	if t == nil {
-		return
-	}
-	if t.om == nil {
-		t.om = orderedmap.New[string, any]()
-	}
-	t.om.Set(key, value)
-}
-
-// Len returns the number of arguments.
-func (t *ToolCallFunctionArguments) Len() int {
-	if t == nil || t.om == nil {
-		return 0
-	}
-	return t.om.Len()
-}
-
-// All returns an iterator over all key-value pairs in insertion order.
-func (t *ToolCallFunctionArguments) All() iter.Seq2[string, any] {
-	if t == nil || t.om == nil {
-		return func(yield func(string, any) bool) {}
-	}
-	return t.om.All()
-}
-
-// ToMap returns a regular map (order not preserved).
-func (t *ToolCallFunctionArguments) ToMap() map[string]any {
-	if t == nil || t.om == nil {
-		return nil
-	}
-	return t.om.ToMap()
-}
-
-func (t *ToolCallFunctionArguments) String() string {
-	if t == nil || t.om == nil {
-		return "{}"
-	}
-	bts, _ := json.Marshal(t.om)
-	return string(bts)
-}
-
-func (t *ToolCallFunctionArguments) UnmarshalJSON(data []byte) error {
-	t.om = orderedmap.New[string, any]()
-	return json.Unmarshal(data, t.om)
-}
-
-func (t ToolCallFunctionArguments) MarshalJSON() ([]byte, error) {
-	if t.om == nil {
-		return []byte("{}"), nil
-	}
-	return json.Marshal(t.om)
-}
-
-type Tool struct {
-	Type     string       `json:"type"`
-	Items    any          `json:"items,omitempty"`
-	Function ToolFunction `json:"function"`
-}
-
-// PropertyType can be either a string or an array of strings
-type PropertyType []string
-
-// UnmarshalJSON implements the json.Unmarshaler interface
-func (pt *PropertyType) UnmarshalJSON(data []byte) error {
-	// Try to unmarshal as a string first
-	var s string
-	if err := json.Unmarshal(data, &s); err == nil {
-		*pt = []string{s}
-		return nil
-	}
-
-	// If that fails, try to unmarshal as an array of strings
-	var a []string
-	if err := json.Unmarshal(data, &a); err != nil {
-		return err
-	}
-	*pt = a
-	return nil
-}
-
-// MarshalJSON implements the json.Marshaler interface
-func (pt PropertyType) MarshalJSON() ([]byte, error) {
-	if len(pt) == 1 {
-		// If there's only one type, marshal as a string
-		return json.Marshal(pt[0])
-	}
-	// Otherwise marshal as an array
-	return json.Marshal([]string(pt))
-}
-
-// String returns a string representation of the PropertyType
-func (pt PropertyType) String() string {
-	if len(pt) == 0 {
-		return ""
-	}
-	if len(pt) == 1 {
-		return pt[0]
-	}
-	return fmt.Sprintf("%v", []string(pt))
-}
-
-// ToolPropertiesMap holds tool properties in insertion order.
-type ToolPropertiesMap struct {
-	om *orderedmap.Map[string, ToolProperty]
-}
-
-// NewToolPropertiesMap creates a new empty ToolPropertiesMap.
-func NewToolPropertiesMap() *ToolPropertiesMap {
-	return &ToolPropertiesMap{om: orderedmap.New[string, ToolProperty]()}
-}
-
-// Get retrieves a property by name.
-func (t *ToolPropertiesMap) Get(key string) (ToolProperty, bool) {
-	if t == nil || t.om == nil {
-		return ToolProperty{}, false
-	}
-	return t.om.Get(key)
-}
-
-// Set sets a property, preserving insertion order.
-func (t *ToolPropertiesMap) Set(key string, value ToolProperty) {
-	if t == nil {
-		return
-	}
-	if t.om == nil {
-		t.om = orderedmap.New[string, ToolProperty]()
-	}
-	t.om.Set(key, value)
-}
-
-// Len returns the number of properties.
-func (t *ToolPropertiesMap) Len() int {
-	if t == nil || t.om == nil {
-		return 0
-	}
-	return t.om.Len()
-}
-
-// All returns an iterator over all properties in insertion order.
-func (t *ToolPropertiesMap) All() iter.Seq2[string, ToolProperty] {
-	if t == nil || t.om == nil {
-		return func(yield func(string, ToolProperty) bool) {}
-	}
-	return t.om.All()
-}
-
-// ToMap returns a regular map (order not preserved).
-func (t *ToolPropertiesMap) ToMap() map[string]ToolProperty {
-	if t == nil || t.om == nil {
-		return nil
-	}
-	return t.om.ToMap()
-}
-
-func (t ToolPropertiesMap) MarshalJSON() ([]byte, error) {
-	if t.om == nil {
-		return []byte("null"), nil
-	}
-	return json.Marshal(t.om)
-}
-
-func (t *ToolPropertiesMap) UnmarshalJSON(data []byte) error {
-	t.om = orderedmap.New[string, ToolProperty]()
-	return json.Unmarshal(data, t.om)
-}
-
-type ToolProperty struct {
-	AnyOf       []ToolProperty     `json:"anyOf,omitempty"`
-	Type        PropertyType       `json:"type,omitempty"`
-	Items       any                `json:"items,omitempty"`
-	Description string             `json:"description,omitempty"`
-	Enum        []any              `json:"enum,omitempty"`
-	Properties  *ToolPropertiesMap `json:"properties,omitempty"`
-	Required    []string           `json:"required,omitempty"`
-}
-
-// ToTypeScriptType converts a ToolProperty to a TypeScript type string
-func (tp ToolProperty) ToTypeScriptType() string {
-	if len(tp.AnyOf) > 0 {
-		var types []string
-		for _, anyOf := range tp.AnyOf {
-			types = append(types, anyOf.ToTypeScriptType())
-		}
-		return strings.Join(types, " | ")
-	}
-
-	if len(tp.Type) == 0 {
-		return "any"
-	}
-
-	if len(tp.Type) == 1 {
-		return mapToTypeScriptType(tp.Type[0])
-	}
-
-	var types []string
-	for _, t := range tp.Type {
-		types = append(types, mapToTypeScriptType(t))
-	}
-	return strings.Join(types, " | ")
-}
-
-// mapToTypeScriptType maps JSON Schema types to TypeScript types
-func mapToTypeScriptType(jsonType string) string {
-	switch jsonType {
-	case "string":
-		return "string"
-	case "number", "integer":
-		return "number"
-	case "boolean":
-		return "boolean"
-	case "array":
-		return "any[]"
-	case "object":
-		return "Record<string, any>"
-	case "null":
-		return "null"
-	default:
-		return "any"
-	}
-}
-
-type ToolFunctionParameters struct {
-	Type       string             `json:"type"`
-	Defs       any                `json:"$defs,omitempty"`
-	Items      any                `json:"items,omitempty"`
-	Required   []string           `json:"required,omitempty"`
-	Properties *ToolPropertiesMap `json:"properties"`
-}
-
-func (t *ToolFunctionParameters) String() string {
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-type ToolFunction struct {
-	Name        string                 `json:"name"`
-	Description string                 `json:"description,omitempty"`
-	Parameters  ToolFunctionParameters `json:"parameters"`
-}
-
-func (t *ToolFunction) String() string {
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-// TokenLogprob represents log probability information for a single token alternative.
-type TokenLogprob struct {
-	// Token is the text representation of the token.
-	Token string `json:"token"`
-
-	// Logprob is the log probability of this token.
-	Logprob float64 `json:"logprob"`
-
-	// Bytes contains the raw byte representation of the token
-	Bytes []int `json:"bytes,omitempty"`
-}
-
-// Logprob contains log probability information for a generated token.
-type Logprob struct {
-	TokenLogprob
-
-	// TopLogprobs contains the most likely tokens and their log probabilities
-	// at this position, if requested via TopLogprobs parameter.
-	TopLogprobs []TokenLogprob `json:"top_logprobs,omitempty"`
-}
-
-// ChatResponse is the response returned by [Client.Chat]. Its fields are
-// similar to [GenerateResponse].
-type ChatResponse struct {
-	// Model is the model name that generated the response.
-	Model string `json:"model"`
-
-	// RemoteModel is the name of the upstream model that generated the response.
-	RemoteModel string `json:"remote_model,omitempty"`
-
-	// RemoteHost is the URL of the upstream Ollama host that generated the response.
-	RemoteHost string `json:"remote_host,omitempty"`
-
-	// CreatedAt is the timestamp of the response.
-	CreatedAt time.Time `json:"created_at"`
-
-	// Message contains the message or part of a message from the model.
-	Message Message `json:"message"`
-
-	// Done specifies if the response is complete.
-	Done bool `json:"done"`
-
-	// DoneReason is the reason the model stopped generating text.
-	DoneReason string `json:"done_reason,omitempty"`
-
-	DebugInfo *DebugInfo `json:"_debug_info,omitempty"`
-
-	// Logprobs contains log probability information for the generated tokens,
-	// if requested via the Logprobs parameter.
-	Logprobs []Logprob `json:"logprobs,omitempty"`
-
-	Metrics
-}
-
-// DebugInfo contains debug information for template rendering
-type DebugInfo struct {
-	RenderedTemplate string `json:"rendered_template"`
-	ImageCount       int    `json:"image_count,omitempty"`
-}
-
-type Metrics struct {
-	TotalDuration      time.Duration `json:"total_duration,omitempty"`
-	LoadDuration       time.Duration `json:"load_duration,omitempty"`
-	PromptEvalCount    int           `json:"prompt_eval_count,omitempty"`
-	PromptEvalDuration time.Duration `json:"prompt_eval_duration,omitempty"`
-	EvalCount          int           `json:"eval_count,omitempty"`
-	EvalDuration       time.Duration `json:"eval_duration,omitempty"`
-}
-
-// Options specified in [GenerateRequest].  If you add a new option here, also
-// add it to the API docs.
+// Options specfied in GenerateRequest, if you add a new option here add it to the API docs also
 type Options struct {
 	Runner
 
@@ -588,203 +53,87 @@ type Options struct {
 	NumPredict       int      `json:"num_predict,omitempty"`
 	TopK             int      `json:"top_k,omitempty"`
 	TopP             float32  `json:"top_p,omitempty"`
-	MinP             float32  `json:"min_p,omitempty"`
+	TFSZ             float32  `json:"tfs_z,omitempty"`
 	TypicalP         float32  `json:"typical_p,omitempty"`
 	RepeatLastN      int      `json:"repeat_last_n,omitempty"`
 	Temperature      float32  `json:"temperature,omitempty"`
 	RepeatPenalty    float32  `json:"repeat_penalty,omitempty"`
 	PresencePenalty  float32  `json:"presence_penalty,omitempty"`
 	FrequencyPenalty float32  `json:"frequency_penalty,omitempty"`
+	Mirostat         int      `json:"mirostat,omitempty"`
+	MirostatTau      float32  `json:"mirostat_tau,omitempty"`
+	MirostatEta      float32  `json:"mirostat_eta,omitempty"`
+	PenalizeNewline  bool     `json:"penalize_newline,omitempty"`
 	Stop             []string `json:"stop,omitempty"`
 }
 
 // Runner options which must be set when the model is loaded into memory
 type Runner struct {
-	NumCtx          int   `json:"num_ctx,omitempty"`
-	NumBatch        int   `json:"num_batch,omitempty"`
-	NumGPU          int   `json:"num_gpu,omitempty"`
-	MainGPU         *int  `json:"main_gpu,omitempty"`
-	UseMMap         *bool `json:"use_mmap,omitempty"`
-	NumThread       int   `json:"num_thread,omitempty"`
-	DraftNumPredict int   `json:"draft_num_predict,omitempty"`
+	UseNUMA            bool    `json:"numa,omitempty"`
+	NumCtx             int     `json:"num_ctx,omitempty"`
+	NumBatch           int     `json:"num_batch,omitempty"`
+	NumGQA             int     `json:"num_gqa,omitempty"`
+	NumGPU             int     `json:"num_gpu,omitempty"`
+	MainGPU            int     `json:"main_gpu,omitempty"`
+	LowVRAM            bool    `json:"low_vram,omitempty"`
+	F16KV              bool    `json:"f16_kv,omitempty"`
+	LogitsAll          bool    `json:"logits_all,omitempty"`
+	VocabOnly          bool    `json:"vocab_only,omitempty"`
+	UseMMap            bool    `json:"use_mmap,omitempty"`
+	UseMLock           bool    `json:"use_mlock,omitempty"`
+	EmbeddingOnly      bool    `json:"embedding_only,omitempty"`
+	RopeFrequencyBase  float32 `json:"rope_frequency_base,omitempty"`
+	RopeFrequencyScale float32 `json:"rope_frequency_scale,omitempty"`
+	NumThread          int     `json:"num_thread,omitempty"`
 }
 
-// EmbedRequest is the request passed to [Client.Embed].
-type EmbedRequest struct {
-	// Model is the model name.
-	Model string `json:"model"`
-
-	// Input is the input to embed.
-	Input any `json:"input"`
-
-	// KeepAlive controls how long the model will stay loaded in memory following
-	// this request.
-	KeepAlive *Duration `json:"keep_alive,omitempty"`
-
-	// Truncate truncates the input to fit the model's max sequence length.
-	Truncate *bool `json:"truncate,omitempty"`
-
-	// Dimensions truncates the output embedding to the specified dimension.
-	Dimensions int `json:"dimensions,omitempty"`
-
-	// Options lists model-specific options.
-	Options map[string]any `json:"options"`
-}
-
-// EmbedResponse is the response from [Client.Embed].
-type EmbedResponse struct {
-	Model      string      `json:"model"`
-	Embeddings [][]float32 `json:"embeddings"`
-
-	TotalDuration   time.Duration `json:"total_duration,omitempty"`
-	LoadDuration    time.Duration `json:"load_duration,omitempty"`
-	PromptEvalCount int           `json:"prompt_eval_count,omitempty"`
-}
-
-// EmbeddingRequest is the request passed to [Client.Embeddings].
 type EmbeddingRequest struct {
-	// Model is the model name.
-	Model string `json:"model"`
-
-	// Prompt is the textual prompt to embed.
+	Model  string `json:"model"`
 	Prompt string `json:"prompt"`
 
-	// KeepAlive controls how long the model will stay loaded in memory following
-	// this request.
-	KeepAlive *Duration `json:"keep_alive,omitempty"`
-
-	// Options lists model-specific options.
-	Options map[string]any `json:"options"`
+	Options map[string]interface{} `json:"options"`
 }
 
-// EmbeddingResponse is the response from [Client.Embeddings].
 type EmbeddingResponse struct {
 	Embedding []float64 `json:"embedding"`
 }
 
-// CreateRequest is the request passed to [Client.Create].
 type CreateRequest struct {
-	// Model is the model name to create.
-	Model string `json:"model"`
-
-	// Stream specifies whether the response is streaming; it is true by default.
-	Stream *bool `json:"stream,omitempty"`
-
-	// Quantize is the quantization format for the model; leave blank to not change the quantization level.
-	Quantize string `json:"quantize,omitempty"`
-
-	// DraftQuantize is the quantization format for the draft model.
-	DraftQuantize string `json:"draft_quantize,omitempty"`
-
-	// From is the name of the model or file to use as the source.
-	From string `json:"from,omitempty"`
-
-	// RemoteHost is the URL of the upstream ollama API for the model (if any).
-	RemoteHost string `json:"remote_host,omitempty"`
-
-	// Files is a map of files include when creating the model.
-	Files map[string]string `json:"files,omitempty"`
-
-	// DraftFiles is a map of draft model files to include when creating the model.
-	DraftFiles map[string]string `json:"draft_files,omitempty"`
-
-	// Adapters is a map of LoRA adapters to include when creating the model.
-	Adapters map[string]string `json:"adapters,omitempty"`
-
-	// Template is the template used when constructing a request to the model.
-	Template string `json:"template,omitempty"`
-
-	// License is a string or list of strings for licenses.
-	License any `json:"license,omitempty"`
-
-	// System is the system prompt for the model.
-	System string `json:"system,omitempty"`
-
-	// Parameters is a map of hyper-parameters which are applied to the model.
-	Parameters map[string]any `json:"parameters,omitempty"`
-
-	// Messages is a list of messages added to the model before chat and generation requests.
-	Messages []Message `json:"messages,omitempty"`
-
-	Renderer string `json:"renderer,omitempty"`
-	Parser   string `json:"parser,omitempty"`
-
-	// Requires is the minimum version of Ollama required by the model.
-	Requires string `json:"requires,omitempty"`
-
-	// Info is a map of additional information for the model
-	Info map[string]any `json:"info,omitempty"`
-
-	// Deprecated: set the model name with Model instead
-	Name string `json:"name"`
-	// Deprecated: use Quantize instead
-	Quantization string `json:"quantization,omitempty"`
+	Name      string `json:"name"`
+	Path      string `json:"path"`
+	Modelfile string `json:"modelfile"`
+	Stream    *bool  `json:"stream,omitempty"`
 }
 
-// DeleteRequest is the request passed to [Client.Delete].
 type DeleteRequest struct {
-	Model string `json:"model"`
-
-	// Deprecated: set the model name with Model instead
 	Name string `json:"name"`
 }
 
-// ShowRequest is the request passed to [Client.Show].
 type ShowRequest struct {
-	Model  string `json:"model"`
-	System string `json:"system"`
-
-	// Template is deprecated
-	Template string `json:"template"`
-	Verbose  bool   `json:"verbose"`
-
-	Options map[string]any `json:"options"`
-
-	// Deprecated: set the model name with Model instead
 	Name string `json:"name"`
 }
 
-// ShowResponse is the response returned from [Client.Show].
 type ShowResponse struct {
-	License       string             `json:"license,omitempty"`
-	Modelfile     string             `json:"modelfile,omitempty"`
-	Parameters    string             `json:"parameters,omitempty"`
-	Template      string             `json:"template,omitempty"`
-	System        string             `json:"system,omitempty"`
-	Renderer      string             `json:"renderer,omitempty"`
-	Parser        string             `json:"parser,omitempty"`
-	Details       ModelDetails       `json:"details,omitempty"`
-	Messages      []Message          `json:"messages,omitempty"`
-	RemoteModel   string             `json:"remote_model,omitempty"`
-	RemoteHost    string             `json:"remote_host,omitempty"`
-	ModelInfo     map[string]any     `json:"model_info"`
-	ProjectorInfo map[string]any     `json:"projector_info,omitempty"`
-	Tensors       []Tensor           `json:"tensors,omitempty"`
-	Capabilities  []model.Capability `json:"capabilities,omitempty"`
-	ModifiedAt    time.Time          `json:"modified_at,omitempty"`
-	Requires      string             `json:"requires,omitempty"`
+	License    string `json:"license,omitempty"`
+	Modelfile  string `json:"modelfile,omitempty"`
+	Parameters string `json:"parameters,omitempty"`
+	Template   string `json:"template,omitempty"`
+	System     string `json:"system,omitempty"`
 }
 
-// CopyRequest is the request passed to [Client.Copy].
 type CopyRequest struct {
 	Source      string `json:"source"`
 	Destination string `json:"destination"`
 }
 
-// PullRequest is the request passed to [Client.Pull].
 type PullRequest struct {
-	Model    string `json:"model"`
-	Insecure bool   `json:"insecure,omitempty"` // Deprecated: ignored
-	Username string `json:"username"`           // Deprecated: ignored
-	Password string `json:"password"`           // Deprecated: ignored
+	Name     string `json:"name"`
+	Insecure bool   `json:"insecure,omitempty"`
+	Username string `json:"username"`
+	Password string `json:"password"`
 	Stream   *bool  `json:"stream,omitempty"`
-
-	// Deprecated: set the model name with Model instead
-	Name string `json:"name"`
 }
 
-// ProgressResponse is the response passed to progress functions like
-// [PullProgressFunc] and [PushProgressFunc].
 type ProgressResponse struct {
 	Status    string `json:"status"`
 	Digest    string `json:"digest,omitempty"`
@@ -792,229 +141,76 @@ type ProgressResponse struct {
 	Completed int64  `json:"completed,omitempty"`
 }
 
-// PushRequest is the request passed to [Client.Push].
 type PushRequest struct {
-	Model    string `json:"model"`
+	Name     string `json:"name"`
 	Insecure bool   `json:"insecure,omitempty"`
 	Username string `json:"username"`
 	Password string `json:"password"`
 	Stream   *bool  `json:"stream,omitempty"`
-
-	// Deprecated: set the model name with Model instead
-	Name string `json:"name"`
 }
 
-// ListResponse is the response from [Client.List].
 type ListResponse struct {
-	Models []ListModelResponse `json:"models"`
+	Models []ModelResponse `json:"models"`
 }
 
-// ModelRecommendationsResponse is the response from [Client.ModelRecommendationsExperimental].
-type ModelRecommendationsResponse struct {
-	Recommendations []ModelRecommendation `json:"recommendations"`
-}
-
-// ModelRecommendation is a single recommendation entry in [ModelRecommendationsResponse].
-type ModelRecommendation struct {
-	Model           string `json:"model"`
-	Description     string `json:"description"`
-	ContextLength   int    `json:"context_length,omitempty"`
-	MaxOutputTokens int    `json:"max_output_tokens,omitempty"`
-	VRAMBytes       int64  `json:"vram_bytes,omitempty"`
-	RequiredPlan    string `json:"required_plan,omitempty"`
-}
-
-// ProcessResponse is the response from [Client.Process].
-type ProcessResponse struct {
-	Models []ProcessModelResponse `json:"models"`
-}
-
-// ListModelResponse is a single model description in [ListResponse].
-type ListModelResponse struct {
-	Name         string             `json:"name"`
-	Model        string             `json:"model"`
-	RemoteModel  string             `json:"remote_model,omitempty"`
-	RemoteHost   string             `json:"remote_host,omitempty"`
-	ModifiedAt   time.Time          `json:"modified_at"`
-	Size         int64              `json:"size"`
-	Digest       string             `json:"digest"`
-	Details      ModelDetails       `json:"details,omitempty"`
-	Capabilities []model.Capability `json:"capabilities,omitempty"`
-}
-
-// ProcessModelResponse is a single model description in [ProcessResponse].
-type ProcessModelResponse struct {
-	Name          string       `json:"name"`
-	Model         string       `json:"model"`
-	Size          int64        `json:"size"`
-	Digest        string       `json:"digest"`
-	Details       ModelDetails `json:"details,omitempty"`
-	ExpiresAt     time.Time    `json:"expires_at"`
-	SizeVRAM      int64        `json:"size_vram"`
-	ContextLength int          `json:"context_length"`
+type ModelResponse struct {
+	Name       string    `json:"name"`
+	ModifiedAt time.Time `json:"modified_at"`
+	Size       int64     `json:"size"`
+	Digest     string    `json:"digest"`
 }
 
 type TokenResponse struct {
 	Token string `json:"token"`
 }
 
-type CloudStatus struct {
-	Disabled bool   `json:"disabled"`
-	Source   string `json:"source"`
-}
-
-// StatusResponse is the response from [Client.CloudStatusExperimental].
-type StatusResponse struct {
-	Cloud         CloudStatus `json:"cloud"`
-	ContextLength int         `json:"context_length,omitempty"`
-}
-
-// WebSearchRequest is the request for [Client.WebSearchExperimental].
-type WebSearchRequest struct {
-	Query      string `json:"query"`
-	MaxResults int    `json:"max_results,omitempty"`
-}
-
-// WebSearchResult is a single result from [Client.WebSearchExperimental].
-type WebSearchResult struct {
-	Title   string `json:"title"`
-	URL     string `json:"url"`
-	Content string `json:"content"`
-}
-
-// WebSearchResponse is the response from [Client.WebSearchExperimental].
-type WebSearchResponse struct {
-	Results []WebSearchResult `json:"results"`
-}
-
-// WebFetchRequest is the request for [Client.WebFetchExperimental].
-type WebFetchRequest struct {
-	URL string `json:"url"`
-}
-
-// WebFetchResponse is the response from [Client.WebFetchExperimental].
-type WebFetchResponse struct {
-	Title   string   `json:"title"`
-	Content string   `json:"content"`
-	Links   []string `json:"links,omitempty"`
-}
-
-// GenerateResponse is the response passed into [GenerateResponseFunc].
 type GenerateResponse struct {
-	// Model is the model name that generated the response.
-	Model string `json:"model"`
-
-	// RemoteModel is the name of the upstream model that generated the response.
-	RemoteModel string `json:"remote_model,omitempty"`
-
-	// RemoteHost is the URL of the upstream Ollama host that generated the response.
-	RemoteHost string `json:"remote_host,omitempty"`
-
-	// CreatedAt is the timestamp of the response.
+	Model     string    `json:"model"`
 	CreatedAt time.Time `json:"created_at"`
+	Response  string    `json:"response"`
 
-	// Response is the textual response itself.
-	Response string `json:"response"`
-
-	// Thinking contains the text that was inside thinking tags in the
-	// original model output when ChatRequest.Think is enabled.
-	Thinking string `json:"thinking,omitempty"`
-
-	// Done specifies if the response is complete.
-	Done bool `json:"done"`
-
-	// DoneReason is the reason the model stopped generating text.
-	DoneReason string `json:"done_reason,omitempty"`
-
-	// Context is an encoding of the conversation used in this response; this
-	// can be sent in the next request to keep a conversational memory.
+	Done    bool  `json:"done"`
 	Context []int `json:"context,omitempty"`
 
-	Metrics
-
-	ToolCalls []ToolCall `json:"tool_calls,omitempty"`
-
-	DebugInfo *DebugInfo `json:"_debug_info,omitempty"`
-
-	// Logprobs contains log probability information for the generated tokens,
-	// if requested via the Logprobs parameter.
-	Logprobs []Logprob `json:"logprobs,omitempty"`
-
-	// Experimental: Image generation fields (may change or be removed)
-
-	// Image contains a base64-encoded generated image.
-	// Only present for image generation models.
-	Image string `json:"image,omitempty"`
-
-	// Completed is the number of completed steps in image generation.
-	// Only present for image generation models during streaming.
-	Completed int64 `json:"completed,omitempty"`
-
-	// Total is the total number of steps for image generation.
-	// Only present for image generation models during streaming.
-	Total int64 `json:"total,omitempty"`
+	TotalDuration      time.Duration `json:"total_duration,omitempty"`
+	LoadDuration       time.Duration `json:"load_duration,omitempty"`
+	PromptEvalCount    int           `json:"prompt_eval_count,omitempty"`
+	PromptEvalDuration time.Duration `json:"prompt_eval_duration,omitempty"`
+	EvalCount          int           `json:"eval_count,omitempty"`
+	EvalDuration       time.Duration `json:"eval_duration,omitempty"`
 }
 
-// ModelDetails provides details about a model.
-type ModelDetails struct {
-	ParentModel       string   `json:"parent_model"`
-	Format            string   `json:"format"`
-	Family            string   `json:"family"`
-	Families          []string `json:"families"`
-	ParameterSize     string   `json:"parameter_size"`
-	QuantizationLevel string   `json:"quantization_level"`
-	ContextLength     int      `json:"context_length,omitempty"`
-	EmbeddingLength   int      `json:"embedding_length,omitempty"`
-}
-
-// UserResponse provides information about a user.
-type UserResponse struct {
-	ID        uuid.UUID `json:"id"`
-	Email     string    `json:"email"`
-	Name      string    `json:"name"`
-	Bio       string    `json:"bio,omitempty"`
-	AvatarURL string    `json:"avatarurl,omitempty"`
-	FirstName string    `json:"firstname,omitempty"`
-	LastName  string    `json:"lastname,omitempty"`
-	Plan      string    `json:"plan,omitempty"`
-}
-
-// Tensor describes the metadata for a given tensor.
-type Tensor struct {
-	Name  string   `json:"name"`
-	Type  string   `json:"type"`
-	Shape []uint64 `json:"shape"`
-}
-
-func (m *Metrics) Summary() {
-	if m.TotalDuration > 0 {
-		fmt.Fprintf(os.Stderr, "total duration:       %v\n", m.TotalDuration)
+func (r *GenerateResponse) Summary() {
+	if r.TotalDuration > 0 {
+		fmt.Fprintf(os.Stderr, "total duration:       %v\n", r.TotalDuration)
 	}
 
-	if m.LoadDuration > 0 {
-		fmt.Fprintf(os.Stderr, "load duration:        %v\n", m.LoadDuration)
+	if r.LoadDuration > 0 {
+		fmt.Fprintf(os.Stderr, "load duration:        %v\n", r.LoadDuration)
 	}
 
-	if m.PromptEvalCount > 0 {
-		fmt.Fprintf(os.Stderr, "prompt eval count:    %d token(s)\n", m.PromptEvalCount)
+	if r.PromptEvalCount > 0 {
+		fmt.Fprintf(os.Stderr, "prompt eval count:    %d token(s)\n", r.PromptEvalCount)
 	}
 
-	if m.PromptEvalDuration > 0 {
-		fmt.Fprintf(os.Stderr, "prompt eval duration: %s\n", m.PromptEvalDuration)
-		fmt.Fprintf(os.Stderr, "prompt eval rate:     %.2f tokens/s\n", float64(m.PromptEvalCount)/m.PromptEvalDuration.Seconds())
+	if r.PromptEvalDuration > 0 {
+		fmt.Fprintf(os.Stderr, "prompt eval duration: %s\n", r.PromptEvalDuration)
+		fmt.Fprintf(os.Stderr, "prompt eval rate:     %.2f tokens/s\n", float64(r.PromptEvalCount)/r.PromptEvalDuration.Seconds())
 	}
 
-	if m.EvalCount > 0 {
-		fmt.Fprintf(os.Stderr, "eval count:           %d token(s)\n", m.EvalCount)
+	if r.EvalCount > 0 {
+		fmt.Fprintf(os.Stderr, "eval count:           %d token(s)\n", r.EvalCount)
 	}
 
-	if m.EvalDuration > 0 {
-		fmt.Fprintf(os.Stderr, "eval duration:        %s\n", m.EvalDuration)
-		fmt.Fprintf(os.Stderr, "eval rate:            %.2f tokens/s\n", float64(m.EvalCount)/m.EvalDuration.Seconds())
+	if r.EvalDuration > 0 {
+		fmt.Fprintf(os.Stderr, "eval duration:        %s\n", r.EvalDuration)
+		fmt.Fprintf(os.Stderr, "eval rate:            %.2f tokens/s\n", float64(r.EvalCount)/r.EvalDuration.Seconds())
 	}
 }
 
-func (opts *Options) FromMap(m map[string]any) error {
+var ErrInvalidOpts = fmt.Errorf("invalid options")
+
+func (opts *Options) FromMap(m map[string]interface{}) error {
 	valueOpts := reflect.ValueOf(opts).Elem() // names of the fields in the options struct
 	typeOpts := reflect.TypeOf(opts).Elem()   // types of the fields in the options struct
 
@@ -1027,245 +223,119 @@ func (opts *Options) FromMap(m map[string]any) error {
 		}
 	}
 
+	invalidOpts := []string{}
 	for key, val := range m {
-		opt, ok := jsonOpts[key]
-		if !ok {
-			slog.Warn("invalid option provided", "option", key)
-			continue
-		}
+		if opt, ok := jsonOpts[key]; ok {
+			field := valueOpts.FieldByName(opt.Name)
+			if field.IsValid() && field.CanSet() {
+				if val == nil {
+					continue
+				}
 
-		field := valueOpts.FieldByName(opt.Name)
-		if field.IsValid() && field.CanSet() {
-			if val == nil {
-				continue
-			}
-
-			switch field.Kind() {
-			case reflect.Int:
-				switch t := val.(type) {
-				case int64:
-					field.SetInt(t)
-				case float64:
-					// when JSON unmarshals numbers, it uses float64, not int
-					field.SetInt(int64(t))
-				default:
-					return fmt.Errorf("option %q must be of type integer", key)
-				}
-			case reflect.Bool:
-				val, ok := val.(bool)
-				if !ok {
-					return fmt.Errorf("option %q must be of type boolean", key)
-				}
-				field.SetBool(val)
-			case reflect.Float32:
-				// JSON unmarshals to float64
-				val, ok := val.(float64)
-				if !ok {
-					return fmt.Errorf("option %q must be of type float32", key)
-				}
-				field.SetFloat(val)
-			case reflect.String:
-				val, ok := val.(string)
-				if !ok {
-					return fmt.Errorf("option %q must be of type string", key)
-				}
-				field.SetString(val)
-			case reflect.Slice:
-				// JSON unmarshals to []any, not []string
-				val, ok := val.([]any)
-				if !ok {
-					return fmt.Errorf("option %q must be of type array", key)
-				}
-				// convert []any to []string
-				slice := make([]string, len(val))
-				for i, item := range val {
-					str, ok := item.(string)
-					if !ok {
-						return fmt.Errorf("option %q must be of an array of strings", key)
+				switch field.Kind() {
+				case reflect.Int:
+					switch t := val.(type) {
+					case int64:
+						field.SetInt(t)
+					case float64:
+						// when JSON unmarshals numbers, it uses float64, not int
+						field.SetInt(int64(t))
+					default:
+						return fmt.Errorf("option %q must be of type integer", key)
 					}
-					slice[i] = str
-				}
-				field.Set(reflect.ValueOf(slice))
-			case reflect.Pointer:
-				switch field.Type().Elem().Kind() {
 				case reflect.Bool:
 					val, ok := val.(bool)
 					if !ok {
 						return fmt.Errorf("option %q must be of type boolean", key)
 					}
-					field.Set(reflect.ValueOf(&val))
-				case reflect.Int:
-					var i int
-					switch t := val.(type) {
-					case int64:
-						i = int(t)
-					case float64:
-						i = int(t)
-					default:
-						return fmt.Errorf("option %q must be of type integer", key)
+					field.SetBool(val)
+				case reflect.Float32:
+					// JSON unmarshals to float64
+					val, ok := val.(float64)
+					if !ok {
+						return fmt.Errorf("option %q must be of type float32", key)
 					}
-					field.Set(reflect.ValueOf(&i))
+					field.SetFloat(val)
+				case reflect.String:
+					val, ok := val.(string)
+					if !ok {
+						return fmt.Errorf("option %q must be of type string", key)
+					}
+					field.SetString(val)
+				case reflect.Slice:
+					// JSON unmarshals to []interface{}, not []string
+					val, ok := val.([]interface{})
+					if !ok {
+						return fmt.Errorf("option %q must be of type array", key)
+					}
+					// convert []interface{} to []string
+					slice := make([]string, len(val))
+					for i, item := range val {
+						str, ok := item.(string)
+						if !ok {
+							return fmt.Errorf("option %q must be of an array of strings", key)
+						}
+						slice[i] = str
+					}
+					field.Set(reflect.ValueOf(slice))
 				default:
-					return fmt.Errorf("unknown type loading config params: %v %v", field.Kind(), field.Type())
+					return fmt.Errorf("unknown type loading config params: %v", field.Kind())
 				}
-			default:
-				return fmt.Errorf("unknown type loading config params: %v", field.Kind())
 			}
+		} else {
+			invalidOpts = append(invalidOpts, key)
 		}
 	}
 
+	if len(invalidOpts) > 0 {
+		return fmt.Errorf("%w: %v", ErrInvalidOpts, strings.Join(invalidOpts, ", "))
+	}
 	return nil
 }
 
-// DefaultOptions is the default set of options for [GenerateRequest]; these
-// values are used unless the user specifies other values explicitly.
 func DefaultOptions() Options {
 	return Options{
 		// options set on request to runner
-		NumPredict: -1,
-
-		// set a minimal num_keep to avoid issues on context shifts
-		NumKeep:          4,
+		NumPredict:       -1,
+		NumKeep:          0,
 		Temperature:      0.8,
 		TopK:             40,
 		TopP:             0.9,
+		TFSZ:             1.0,
 		TypicalP:         1.0,
 		RepeatLastN:      64,
 		RepeatPenalty:    1.1,
 		PresencePenalty:  0.0,
 		FrequencyPenalty: 0.0,
+		Mirostat:         0,
+		MirostatTau:      5.0,
+		MirostatEta:      0.1,
+		PenalizeNewline:  true,
 		Seed:             -1,
 
 		Runner: Runner{
 			// options set when the model is loaded
-			NumCtx:          int(envconfig.ContextLength()),
-			NumBatch:        512,
-			NumGPU:          -1, // -1 here indicates that NumGPU should be set dynamically
-			NumThread:       0,  // let the runtime decide
-			DraftNumPredict: 4,
-			UseMMap:         nil,
+			NumCtx:             2048,
+			RopeFrequencyBase:  10000.0,
+			RopeFrequencyScale: 1.0,
+			NumBatch:           512,
+			NumGPU:             -1, // -1 here indicates that NumGPU should be set dynamically
+			NumGQA:             1,
+			NumThread:          0, // let the runtime decide
+			LowVRAM:            false,
+			F16KV:              true,
+			UseMLock:           false,
+			UseMMap:            true,
+			UseNUMA:            false,
+			EmbeddingOnly:      true,
 		},
 	}
 }
 
-// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low", "max")
-type ThinkValue struct {
-	// Value can be a bool or string
-	Value interface{}
-}
-
-// IsValid checks if the ThinkValue is valid
-func (t *ThinkValue) IsValid() bool {
-	if t == nil || t.Value == nil {
-		return true // nil is valid (means not set)
-	}
-
-	switch v := t.Value.(type) {
-	case bool:
-		return true
-	case string:
-		return v == "high" || v == "medium" || v == "low" || v == "max"
-	default:
-		return false
-	}
-}
-
-// IsBool returns true if the value is a boolean
-func (t *ThinkValue) IsBool() bool {
-	if t == nil || t.Value == nil {
-		return false
-	}
-	_, ok := t.Value.(bool)
-	return ok
-}
-
-// IsString returns true if the value is a string
-func (t *ThinkValue) IsString() bool {
-	if t == nil || t.Value == nil {
-		return false
-	}
-	_, ok := t.Value.(string)
-	return ok
-}
-
-// Bool returns the value as a bool (true if enabled in any way)
-func (t *ThinkValue) Bool() bool {
-	if t == nil || t.Value == nil {
-		return false
-	}
-
-	switch v := t.Value.(type) {
-	case bool:
-		return v
-	case string:
-		// Any string value ("high", "medium", "low", "max") means thinking is enabled
-		return v == "high" || v == "medium" || v == "low" || v == "max"
-	default:
-		return false
-	}
-}
-
-// String returns the value as a string
-func (t *ThinkValue) String() string {
-	if t == nil || t.Value == nil {
-		return ""
-	}
-
-	switch v := t.Value.(type) {
-	case string:
-		return v
-	case bool:
-		if v {
-			return "medium" // Default level when just true
-		}
-		return ""
-	default:
-		return ""
-	}
-}
-
-// UnmarshalJSON implements json.Unmarshaler
-func (t *ThinkValue) UnmarshalJSON(data []byte) error {
-	// Try to unmarshal as bool first
-	var b bool
-	if err := json.Unmarshal(data, &b); err == nil {
-		t.Value = b
-		return nil
-	}
-
-	// Try to unmarshal as string
-	var s string
-	if err := json.Unmarshal(data, &s); err == nil {
-		// Validate string values
-		if s != "high" && s != "medium" && s != "low" && s != "max" {
-			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", \"max\", true, or false)", s)
-		}
-		t.Value = s
-		return nil
-	}
-
-	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", \"max\", true, or false)")
-}
-
-// MarshalJSON implements json.Marshaler
-func (t *ThinkValue) MarshalJSON() ([]byte, error) {
-	if t == nil || t.Value == nil {
-		return []byte("null"), nil
-	}
-	return json.Marshal(t.Value)
-}
-
 type Duration struct {
 	time.Duration
 }
 
-func (d Duration) MarshalJSON() ([]byte, error) {
-	if d.Duration < 0 {
-		return []byte("-1"), nil
-	}
-	return []byte("\"" + d.Duration.String() + "\""), nil
-}
-
 func (d *Duration) UnmarshalJSON(b []byte) (err error) {
 	var v any
 	if err := json.Unmarshal(b, &v); err != nil {
@@ -1277,98 +347,16 @@ func (d *Duration) UnmarshalJSON(b []byte) (err error) {
 	switch t := v.(type) {
 	case float64:
 		if t < 0 {
-			d.Duration = time.Duration(math.MaxInt64)
-		} else {
-			d.Duration = time.Duration(t * float64(time.Second))
+			t = math.MaxFloat64
 		}
+
+		d.Duration = time.Duration(t)
 	case string:
 		d.Duration, err = time.ParseDuration(t)
 		if err != nil {
 			return err
 		}
-		if d.Duration < 0 {
-			d.Duration = time.Duration(math.MaxInt64)
-		}
-	default:
-		return fmt.Errorf("Unsupported type: '%s'", reflect.TypeOf(v))
 	}
 
 	return nil
 }
-
-// FormatParams converts specified parameter options to their correct types
-func FormatParams(params map[string][]string) (map[string]any, error) {
-	opts := Options{}
-	valueOpts := reflect.ValueOf(&opts).Elem() // names of the fields in the options struct
-	typeOpts := reflect.TypeOf(opts)           // types of the fields in the options struct
-
-	// build map of json struct tags to their types
-	jsonOpts := make(map[string]reflect.StructField)
-	for _, field := range reflect.VisibleFields(typeOpts) {
-		jsonTag := strings.Split(field.Tag.Get("json"), ",")[0]
-		if jsonTag != "" {
-			jsonOpts[jsonTag] = field
-		}
-	}
-
-	out := make(map[string]any)
-	// iterate params and set values based on json struct tags
-	for key, vals := range params {
-		if opt, ok := jsonOpts[key]; !ok {
-			return nil, fmt.Errorf("unknown parameter '%s'", key)
-		} else {
-			field := valueOpts.FieldByName(opt.Name)
-			if field.IsValid() && field.CanSet() {
-				switch field.Kind() {
-				case reflect.Float32:
-					floatVal, err := strconv.ParseFloat(vals[0], 32)
-					if err != nil {
-						return nil, fmt.Errorf("invalid float value %s", vals)
-					}
-
-					out[key] = float32(floatVal)
-				case reflect.Int:
-					intVal, err := strconv.ParseInt(vals[0], 10, 64)
-					if err != nil {
-						return nil, fmt.Errorf("invalid int value %s", vals)
-					}
-
-					out[key] = intVal
-				case reflect.Bool:
-					boolVal, err := strconv.ParseBool(vals[0])
-					if err != nil {
-						return nil, fmt.Errorf("invalid bool value %s", vals)
-					}
-
-					out[key] = boolVal
-				case reflect.String:
-					out[key] = vals[0]
-				case reflect.Slice:
-					// TODO: only string slices are supported right now
-					out[key] = vals
-				case reflect.Pointer:
-					switch field.Type().Elem().Kind() {
-					case reflect.Bool:
-						boolVal, err := strconv.ParseBool(vals[0])
-						if err != nil {
-							return nil, fmt.Errorf("invalid bool value %s", vals)
-						}
-						out[key] = &boolVal
-					case reflect.Int:
-						intVal, err := strconv.ParseInt(vals[0], 10, 64)
-						if err != nil {
-							return nil, fmt.Errorf("invalid int value %s", vals)
-						}
-						out[key] = intVal
-					default:
-						return nil, fmt.Errorf("unknown type %s for %s", field.Kind(), key)
-					}
-				default:
-					return nil, fmt.Errorf("unknown type %s for %s", field.Kind(), key)
-				}
-			}
-		}
-	}
-
-	return out, nil
-}

api/types_test.go

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

api/types_typescript_test.go

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

app/.eslintrc.json

@@ -0,0 +1,16 @@
+{
+  "env": {
+    "browser": true,
+    "es6": true,
+    "node": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:import/recommended",
+    "plugin:import/electron",
+    "plugin:import/typescript"
+  ],
+  "parser": "@typescript-eslint/parser"
+}

app/.gitignore

@@ -1,11 +1,92 @@
-ollama.syso
-*.crt
-*.exe
-/app/app
-/app/squirrel
-ollama
-*cover*
-.vscode
-.env
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
 .DS_Store
-.claude
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Webpack
+.webpack/
+
+# Vite
+.vite/
+
+# Electron-Forge
+out/

app/README.md

@@ -1,97 +1,21 @@
-# Ollama for macOS and Windows
+# Desktop
 
-## Download
+This app builds upon Ollama to provide a desktop experience for running models.
 
-- [macOS](https://github.com/ollama/app/releases/download/latest/Ollama.dmg)
-- [Windows](https://github.com/ollama/app/releases/download/latest/OllamaSetup.exe)
+## Developing
 
-## Development
+First, build the `ollama` binary:
 
-### Desktop App
-
-```bash
-go generate ./... &&
-go run ./cmd/app
+```
+cd ..
+go build .
 ```
 
-### UI Development
+Then run the desktop app with `npm start`:
 
-#### 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
+cd app
 npm install
-npm run dev
+npm start
 ```
 
-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
-
-- 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:
-
-```
-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
-```

app/assets/assets.go

@@ -1,19 +0,0 @@
-//go:build windows || darwin
-
-package assets
-
-import (
-	"embed"
-	"io/fs"
-)
-
-//go:embed *.ico
-var icons embed.FS
-
-func ListIcons() ([]string, error) {
-	return fs.Glob(icons, "*")
-}
-
-func GetIcon(filename string) ([]byte, error) {
-	return icons.ReadFile(filename)
-}

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_darwin.m

@@ -1,1131 +0,0 @@
-#import "app_darwin.h"
-#import "menu.h"
-#import "../../updater/updater_darwin.h"
-#import <AppKit/AppKit.h>
-#import <Cocoa/Cocoa.h>
-#import <CoreServices/CoreServices.h>
-#import <Security/Security.h>
-#import <ServiceManagement/ServiceManagement.h>
-#import <WebKit/WebKit.h>
-#import <objc/runtime.h>
-
-extern NSString *SystemWidePath;
-
-@interface AppDelegate () <NSWindowDelegate, WKNavigationDelegate, WKUIDelegate>
-@property(strong, nonatomic) NSStatusItem *statusItem;
-@property(assign, nonatomic) BOOL updateAvailable;
-@property(assign, nonatomic) BOOL systemShutdownInProgress;
-@end
-
-@implementation AppDelegate
-
-bool firstTimeRun,startHidden; // Set in run before initialization
-
-- (void)application:(NSApplication *)application openURLs:(NSArray<NSURL *> *)urls {
-    for (NSURL *url in urls) {
-        if ([url.scheme isEqualToString:@"ollama"]) {
-            NSString *path = url.path;
-
-            if (path && ([path isEqualToString:@"/connect"] || [url.host isEqualToString:@"connect"])) {
-                // Special case: handle connect by opening browser instead of app
-                handleConnectURL();
-            } else {
-                // Set app to be active and visible
-                [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
-                [NSApp activateIgnoringOtherApps:YES];
-            }
-            
-            break;
-        }
-    }
-}
-
-- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
-    // Register for system shutdown/restart notification so we can allow termination
-    [[[NSWorkspace sharedWorkspace] notificationCenter]
-        addObserver:self
-           selector:@selector(systemWillPowerOff:)
-               name:NSWorkspaceWillPowerOffNotification
-             object:nil];
-
-    // if we're in development mode, set the app icon
-    NSString *bundlePath = [[NSBundle mainBundle] bundlePath];
-    if (![bundlePath hasSuffix:@".app"]) {
-        NSString *cwdPath =
-            [[NSFileManager defaultManager] currentDirectoryPath];
-        NSString *iconPath = [cwdPath
-            stringByAppendingPathComponent:
-                [NSString
-                    stringWithFormat:
-                        @"darwin/Ollama.app/Contents/Resources/icon.icns"]];
-        NSImage *customIcon = [[NSImage alloc] initWithContentsOfFile:iconPath];
-        [NSApp setApplicationIconImage:customIcon];
-    }
-
-    // Create status item and menu
-    NSMenu *menu = [[NSMenu alloc] init];
-    NSMenuItem *openMenuItem =
-        [[NSMenuItem alloc] initWithTitle:@"Open Ollama"
-                                   action:@selector(openUI)
-                            keyEquivalent:@""];
-    [openMenuItem setTarget:self];
-    [menu addItem:openMenuItem];
-
-    [menu addItemWithTitle:@"Settings..."
-                    action:@selector(settingsUI)
-             keyEquivalent:@","];
-    [menu addItem:[NSMenuItem separatorItem]];
-
-    NSMenuItem *updateAvailable =
-        [[NSMenuItem alloc] initWithTitle:@"An update is available"
-                                   action:nil
-                            keyEquivalent:@""];
-    [updateAvailable setEnabled:NO];
-    [updateAvailable setHidden:YES];
-    [menu addItem:updateAvailable];
-
-    NSMenuItem *restartMenuItem =
-        [[NSMenuItem alloc] initWithTitle:@"Restart to update"
-                                   action:@selector(startUpdate)
-                            keyEquivalent:@""];
-    [restartMenuItem setTarget:self];
-    [restartMenuItem setHidden:YES];
-    [menu addItem:restartMenuItem];
-
-    [menu addItem:[NSMenuItem separatorItem]];
-
-    [menu addItemWithTitle:@"Quit Ollama"
-                    action:@selector(quit)
-             keyEquivalent:@"q"];
-
-    self.statusItem = [[NSStatusBar systemStatusBar]
-        statusItemWithLength:NSVariableStatusItemLength];
-    [self.statusItem addObserver:self
-                      forKeyPath:@"button.effectiveAppearance"
-                         options:NSKeyValueObservingOptionNew |
-                                 NSKeyValueObservingOptionInitial
-                         context:nil];
-
-    self.statusItem.menu = menu;
-    [self showIcon];
-
-    // Application menu
-    NSString *appName = @"Ollama";
-
-    NSMenu *mainMenu = [[NSMenu alloc] init];
-    NSMenuItem *appMenuItem = [[NSMenuItem alloc] initWithTitle:appName
-                                                        action:nil
-                                                 keyEquivalent:@""];
-    NSMenu *appMenu = [[NSMenu alloc] initWithTitle:appName];
-    [appMenuItem setSubmenu:appMenu];
-    [mainMenu addItem:appMenuItem];
-
-    [appMenu addItemWithTitle:[NSString stringWithFormat:@"About %@", appName]
-                       action:@selector(aboutOllama)
-                keyEquivalent:@""];
-    [appMenu addItem:[NSMenuItem separatorItem]];
-    [appMenu addItemWithTitle:@"Settings..."
-                    action:@selector(settingsUI)
-                keyEquivalent:@","];
-    [appMenu addItem:[NSMenuItem separatorItem]];
-    [appMenu addItemWithTitle:[NSString stringWithFormat:@"Hide %@", appName]
-                       action:@selector(hide:)
-                keyEquivalent:@"h"];
-
-    NSMenuItem *hideOthers = [[NSMenuItem alloc] initWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
-    hideOthers.keyEquivalentModifierMask = NSEventModifierFlagOption | NSEventModifierFlagCommand;
-    [appMenu addItem:hideOthers];
-    [appMenu addItemWithTitle:@"Show All"
-                       action:@selector(unhideAllApplications:)
-                keyEquivalent:@""];
-    [appMenu addItem:[NSMenuItem separatorItem]];
-    [appMenu addItemWithTitle:[NSString stringWithFormat:@"Quit %@", appName]
-                       action:@selector(hide)
-                keyEquivalent:@"q"];
-
-    NSMenuItem *fileMenuItem = [[NSMenuItem alloc] init];
-    NSMenu *fileMenu        = [[NSMenu alloc] initWithTitle:@"File"];
-
-    NSMenuItem *newChatItem = [[NSMenuItem alloc] initWithTitle:@"New Chat"
-                                                    action:@selector(newChat)
-                                                keyEquivalent:@"n"];
-    [newChatItem setTarget:self];
-    [fileMenu addItem:newChatItem];
-    [fileMenu addItem:[NSMenuItem separatorItem]];
-
-    NSMenuItem *closeItem = [[NSMenuItem alloc] initWithTitle:@"Close Window" action:@selector(hide:) keyEquivalent:@"w"];
-    [fileMenu addItem:closeItem];
-    [fileMenuItem setSubmenu:fileMenu];
-    [mainMenu addItem:fileMenuItem];
-
-    NSMenuItem *editMenuItem = [[NSMenuItem alloc] init];
-    NSMenu *editMenu = [[NSMenu alloc] initWithTitle:@"Edit"];
-
-    [editMenu addItemWithTitle:@"Undo"
-                        action:@selector(undo:)
-                 keyEquivalent:@"z"];
-    [editMenu addItemWithTitle:@"Redo"
-                        action:@selector(redo:)
-                 keyEquivalent:@"Z"];
-    [editMenu addItem:[NSMenuItem separatorItem]];
-    [editMenu addItemWithTitle:@"Cut"
-                        action:@selector(cut:)
-                 keyEquivalent:@"x"];
-    [editMenu addItemWithTitle:@"Copy"
-                        action:@selector(copy:)
-                 keyEquivalent:@"c"];
-    [editMenu addItemWithTitle:@"Paste"
-                        action:@selector(paste:)
-                 keyEquivalent:@"v"];
-    [editMenu addItemWithTitle:@"Select All"
-                        action:@selector(selectAll:)
-                 keyEquivalent:@"a"];
-
-    [editMenuItem setSubmenu:editMenu];
-    [mainMenu addItem:editMenuItem];
-
-    NSMenuItem *windowMenuItem = [[NSMenuItem alloc] init];
-    NSMenu *windowMenu         = [[NSMenu alloc] initWithTitle:@"Window"];
-    [windowMenu addItemWithTitle:@"Minimize"
-                          action:@selector(performMiniaturize:)
-                   keyEquivalent:@"m"];
-    [windowMenu addItemWithTitle:@"Zoom"
-                          action:@selector(performZoom:)
-                   keyEquivalent:@""];
-    [windowMenu addItem:[NSMenuItem separatorItem]];
-    [windowMenu addItemWithTitle:@"Bring All to Front"
-                          action:@selector(arrangeInFront:)
-                   keyEquivalent:@""];
-    [windowMenuItem setSubmenu:windowMenu];
-    [mainMenu addItem:windowMenuItem];
-    [NSApp setWindowsMenu:windowMenu];
-
-    NSMenuItem *helpMenuItem = [[NSMenuItem alloc] init];
-    NSMenu *helpMenu         = [[NSMenu alloc] initWithTitle:@"Help"];
-    [helpMenu addItemWithTitle:[NSString stringWithFormat:@"%@ Help", appName]
-                        action:@selector(openHelp:)
-                 keyEquivalent:@"?"];
-    [helpMenuItem setSubmenu:helpMenu];
-    [mainMenu addItem:helpMenuItem];
-    [NSApp setHelpMenu:helpMenu];
-    [NSApp setMainMenu:mainMenu];
-
-    BOOL hidden = [NSApp isHidden];
-    dispatch_async(dispatch_get_main_queue(), ^{
-        if (hidden || startHidden) {
-            darwinStartHiddenTasks();
-        } else {
-            if (!startHidden) {
-                StartUI("/");
-            }
-        }
-    });
-}
-
-- (void)applicationDidBecomeActive:(NSNotification *)notification {
-    NSRunningApplication *currentApp = [NSRunningApplication currentApplication];
-    if (currentApp.activationPolicy == NSApplicationActivationPolicyAccessory) {
-        for (NSWindow *window in [NSApp windows]) {
-            if ([window isVisible]) {
-                // Switch to regular activation policy since we have a visible window
-                [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
-                return;
-            }
-        }
-        [NSApp hide:nil];
-        return;
-    }
-}
-
-- (BOOL)applicationShouldHandleReopen:(NSApplication *)sender hasVisibleWindows:(BOOL)hasVisibleWindows {
-    [self openUI];
-    return YES;
-}
-
-- (void)showUpdateAvailable {
-    self.updateAvailable = YES;
-    [self.statusItem.menu.itemArray[3] setHidden:NO];
-    [self.statusItem.menu.itemArray[4] setHidden:NO];
-    [self showIcon];
-}
-
-- (void)aboutOllama {
-    [[NSApplication sharedApplication] orderFrontStandardAboutPanel:nil];
-    [NSApp activateIgnoringOtherApps:YES];
-}
-
-- (void)openHelp:(id)sender {
-    NSURL *url = [NSURL URLWithString:@"https://docs.ollama.com/"];
-    [[NSWorkspace sharedWorkspace] openURL:url];
-}
-
-- (void)settingsUI {
-    [self uiRequest:@"/settings"];
-}
-
-- (void)openUI {
-    ShowUI();
-}
-
-- (void)newChat {
-    [self uiRequest:@"/c/new"];
-}
-
-- (void)uiRequest:(NSString *)path {
-    if (path == nil) {
-        appLogInfo(@"app UI request for URL is missing");
-    }
-
-    appLogInfo([NSString
-        stringWithFormat:@"XXX got app UI request for URL: %@", path]);
-    StartUI([path UTF8String]);
-}
-
-- (void)startUpdate {
-    StartUpdate();
-    [NSApp activateIgnoringOtherApps:YES];
-}
-
-- (void)systemWillPowerOff:(NSNotification *)notification {
-    // Set flag so applicationShouldTerminate: knows to allow termination.
-    // The system will call applicationShouldTerminate: after posting this notification.
-    self.systemShutdownInProgress = YES;
-}
-
-- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender {
-    // Allow termination if the system is shutting down or restarting
-    if (self.systemShutdownInProgress) {
-        return NSTerminateNow;
-    }
-    // Otherwise just hide the app (for Cmd+Q, close button, etc.)
-    [NSApp hide:nil];
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
-    return NSTerminateCancel;
-}
-
-- (IBAction)terminate:(id)sender {
-    [NSApp hide:nil];
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
-}
-
-- (BOOL)windowShouldClose:(id)sender {
-    [NSApp hide:nil];
-    return NO;
-}
-
-- (void)showIcon {
-    NSAppearance *appearance = self.statusItem.button.effectiveAppearance;
-    NSString *appearanceName = (NSString *)(appearance.name);
-    NSString *iconName = @"ollama";
-    if (self.updateAvailable) {
-        iconName = [iconName stringByAppendingString:@"Update"];
-    }
-    if ([appearanceName containsString:@"Dark"]) {
-        iconName = [iconName stringByAppendingString:@"Dark"];
-    }
-
-    NSImage *statusImage;
-    NSBundle *bundle = [NSBundle mainBundle];
-    if (![bundle.bundlePath hasSuffix:@".app"]) {
-        NSString *cwdPath =
-            [[NSFileManager defaultManager] currentDirectoryPath];
-        NSString *bundlePath =
-            [cwdPath stringByAppendingPathComponent:
-                         [NSString stringWithFormat:@"darwin/Ollama.app"]];
-        bundle = [NSBundle bundleWithPath:bundlePath];
-    }
-
-    statusImage = [bundle imageForResource:iconName];
-    [statusImage setTemplate:YES];
-    self.statusItem.button.image = statusImage;
-}
-
-- (void)observeValueForKeyPath:(NSString *)keyPath
-                      ofObject:(id)object
-                        change:(NSDictionary<NSKeyValueChangeKey, id> *)change
-                       context:(void *)context {
-    [self showIcon];
-}
-
-- (void)hide {
-    [NSApp hide:nil];
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
-}
-
-- (void)quit {
-    [NSApp stop:self];
-    [NSApp postEvent:[NSEvent otherEventWithType:NSEventTypeApplicationDefined
-                                        location:NSZeroPoint
-                                   modifierFlags:0
-                                       timestamp:0
-                                    windowNumber:0
-                                         context:nil
-                                         subtype:0
-                                           data1:0
-                                           data2:0]
-             atStart:YES];
-}
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-- (void)registerSelfAsLoginItem:(BOOL)firstTimeRun {
-    appLogInfo(@"using v13+ SMAppService for login registration");
-    // Maps to the file Ollama.app/Contents/Library/LaunchAgents/com.ollama.ollama.plist
-    SMAppService* service = [SMAppService agentServiceWithPlistName:@"com.ollama.ollama.plist"];
-    if (!service) {
-        appLogInfo(@"SMAppService failed to find service for com.ollama.ollama.plist");
-        return;
-    }
-    SMAppServiceStatus status = [service status];
-    switch (status) {
-        case SMAppServiceStatusNotRegistered:
-            appLogInfo(@"service not registered, registering now");
-            break;
-        case SMAppServiceStatusEnabled:
-            appLogInfo(@"service is already enabled, no need to register again");
-            return;
-        case SMAppServiceStatusRequiresApproval: 
-            // User has disabled our login behavior explicitly so leave it as is
-            appLogInfo(@"service is currently disabled and will not start at login");
-            return;
-        case SMAppServiceStatusNotFound:
-            appLogInfo(@"service not found, registering now");
-            break;
-        default:
-            appLogInfo([NSString stringWithFormat:@"unexpected status: %ld", (long)status]);
-            break;
-    }
-    NSError *error = nil;
-    if (![service registerAndReturnError:&error]) {
-        appLogInfo([NSString stringWithFormat:@"Failed to register %@ as a login item: %@", NSBundle.mainBundle.bundleURL, error]);
-        return;
-    }
-    return;
-}
-
-/// Remove ollama from the deprecated Login Items list as we now use LaunchAgents
-- (void)unregisterSelfFromLoginItem {
-    NSURL *bundleURL = NSBundle.mainBundle.bundleURL;
-    NSString *bundlePrefix = [SystemWidePath stringByDeletingPathExtension];
-
-    LSSharedFileListRef loginItems =
-        LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
-    if (!loginItems) {
-        return;
-    }
-
-    UInt32 seed;
-    CFArrayRef currentItems = LSSharedFileListCopySnapshot(loginItems, &seed);
-
-    for (id item in (__bridge NSArray *)currentItems) {
-        CFURLRef itemURL = NULL;
-        if (LSSharedFileListItemResolve((LSSharedFileListItemRef)item, 0,
-                                        &itemURL, NULL) == noErr) {
-            CFStringRef loginPath = CFURLCopyFileSystemPath(itemURL, kCFURLPOSIXPathStyle);
-            // Compare the prefix to match against "keep existing" flow, e.g. // "/Applications/Ollama.app" vs "/Applications/Ollama 2.app"
-            if (loginPath && [(NSString *)loginPath hasPrefix:bundlePrefix]) {
-                appLogInfo([NSString stringWithFormat:@"removing login item %@", loginPath]);
-                LSSharedFileListItemRemove(loginItems,
-                                           (LSSharedFileListItemRef)item);
-            }
-            if (itemURL) {
-                CFRelease(itemURL);
-            }
-        } else if (!itemURL) {
-            // If the user has removed the App that has a current login item, we can't use
-            // LSSharedFileListItemResolve to get the file path, since it doesn't "resolve"
-            CFStringRef displayName = LSSharedFileListItemCopyDisplayName((LSSharedFileListItemRef)item);
-            if (displayName) {
-                NSString *name = (__bridge NSString *)displayName;
-                if ([name hasPrefix:@"Ollama"]) {
-                    LSSharedFileListItemRemove(loginItems, (LSSharedFileListItemRef)item);
-                    appLogInfo([NSString stringWithFormat:@"removing dangling login item %@", displayName]);
-                }
-                CFRelease(displayName);
-            }
-        }
-    }
-    if (currentItems) {
-        CFRelease(currentItems);
-    }
-    CFRelease(loginItems);
-}
-#pragma clang diagnostic pop
-
-- (void)windowWillEnterFullScreen:(NSNotification *)notification {
-    NSWindow *w = notification.object;
-    if (w.toolbar != nil) {
-        [w.toolbar setVisible:NO];            // hide the (empty) toolbar
-    }
-}
-
-- (void)windowDidExitFullScreen:(NSNotification *)notification {
-    NSWindow *w = notification.object;
-    if (w.toolbar != nil) {
-        [w.toolbar setVisible:YES];           // show it again
-    }
-}
-
-- (void)      webView:(WKWebView *)webView
-decidePolicyForNavigationAction:(WKNavigationAction *)action
-        decisionHandler:(void (^)(WKNavigationActionPolicy))handler
-{
-    NSURL *url = action.request.URL;
-    if (action.navigationType == WKNavigationTypeLinkActivated) {
-        NSString *host = [url.host lowercaseString];
-        if ([host isEqualToString:@"localhost"] ||
-            [host isEqualToString:@"127.0.0.1"]) {
-            handler(WKNavigationActionPolicyCancel);
-            NSString *path = url.path;
-            if (path.length == 0) {
-                path = @"/";
-            }
-            [self uiRequest:path];
-            return;
-        }
-
-        [[NSWorkspace sharedWorkspace] openURL:url];
-        handler(WKNavigationActionPolicyCancel);
-        return;
-    }
-    handler(WKNavigationActionPolicyAllow);
-}
-
-- (nullable WKWebView *)webView:(WKWebView *)webView
-   createWebViewWithConfiguration:(WKWebViewConfiguration *)configuration
-             forNavigationAction:(WKNavigationAction *)action
-                  windowFeatures:(WKWindowFeatures *)features
-{
-    // "Open Link in New Window" (or target="_blank") ends up here.
-    NSURL *url = action.request.URL;
-    if (url) {
-        NSString *host = [url.host lowercaseString];
-        if ([host isEqualToString:@"localhost"] ||
-            [host isEqualToString:@"127.0.0.1"]) {
-            return nil;
-        }
-        [[NSWorkspace sharedWorkspace] openURL:url];
-    }
-    return nil;
-}
-
-// TODO (jmorganca): the confirm button is always "Confirm"
-// it should be customizable in the future
-- (void)webView:(WKWebView *)webView
-    runJavaScriptConfirmPanelWithMessage:(NSString *)message
-    initiatedByFrame:(WKFrameInfo *)frame
-    completionHandler:(void (^)(BOOL))completionHandler {
-
-    NSAlert *alert = [[NSAlert alloc] init];
-    [alert setMessageText:message];
-    [alert addButtonWithTitle:@"Confirm"];
-    [alert addButtonWithTitle:@"Cancel"];
-
-    completionHandler([alert runModal] == NSAlertFirstButtonReturn);
-}
-
-// HACK (jmorganca): remove the "Copy Link with Highlight" item from the context menu by
-// swizzling the WKWebView's willOpenMenu:withEvent: method. In the future we should probably
-// subclass the WKWebView and override the context menu items, but this is a quick fix for now.
-+ (void)load {
-    static dispatch_once_t onceToken;
-    dispatch_once(&onceToken, ^{
-        [self swizzleWKWebViewContextMenu];
-    });
-}
-
-+ (void)swizzleWKWebViewContextMenu {
-    Class class = [WKWebView class];
-
-    SEL originalSelector = @selector(willOpenMenu:withEvent:);
-    SEL swizzledSelector = @selector(ollama_willOpenMenu:withEvent:);
-
-    Method originalMethod = class_getInstanceMethod(class, originalSelector);
-    Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
-    BOOL didAddMethod = class_addMethod(class, originalSelector,
-                                       method_getImplementation(swizzledMethod),
-                                       method_getTypeEncoding(swizzledMethod));
-
-    if (didAddMethod) {
-        class_replaceMethod(class,
-                           swizzledSelector,
-                           method_getImplementation(originalMethod),
-                           method_getTypeEncoding(originalMethod));
-    } else {
-        method_exchangeImplementations(originalMethod, swizzledMethod);
-    }
-}
-
-@end
-
-@implementation WKWebView (OllamaContextMenu)
-- (void)ollama_willOpenMenu:(NSMenu *)menu withEvent:(NSEvent *)event {
-    [self ollama_willOpenMenu:menu withEvent:event];
-    NSMutableArray *itemsToRemove = [NSMutableArray array];
-    for (NSMenuItem *item in menu.itemArray) {
-        if ([item.title containsString:@"Copy Link with Highlight"] ||
-            [item.title containsString:@"Open Link in New Window"] ||
-            [item.title containsString:@"Services"] ||
-            [item.title containsString:@"Download Linked File"] ||
-            [item.title containsString:@"Back"] ||
-            [item.title containsString:@"Reload"] ||
-            [item.title containsString:@"Refresh"] ||
-            [item.title containsString:@"Open Link"] ||
-            [item.title containsString:@"Copy Link"] ||
-            [item.title containsString:@"Share"]) {
-            [itemsToRemove addObject:item];
-            continue;
-        }
-    }
-
-    for (NSMenuItem *item in itemsToRemove) {
-        [menu removeItem:item];
-    }
-
-    int customItemCount = menu_get_item_count();
-    if (customItemCount > 0) {
-        menuItem* customItems = (menuItem*)menu_get_items();
-        if (customItems) {
-            NSInteger insertIndex = 0;
-            
-            for (int i = 0; i < customItemCount; i++) {
-                if (customItems[i].separator) {
-                    [menu insertItem:[NSMenuItem separatorItem] atIndex:insertIndex++];
-                } else if (customItems[i].label) {
-                    NSString *label = [NSString stringWithUTF8String:customItems[i].label];
-                    NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:label
-                                                                  action:@selector(handleCustomMenuItem:)
-                                                           keyEquivalent:@""];
-                    [item setTarget:self];
-                    [item setRepresentedObject:label];
-                    [item setEnabled:customItems[i].enabled];
-                    [menu insertItem:item atIndex:insertIndex++];
-                }
-            }
-            
-            // Add separator after custom items if there are remaining items
-            if (insertIndex > 0 && menu.itemArray.count > insertIndex) {
-                [menu insertItem:[NSMenuItem separatorItem] atIndex:insertIndex];
-            }
-        }
-    }
-}
-
-- (void)handleCustomMenuItem:(NSMenuItem *)sender {
-    NSString *label = [sender representedObject];
-    if (label) {
-        menu_handle_selection((char*)[label UTF8String]);
-    }
-}
-
-@end
-
-AppDelegate *appDelegate;
-void run(bool ftr, bool sh) {
-    [NSApplication sharedApplication];
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
-    appDelegate = [[AppDelegate alloc] init];
-    [NSApp setDelegate:appDelegate];
-    firstTimeRun = ftr;
-    startHidden = sh;
-    [NSApp run];
-    StopUI();
-}
-
-// killOtherInstances kills all other instances of the app currently
-// running. This way we can ensure that only the most recently started
-// instance of Ollama is running
-void killOtherInstances() {
-    pid_t myPid = getpid();
-    NSArray *apps = [[NSWorkspace sharedWorkspace] runningApplications];
-
-    for (NSRunningApplication *app in apps) {
-        NSString *bundleId = app.bundleIdentifier;
-        
-        // Skip apps without bundle identifiers
-        if (!bundleId || [bundleId length] == 0) {
-            continue;
-        }
-        
-        if ([bundleId isEqualToString:[[NSBundle mainBundle] bundleIdentifier]] ||
-            [bundleId isEqualToString:@"ai.ollama.ollama"] ||
-            [bundleId isEqualToString:@"com.electron.ollama"]) {
-            
-            pid_t pid = app.processIdentifier;
-            if (pid != myPid && pid > 0) {
-                appLogInfo([NSString stringWithFormat:@"terminating other ollama instance %d", pid]);
-                kill(pid, SIGTERM);
-            } else if (pid == -1) {
-                appLogInfo([NSString stringWithFormat:@"skipping app with invalid pid: %@", bundleId]);
-            }
-        }
-    }
-}
-
-// Move the source bundle to the system-wide applications location
-// without prompting for additional authorization
-bool moveToApplications(const char *src) {
-    NSString *bundlePath = @(src);
-    appLogInfo([NSString
-        stringWithFormat:
-            @"trying move to /Applications without extra authorization"]);
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-
-    // Check if the newPath already exists
-    if ([fileManager fileExistsAtPath:SystemWidePath]) {
-        appLogInfo([NSString stringWithFormat:@"existing install exists"]);
-        NSError *removeError = nil;
-        [fileManager removeItemAtPath:SystemWidePath error:&removeError];
-        if (removeError) {
-            appLogInfo([NSString
-                stringWithFormat:@"Error removing without authorization %@: %@",
-                                 SystemWidePath, removeError]);
-            return false;
-        }
-    }
-
-    // Move can be problematic, so use copy
-    NSError *err = nil;
-    [fileManager copyItemAtPath:bundlePath toPath:SystemWidePath error:&err];
-    if (err) {
-        appLogInfo(
-            [NSString stringWithFormat:
-                          @"unable to copy without authorization %@ to %@: %@",
-                          bundlePath, SystemWidePath, err]);
-        return false;
-    }
-
-    // Best effort attempt to remove old content
-    if ([fileManager isDeletableFileAtPath:bundlePath]) {
-        err = nil;
-        [fileManager trashItemAtURL:[NSURL fileURLWithPath:bundlePath]
-                   resultingItemURL:nil
-                              error:&err];
-        if (err) {
-            appLogInfo(
-                [NSString stringWithFormat:@"unable to clean up now stale "
-                                           @"bundle via file manager %@: %@",
-                                           bundlePath, err]);
-        }
-    } else {
-        appLogInfo([NSString stringWithFormat:@"unable to clean up now stale "
-                                              @"bundle via file manager %@",
-                                              bundlePath]);
-    }
-
-    appLogInfo([NSString stringWithFormat:@"app relocated %@ to %@", bundlePath,
-                                          SystemWidePath]);
-    return true;
-}
-
-AuthorizationRef getSymlinkAuthorization() {
-    return getAuthorization(@"Ollama is trying to install its command line "
-                            @"interface (CLI) tool.",
-                            @"symlink");
-}
-
-// Prompt the user for authorization and move to the system wide
-// location
-//
-// Note: this flow must not be executed from the old app instance
-//       otherwise the malware scanner will trigger on subsequent
-//       AuthorizationExecuteWithPrivileges calls as it can not
-//       verify the calling app's signature on the filesystem
-//       once the files are removed
-bool moveToApplicationsWithAuthorization(const char *src) {
-    int pid, status;
-    AuthorizationRef authRef = getAppInstallAuthorization();
-    if (authRef == NULL) {
-        return NO;
-    }
-
-    // Remove existing /Applications/Ollama.app (if any)
-    //    - We do this via /bin/rm with elevated privileges
-    //
-    const char *rmTool = "/bin/rm";
-    const char *rmArgs[] = {"-rf", [SystemWidePath UTF8String], NULL};
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    OSStatus err = AuthorizationExecuteWithPrivileges(
-        authRef, rmTool, kAuthorizationFlagDefaults, (char *const *)rmArgs,
-        NULL);
-#pragma clang diagnostic pop
-
-    if (err != errAuthorizationSuccess) {
-        appLogInfo([NSString
-            stringWithFormat:@"Failed to remove existing %@. err = %d",
-                             SystemWidePath, err]);
-        AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-        return NO;
-    }
-
-    // wait for the command to finish
-    pid = wait(&status);
-    if (pid == -1 || !WIFEXITED(status)) {
-        appLogInfo([NSString stringWithFormat:@"rm of %@ failed pid=%d exit=%d",
-                                              SystemWidePath, pid,
-                                              WEXITSTATUS(status)]);
-    }
-    appLogDebug([NSString
-        stringWithFormat:@"finished cleaning up prior %@", SystemWidePath]);
-
-    // Copy bundle to /Applications
-    // We can't use mv as we may be denied if we're sandboxed
-    const char *cpTool = "/bin/cp";
-    const char *cpArgs[] = {"-pR", src, [SystemWidePath UTF8String], NULL};
-    appLogDebug([NSString stringWithFormat:@"running authorized cp -pR %s %@",
-                                           src, SystemWidePath]);
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    err = AuthorizationExecuteWithPrivileges(authRef, cpTool,
-                                             kAuthorizationFlagDefaults,
-                                             (char *const *)cpArgs, NULL);
-#pragma clang diagnostic pop
-
-    if (err != errAuthorizationSuccess) {
-        appLogInfo(
-            [NSString stringWithFormat:@"Failed to copy %s -> %@. err = %d",
-                                       src, SystemWidePath, err]);
-        AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-        return NO;
-    }
-
-    // Wait for the command to finish
-    pid = wait(&status);
-    appLogInfo([NSString stringWithFormat:@"cp -pR %s %@ - pid=%d exit=%d", src,
-                                          SystemWidePath, pid,
-                                          WEXITSTATUS(status)]);
-
-    if (pid == -1 || !WIFEXITED(status) || WEXITSTATUS(status)) {
-        AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-        return NO;
-    }
-
-    // Copy worked, now best effort try to clean up the source bundle
-    // Try file manager, then authorized rm -rf
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSString *bundlePath = @(src);
-    NSError *removeError = nil;
-    err = [fileManager trashItemAtURL:[NSURL fileURLWithPath:bundlePath]
-                     resultingItemURL:nil
-                                error:&removeError];
-    if (removeError) {
-        appLogInfo(
-            [NSString stringWithFormat:@"unable to clean up now stale "
-                                       @"bundle via NSFileManager %@: %@",
-                                       bundlePath, removeError]);
-        const char *rm2Args[] = {"-rf", src, NULL};
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-        err = AuthorizationExecuteWithPrivileges(authRef, rmTool,
-                                                 kAuthorizationFlagDefaults,
-                                                 (char *const *)rm2Args, NULL);
-#pragma clang diagnostic pop
-        if (err != errAuthorizationSuccess) {
-            appLogInfo([NSString
-                stringWithFormat:@"Failed to remove existing %s. err = %d", src,
-                                 err]);
-        } else {
-            // wait for the command to finish
-            pid = wait(&status);
-            appLogInfo([NSString stringWithFormat:@"rm of %s pid=%d exit=%d",
-                                                  src, pid,
-                                                  WEXITSTATUS(status)]);
-            if (pid == -1 || !WIFEXITED(status) || WEXITSTATUS(status)) {
-                appLogInfo([NSString
-                    stringWithFormat:@"rm of %s failed pid=%d exit=%d", src,
-                                     pid, WEXITSTATUS(status)]);
-            } else {
-                appLogDebug([NSString
-                    stringWithFormat:@"finished cleaning up %s", src]);
-            }
-        }
-    }
-    AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-    return YES;
-}
-
-enum AppMove askToMoveToApplications() {
-    NSAppleEventDescriptor *evt =
-        [[NSAppleEventManager sharedAppleEventManager] currentAppleEvent];
-    if (!evt || [evt eventID] != kAEOpenApplication) {
-        // This scenario triggers if we were launched from a double click,
-        // or the CLI spawns the app via open -a Ollama.app
-        appLogDebug([NSString
-            stringWithFormat:@"launched from double click or open -a"]);
-    }
-    NSAppleEventDescriptor *prop =
-        [evt paramDescriptorForKeyword:keyAEPropData];
-    if (prop && [prop enumCodeValue] == keyAELaunchedAsLogInItem) {
-        // For a login session launch, we don't want to prompt for moving if
-        // the user opted out
-        appLogDebug([NSString stringWithFormat:@"launched from login"]);
-        return LoginSession;
-    }
-    pid_t pid = getpid();
-    NSString *bundlePath = [[NSBundle mainBundle] bundlePath];
-    appLogInfo(@"asking to move to system wide location");
-
-    NSAlert *alert = [[NSAlert alloc] init];
-    [alert setMessageText:@"Move to Applications?"];
-    [alert setInformativeText:
-               @"Ollama works best when run from the Applications directory."];
-    [alert addButtonWithTitle:@"Move to Applications"];
-    [alert addButtonWithTitle:@"Don't move"];
-
-    [NSApp activateIgnoringOtherApps:YES];
-
-    if ([alert runModal] != NSAlertFirstButtonReturn) {
-        appLogInfo([NSString
-            stringWithFormat:@"user rejected moving to /Applications"]);
-        return UserDeclinedMove;
-    }
-
-    // move to applications
-    if (!moveToApplications([bundlePath UTF8String])) {
-        if (!moveToApplicationsWithAuthorization([bundlePath UTF8String])) {
-            appLogInfo([NSString
-                stringWithFormat:@"unable to move with authorization"]);
-            return PermissionDenied;
-        }
-    }
-
-    appLogInfo([NSString
-        stringWithFormat:@"Launching %@ from PID=%d", SystemWidePath, pid]);
-    NSError *error = nil;
-    NSWorkspace *workspace = [NSWorkspace sharedWorkspace];
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    [workspace launchApplicationAtURL:[NSURL fileURLWithPath:SystemWidePath]
-                              options:NSWorkspaceLaunchNewInstance |
-                                      NSWorkspaceLaunchDefault
-                        configuration:@{}
-                                error:&error];
-    return MoveCompleted;
-}
-
-void launchApp(const char *appPath) {
-    pid_t pid = getpid();
-    appLogInfo([NSString
-        stringWithFormat:@"Launching %@ from PID=%d", @(appPath), pid]);
-    NSError *error = nil;
-    NSWorkspace *workspace = [NSWorkspace sharedWorkspace];
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    [workspace launchApplicationAtURL:[NSURL fileURLWithPath:@(appPath)]
-                              options:NSWorkspaceLaunchNewInstance |
-                                      NSWorkspaceLaunchDefault
-                        configuration:@{}
-                                error:&error];
-}
-
-int installSymlink(const char *cliPath) {
-    NSString *linkPath = @"/usr/local/bin/ollama";
-    NSString *dirPath = @"/usr/local/bin";
-    NSError *error = nil;
-
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSString *symlinkPath =
-        [fileManager destinationOfSymbolicLinkAtPath:linkPath error:&error];
-    NSString *resPath = [NSString stringWithUTF8String:cliPath];
-
-    // if the symlink already exists and points to the right place, don't
-    // prompt
-    if ([symlinkPath isEqualToString:resPath]) {
-        appLogDebug(
-            @"symbolic link already exists and points to the right place");
-        return 0;
-    }
-
-    // Get authorization once for both operations
-    AuthorizationRef authRef = getSymlinkAuthorization();
-    if (authRef == NULL) {
-        return NO;
-    }
-
-    // Check if /usr/local/bin directory exists, create it if it doesn't
-    BOOL isDirectory;
-    if (![fileManager fileExistsAtPath:dirPath isDirectory:&isDirectory] || !isDirectory) {
-        appLogInfo(@"/usr/local/bin directory does not exist, creating it");
-        
-        const char *mkdirTool = "/bin/mkdir";
-        const char *mkdirArgs[] = {"-p", [dirPath UTF8String], NULL};
-        
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-        OSStatus err = AuthorizationExecuteWithPrivileges(
-            authRef, mkdirTool, kAuthorizationFlagDefaults, (char *const *)mkdirArgs,
-            NULL);
-        if (err != errAuthorizationSuccess) {
-            appLogInfo(@"Failed to create /usr/local/bin directory");
-            AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-            return -1;
-        }
-        
-        // Wait for mkdir to complete
-        int status;
-        wait(&status);
-    }
-
-    // Create the symlink using the same authorization
-    const char *toolPath = "/bin/ln";
-    const char *args[] = {"-s", "-F", [resPath UTF8String],
-                          "/usr/local/bin/ollama", NULL};
-    FILE *pipe = NULL;
-
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    OSStatus err = AuthorizationExecuteWithPrivileges(
-        authRef, toolPath, kAuthorizationFlagDefaults, (char *const *)args,
-        &pipe);
-    if (err != errAuthorizationSuccess) {
-        appLogInfo(@"Failed to create symlink");
-        AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-        return -1;
-    }
-
-    AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
-    return 0;
-}
-
-void updateAvailable() {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [appDelegate showUpdateAvailable];
-    });
-}
-
-void quit() {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [appDelegate quit];
-    });
-}
-
-void uiRequest(char *path) {
-    NSString *p = [NSString stringWithFormat:@"%s", path];
-    appLogInfo([NSString stringWithFormat:@"XXX UI request for URL: %@", p]);
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [appDelegate uiRequest:p];
-    });
-}
-
-void registerSelfAsLoginItem(bool firstTimeRun) {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [appDelegate registerSelfAsLoginItem:firstTimeRun];
-    });
-}
-
-void unregisterSelfFromLoginItem() {
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [appDelegate unregisterSelfFromLoginItem];
-    });
-}
-
-static WKWebView *FindWKWebView(NSView *root) {
-    if ([root isKindOfClass:[WKWebView class]]) {
-        return (WKWebView *)root;
-    }
-    for (NSView *child in root.subviews) {
-        WKWebView *found = FindWKWebView(child);
-        if (found) {
-            return found;
-        }
-    }
-    return nil;
-}
-
-void setWindowDelegate(void* window) {
-    NSWindow *w = (__bridge NSWindow *)window;
-    [w setDelegate:appDelegate];
-    WKWebView *webView = FindWKWebView(w.contentView);
-    if (webView) {
-        webView.navigationDelegate = appDelegate;
-        webView.UIDelegate = appDelegate;
-    }
-}
-
-void hideWindow(uintptr_t wndPtr) {
-    NSWindow *w = (__bridge NSWindow *)wndPtr;
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
-    [w orderOut:nil];
-}
-
-void showWindow(uintptr_t wndPtr) {
-    NSWindow *w = (__bridge NSWindow *)wndPtr;
-        
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
-
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [NSApp unhide:nil];
-        [NSApp activateIgnoringOtherApps:YES];
-        [w makeKeyAndOrderFront:nil];
-    });
-}
-
-void styleWindow(uintptr_t wndPtr) {
-    NSWindow *w = (__bridge NSWindow *)wndPtr;
-    if (!w) return;
-
-    // Define the desired style mask
-    NSWindowStyleMask desiredStyleMask = NSWindowStyleMaskTitled |
-                    NSWindowStyleMaskClosable |
-                    NSWindowStyleMaskMiniaturizable |
-                    NSWindowStyleMaskResizable |
-                    NSWindowStyleMaskFullSizeContentView |
-                    NSWindowStyleMaskUnifiedTitleAndToolbar;
-
-    if (!(w.styleMask & NSWindowStyleMaskFullScreen)) {
-        w.styleMask = desiredStyleMask;
-    }
-
-    if (w.toolbar == nil) {
-        NSToolbar *tb = [[NSToolbar alloc] initWithIdentifier:@"OllamaToolbar"];
-        tb.displayMode            = NSToolbarDisplayModeIconOnly;
-        tb.showsBaselineSeparator = NO;
-        w.toolbar                 = tb;
-    }
-
-    w.titleVisibility = NSWindowTitleHidden;
-    w.titlebarAppearsTransparent = YES;
-    w.toolbarStyle = NSWindowToolbarStyleUnified;
-    w.movableByWindowBackground = NO;
-    w.hasShadow = YES;
-
-    NSView *cv = w.contentView;
-    cv.wantsLayer = YES;
-    CALayer *L = cv.layer;
-    L.cornerRadius = 0.0;
-    L.masksToBounds = NO;
-    L.borderColor = nil;
-    L.borderWidth = 0.0;
-}
-
-void drag(uintptr_t wndPtr) {
-    NSWindow *w = (__bridge NSWindow *)wndPtr;
-    if (!w) return;
-    NSPoint mouseLoc = [NSEvent mouseLocation];
-    NSPoint locInWindow = [w convertPointFromScreen:mouseLoc];
-
-    NSEvent *e = [NSEvent mouseEventWithType:NSEventTypeLeftMouseDown
-                                    location:locInWindow
-                                modifierFlags:0
-                                    timestamp:NSTimeIntervalSince1970
-                                windowNumber:[w windowNumber]
-                                        context:nil
-                                    eventNumber:0
-                                    clickCount:1
-                                    pressure:1.0];
-    [w performWindowDragWithEvent:e];
-}
-
-void doubleClick(uintptr_t wndPtr) {
-    NSWindow *w = (__bridge NSWindow *)wndPtr;
-    if (!w) return;
-
-    // Respect the user's Dock preference
-    NSString *action =
-        [[NSUserDefaults standardUserDefaults] stringForKey:@"AppleActionOnDoubleClick"];
-
-    if ([action isEqualToString:@"Minimize"]) {
-        [w performMiniaturize:nil];
-    } else {
-        [w performZoom:nil];
-    }
-}

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>