feat: make ollama with no args launch integrations UI

2026-09-11 05:33:32 -04:00 · 2026-02-07 15:49:41 -08:00
576 changed files with 16163 additions and 103122 deletions
@@ -27,7 +27,7 @@ jobs:
          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT

  darwin-build:
-    runs-on: macos-26-xlarge
+    runs-on: macos-14-xlarge
    environment: release
    needs: setup-environment
    env:
@@ -117,25 +117,6 @@ jobs:
            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
            flags: ''
            runner_dir: 'vulkan'
-          - os: windows
-            arch: amd64
-            preset: 'MLX CUDA 13'
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
-            flags: ''
    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
    environment: release
    env:
@@ -144,10 +125,8 @@ jobs:
      - 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: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan') || startsWith(matrix.preset, 'MLX ')
+          ccache -o cache_dir=${{ github.workspace }}\.ccache
+      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan')
        id: cache-install
        uses: actions/cache/restore@v4
        with:
@@ -155,9 +134,8 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'MLX ')
+          key: ${{ matrix.install }}
+      - if: startsWith(matrix.preset, 'CUDA ')
        name: Install CUDA ${{ matrix.cuda-version }}
        run: |
          $ErrorActionPreference = "Stop"
@@ -201,23 +179,6 @@ jobs:
        run: |
          echo "CC=clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
          echo "CXX=clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-      - if: startsWith(matrix.preset, 'MLX ')
-        name: Install cuDNN for MLX
-        run: |
-          $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:
@@ -225,8 +186,7 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
+          key: ${{ matrix.install }}
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
        with:
@@ -238,7 +198,7 @@ jobs:
          Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }} --install-prefix "$((pwd).Path)\dist\${{ matrix.os }}-${{ matrix.arch }}"
          cmake --build --parallel ([Environment]::ProcessorCount) --preset "${{ matrix.preset }}"
-          cmake --install build --component "${{ startsWith(matrix.preset, 'MLX ') && 'MLX' || startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || startsWith(matrix.preset, 'Vulkan') && 'Vulkan' || 'CPU' }}" --strip
+          cmake --install build --component "${{ startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || startsWith(matrix.preset, 'Vulkan') && 'Vulkan' || 'CPU' }}" --strip
          Remove-Item -Path dist\lib\ollama\rocm\rocblas\library\*gfx906* -ErrorAction SilentlyContinue
        env:
          CMAKE_GENERATOR: Ninja
@@ -377,7 +337,6 @@ jobs:
          name: bundles-windows
          path: |
            dist/*.zip
-            dist/*.ps1
            dist/OllamaSetup.exe

  linux-build:
@@ -424,7 +383,6 @@ jobs:
              lib/ollama/cuda_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
              lib/ollama/vulkan*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
              lib/ollama/mlx*)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/include*)       echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
              lib/ollama/cuda_jetpack5)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack5.tar.in ;;
              lib/ollama/cuda_jetpack6)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack6.tar.in ;;
              lib/ollama/rocm)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-rocm.tar.in ;;
@@ -556,9 +514,6 @@ jobs:
      - name: Log dist contents
        run: |
          ls -l dist/
-      - name: Copy install scripts to dist
-        run: |
-          cp scripts/install.sh dist/install.sh
      - name: Generate checksum file
        run: find . -type f -not -name 'sha256sum.txt' | xargs sha256sum | tee sha256sum.txt
        working-directory: dist
@@ -581,22 +536,14 @@ jobs:
      - name: Upload release artifacts
        run: |
          pids=()
-          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.tar.zst dist/*.exe dist/*.dmg dist/*.ps1 dist/*.sh ; do
+          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.tar.zst dist/*.exe dist/*.dmg ; do
            echo "Uploading $payload"
            gh release upload ${GITHUB_REF_NAME} $payload --clobber &
-            pids+=($!)
+            pids[$!]=$!
            sleep 1
          done
          echo "Waiting for uploads to complete"
-          failed=0
-          for pid in "${pids[@]}"; do
-            if ! wait $pid; then
-              echo "::error::Upload failed (pid $pid)"
-              failed=1
-            fi
+          for pid in "${pids[*]}"; do
+            wait $pid
          done
-          if [ $failed -ne 0 ]; then
-            echo "One or more uploads failed"
-            exit 1
-          fi
          echo "done"
@@ -37,7 +37,7 @@ jobs:
              | xargs python3 -c "import sys; from pathlib import Path; print(any(Path(x).match(glob) for x in sys.argv[1:] for glob in '$*'.split(' ')))"
          }

-          echo changed=$(changed 'llama/llama.cpp/**/*' 'ml/backend/ggml/ggml/**/*' '.github/**/*') | tee -a $GITHUB_OUTPUT
+          echo changed=$(changed 'llama/llama.cpp/**/*' 'ml/backend/ggml/ggml/**/*') | tee -a $GITHUB_OUTPUT
          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT

  linux:
@@ -51,7 +51,7 @@ jobs:
            container: nvidia/cuda:13.0.0-devel-ubuntu22.04
            flags: '-DCMAKE_CUDA_ARCHITECTURES=87'
          - preset: ROCm
-            container: rocm/dev-ubuntu-22.04:7.2.1
+            container: rocm/dev-ubuntu-22.04:6.1.2
            extra-packages: rocm-libs
            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_PREFIX_PATH=/opt/rocm'
          - preset: Vulkan
@@ -60,11 +60,6 @@ jobs:
              mesa-vulkan-drivers vulkan-tools
              libvulkan1 libvulkan-dev
              vulkan-sdk cmake ccache g++ make
-          - preset: 'MLX CUDA 13'
-            container: nvidia/cuda:13.0.0-devel-ubuntu22.04
-            extra-packages: libcudnn9-dev-cuda-13 libopenblas-dev liblapack-dev liblapacke-dev git curl
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=87 -DBLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu -DLAPACK_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu'
-            install-go: true
    runs-on: linux
    container: ${{ matrix.container }}
    steps:
@@ -81,29 +76,19 @@ jobs:
            $sudo apt-get update
          fi
          $sudo apt-get install -y cmake ccache ${{ matrix.extra-packages }}
-          # MLX requires CMake 3.25+, install from official releases
-          if [ "${{ matrix.preset }}" = "MLX CUDA 13" ]; then
-            curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.31.2/cmake-3.31.2-linux-$(uname -m).tar.gz | $sudo tar xz -C /usr/local --strip-components 1
-          fi
          # 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: |
-          GO_VERSION=$(awk '/^go / { print $2 }' go.mod)
-          curl -fsSL "https://golang.org/dl/go${GO_VERSION}.linux-$(dpkg --print-architecture).tar.gz" | tar xz -C /usr/local
-          echo "/usr/local/go/bin" >> $GITHUB_PATH
      - uses: actions/cache@v4
        with:
          path: /github/home/.cache/ccache
          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.vendorsha }}
      - run: |
-          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }}
-          cmake --build --preset "${{ matrix.preset }}" --parallel
+          cmake --preset ${{ matrix.preset }} ${{ matrix.flags }}
+          cmake --build --preset ${{ matrix.preset }} --parallel

  windows:
    needs: [changes]
@@ -129,31 +114,12 @@ jobs:
            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma" -DCMAKE_CXX_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma"'
          - preset: Vulkan
            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
-          - preset: 'MLX CUDA 13'
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=80'
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
    runs-on: windows
    steps:
      - run: |
          choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan' || matrix.preset == 'MLX CUDA 13'
+          ccache -o cache_dir=${{ github.workspace }}\.ccache
+      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan'
        id: cache-install
        uses: actions/cache/restore@v4
        with:
@@ -161,9 +127,8 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'MLX CUDA 13'
+          key: ${{ matrix.install }}
+      - if: matrix.preset == 'CUDA'
        name: Install CUDA ${{ matrix.cuda-version }}
        run: |
          $ErrorActionPreference = "Stop"
@@ -199,27 +164,10 @@ jobs:
            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
            Start-Process -FilePath .\install.exe -ArgumentList "-c","--am","--al","in" -NoNewWindow -Wait
          }
-
+          
          $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
          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:
@@ -227,8 +175,7 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
+          key: ${{ matrix.install }}
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
        with:
@@ -15,4 +15,3 @@ __debug_bin*
 llama/build
 llama/vendor
 /ollama
-integration/testdata/models/
@@ -64,15 +64,10 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})

-# Store ggml include paths for use with target_include_directories later.
-# We avoid global include_directories() to prevent polluting the include path
-# for other projects like MLX (whose openblas dependency has its own common.h).
-set(GGML_INCLUDE_DIRS
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/include
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu/amx
-)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu/amx)

 add_compile_definitions(NDEBUG GGML_VERSION=0x0 GGML_COMMIT=0x0)

@@ -92,14 +87,6 @@ if(NOT CPU_VARIANTS)
    set(CPU_VARIANTS "ggml-cpu")
 endif()

-# Apply ggml include directories to ggml targets only (not globally)
-target_include_directories(ggml-base PRIVATE ${GGML_INCLUDE_DIRS})
-foreach(variant ${CPU_VARIANTS})
-    if(TARGET ${variant})
-        target_include_directories(${variant} PRIVATE ${GGML_INCLUDE_DIRS})
-    endif()
-endforeach()
-
 install(TARGETS ggml-base ${CPU_VARIANTS}
    RUNTIME_DEPENDENCIES
        PRE_EXCLUDE_REGEXES ".*"
@@ -116,7 +103,6 @@ if(CMAKE_CUDA_COMPILER)

    find_package(CUDAToolkit)
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cuda)
-    target_include_directories(ggml-cuda PRIVATE ${GGML_INCLUDE_DIRS})
    install(TARGETS ggml-cuda
        RUNTIME_DEPENDENCIES
            DIRECTORIES ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR}
@@ -148,7 +134,6 @@ if(CMAKE_HIP_COMPILER)
    if(AMDGPU_TARGETS)
        find_package(hip REQUIRED)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-hip)
-        target_include_directories(ggml-hip PRIVATE ${GGML_INCLUDE_DIRS})

        if (WIN32)
            target_compile_definitions(ggml-hip PRIVATE GGML_CUDA_NO_PEER_COPY)
@@ -163,7 +148,7 @@ if(CMAKE_HIP_COMPILER)
        )
        install(RUNTIME_DEPENDENCY_SET rocm
                DIRECTORIES ${HIP_BIN_INSTALL_DIR} ${HIP_LIB_INSTALL_DIR}
-                PRE_INCLUDE_REGEXES hipblas rocblas amdhip64 rocsolver amd_comgr hsa-runtime64 rocsparse tinfo rocprofiler-register roctx64 rocroller drm drm_amdgpu numa elf
+                PRE_INCLUDE_REGEXES hipblas rocblas amdhip64 rocsolver amd_comgr hsa-runtime64 rocsparse tinfo rocprofiler-register drm drm_amdgpu numa elf
                PRE_EXCLUDE_REGEXES ".*"
                POST_EXCLUDE_REGEXES "system32"
            RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP
@@ -183,7 +168,6 @@ if(NOT APPLE)
    find_package(Vulkan)
    if(Vulkan_FOUND)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-vulkan)
-        target_include_directories(ggml-vulkan PRIVATE ${GGML_INCLUDE_DIRS})
        install(TARGETS ggml-vulkan
            RUNTIME_DEPENDENCIES
                PRE_INCLUDE_REGEXES vulkan
@@ -195,6 +179,7 @@ if(NOT APPLE)
 endif()

 option(MLX_ENGINE "Enable MLX backend" OFF)
+
 if(MLX_ENGINE)
    message(STATUS "Setting up MLX (this takes a while...)")
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/x/imagegen/mlx)
@@ -202,36 +187,10 @@ if(MLX_ENGINE)
    # Find CUDA toolkit if MLX is built with CUDA support
    find_package(CUDAToolkit)

-    # Build list of directories for runtime dependency resolution
-    set(MLX_RUNTIME_DIRS ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR})
-    # Add cuDNN bin paths for DLLs (Windows MLX CUDA builds)
-    # CUDNN_ROOT_DIR is the standard CMake variable for cuDNN location
-    if(DEFINED ENV{CUDNN_ROOT_DIR})
-        # cuDNN 9.x has versioned subdirectories under bin/ (e.g., bin/13.0/)
-        file(GLOB CUDNN_BIN_SUBDIRS "$ENV{CUDNN_ROOT_DIR}/bin/*")
-        list(APPEND MLX_RUNTIME_DIRS ${CUDNN_BIN_SUBDIRS})
-    endif()
-    # Add build output directory and MLX dependency build directories
-    list(APPEND MLX_RUNTIME_DIRS ${OLLAMA_BUILD_DIR})
-    # OpenBLAS DLL location (pre-built zip extracts into openblas-src/bin/)
-    list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/openblas-src/bin)
-    # NCCL: on Linux, if real NCCL is found, cmake bundles libnccl.so via the
-    # regex below. If NCCL is not found, MLX links a static stub (OBJECT lib)
-    # so there is no runtime dependency. This path covers the stub build dir
-    # for windows so we include the DLL in our dependencies.
-    list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/mlx-build/mlx/distributed/nccl/nccl_stub-prefix/src/nccl_stub-build/Release)
-
-    # Base regexes for runtime dependencies (cross-platform)
-    set(MLX_INCLUDE_REGEXES cublas cublasLt cudart cufft nvrtc nvrtc-builtins cudnn nccl openblas gfortran)
-    # On Windows, also include dl.dll (dlfcn-win32 POSIX emulation layer)
-    if(WIN32)
-        list(APPEND MLX_INCLUDE_REGEXES "^dl\\.dll$")
-    endif()
-
    install(TARGETS mlx mlxc
        RUNTIME_DEPENDENCIES
-            DIRECTORIES ${MLX_RUNTIME_DIRS}
-            PRE_INCLUDE_REGEXES ${MLX_INCLUDE_REGEXES}
+            DIRECTORIES ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR}
+            PRE_INCLUDE_REGEXES cublas cublasLt cudart nvrtc nvrtc-builtins cudnn nccl openblas gfortran
            PRE_EXCLUDE_REGEXES ".*"
        RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
        LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
@@ -246,117 +205,13 @@ if(MLX_ENGINE)
            COMPONENT MLX)
    endif()

-    # Install headers for NVRTC JIT compilation at runtime.
-    # MLX's own install rules use the default component so they get skipped by
-    # --component MLX. Headers are installed alongside libmlx in OLLAMA_INSTALL_DIR.
-    #
-    # Layout:
-    #   ${OLLAMA_INSTALL_DIR}/include/cccl/{cuda,nv}/  — CCCL headers
-    #   ${OLLAMA_INSTALL_DIR}/include/*.h               — CUDA toolkit headers
-    #
-    # MLX's jit_module.cpp resolves CCCL via
-    #   current_binary_dir()[.parent_path()] / "include" / "cccl"
-    # On Linux, MLX's jit_module.cpp resolves CCCL via
-    #   current_binary_dir().parent_path() / "include" / "cccl", so we create a
-    #   symlink from lib/ollama/include -> ${OLLAMA_RUNNER_DIR}/include
-    #   This will need refinement if we add multiple CUDA versions for MLX in the future.
-    # CUDA runtime headers are found via CUDA_PATH env var (set by mlxrunner).
-    if(EXISTS ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda)
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda
-            DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
-            COMPONENT MLX)
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/nv
-            DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
-            COMPONENT MLX)
-        if(NOT WIN32 AND NOT APPLE)
-            install(CODE "
-                set(_link \"${CMAKE_INSTALL_PREFIX}/lib/ollama/include\")
-                set(_target \"${OLLAMA_RUNNER_DIR}/include\")
-                if(NOT EXISTS \${_link})
-                    execute_process(COMMAND \${CMAKE_COMMAND} -E create_symlink \${_target} \${_link})
-                endif()
-            " COMPONENT MLX)
-        endif()
-    endif()
-
-    # Install minimal CUDA toolkit headers needed by MLX JIT kernels.
-    # These are the transitive closure of includes from mlx/backend/cuda/device/*.cuh.
-    # The Go mlxrunner sets CUDA_PATH to OLLAMA_INSTALL_DIR so MLX finds them at
-    # $CUDA_PATH/include/*.h via NVRTC --include-path.
+    # Manually install cudart and cublas since they might not be picked up as direct dependencies
    if(CUDAToolkit_FOUND)
-        # CUDAToolkit_INCLUDE_DIRS may be a semicolon-separated list
-        # (e.g. ".../include;.../include/cccl"). Find the entry that
-        # contains the CUDA runtime headers we need.
-        set(_cuda_inc "")
-        foreach(_dir ${CUDAToolkit_INCLUDE_DIRS})
-            if(EXISTS "${_dir}/cuda_runtime_api.h")
-                set(_cuda_inc "${_dir}")
-                break()
-            endif()
-        endforeach()
-        if(NOT _cuda_inc)
-            message(WARNING "Could not find cuda_runtime_api.h in CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
-        else()
-            set(_dst "${OLLAMA_INSTALL_DIR}/include")
-            set(_MLX_JIT_CUDA_HEADERS
-                builtin_types.h
-                cooperative_groups.h
-                cuda_bf16.h
-                cuda_bf16.hpp
-                cuda_device_runtime_api.h
-                cuda_fp16.h
-                cuda_fp16.hpp
-                cuda_fp8.h
-                cuda_fp8.hpp
-                cuda_runtime_api.h
-                device_types.h
-                driver_types.h
-                math_constants.h
-                surface_types.h
-                texture_types.h
-                vector_functions.h
-                vector_functions.hpp
-                vector_types.h
-            )
-            foreach(_hdr ${_MLX_JIT_CUDA_HEADERS})
-                install(FILES "${_cuda_inc}/${_hdr}"
-                    DESTINATION ${_dst}
-                    COMPONENT MLX)
-            endforeach()
-            # Subdirectory headers
-            install(DIRECTORY "${_cuda_inc}/cooperative_groups"
-                DESTINATION ${_dst}
-                COMPONENT MLX
-                FILES_MATCHING PATTERN "*.h")
-            install(FILES "${_cuda_inc}/crt/host_defines.h"
-                DESTINATION "${_dst}/crt"
-                COMPONENT MLX)
-        endif()
-    endif()
-
-    # On Windows, explicitly install dl.dll (dlfcn-win32 POSIX dlopen emulation)
-    # RUNTIME_DEPENDENCIES auto-excludes it via POST_EXCLUDE_FILES_STRICT because
-    # dlfcn-win32 is a known CMake target with its own install rules (which install
-    # to the wrong destination). We must install it explicitly here.
-    if(WIN32)
-        install(FILES ${OLLAMA_BUILD_DIR}/dl.dll
-            DESTINATION ${OLLAMA_INSTALL_DIR}
-            COMPONENT MLX)
-    endif()
-
-    # Manually install CUDA runtime libraries that MLX loads via dlopen
-    # (not detected by RUNTIME_DEPENDENCIES since they aren't link-time deps)
-    if(CUDAToolkit_FOUND)
-        file(GLOB MLX_CUDA_LIBS
+        file(GLOB CUDART_LIBS
            "${CUDAToolkit_LIBRARY_DIR}/libcudart.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcublasLt.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libnvrtc.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libnvrtc-builtins.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcufft.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcudnn.so*")
-        if(MLX_CUDA_LIBS)
-            install(FILES ${MLX_CUDA_LIBS}
+            "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*")
+        if(CUDART_LIBS)
+            install(FILES ${CUDART_LIBS}
                DESTINATION ${OLLAMA_INSTALL_DIR}
                COMPONENT MLX)
        endif()
@@ -77,15 +77,6 @@
        "OLLAMA_RUNNER_DIR": "rocm"
      }
    },
-    {
-      "name": "ROCm 7",
-      "inherits": [ "ROCm" ],
-      "cacheVariables": {
-        "CMAKE_HIP_FLAGS": "-parallel-jobs=4",
-        "AMDGPU_TARGETS": "gfx942;gfx950;gfx1010;gfx1012;gfx1030;gfx1100;gfx1101;gfx1102;gfx1103;gfx1150;gfx1151;gfx1200;gfx1201;gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-",
-        "OLLAMA_RUNNER_DIR": "rocm"
-      }
-    },
    {
      "name": "Vulkan",
      "inherits": [ "Default" ],
@@ -112,7 +103,6 @@
      "name": "MLX CUDA 13",
      "inherits": [ "MLX", "CUDA 13" ],
      "cacheVariables": {
-        "MLX_CUDA_ARCHITECTURES": "86;89;90;90a;100;103;75-virtual;80-virtual;110-virtual;120-virtual;121-virtual",
        "OLLAMA_RUNNER_DIR": "mlx_cuda_v13"
      }
    }
@@ -168,11 +158,6 @@
      "inherits": [ "ROCm" ],
      "configurePreset": "ROCm 6"
    },
-    {
-      "name": "ROCm 7",
-      "inherits": [ "ROCm" ],
-      "configurePreset": "ROCm 7"
-    },
    {
      "name": "Vulkan",
      "targets": [ "ggml-vulkan" ],
@@ -1,23 +1,33 @@
 # vim: filetype=dockerfile

 ARG FLAVOR=${TARGETARCH}
+ARG PARALLEL=8

-ARG ROCMVERSION=7.2.1
+ARG ROCMVERSION=6.3.3
 ARG JETPACK5VERSION=r35.4.1
 ARG JETPACK6VERSION=r36.4.0
 ARG CMAKEVERSION=3.31.2
-ARG NINJAVERSION=1.12.1
 ARG VULKANVERSION=1.4.321.1

-# Default empty stages for local MLX source overrides.
-# Override with: docker build --build-context local-mlx=../mlx --build-context local-mlx-c=../mlx-c
-FROM scratch AS local-mlx
-FROM scratch AS local-mlx-c
-
+# We require gcc v10 minimum.  v10.3 has regressions, so the rockylinux 8.5 AppStream has the latest compatible version
 FROM --platform=linux/amd64 rocm/dev-almalinux-8:${ROCMVERSION}-complete AS base-amd64
-RUN dnf install -y yum-utils ccache gcc-toolset-11-gcc gcc-toolset-11-gcc-c++ gcc-toolset-11-binutils \
+RUN yum install -y yum-utils \
+    && yum-config-manager --add-repo https://dl.rockylinux.org/vault/rocky/8.5/AppStream/\$basearch/os/ \
+    && rpm --import https://dl.rockylinux.org/pub/rocky/RPM-GPG-KEY-Rocky-8 \
+    && dnf install -y yum-utils ccache gcc-toolset-10-gcc-10.2.1-8.2.el8 gcc-toolset-10-gcc-c++-10.2.1-8.2.el8 gcc-toolset-10-binutils-2.35-11.el8 \
+    && dnf install -y ccache \
    && yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
-ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
+ENV PATH=/opt/rh/gcc-toolset-10/root/usr/bin:$PATH
+ARG VULKANVERSION
+RUN wget https://sdk.lunarg.com/sdk/download/${VULKANVERSION}/linux/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz -O /tmp/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz \
+    && tar xvf /tmp/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz \
+    && dnf -y install ninja-build \
+    && ln -s /usr/bin/python3 /usr/bin/python \  
+    && /${VULKANVERSION}/vulkansdk -j 8 vulkan-headers \
+    && /${VULKANVERSION}/vulkansdk -j 8 shaderc
+RUN cp -r /${VULKANVERSION}/x86_64/include/* /usr/local/include/ \
+    && cp -r /${VULKANVERSION}/x86_64/lib/* /usr/local/lib
+ENV PATH=/${VULKANVERSION}/x86_64/bin:$PATH

 FROM --platform=linux/arm64 almalinux:8 AS base-arm64
 # install epel-release for ccache
@@ -28,119 +38,100 @@ 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

 FROM base AS cpu
 RUN dnf install -y gcc-toolset-11-gcc gcc-toolset-11-gcc-c++
 ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CPU' \
-        && cmake --build --preset 'CPU' -- -l $(nproc) \
-        && cmake --install build --component CPU --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CPU' \
+        && cmake --install build --component CPU --strip --parallel ${PARALLEL}

 FROM base AS cuda-11
 ARG CUDA11VERSION=11.8
 RUN dnf install -y cuda-toolkit-${CUDA11VERSION//./-}
 ENV PATH=/usr/local/cuda-11/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CUDA 11' \
-        && cmake --build --preset 'CUDA 11' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 11' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}

 FROM base AS cuda-12
 ARG CUDA12VERSION=12.8
 RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
 ENV PATH=/usr/local/cuda-12/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CUDA 12' \
-        && cmake --build --preset 'CUDA 12' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 12' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}


 FROM base AS cuda-13
 ARG CUDA13VERSION=13.0
 RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
 ENV PATH=/usr/local/cuda-13/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CUDA 13' \
-        && cmake --build --preset 'CUDA 13' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 13' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}


-FROM base AS rocm-7
+FROM base AS rocm-6
 ENV PATH=/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:/opt/rocm/hcc/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'ROCm 7' \
-        && cmake --build --preset 'ROCm 7' -- -l $(nproc) \
-        && cmake --install build --component HIP --strip
+    cmake --preset 'ROCm 6' \
+        && cmake --build --parallel ${PARALLEL} --preset 'ROCm 6' \
+        && cmake --install build --component HIP --strip --parallel ${PARALLEL}
 RUN rm -f dist/lib/ollama/rocm/rocblas/library/*gfx90[06]*

 FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK5VERSION} AS jetpack-5
 ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache 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
+RUN apt-get update && apt-get install -y curl ccache \
+    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'JetPack 5' \
-        && cmake --build --preset 'JetPack 5' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'JetPack 5' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}

 FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK6VERSION} AS jetpack-6
 ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache 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
+RUN apt-get update && apt-get install -y curl ccache \
+    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'JetPack 6' \
-        && cmake --build --preset 'JetPack 6' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'JetPack 6' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}

 FROM base AS vulkan
-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 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/bin/* /usr/local/bin/ \
-    && rm -rf /tmp/${VULKANVERSION} /tmp/vulkansdk.tar.xz
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'Vulkan' \
-        && cmake --build --preset 'Vulkan' -- -l $(nproc) \
-        && cmake --install build --component Vulkan --strip
+        && cmake --build --parallel --preset 'Vulkan' \
+        && cmake --install build --component Vulkan --strip --parallel 8

 FROM base AS mlx
 ARG CUDA13VERSION=13.0
@@ -152,27 +143,20 @@ ENV PATH=/usr/local/cuda-13/bin:$PATH
 ENV BLAS_INCLUDE_DIRS=/usr/include/openblas
 ENV LAPACK_INCLUDE_DIRS=/usr/include/openblas
 ENV CGO_LDFLAGS="-L/usr/local/cuda-13/lib64 -L/usr/local/cuda-13/targets/x86_64-linux/lib/stubs"
+ARG PARALLEL
 WORKDIR /go/src/github.com/ollama/ollama
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 COPY x/imagegen/mlx x/imagegen/mlx
 COPY go.mod go.sum .
-COPY MLX_VERSION MLX_C_VERSION .
+COPY MLX_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 --preset 'MLX CUDA 13' -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas \
-        && cmake --build --preset 'MLX CUDA 13' -- -l $(nproc) \
-        && cmake --install build --component MLX --strip
+    cmake --preset 'MLX CUDA 13' -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas \
+        && cmake --build --parallel ${PARALLEL} --preset 'MLX CUDA 13' \
+        && cmake --install build --component MLX --strip --parallel ${PARALLEL}

 FROM base AS build
 WORKDIR /go/src/github.com/ollama/ollama
@@ -181,14 +165,16 @@ RUN curl -fsSL https://golang.org/dl/go$(awk '/^go/ { print $2 }' go.mod).linux-
 ENV PATH=/usr/local/go/bin:$PATH
 RUN go mod download
 COPY . .
+# Clone mlx-c headers for CGO (version from MLX_VERSION file)
+RUN git clone --depth 1 --branch "$(cat MLX_VERSION)" https://github.com/ml-explore/mlx-c.git build/_deps/mlx-c-src
 ARG GOFLAGS="'-ldflags=-w -s'"
 ENV CGO_ENABLED=1
 ARG CGO_CFLAGS
 ARG CGO_CXXFLAGS
-ENV CGO_CFLAGS="${CGO_CFLAGS}"
+ENV CGO_CFLAGS="${CGO_CFLAGS} -I/go/src/github.com/ollama/ollama/build/_deps/mlx-c-src"
 ENV CGO_CXXFLAGS="${CGO_CXXFLAGS}"
 RUN --mount=type=cache,target=/root/.cache/go-build \
-    go build -trimpath -buildmode=pie -o /bin/ollama .
+    go build -tags mlx -trimpath -buildmode=pie -o /bin/ollama .

 FROM --platform=linux/amd64 scratch AS amd64
 # COPY --from=cuda-11 dist/lib/ollama/ /lib/ollama/
@@ -205,9 +191,10 @@ COPY --from=jetpack-5 dist/lib/ollama/ /lib/ollama/
 COPY --from=jetpack-6 dist/lib/ollama/ /lib/ollama/

 FROM scratch AS rocm
-COPY --from=rocm-7 dist/lib/ollama /lib/ollama
+COPY --from=rocm-6 dist/lib/ollama /lib/ollama

 FROM ${FLAVOR} AS archive
+ARG VULKANVERSION
 COPY --from=cpu dist/lib/ollama /lib/ollama
 COPY --from=build /bin/ollama /bin/ollama

@@ -1 +0,0 @@
-0726ca922fc902c4c61ef9c27d94132be418e945
@@ -1 +1 @@
-38ad257088fb2193ad47e527cf6534a689f30943
+v0.4.1
@@ -1,30 +1,20 @@
-<p align="center">
-  <a href="https://ollama.com">
-    <img src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7" alt="ollama" width="200"/>
+<div align="center">
+  <a href="https://ollama.com">
+    <img alt="ollama" width="240" src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7">
  </a>
-</p>
+</div>

 # Ollama

-Start building with open models.
-
-## Download
+Get up and running with large language models.

 ### macOS

-```shell
-curl -fsSL https://ollama.com/install.sh | sh
-```
-
-or [download manually](https://ollama.com/download/Ollama.dmg)
+[Download](https://ollama.com/download/Ollama.dmg)

 ### Windows

-```shell
-irm https://ollama.com/install.ps1 | iex
-```
-
-or [download manually](https://ollama.com/download/OllamaSetup.exe)
+[Download](https://ollama.com/download/OllamaSetup.exe)

 ### Linux

@@ -46,311 +36,649 @@ The official [Ollama Docker image](https://hub.docker.com/r/ollama/ollama) `olla
 ### Community

 - [Discord](https://discord.gg/ollama)
- [𝕏 (Twitter)](https://x.com/ollama)
 - [Reddit](https://reddit.com/r/ollama)

-## Get started
+## Quickstart

-```
-ollama
-```
+To run and chat with [Gemma 3](https://ollama.com/library/gemma3):

-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.
-
-### Coding
-
-To launch a specific integration:
-
-```
-ollama launch claude
-```
-
-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:
-
-```
-ollama launch openclaw
-```
-
-### Chat with a model
-
-Run and chat with [Gemma 3](https://ollama.com/library/gemma3):
-
-```
+```shell
 ollama run gemma3
 ```

-See [ollama.com/library](https://ollama.com/library) for the full list.
+## Model library

-See the [quickstart guide](https://docs.ollama.com/quickstart) for more details.
+Ollama supports a list of models available on [ollama.com/library](https://ollama.com/library "ollama model library")
+
+Here are some example models that can be downloaded:
+
+| Model              | Parameters | Size  | Download                         |
+| ------------------ | ---------- | ----- | -------------------------------- |
+| Gemma 3            | 1B         | 815MB | `ollama run gemma3:1b`           |
+| Gemma 3            | 4B         | 3.3GB | `ollama run gemma3`              |
+| Gemma 3            | 12B        | 8.1GB | `ollama run gemma3:12b`          |
+| Gemma 3            | 27B        | 17GB  | `ollama run gemma3:27b`          |
+| QwQ                | 32B        | 20GB  | `ollama run qwq`                 |
+| DeepSeek-R1        | 7B         | 4.7GB | `ollama run deepseek-r1`         |
+| DeepSeek-R1        | 671B       | 404GB | `ollama run deepseek-r1:671b`    |
+| Llama 4            | 109B       | 67GB  | `ollama run llama4:scout`        |
+| Llama 4            | 400B       | 245GB | `ollama run llama4:maverick`     |
+| Llama 3.3          | 70B        | 43GB  | `ollama run llama3.3`            |
+| Llama 3.2          | 3B         | 2.0GB | `ollama run llama3.2`            |
+| Llama 3.2          | 1B         | 1.3GB | `ollama run llama3.2:1b`         |
+| Llama 3.2 Vision   | 11B        | 7.9GB | `ollama run llama3.2-vision`     |
+| Llama 3.2 Vision   | 90B        | 55GB  | `ollama run llama3.2-vision:90b` |
+| Llama 3.1          | 8B         | 4.7GB | `ollama run llama3.1`            |
+| Llama 3.1          | 405B       | 231GB | `ollama run llama3.1:405b`       |
+| Phi 4              | 14B        | 9.1GB | `ollama run phi4`                |
+| Phi 4 Mini         | 3.8B       | 2.5GB | `ollama run phi4-mini`           |
+| Mistral            | 7B         | 4.1GB | `ollama run mistral`             |
+| Moondream 2        | 1.4B       | 829MB | `ollama run moondream`           |
+| Neural Chat        | 7B         | 4.1GB | `ollama run neural-chat`         |
+| Starling           | 7B         | 4.1GB | `ollama run starling-lm`         |
+| Code Llama         | 7B         | 3.8GB | `ollama run codellama`           |
+| Llama 2 Uncensored | 7B         | 3.8GB | `ollama run llama2-uncensored`   |
+| LLaVA              | 7B         | 4.5GB | `ollama run llava`               |
+| Granite-3.3        | 8B         | 4.9GB | `ollama run granite3.3`          |
+
+> [!NOTE]
+> You should have at least 8 GB of RAM available to run the 7B models, 16 GB to run the 13B models, and 32 GB to run the 33B models.
+
+## Customize a model
+
+### Import from GGUF
+
+Ollama supports importing GGUF models in the Modelfile:
+
+1. Create a file named `Modelfile`, with a `FROM` instruction with the local filepath to the model you want to import.
+
+   ```
+   FROM ./vicuna-33b.Q4_0.gguf
+   ```
+
+2. Create the model in Ollama
+
+   ```shell
+   ollama create example -f Modelfile
+   ```
+
+3. Run the model
+
+   ```shell
+   ollama run example
+   ```
+
+### Import from Safetensors
+
+See the [guide](https://docs.ollama.com/import) on importing models for more information.
+
+### Customize a prompt
+
+Models from the Ollama library can be customized with a prompt. For example, to customize the `llama3.2` model:
+
+```shell
+ollama pull llama3.2
+```
+
+Create a `Modelfile`:
+
+```
+FROM llama3.2
+
+# set the temperature to 1 [higher is more creative, lower is more coherent]
+PARAMETER temperature 1
+
+# set the system message
+SYSTEM """
+You are Mario from Super Mario Bros. Answer as Mario, the assistant, only.
+"""
+```
+
+Next, create and run the model:
+
+```
+ollama create mario -f ./Modelfile
+ollama run mario
+>>> hi
+Hello! It's your friend Mario.
+```
+
+For more information on working with a Modelfile, see the [Modelfile](https://docs.ollama.com/modelfile) documentation.
+
+## CLI Reference
+
+### Create a model
+
+`ollama create` is used to create a model from a Modelfile.
+
+```shell
+ollama create mymodel -f ./Modelfile
+```
+
+### Pull a model
+
+```shell
+ollama pull llama3.2
+```
+
+> This command can also be used to update a local model. Only the diff will be pulled.
+
+### Remove a model
+
+```shell
+ollama rm llama3.2
+```
+
+### Copy a model
+
+```shell
+ollama cp llama3.2 my-model
+```
+
+### Multiline input
+
+For multiline input, you can wrap text with `"""`:
+
+```
+>>> """Hello,
+... world!
+... """
+I'm a basic program that prints the famous "Hello, world!" message to the console.
+```
+
+### Multimodal models
+
+```
+ollama run llava "What's in this image? /Users/jmorgan/Desktop/smile.png"
+```
+
+> **Output**: The image features a yellow smiley face, which is likely the central focus of the picture.
+
+### Pass the prompt as an argument
+
+```shell
+ollama run llama3.2 "Summarize this file: $(cat README.md)"
+```
+
+> **Output**: Ollama is a lightweight, extensible framework for building and running language models on the local machine. It provides a simple API for creating, running, and managing models, as well as a library of pre-built models that can be easily used in a variety of applications.
+
+### Show model information
+
+```shell
+ollama show llama3.2
+```
+
+### List models on your computer
+
+```shell
+ollama list
+```
+
+### List which models are currently loaded
+
+```shell
+ollama ps
+```
+
+### Stop a model which is currently running
+
+```shell
+ollama stop llama3.2
+```
+
+### Generate embeddings from the CLI
+
+```shell
+ollama run embeddinggemma "Your text to embed"
+```
+
+You can also pipe text for scripted workflows:
+
+```shell
+echo "Your text to embed" | ollama run embeddinggemma
+```
+
+### Start Ollama
+
+`ollama serve` is used when you want to start ollama without running the desktop application.
+
+## Building
+
+See the [developer guide](https://github.com/ollama/ollama/blob/main/docs/development.md)
+
+### Running local builds
+
+Next, start the server:
+
+```shell
+./ollama serve
+```
+
+Finally, in a separate shell, run a model:
+
+```shell
+./ollama run llama3.2
+```
+
+## Building with MLX (experimental)
+
+First build the MLX libraries:
+
+```shell
+cmake --preset MLX
+cmake --build --preset MLX --parallel
+cmake --install build --component MLX
+```
+
+When building with the `-tags mlx` flag, the main `ollama` binary includes MLX support for experimental features like image generation:
+
+```shell
+go build -tags mlx .
+```
+
+Finally, start the server:
+
+```
+./ollama serve
+```
+
+### Building MLX with CUDA
+
+When building with CUDA, use the preset "MLX CUDA 13" or "MLX CUDA 12" to enable CUDA with default architectures:
+
+```shell
+cmake --preset 'MLX CUDA 13'
+cmake --build --preset 'MLX CUDA 13' --parallel
+cmake --install build --component MLX
+```

 ## REST API

 Ollama has a REST API for running and managing models.

-```
-curl http://localhost:11434/api/chat -d '{
-  "model": "gemma3",
-  "messages": [{
-    "role": "user",
-    "content": "Why is the sky blue?"
-  }],
-  "stream": false
+### Generate a response
+
+```shell
+curl http://localhost:11434/api/generate -d '{
+  "model": "llama3.2",
+  "prompt":"Why is the sky blue?"
 }'
 ```

-See the [API documentation](https://docs.ollama.com/api) for all endpoints.
+### Chat with a model

-### Python
-
-```
-pip install ollama
+```shell
+curl http://localhost:11434/api/chat -d '{
+  "model": "llama3.2",
+  "messages": [
+    { "role": "user", "content": "why is the sky blue?" }
+  ]
+}'
 ```

-```python
-from ollama import chat
-
-response = chat(model='gemma3', 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: "gemma3",
-  messages: [{ role: "user", content: "Why is the sky blue?" }],
-});
-console.log(response.message.content);
-```
-
-## Supported backends
-
- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
-
-## Documentation
-
- [CLI reference](https://docs.ollama.com/cli)
- [REST API reference](https://docs.ollama.com/api)
- [Importing models](https://docs.ollama.com/import)
- [Modelfile reference](https://docs.ollama.com/modelfile)
- [Building from source](https://github.com/ollama/ollama/blob/main/docs/development.md)
+See the [API documentation](./docs/api.md) for all endpoints.

 ## Community Integrations

-> Want to add your project? Open a pull request.
+### Web & Desktop

-### Chat Interfaces
+- [Onyx](https://github.com/onyx-dot-app/onyx)
+- [Open WebUI](https://github.com/open-webui/open-webui)
+- [SwiftChat (macOS with ReactNative)](https://github.com/aws-samples/swift-chat)
+- [Enchanted (macOS native)](https://github.com/AugustDev/enchanted)
+- [Hollama](https://github.com/fmaclen/hollama)
+- [Lollms WebUI (Single user)](https://github.com/ParisNeo/lollms-webui)
+- [Lollms (Multi users)](https://github.com/ParisNeo/lollms)
+- [LibreChat](https://github.com/danny-avila/LibreChat)
+- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt)
+- [HTML UI](https://github.com/rtcfirefly/ollama-ui)
+- [AI-UI](https://github.com/bajahaw/ai-ui)
+- [Saddle](https://github.com/jikkuatwork/saddle)
+- [TagSpaces](https://www.tagspaces.org) (A platform for file-based apps, [utilizing Ollama](https://docs.tagspaces.org/ai/) for the generation of tags and descriptions)
+- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama)
+- [Chatbot UI v2](https://github.com/mckaywrigley/chatbot-ui)
+- [Typescript UI](https://github.com/ollama-interface/Ollama-Gui?tab=readme-ov-file)
+- [Minimalistic React UI for Ollama Models](https://github.com/richawo/minimal-llm-ui)
+- [Ollamac](https://github.com/kevinhermawan/Ollamac)
+- [big-AGI](https://github.com/enricoros/big-AGI)
+- [Cheshire Cat assistant framework](https://github.com/cheshire-cat-ai/core)
+- [Amica](https://github.com/semperai/amica)
+- [chatd](https://github.com/BruceMacD/chatd)
+- [Ollama-SwiftUI](https://github.com/kghandour/Ollama-SwiftUI)
+- [Dify.AI](https://github.com/langgenius/dify)
+- [MindMac](https://mindmac.app)
+- [NextJS Web Interface for Ollama](https://github.com/jakobhoeg/nextjs-ollama-llm-ui)
+- [Msty](https://msty.app)
+- [Chatbox](https://github.com/Bin-Huang/Chatbox)
+- [WinForm Ollama Copilot](https://github.com/tgraupmann/WinForm_Ollama_Copilot)
+- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) with [Get Started Doc](https://docs.nextchat.dev/models/ollama)
+- [Alpaca WebUI](https://github.com/mmo80/alpaca-webui)
+- [OllamaGUI](https://github.com/enoch1118/ollamaGUI)
+- [OpenAOE](https://github.com/InternLM/OpenAOE)
+- [Odin Runes](https://github.com/leonid20000/OdinRunes)
+- [LLM-X](https://github.com/mrdjohnson/llm-x) (Progressive Web App)
+- [AnythingLLM (Docker + MacOs/Windows/Linux native app)](https://github.com/Mintplex-Labs/anything-llm)
+- [Screenpipe](https://github.com/mediar-ai/screenpipe) (24/7 screen & mic recording with AI-powered search, uses Ollama for local LLM features)
+- [Ollama Basic Chat: Uses HyperDiv Reactive UI](https://github.com/rapidarchitect/ollama_basic_chat)
+- [Ollama-chats RPG](https://github.com/drazdra/ollama-chats)
+- [IntelliBar](https://intellibar.app/) (AI-powered assistant for macOS)
+- [Jirapt](https://github.com/AliAhmedNada/jirapt) (Jira Integration to generate issues, tasks, epics)
+- [ojira](https://github.com/AliAhmedNada/ojira) (Jira chrome plugin to easily generate descriptions for tasks)
+- [QA-Pilot](https://github.com/reid41/QA-Pilot) (Interactive chat tool that can leverage Ollama models for rapid understanding and navigation of GitHub code repositories)
+- [ChatOllama](https://github.com/sugarforever/chat-ollama) (Open Source Chatbot based on Ollama with Knowledge Bases)
+- [CRAG Ollama Chat](https://github.com/Nagi-ovo/CRAG-Ollama-Chat) (Simple Web Search with Corrective RAG)
+- [RAGFlow](https://github.com/infiniflow/ragflow) (Open-source Retrieval-Augmented Generation engine based on deep document understanding)
+- [StreamDeploy](https://github.com/StreamDeploy-DevRel/streamdeploy-llm-app-scaffold) (LLM Application Scaffold)
+- [chat](https://github.com/swuecho/chat) (chat web app for teams)
+- [Lobe Chat](https://github.com/lobehub/lobe-chat) with [Integrating Doc](https://lobehub.com/docs/self-hosting/examples/ollama)
+- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) (Local Chat with multiple PDFs using Ollama and RAG)
+- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) (Flexible native client with RAG & multi-agent automation)
+- [macai](https://github.com/Renset/macai) (macOS client for Ollama, ChatGPT, and other compatible API back-ends)
+- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) (RWKV offline LLM deployment tool, also usable as a client for ChatGPT and Ollama)
+- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) (app to evaluate and compare models)
+- [Olpaka](https://github.com/Otacon/olpaka) (User-friendly Flutter Web App for Ollama)
+- [Casibase](https://casibase.org) (An open source AI knowledge base and dialogue system combining the latest RAG, SSO, ollama support, and multiple large language models.)
+- [OllamaSpring](https://github.com/CrazyNeil/OllamaSpring) (Ollama Client for macOS)
+- [LLocal.in](https://github.com/kartikm7/llocal) (Easy to use Electron Desktop Client for Ollama)
+- [Shinkai Desktop](https://github.com/dcSpark/shinkai-apps) (Two click install Local AI using Ollama + Files + RAG)
+- [AiLama](https://github.com/zeyoyt/ailama) (A Discord User App that allows you to interact with Ollama anywhere in Discord)
+- [Ollama with Google Mesop](https://github.com/rapidarchitect/ollama_mesop/) (Mesop Chat Client implementation with Ollama)
+- [R2R](https://github.com/SciPhi-AI/R2R) (Open-source RAG engine)
+- [Ollama-Kis](https://github.com/elearningshow/ollama-kis) (A simple easy-to-use GUI with sample custom LLM for Drivers Education)
+- [OpenGPA](https://opengpa.org) (Open-source offline-first Enterprise Agentic Application)
+- [Painting Droid](https://github.com/mateuszmigas/painting-droid) (Painting app with AI integrations)
+- [Kerlig AI](https://www.kerlig.com/) (AI writing assistant for macOS)
+- [AI Studio](https://github.com/MindWorkAI/AI-Studio)
+- [Sidellama](https://github.com/gyopak/sidellama) (browser-based LLM client)
+- [LLMStack](https://github.com/trypromptly/LLMStack) (No-code multi-agent framework to build LLM agents and workflows)
+- [BoltAI for Mac](https://boltai.com) (AI Chat Client for Mac)
+- [Harbor](https://github.com/av/harbor) (Containerized LLM Toolkit with Ollama as default backend)
+- [PyGPT](https://github.com/szczyglis-dev/py-gpt) (AI desktop assistant for Linux, Windows, and Mac)
+- [Alpaca](https://github.com/Jeffser/Alpaca) (An Ollama client application for Linux and macOS made with GTK4 and Adwaita)
+- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) (AutoGPT Ollama integration)
+- [Go-CREW](https://www.jonathanhecl.com/go-crew/) (Powerful Offline RAG in Golang)
+- [PartCAD](https://github.com/openvmp/partcad/) (CAD model generation with OpenSCAD and CadQuery)
+- [Ollama4j Web UI](https://github.com/ollama4j/ollama4j-web-ui) - Java-based Web UI for Ollama built with Vaadin, Spring Boot, and Ollama4j
+- [PyOllaMx](https://github.com/kspviswa/pyOllaMx) - macOS application capable of chatting with both Ollama and Apple MLX models.
+- [Cline](https://github.com/cline/cline) - Formerly known as Claude Dev is a VS Code extension for multi-file/whole-repo coding
+- [Void](https://github.com/voideditor/void) (Open source AI code editor and Cursor alternative)
+- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) (Desktop client with Ollama support)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
+- [Archyve](https://github.com/nickthecook/archyve) (RAG-enabling document library)
+- [crewAI with Mesop](https://github.com/rapidarchitect/ollama-crew-mesop) (Mesop Web Interface to run crewAI with Ollama)
+- [Tkinter-based client](https://github.com/chyok/ollama-gui) (Python tkinter-based Client for Ollama)
+- [LLMChat](https://github.com/trendy-design/llmchat) (Privacy focused, 100% local, intuitive all-in-one chat interface)
+- [Local Multimodal AI Chat](https://github.com/Leon-Sander/Local-Multimodal-AI-Chat) (Ollama-based LLM Chat with support for multiple features, including PDF RAG, voice chat, image-based interactions, and integration with OpenAI.)
+- [ARGO](https://github.com/xark-argo/argo) (Locally download and run Ollama and Huggingface models with RAG and deep research on Mac/Windows/Linux)
+- [OrionChat](https://github.com/EliasPereirah/OrionChat) - OrionChat is a web interface for chatting with different AI providers
+- [G1](https://github.com/bklieger-groq/g1) (Prototype of using prompting strategies to improve the LLM's reasoning through o1-like reasoning chains.)
+- [Web management](https://github.com/lemonit-eric-mao/ollama-web-management) (Web management page)
+- [Promptery](https://github.com/promptery/promptery) (desktop client for Ollama.)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [chat-ollama](https://github.com/annilq/chat-ollama) (a React Native client for Ollama)
+- [SpaceLlama](https://github.com/tcsenpai/spacellama) (Firefox and Chrome extension to quickly summarize web pages with ollama in a sidebar)
+- [YouLama](https://github.com/tcsenpai/youlama) (Webapp to quickly summarize any YouTube video, supporting Invidious as well)
+- [DualMind](https://github.com/tcsenpai/dualmind) (Experimental app allowing two models to talk to each other in the terminal or in a web interface)
+- [ollamarama-matrix](https://github.com/h1ddenpr0cess20/ollamarama-matrix) (Ollama chatbot for the Matrix chat protocol)
+- [ollama-chat-app](https://github.com/anan1213095357/ollama-chat-app) (Flutter-based chat app)
+- [Perfect Memory AI](https://www.perfectmemory.ai/) (Productivity AI assists personalized by what you have seen on your screen, heard, and said in the meetings)
+- [Hexabot](https://github.com/hexastack/hexabot) (A conversational AI builder)
+- [Reddit Rate](https://github.com/rapidarchitect/reddit_analyzer) (Search and Rate Reddit topics with a weighted summation)
+- [OpenTalkGpt](https://github.com/adarshM84/OpenTalkGpt) (Chrome Extension to manage open-source models supported by Ollama, create custom models, and chat with models from a user-friendly UI)
+- [VT](https://github.com/vinhnx/vt.ai) (A minimal multimodal AI chat app, with dynamic conversation routing. Supports local models via Ollama)
+- [Nosia](https://github.com/nosia-ai/nosia) (Easy to install and use RAG platform based on Ollama)
+- [Witsy](https://github.com/nbonamy/witsy) (An AI Desktop application available for Mac/Windows/Linux)
+- [Abbey](https://github.com/US-Artificial-Intelligence/abbey) (A configurable AI interface server with notebooks, document storage, and YouTube support)
+- [Minima](https://github.com/dmayboroda/minima) (RAG with on-premises or fully local workflow)
+- [aidful-ollama-model-delete](https://github.com/AidfulAI/aidful-ollama-model-delete) (User interface for simplified model cleanup)
+- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) (An AI-powered search engine & an open-source alternative to Perplexity AI)
+- [Ollama Chat WebUI for Docker ](https://github.com/oslook/ollama-webui) (Support for local docker deployment, lightweight ollama webui)
+- [AI Toolkit for Visual Studio Code](https://aka.ms/ai-tooklit/ollama-docs) (Microsoft-official VS Code extension to chat, test, evaluate models with Ollama support, and use them in your AI applications.)
+- [MinimalNextOllamaChat](https://github.com/anilkay/MinimalNextOllamaChat) (Minimal Web UI for Chat and Model Control)
+- [Chipper](https://github.com/TilmanGriesel/chipper) AI interface for tinkerers (Ollama, Haystack RAG, Python)
+- [ChibiChat](https://github.com/CosmicEventHorizon/ChibiChat) (Kotlin-based Android app to chat with Ollama and Koboldcpp API endpoints)
+- [LocalLLM](https://github.com/qusaismael/localllm) (Minimal Web-App to run ollama models on it with a GUI)
+- [Ollamazing](https://github.com/buiducnhat/ollamazing) (Web extension to run Ollama models)
+- [OpenDeepResearcher-via-searxng](https://github.com/benhaotang/OpenDeepResearcher-via-searxng) (A Deep Research equivalent endpoint with Ollama support for running locally)
+- [AntSK](https://github.com/AIDotNet/AntSK) (Out-of-the-box & Adaptable RAG Chatbot)
+- [MaxKB](https://github.com/1Panel-dev/MaxKB/) (Ready-to-use & flexible RAG Chatbot)
+- [yla](https://github.com/danielekp/yla) (Web interface to freely interact with your customized models)
+- [LangBot](https://github.com/RockChinQ/LangBot) (LLM-based instant messaging bots platform, with Agents, RAG features, supports multiple platforms)
+- [1Panel](https://github.com/1Panel-dev/1Panel/) (Web-based Linux Server Management Tool)
+- [AstrBot](https://github.com/Soulter/AstrBot/) (User-friendly LLM-based multi-platform chatbot with a WebUI, supporting RAG, LLM agents, and plugins integration)
+- [Reins](https://github.com/ibrahimcetin/reins) (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
+- [Flufy](https://github.com/Aharon-Bensadoun/Flufy) (A beautiful chat interface for interacting with Ollama's API. Built with React, TypeScript, and Material-UI.)
+- [Ellama](https://github.com/zeozeozeo/ellama) (Friendly native app to chat with an Ollama instance)
+- [screenpipe](https://github.com/mediar-ai/screenpipe) Build agents powered by your screen history
+- [Ollamb](https://github.com/hengkysteen/ollamb) (Simple yet rich in features, cross-platform built with Flutter and designed for Ollama. Try the [web demo](https://hengkysteen.github.io/demo/ollamb/).)
+- [Writeopia](https://github.com/Writeopia/Writeopia) (Text editor with integration with Ollama)
+- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) (AI collaborative workspace with Ollama, cross-platform and self-hostable)
+- [Lumina](https://github.com/cushydigit/lumina.git) (A lightweight, minimal React.js frontend for interacting with Ollama servers)
+- [Tiny Notepad](https://pypi.org/project/tiny-notepad) (A lightweight, notepad-like interface to chat with ollama available on PyPI)
+- [macLlama (macOS native)](https://github.com/hellotunamayo/macLlama) (A native macOS GUI application for interacting with Ollama models, featuring a chat interface.)
+- [GPTranslate](https://github.com/philberndt/GPTranslate) (A fast and lightweight, AI powered desktop translation application written with Rust and Tauri. Features real-time translation with OpenAI/Azure/Ollama.)
+- [ollama launcher](https://github.com/NGC13009/ollama-launcher) (A launcher for Ollama, aiming to provide users with convenient functions such as ollama server launching, management, or configuration.)
+- [ai-hub](https://github.com/Aj-Seven/ai-hub) (AI Hub supports multiple models via API keys and Chat support via Ollama API.)
+- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) (Open source document management system to organize, tag, search, and automate your files with powerful Ollama driven workflows.)
+- [Serene Pub](https://github.com/doolijb/serene-pub) (Beginner friendly, open source AI Roleplaying App for Windows, Mac OS and Linux. Search, download and use models with Ollama all inside the app.)
+- [Andes](https://github.com/aqerd/andes) (A Visual Studio Code extension that provides a local UI interface for Ollama models)
+- [KDeps](https://github.com/kdeps/kdeps) (Kdeps is an offline-first AI framework for building Dockerized full-stack AI applications declaratively using Apple PKL and integrates APIs with Ollama on the backend.)
+- [Clueless](https://github.com/KashyapTan/clueless) (Open Source & Local Cluely: A desktop application LLM assistant to help you talk to anything on your screen using locally served Ollama models. Also undetectable to screenshare)
+- [ollama-co2](https://github.com/carbonatedWaterOrg/ollama-co2) (FastAPI web interface for monitoring and managing local and remote Ollama servers with real-time model monitoring and concurrent downloads)
+- [Hillnote](https://hillnote.com) (A Markdown-first workspace designed to supercharge your AI workflow. Create documents ready to integrate with Claude, ChatGPT, Gemini, Cursor, and more - all while keeping your work on your device.)
+- [Stakpak](https://github.com/stakpak/agent) (An open source, vendor neutral DevOps agent that works with any model, and any stack, for teams who just want to ship)

-#### Web
-
- [Open WebUI](https://github.com/open-webui/open-webui) - Extensible, self-hosted AI interface
- [Onyx](https://github.com/onyx-dot-app/onyx) - Connected AI workspace
- [LibreChat](https://github.com/danny-avila/LibreChat) - Enhanced ChatGPT clone with multi-provider support
- [Lobe Chat](https://github.com/lobehub/lobe-chat) - Modern chat framework with plugin ecosystem ([docs](https://lobehub.com/docs/self-hosting/examples/ollama))
- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) - Cross-platform ChatGPT UI ([docs](https://docs.nextchat.dev/models/ollama))
- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) - AI-powered search engine, open-source Perplexity alternative
- [big-AGI](https://github.com/enricoros/big-AGI) - AI suite for professionals
- [Lollms WebUI](https://github.com/ParisNeo/lollms-webui) - Multi-model web interface
- [ChatOllama](https://github.com/sugarforever/chat-ollama) - Chatbot with knowledge bases
- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt) - On-premise AI platform
- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama) - ChatGPT-style web interface
- [Hollama](https://github.com/fmaclen/hollama) - Minimal web interface
- [Chatbox](https://github.com/Bin-Huang/Chatbox) - Desktop and web AI client
- [chat](https://github.com/swuecho/chat) - Chat web app for teams
- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) - Chat with multiple PDFs using RAG
- [Tkinter-based client](https://github.com/chyok/ollama-gui) - Python desktop client
-
-#### Desktop
-
- [Dify.AI](https://github.com/langgenius/dify) - LLM app development platform
- [AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) - All-in-one AI app for Mac, Windows, and Linux
- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid) - Cross-platform mobile and desktop client
- [Witsy](https://github.com/nbonamy/witsy) - AI desktop app for Mac, Windows, and Linux
- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) - Multi-provider desktop client
- [Ollama App](https://github.com/JHubi1/ollama-app) - Multi-platform client for desktop and mobile
- [PyGPT](https://github.com/szczyglis-dev/py-gpt) - AI desktop assistant for Linux, Windows, and Mac
- [Alpaca](https://github.com/Jeffser/Alpaca) - GTK4 client for Linux and macOS
- [SwiftChat](https://github.com/aws-samples/swift-chat) - Cross-platform including iOS, Android, and Apple Vision Pro
- [Enchanted](https://github.com/AugustDev/enchanted) - Native macOS and iOS client
- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) - Multi-model desktop runner
- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) - Evaluate and compare models
- [macai](https://github.com/Renset/macai) - macOS client for Ollama and ChatGPT
- [AI Studio](https://github.com/MindWorkAI/AI-Studio) - Multi-provider desktop IDE
- [Reins](https://github.com/ibrahimcetin/reins) - Parameter tuning and reasoning model support
- [ConfiChat](https://github.com/1runeberg/confichat) - Privacy-focused with optional encryption
- [LLocal.in](https://github.com/kartikm7/llocal) - Electron desktop client
- [MindMac](https://mindmac.app) - AI chat client for Mac
- [Msty](https://msty.app) - Multi-model desktop client
- [BoltAI for Mac](https://boltai.com) - AI chat client for Mac
- [IntelliBar](https://intellibar.app/) - AI-powered assistant for macOS
- [Kerlig AI](https://www.kerlig.com/) - AI writing assistant for macOS
- [Hillnote](https://hillnote.com) - Markdown-first AI workspace
- [Perfect Memory AI](https://www.perfectmemory.ai/) - Productivity AI personalized by screen and meeting history
-
-#### Mobile
-
- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) - One-click Ollama on Android
-
-> SwiftChat, Enchanted, Maid, Ollama App, Reins, and ConfiChat listed above also support mobile platforms.
-
-### Code Editors & Development
-
- [Cline](https://github.com/cline/cline) - VS Code extension for multi-file/whole-repo coding
- [Continue](https://github.com/continuedev/continue) - Open-source AI code assistant for any IDE
- [Void](https://github.com/voideditor/void) - Open source AI code editor, Cursor alternative
- [Copilot for Obsidian](https://github.com/logancyang/obsidian-copilot) - AI assistant for Obsidian
- [twinny](https://github.com/rjmacarthy/twinny) - Copilot and Copilot chat alternative
- [gptel Emacs client](https://github.com/karthink/gptel) - LLM client for Emacs
- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) - Use Ollama as GitHub Copilot
- [Obsidian Local GPT](https://github.com/pfrankov/obsidian-local-gpt) - Local AI for Obsidian
- [Ellama Emacs client](https://github.com/s-kostyaev/ellama) - LLM tool for Emacs
- [orbiton](https://github.com/xyproto/orbiton) - Config-free text editor with Ollama tab completion
- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) - Sublime Text 4 AI assistant
- [VT Code](https://github.com/vinhnx/vtcode) - Rust-based terminal coding agent with Tree-sitter
- [QodeAssist](https://github.com/Palm1r/QodeAssist) - AI coding assistant for Qt Creator
- [AI Toolkit for VS Code](https://aka.ms/ai-tooklit/ollama-docs) - Microsoft-official VS Code extension
- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama) - Natural language interface for computers
-
-### Libraries & SDKs
-
- [LiteLLM](https://github.com/BerriAI/litellm) - Unified API for 100+ LLM providers
- [Semantic Kernel](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama) - Microsoft AI orchestration SDK
- [LangChain4j](https://github.com/langchain4j/langchain4j) - Java LangChain ([example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java))
- [LangChainGo](https://github.com/tmc/langchaingo/) - Go LangChain ([example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example))
- [Spring AI](https://github.com/spring-projects/spring-ai) - Spring framework AI support ([docs](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html))
- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
- [Ollama for Ruby](https://github.com/crmne/ruby_llm) - Ruby LLM library
- [any-llm](https://github.com/mozilla-ai/any-llm) - Unified LLM interface by Mozilla
- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp) - .NET SDK
- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) - Rust LangChain ([example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs))
- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) - Java agent framework ([example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama))
- [Elixir LangChain](https://github.com/brainlid/langchain) - Elixir LangChain
- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs) - Rust SDK
- [LangChain for .NET](https://github.com/tryAGI/LangChain) - .NET LangChain ([example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs))
- [chromem-go](https://github.com/philippgille/chromem-go) - Go vector database with Ollama embeddings ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
- [LangChainDart](https://github.com/davidmigloz/langchain_dart) - Dart LangChain
- [LlmTornado](https://github.com/lofcz/llmtornado) - Unified C# interface for multiple inference APIs
- [Ollama4j for Java](https://github.com/ollama4j/ollama4j) - Java SDK
- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel) - Laravel integration
- [Ollama for Swift](https://github.com/mattt/ollama-swift) - Swift SDK
- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama) - Data framework for LLM apps
- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md) - AI pipeline framework
- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama) - Google AI framework
- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp) - C++ SDK
- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) - Julia LLM toolkit ([example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama))
- [Ollama for R - rollama](https://github.com/JBGruber/rollama) - R SDK
- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama) - AI gateway
- [Testcontainers](https://testcontainers.com/modules/ollama/) - Container-based testing
- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama) - PHP AI framework
-
-### Frameworks & Agents
-
- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) - Autonomous AI agent platform
- [crewAI](https://github.com/crewAIInc/crewAI) - Multi-agent orchestration framework
- [Strands Agents](https://github.com/strands-agents/sdk-python) - Model-driven agent building by AWS
- [Cheshire Cat](https://github.com/cheshire-cat-ai/core) - AI assistant framework
- [any-agent](https://github.com/mozilla-ai/any-agent) - Unified agent framework interface by Mozilla
- [Stakpak](https://github.com/stakpak/agent) - Open source DevOps agent
- [Hexabot](https://github.com/hexastack/hexabot) - Conversational AI builder
- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) - Multi-agent orchestration ([docs](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama))
-
-### RAG & Knowledge Bases
-
- [RAGFlow](https://github.com/infiniflow/ragflow) - RAG engine based on deep document understanding
- [R2R](https://github.com/SciPhi-AI/R2R) - Open-source RAG engine
- [MaxKB](https://github.com/1Panel-dev/MaxKB/) - Ready-to-use RAG chatbot
- [Minima](https://github.com/dmayboroda/minima) - On-premises or fully local RAG
- [Chipper](https://github.com/TilmanGriesel/chipper) - AI interface with Haystack RAG
- [ARGO](https://github.com/xark-argo/argo) - RAG and deep research on Mac/Windows/Linux
- [Archyve](https://github.com/nickthecook/archyve) - RAG-enabling document library
- [Casibase](https://casibase.org) - AI knowledge base with RAG and SSO
- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) - Native client with RAG and multi-agent automation
-
-### Bots & Messaging
-
- [LangBot](https://github.com/RockChinQ/LangBot) - Multi-platform messaging bots with agents and RAG
- [AstrBot](https://github.com/Soulter/AstrBot/) - Multi-platform chatbot with RAG and plugins
- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) - TypeScript Discord bot
- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram) - Telegram bot
- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) - Telegram bot for roleplay
-
-### Terminal & CLI
-
- [aichat](https://github.com/sigoden/aichat) - All-in-one LLM CLI with Shell Assistant, RAG, and AI tools
- [oterm](https://github.com/ggozad/oterm) - Terminal client for Ollama
- [gollama](https://github.com/sammcj/gollama) - Go-based model manager for Ollama
- [tlm](https://github.com/yusufcanb/tlm) - Local shell copilot
- [tenere](https://github.com/pythops/tenere) - TUI for LLMs
- [ParLlama](https://github.com/paulrobello/parllama) - TUI for Ollama
- [llm-ollama](https://github.com/taketwo/llm-ollama) - Plugin for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/)
- [ShellOracle](https://github.com/djcopley/ShellOracle) - Shell command suggestions
- [LLM-X](https://github.com/mrdjohnson/llm-x) - Progressive web app for LLMs
- [cmdh](https://github.com/pgibler/cmdh) - Natural language to shell commands
- [VT](https://github.com/vinhnx/vt.ai) - Minimal multimodal AI chat app
-
-### Productivity & Apps
-
- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) - AI collaborative workspace, self-hostable Notion alternative
- [Screenpipe](https://github.com/mediar-ai/screenpipe) - 24/7 screen and mic recording with AI-powered search
- [Vibe](https://github.com/thewh1teagle/vibe) - Transcribe and analyze meetings
- [Page Assist](https://github.com/n4ze3m/page-assist) - Chrome extension for AI-powered browsing
- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) - Private, on-device browser AI assistant
- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server) - Security proxy for Ollama
- [1Panel](https://github.com/1Panel-dev/1Panel/) - Web-based Linux server management
- [Writeopia](https://github.com/Writeopia/Writeopia) - Text editor with Ollama integration
- [QA-Pilot](https://github.com/reid41/QA-Pilot) - GitHub code repository understanding
- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama) - Ollama in Raycast
- [Painting Droid](https://github.com/mateuszmigas/painting-droid) - Painting app with AI integrations
- [Serene Pub](https://github.com/doolijb/serene-pub) - AI roleplaying app
- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) - Document management with Ollama workflows
- [TagSpaces](https://www.tagspaces.org) - File management with [AI tagging](https://docs.tagspaces.org/ai/)
-
-### Observability & Monitoring
-
- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) - Debug, evaluate, and monitor LLM applications
- [OpenLIT](https://github.com/openlit/openlit) - OpenTelemetry-native monitoring for Ollama and GPUs
- [Lunary](https://lunary.ai/docs/integrations/ollama) - LLM observability with analytics and PII masking
- [Langfuse](https://langfuse.com/docs/integrations/ollama) - Open source LLM observability
- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) - AI observability and evaluation for agents
- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) - Open source LLM observability
-
-### Database & Embeddings
-
- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database ([guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md))
- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) - Connect Ollama with 200+ data platforms
- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) - Embeddable vector database for Go ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
- [Kangaroo](https://github.com/dbkangaroo/kangaroo) - AI-powered SQL client
-
-### Infrastructure & Deployment
-
-#### Cloud
+### Cloud

 - [Google Cloud](https://cloud.google.com/run/docs/tutorials/gpu-gemma2-with-ollama)
 - [Fly.io](https://fly.io/docs/python/do-more/add-ollama/)
 - [Koyeb](https://www.koyeb.com/deploy/ollama)
- [Harbor](https://github.com/av/harbor) - Containerized LLM toolkit with Ollama as default backend

-#### Package Managers
+### Tutorial
+
+- [handy-ollama](https://github.com/datawhalechina/handy-ollama) (Chinese Tutorial for Ollama by [Datawhale ](https://github.com/datawhalechina) - China's Largest Open Source AI Learning Community)
+
+### Terminal
+
+- [oterm](https://github.com/ggozad/oterm)
+- [Ellama Emacs client](https://github.com/s-kostyaev/ellama)
+- [Emacs client](https://github.com/zweifisch/ollama)
+- [neollama](https://github.com/paradoxical-dev/neollama) UI client for interacting with models from within Neovim
+- [gen.nvim](https://github.com/David-Kunz/gen.nvim)
+- [ollama.nvim](https://github.com/nomnivore/ollama.nvim)
+- [ollero.nvim](https://github.com/marco-souza/ollero.nvim)
+- [ollama-chat.nvim](https://github.com/gerazov/ollama-chat.nvim)
+- [ogpt.nvim](https://github.com/huynle/ogpt.nvim)
+- [gptel Emacs client](https://github.com/karthink/gptel)
+- [Oatmeal](https://github.com/dustinblackman/oatmeal)
+- [cmdh](https://github.com/pgibler/cmdh)
+- [ooo](https://github.com/npahlfer/ooo)
+- [shell-pilot](https://github.com/reid41/shell-pilot)(Interact with models via pure shell scripts on Linux or macOS)
+- [tenere](https://github.com/pythops/tenere)
+- [llm-ollama](https://github.com/taketwo/llm-ollama) for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/).
+- [typechat-cli](https://github.com/anaisbetts/typechat-cli)
+- [ShellOracle](https://github.com/djcopley/ShellOracle)
+- [tlm](https://github.com/yusufcanb/tlm)
+- [podman-ollama](https://github.com/ericcurtin/podman-ollama)
+- [gollama](https://github.com/sammcj/gollama)
+- [ParLlama](https://github.com/paulrobello/parllama)
+- [Ollama eBook Summary](https://github.com/cognitivetech/ollama-ebook-summary/)
+- [Ollama Mixture of Experts (MOE) in 50 lines of code](https://github.com/rapidarchitect/ollama_moe)
+- [vim-intelligence-bridge](https://github.com/pepo-ec/vim-intelligence-bridge) Simple interaction of "Ollama" with the Vim editor
+- [x-cmd ollama](https://x-cmd.com/mod/ollama)
+- [bb7](https://github.com/drunkwcodes/bb7)
+- [SwollamaCLI](https://github.com/marcusziade/Swollama) bundled with the Swollama Swift package. [Demo](https://github.com/marcusziade/Swollama?tab=readme-ov-file#cli-usage)
+- [aichat](https://github.com/sigoden/aichat) All-in-one LLM CLI tool featuring Shell Assistant, Chat-REPL, RAG, AI tools & agents, with access to OpenAI, Claude, Gemini, Ollama, Groq, and more.
+- [PowershAI](https://github.com/rrg92/powershai) PowerShell module that brings AI to terminal on Windows, including support for Ollama
+- [DeepShell](https://github.com/Abyss-c0re/deepshell) Your self-hosted AI assistant. Interactive Shell, Files and Folders analysis.
+- [orbiton](https://github.com/xyproto/orbiton) Configuration-free text editor and IDE with support for tab completion with Ollama.
+- [orca-cli](https://github.com/molbal/orca-cli) Ollama Registry CLI Application - Browse, pull, and download models from Ollama Registry in your terminal.
+- [GGUF-to-Ollama](https://github.com/jonathanhecl/gguf-to-ollama) - Importing GGUF to Ollama made easy (multiplatform)
+- [AWS-Strands-With-Ollama](https://github.com/rapidarchitect/ollama_strands) - AWS Strands Agents with Ollama Examples
+- [ollama-multirun](https://github.com/attogram/ollama-multirun) - A bash shell script to run a single prompt against any or all of your locally installed ollama models, saving the output and performance statistics as easily navigable web pages. ([Demo](https://attogram.github.io/ai_test_zone/))
+- [ollama-bash-toolshed](https://github.com/attogram/ollama-bash-toolshed) - Bash scripts to chat with tool using models. Add new tools to your shed with ease. Runs on Ollama.
+- [hle-eval-ollama](https://github.com/mags0ft/hle-eval-ollama) - Runs benchmarks like "Humanity's Last Exam" (HLE) on your favorite local Ollama models and evaluates the quality of their responses
+- [VT Code](https://github.com/vinhnx/vtcode) - VT Code is a Rust-based terminal coding agent with semantic code intelligence via Tree-sitter. Ollama integration for running local/cloud models with configurable endpoints.
+
+### Apple Vision Pro
+
+- [SwiftChat](https://github.com/aws-samples/swift-chat) (Cross-platform AI chat app supporting Apple Vision Pro via "Designed for iPad")
+- [Enchanted](https://github.com/AugustDev/enchanted)
+
+### Database
+
+- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database (Create and search embeddings from Ollama models using pgvector)
+  - [Get started guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md)
+- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) (Connects Ollama models with nearly 200 data platforms and apps)
+- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) with [example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama)
+- [Kangaroo](https://github.com/dbkangaroo/kangaroo) (AI-powered SQL client and admin tool for popular databases)
+
+### Package managers

 - [Pacman](https://archlinux.org/packages/extra/x86_64/ollama/)
- [Homebrew](https://formulae.brew.sh/formula/ollama)
- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Gentoo](https://github.com/gentoo/guru/tree/master/app-misc/ollama)
- [Flox](https://flox.dev/blog/ollama-part-one)
+- [Homebrew](https://formulae.brew.sh/formula/ollama)
+- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Guix channel](https://codeberg.org/tusharhero/ollama-guix)
+- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
+- [Flox](https://flox.dev/blog/ollama-part-one)
+
+### Libraries
+
+- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
+- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama)
+- [crewAI](https://github.com/crewAIInc/crewAI)
+- [Yacana](https://remembersoftwares.github.io/yacana/) (User-friendly multi-agent framework for brainstorming and executing predetermined flows with built-in tool integration)
+- [Strands Agents](https://github.com/strands-agents/sdk-python) (A model-driven approach to building AI agents in just a few lines of code)
+- [Spring AI](https://github.com/spring-projects/spring-ai) with [reference](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html) and [example](https://github.com/tzolov/ollama-tools)
+- [LangChainGo](https://github.com/tmc/langchaingo/) with [example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example)
+- [LangChain4j](https://github.com/langchain4j/langchain4j) with [example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java)
+- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) with [example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs)
+- [LangChain for .NET](https://github.com/tryAGI/LangChain) with [example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs)
+- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama)
+- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama)
+- [LiteLLM](https://github.com/BerriAI/litellm)
+- [OllamaFarm for Go](https://github.com/presbrey/ollamafarm)
+- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp)
+- [Ollama for Ruby](https://github.com/crmne/ruby_llm)
+- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs)
+- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp)
+- [Ollama4j for Java](https://github.com/ollama4j/ollama4j)
+- [ModelFusion Typescript Library](https://modelfusion.dev/integration/model-provider/ollama)
+- [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
+- [Ollama for Dart](https://github.com/breitburg/dart-ollama)
+- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel)
+- [LangChainDart](https://github.com/davidmigloz/langchain_dart)
+- [Semantic Kernel - Python](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama)
+- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md)
+- [Elixir LangChain](https://github.com/brainlid/langchain)
+- [Ollama for R - rollama](https://github.com/JBGruber/rollama)
+- [Ollama for R - ollama-r](https://github.com/hauselin/ollama-r)
+- [Ollama-ex for Elixir](https://github.com/lebrunel/ollama-ex)
+- [Ollama Connector for SAP ABAP](https://github.com/b-tocs/abap_btocs_ollama)
+- [Testcontainers](https://testcontainers.com/modules/ollama/)
+- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama)
+- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) with an [example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama)
+- [LlamaScript](https://github.com/Project-Llama/llamascript)
+- [llm-axe](https://github.com/emirsahin1/llm-axe) (Python Toolkit for Building LLM Powered Apps)
+- [Gollm](https://docs.gollm.co/examples/ollama-example)
+- [Gollama for Golang](https://github.com/jonathanhecl/gollama)
+- [Ollamaclient for Golang](https://github.com/xyproto/ollamaclient)
+- [High-level function abstraction in Go](https://gitlab.com/tozd/go/fun)
+- [Ollama PHP](https://github.com/ArdaGnsrn/ollama-php)
+- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) with [example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama)
+- [Parakeet](https://github.com/parakeet-nest/parakeet) is a GoLang library, made to simplify the development of small generative AI applications with Ollama.
+- [Haverscript](https://github.com/andygill/haverscript) with [examples](https://github.com/andygill/haverscript/tree/main/examples)
+- [Ollama for Swift](https://github.com/mattt/ollama-swift)
+- [Swollama for Swift](https://github.com/guitaripod/Swollama) with [DocC](https://guitaripod.github.io/Swollama/documentation/swollama)
+- [GoLamify](https://github.com/prasad89/golamify)
+- [Ollama for Haskell](https://github.com/tusharad/ollama-haskell)
+- [multi-llm-ts](https://github.com/nbonamy/multi-llm-ts) (A Typescript/JavaScript library allowing access to different LLM in a unified API)
+- [LlmTornado](https://github.com/lofcz/llmtornado) (C# library providing a unified interface for major FOSS & Commercial inference APIs)
+- [Ollama for Zig](https://github.com/dravenk/ollama-zig)
+- [Abso](https://github.com/lunary-ai/abso) (OpenAI-compatible TypeScript SDK for any LLM provider)
+- [Nichey](https://github.com/goodreasonai/nichey) is a Python package for generating custom wikis for your research topic
+- [Ollama for D](https://github.com/kassane/ollama-d)
+- [OllamaPlusPlus](https://github.com/HardCodeDev777/OllamaPlusPlus) (Very simple C++ library for Ollama)
+- [any-llm](https://github.com/mozilla-ai/any-llm) (A single interface to use different llm providers by [mozilla.ai](https://www.mozilla.ai/))
+- [any-agent](https://github.com/mozilla-ai/any-agent) (A single interface to use and evaluate different agent frameworks by [mozilla.ai](https://www.mozilla.ai/))
+- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) (Data-driven multi-agent orchestration framework) with [example](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama)
+- [achatbot-go](https://github.com/ai-bot-pro/achatbot-go) a multimodal(text/audio/image) chatbot.
+- [Ollama Bash Lib](https://github.com/attogram/ollama-bash-lib) - A Bash Library for Ollama. Run LLM prompts straight from your shell, and more
+
+### Mobile
+
+- [SwiftChat](https://github.com/aws-samples/swift-chat) (Lightning-fast Cross-platform AI chat app with native UI for Android, iOS, and iPad)
+- [Enchanted](https://github.com/AugustDev/enchanted)
+- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
+- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) (No need for Termux, start the Ollama service with one click on an Android device)
+- [Reins](https://github.com/ibrahimcetin/reins) (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
+
+### Extensions & Plugins
+
+- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)
+- [Discollama](https://github.com/mxyng/discollama) (Discord bot inside the Ollama discord channel)
+- [Continue](https://github.com/continuedev/continue)
+- [Vibe](https://github.com/thewh1teagle/vibe) (Transcribe and analyze meetings with Ollama)
+- [Obsidian Ollama plugin](https://github.com/hinterdupfinger/obsidian-ollama)
+- [Logseq Ollama plugin](https://github.com/omagdy7/ollama-logseq)
+- [NotesOllama](https://github.com/andersrex/notesollama) (Apple Notes Ollama plugin)
+- [Dagger Chatbot](https://github.com/samalba/dagger-chatbot)
+- [Discord AI Bot](https://github.com/mekb-turtle/discord-ai-bot)
+- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram)
+- [Hass Ollama Conversation](https://github.com/ej52/hass-ollama-conversation)
+- [Rivet plugin](https://github.com/abrenneke/rivet-plugin-ollama)
+- [Obsidian BMO Chatbot plugin](https://github.com/longy2k/obsidian-bmo-chatbot)
+- [Cliobot](https://github.com/herval/cliobot) (Telegram bot with Ollama support)
+- [Copilot for Obsidian plugin](https://github.com/logancyang/obsidian-copilot)
+- [Obsidian Local GPT plugin](https://github.com/pfrankov/obsidian-local-gpt)
+- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama)
+- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using Ollama)
+- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) (Proxy that allows you to use Ollama as a copilot like GitHub Copilot)
+- [twinny](https://github.com/rjmacarthy/twinny) (Copilot and Copilot chat alternative using Ollama)
+- [Wingman-AI](https://github.com/RussellCanfield/wingman-ai) (Copilot code and chat alternative using Ollama and Hugging Face)
+- [Page Assist](https://github.com/n4ze3m/page-assist) (Chrome Extension)
+- [Plasmoid Ollama Control](https://github.com/imoize/plasmoid-ollamacontrol) (KDE Plasma extension that allows you to quickly manage/control Ollama model)
+- [AI Telegram Bot](https://github.com/tusharhero/aitelegrambot) (Telegram bot using Ollama in backend)
+- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) (Sublime Text 4 AI assistant plugin with Ollama support)
+- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) (Generalized TypeScript Discord Bot w/ Tuning Documentation)
+- [ChatGPTBox: All in one browser extension](https://github.com/josStorer/chatGPTBox) with [Integrating Tutorial](https://github.com/josStorer/chatGPTBox/issues/616#issuecomment-1975186467)
+- [Discord AI chat/moderation bot](https://github.com/rapmd73/Companion) Chat/moderation bot written in python. Uses Ollama to create personalities.
+- [Headless Ollama](https://github.com/nischalj10/headless-ollama) (Scripts to automatically install ollama client & models on any OS for apps that depend on ollama server)
+- [Terraform AWS Ollama & Open WebUI](https://github.com/xuyangbocn/terraform-aws-self-host-llm) (A Terraform module to deploy on AWS a ready-to-use Ollama service, together with its front-end Open WebUI service.)
+- [node-red-contrib-ollama](https://github.com/jakubburkiewicz/node-red-contrib-ollama)
+- [Local AI Helper](https://github.com/ivostoykov/localAI) (Chrome and Firefox extensions that enable interactions with the active tab and customisable API endpoints. Includes secure storage for user prompts.)
+- [LSP-AI](https://github.com/SilasMarvin/lsp-ai) (Open-source language server for AI-powered functionality)
+- [QodeAssist](https://github.com/Palm1r/QodeAssist) (AI-powered coding assistant plugin for Qt Creator)
+- [Obsidian Quiz Generator plugin](https://github.com/ECuiDev/obsidian-quiz-generator)
+- [AI Summary Helper plugin](https://github.com/philffm/ai-summary-helper)
+- [TextCraft](https://github.com/suncloudsmoon/TextCraft) (Copilot in Word alternative using Ollama)
+- [Alfred Ollama](https://github.com/zeitlings/alfred-ollama) (Alfred Workflow)
+- [TextLLaMA](https://github.com/adarshM84/TextLLaMA) A Chrome Extension that helps you write emails, correct grammar, and translate into any language
+- [Simple-Discord-AI](https://github.com/zyphixor/simple-discord-ai)
+- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) (telegram bot, primary for RP. Oobabooga-like buttons, [A1111](https://github.com/AUTOMATIC1111/stable-diffusion-webui) API integration e.t.c)
+- [mcp-llm](https://github.com/sammcj/mcp-llm) (MCP Server to allow LLMs to call other LLMs)
+- [SimpleOllamaUnity](https://github.com/HardCodeDev777/SimpleOllamaUnity) (Unity Engine extension for communicating with Ollama in a few lines of code. Also works at runtime)
+- [UnityCodeLama](https://github.com/HardCodeDev777/UnityCodeLama) (Unity Editor tool to analyze scripts via Ollama)
+- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) (Private, on-device AI Assistant, no cloud dependencies)
+- [GMAI - Gradle Managed AI](https://gmai.premex.se/) (Gradle plugin for automated Ollama lifecycle management during build phases)
+- [NOMYO Router](https://github.com/nomyo-ai/nomyo-router) (A transparent Ollama proxy with model deployment aware routing which auto-manages multiple Ollama instances in a given network)
+
+### Supported backends
+
+- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
+
+### Observability
+
+- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) is an open-source platform to debug, evaluate, and monitor your LLM applications, RAG systems, and agentic workflows with comprehensive tracing, automated evaluations, and production-ready dashboards. Opik supports native integration to Ollama.
+- [Lunary](https://lunary.ai/docs/integrations/ollama) is the leading open-source LLM observability platform. It provides a variety of enterprise-grade features such as real-time analytics, prompt templates management, PII masking, and comprehensive agent tracing.
+- [OpenLIT](https://github.com/openlit/openlit) is an OpenTelemetry-native tool for monitoring Ollama Applications & GPUs using traces and metrics.
+- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) is an AI observability and evaluation platform for AI agents. Use HoneyHive to evaluate agent performance, interrogate failures, and monitor quality in production.
+- [Langfuse](https://langfuse.com/docs/integrations/ollama) is an open source LLM observability platform that enables teams to collaboratively monitor, evaluate and debug AI applications.
+- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) is an open source LLM observability tool with a convenient API to log and visualize traces, making it easy to debug and evaluate GenAI applications.
+
+### Security
+
+- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server)
@@ -1,25 +1,17 @@
 package anthropic

 import (
-	"bytes"
-	"context"
 	"crypto/rand"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net/http"
-	"net/url"
-	"strconv"
 	"strings"
 	"time"

 	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/auth"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-	"github.com/ollama/ollama/logutil"
 )

 // Error types matching Anthropic API
@@ -68,7 +60,7 @@ type MessagesRequest struct {
 	Model         string          `json:"model"`
 	MaxTokens     int             `json:"max_tokens"`
 	Messages      []MessageParam  `json:"messages"`
-	System        any             `json:"system,omitempty"` // string or []map[string]any (JSON-decoded ContentBlock)
+	System        any             `json:"system,omitempty"` // string or []ContentBlock
 	Stream        bool            `json:"stream,omitempty"`
 	Temperature   *float64        `json:"temperature,omitempty"`
 	TopP          *float64        `json:"top_p,omitempty"`
@@ -82,52 +74,30 @@ type MessagesRequest struct {

 // MessageParam represents a message in the request
 type MessageParam struct {
-	Role    string         `json:"role"`    // "user" or "assistant"
-	Content []ContentBlock `json:"content"` // always []ContentBlock; plain strings are normalized on unmarshal
-}
-
-func (m *MessageParam) UnmarshalJSON(data []byte) error {
-	var raw struct {
-		Role    string          `json:"role"`
-		Content json.RawMessage `json:"content"`
-	}
-	if err := json.Unmarshal(data, &raw); err != nil {
-		return err
-	}
-	m.Role = raw.Role
-
-	var s string
-	if err := json.Unmarshal(raw.Content, &s); err == nil {
-		m.Content = []ContentBlock{{Type: "text", Text: &s}}
-		return nil
-	}
-
-	return json.Unmarshal(raw.Content, &m.Content)
+	Role    string `json:"role"`    // "user" or "assistant"
+	Content any    `json:"content"` // string or []ContentBlock
 }

 // ContentBlock represents a content block in a message.
 // Text and Thinking use pointers so they serialize as the field being present (even if empty)
 // only when set, which is required for SDK streaming accumulation.
 type ContentBlock struct {
-	Type string `json:"type"` // text, image, tool_use, tool_result, thinking, server_tool_use, web_search_tool_result
+	Type string `json:"type"` // text, image, tool_use, tool_result, thinking

 	// For text blocks - pointer so field only appears when set (SDK requires it for accumulation)
 	Text *string `json:"text,omitempty"`

-	// For text blocks with citations
-	Citations []Citation `json:"citations,omitempty"`
-
 	// For image blocks
 	Source *ImageSource `json:"source,omitempty"`

-	// For tool_use and server_tool_use blocks
-	ID    string                        `json:"id,omitempty"`
-	Name  string                        `json:"name,omitempty"`
-	Input api.ToolCallFunctionArguments `json:"input,omitzero"`
+	// For tool_use blocks
+	ID    string `json:"id,omitempty"`
+	Name  string `json:"name,omitempty"`
+	Input any    `json:"input,omitempty"`

-	// For tool_result and web_search_tool_result blocks
+	// For tool_result blocks
 	ToolUseID string `json:"tool_use_id,omitempty"`
-	Content   any    `json:"content,omitempty"` // string, []ContentBlock, []WebSearchResult, or WebSearchToolResultError
+	Content   any    `json:"content,omitempty"` // string or []ContentBlock
 	IsError   bool   `json:"is_error,omitempty"`

 	// For thinking blocks - pointer so field only appears when set (SDK requires it for accumulation)
@@ -135,30 +105,6 @@ type ContentBlock struct {
 	Signature string  `json:"signature,omitempty"`
 }

-// Citation represents a citation in a text block
-type Citation struct {
-	Type           string `json:"type"` // "web_search_result_location"
-	URL            string `json:"url"`
-	Title          string `json:"title"`
-	EncryptedIndex string `json:"encrypted_index,omitempty"`
-	CitedText      string `json:"cited_text,omitempty"`
-}
-
-// WebSearchResult represents a single web search result
-type WebSearchResult struct {
-	Type             string `json:"type"` // "web_search_result"
-	URL              string `json:"url"`
-	Title            string `json:"title"`
-	EncryptedContent string `json:"encrypted_content,omitempty"`
-	PageAge          string `json:"page_age,omitempty"`
-}
-
-// WebSearchToolResultError represents an error from web search
-type WebSearchToolResultError struct {
-	Type      string `json:"type"` // "web_search_tool_result_error"
-	ErrorCode string `json:"error_code"`
-}
-
 // ImageSource represents the source of an image
 type ImageSource struct {
 	Type      string `json:"type"` // "base64" or "url"
@@ -169,13 +115,10 @@ type ImageSource struct {

 // Tool represents a tool definition
 type Tool struct {
-	Type        string          `json:"type,omitempty"` // "custom" for user-defined tools, or "web_search_20250305" for web search
+	Type        string          `json:"type,omitempty"` // "custom" for user-defined tools
 	Name        string          `json:"name"`
 	Description string          `json:"description,omitempty"`
 	InputSchema json.RawMessage `json:"input_schema,omitempty"`
-
-	// Web search specific fields
-	MaxUses int `json:"max_uses,omitempty"`
 }

 // ToolChoice controls how the model uses tools
@@ -290,8 +233,6 @@ type StreamErrorEvent struct {

 // FromMessagesRequest converts an Anthropic MessagesRequest to an Ollama api.ChatRequest
 func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
-	logutil.Trace("anthropic: converting request", "req", TraceMessagesRequest(r))
-
 	var messages []api.Message

 	if r.System != nil {
@@ -318,10 +259,9 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 		}
 	}

-	for i, msg := range r.Messages {
+	for _, msg := range r.Messages {
 		converted, err := convertMessage(msg)
 		if err != nil {
-			logutil.Trace("anthropic: message conversion failed", "index", i, "role", msg.Role, "err", err)
 			return nil, err
 		}
 		messages = append(messages, converted...)
@@ -348,24 +288,8 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 	}

 	var tools api.Tools
-	hasBuiltinWebSearch := false
 	for _, t := range r.Tools {
-		if strings.HasPrefix(t.Type, "web_search") {
-			hasBuiltinWebSearch = true
-			break
-		}
-	}
-
-	for _, t := range r.Tools {
-		// Anthropic built-in web_search maps to Ollama function name "web_search".
-		// If a user-defined tool also uses that name in the same request, drop the
-		// user-defined one to avoid ambiguous tool-call routing.
-		if hasBuiltinWebSearch && !strings.HasPrefix(t.Type, "web_search") && t.Name == "web_search" {
-			logutil.Trace("anthropic: dropping colliding custom web_search tool", "tool", TraceTool(t))
-			continue
-		}
-
-		tool, _, err := convertTool(t)
+		tool, err := convertTool(t)
 		if err != nil {
 			return nil, err
 		}
@@ -378,17 +302,15 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 	}

 	stream := r.Stream
-	convertedRequest := &api.ChatRequest{
+
+	return &api.ChatRequest{
 		Model:    r.Model,
 		Messages: messages,
 		Options:  options,
 		Stream:   &stream,
 		Tools:    tools,
 		Think:    think,
-	}
-	logutil.Trace("anthropic: converted request", "req", TraceChatRequest(convertedRequest))
-
-	return convertedRequest, nil
+	}, nil
 }

 // convertMessage converts an Anthropic MessageParam to Ollama api.Message(s)
@@ -396,236 +318,129 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 	var messages []api.Message
 	role := strings.ToLower(msg.Role)

-	var textContent strings.Builder
-	var images []api.ImageData
-	var toolCalls []api.ToolCall
-	var thinking string
-	var toolResults []api.Message
-	textBlocks := 0
-	imageBlocks := 0
-	toolUseBlocks := 0
-	toolResultBlocks := 0
-	serverToolUseBlocks := 0
-	webSearchToolResultBlocks := 0
-	thinkingBlocks := 0
-	unknownBlocks := 0
+	switch content := msg.Content.(type) {
+	case string:
+		messages = append(messages, api.Message{Role: role, Content: content})

-	for _, block := range msg.Content {
-		switch block.Type {
-		case "text":
-			textBlocks++
-			if block.Text != nil {
-				textContent.WriteString(*block.Text)
+	case []any:
+		var textContent strings.Builder
+		var images []api.ImageData
+		var toolCalls []api.ToolCall
+		var thinking string
+		var toolResults []api.Message
+
+		for _, block := range content {
+			blockMap, ok := block.(map[string]any)
+			if !ok {
+				return nil, errors.New("invalid content block format")
 			}

-		case "image":
-			imageBlocks++
-			if block.Source == nil {
-				logutil.Trace("anthropic: invalid image source", "role", role)
-				return nil, errors.New("invalid image source")
-			}
+			blockType, _ := blockMap["type"].(string)

-			if block.Source.Type == "base64" {
-				decoded, err := base64.StdEncoding.DecodeString(block.Source.Data)
-				if err != nil {
-					logutil.Trace("anthropic: invalid base64 image data", "role", role, "error", err)
-					return nil, fmt.Errorf("invalid base64 image data: %w", err)
+			switch blockType {
+			case "text":
+				if text, ok := blockMap["text"].(string); ok {
+					textContent.WriteString(text)
 				}
-				images = append(images, decoded)
-			} else {
-				logutil.Trace("anthropic: unsupported image source type", "role", role, "source_type", block.Source.Type)
-				return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", block.Source.Type)
-			}

-		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 "image":
+				source, ok := blockMap["source"].(map[string]any)
+				if !ok {
+					return nil, errors.New("invalid image source")
+				}

-		case "tool_result":
-			toolResultBlocks++
-			var resultContent string
+				sourceType, _ := source["type"].(string)
+				if sourceType == "base64" {
+					data, _ := source["data"].(string)
+					decoded, err := base64.StdEncoding.DecodeString(data)
+					if err != nil {
+						return nil, fmt.Errorf("invalid base64 image data: %w", err)
+					}
+					images = append(images, decoded)
+				} else {
+					return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", sourceType)
+				}
+				// URL images would need to be fetched - skip for now

-			switch c := block.Content.(type) {
-			case string:
-				resultContent = c
-			case []any:
-				for _, cb := range c {
-					if cbMap, ok := cb.(map[string]any); ok {
-						if cbMap["type"] == "text" {
-							if text, ok := cbMap["text"].(string); ok {
-								resultContent += text
+			case "tool_use":
+				id, ok := blockMap["id"].(string)
+				if !ok {
+					return nil, errors.New("tool_use block missing required 'id' field")
+				}
+				name, ok := blockMap["name"].(string)
+				if !ok {
+					return nil, errors.New("tool_use block missing required 'name' field")
+				}
+				tc := api.ToolCall{
+					ID: id,
+					Function: api.ToolCallFunction{
+						Name: name,
+					},
+				}
+				if input, ok := blockMap["input"].(map[string]any); ok {
+					tc.Function.Arguments = mapToArgs(input)
+				}
+				toolCalls = append(toolCalls, tc)
+
+			case "tool_result":
+				toolUseID, _ := blockMap["tool_use_id"].(string)
+				var resultContent string
+
+				switch c := blockMap["content"].(type) {
+				case string:
+					resultContent = c
+				case []any:
+					for _, cb := range c {
+						if cbMap, ok := cb.(map[string]any); ok {
+							if cbMap["type"] == "text" {
+								if text, ok := cbMap["text"].(string); ok {
+									resultContent += text
+								}
 							}
 						}
 					}
 				}
+
+				toolResults = append(toolResults, api.Message{
+					Role:       "tool",
+					Content:    resultContent,
+					ToolCallID: toolUseID,
+				})
+
+			case "thinking":
+				if t, ok := blockMap["thinking"].(string); ok {
+					thinking = t
+				}
 			}
+		}

-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    resultContent,
-				ToolCallID: block.ToolUseID,
-			})
-
-		case "thinking":
-			thinkingBlocks++
-			if block.Thinking != nil {
-				thinking = *block.Thinking
+		if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
+			m := api.Message{
+				Role:      role,
+				Content:   textContent.String(),
+				Images:    images,
+				ToolCalls: toolCalls,
+				Thinking:  thinking,
 			}
-
-		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++
+			messages = append(messages, m)
 		}
-	}

-	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
+		messages = append(messages, toolResults...)

-	// Add tool results as separate messages
-	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),
-	)
+	default:
+		return nil, fmt.Errorf("invalid message content type: %T", content)
+	}

 	return messages, nil
 }

-func formatWebSearchToolResultContent(content any) string {
-	switch c := content.(type) {
-	case string:
-		return c
-	case []WebSearchResult:
-		var resultContent strings.Builder
-		for _, item := range c {
-			if item.Type != "web_search_result" {
-				continue
-			}
-			fmt.Fprintf(&resultContent, "- %s: %s\n", item.Title, item.URL)
-		}
-		return resultContent.String()
-	case []any:
-		var resultContent strings.Builder
-		for _, item := range c {
-			itemMap, ok := item.(map[string]any)
-			if !ok {
-				continue
-			}
-			switch itemMap["type"] {
-			case "web_search_result":
-				title, _ := itemMap["title"].(string)
-				url, _ := itemMap["url"].(string)
-				fmt.Fprintf(&resultContent, "- %s: %s\n", title, url)
-			case "web_search_tool_result_error":
-				errorCode, _ := itemMap["error_code"].(string)
-				if errorCode == "" {
-					return "web_search_tool_result_error"
-				}
-				return "web_search_tool_result_error: " + errorCode
-			}
-		}
-		return resultContent.String()
-	case map[string]any:
-		if c["type"] == "web_search_tool_result_error" {
-			errorCode, _ := c["error_code"].(string)
-			if errorCode == "" {
-				return "web_search_tool_result_error"
-			}
-			return "web_search_tool_result_error: " + errorCode
-		}
-		data, err := json.Marshal(c)
-		if err != nil {
-			return ""
-		}
-		return string(data)
-	case WebSearchToolResultError:
-		if c.ErrorCode == "" {
-			return "web_search_tool_result_error"
-		}
-		return "web_search_tool_result_error: " + c.ErrorCode
-	default:
-		data, err := json.Marshal(c)
-		if err != nil {
-			return ""
-		}
-		return string(data)
-	}
-}
-
-// convertTool converts an Anthropic Tool to an Ollama api.Tool, returning true if it's a server tool
-func convertTool(t Tool) (api.Tool, bool, error) {
-	if strings.HasPrefix(t.Type, "web_search") {
-		props := api.NewToolPropertiesMap()
-		props.Set("query", api.ToolProperty{
-			Type:        api.PropertyType{"string"},
-			Description: "The search query to look up on the web",
-		})
-		return api.Tool{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name:        "web_search",
-				Description: "Search the web for current information. Use this to find up-to-date information about any topic.",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Required:   []string{"query"},
-					Properties: props,
-				},
-			},
-		}, true, nil
-	}
-
+// convertTool converts an Anthropic Tool to an Ollama api.Tool
+func convertTool(t Tool) (api.Tool, error) {
 	var params api.ToolFunctionParameters
 	if len(t.InputSchema) > 0 {
 		if err := json.Unmarshal(t.InputSchema, &params); err != nil {
-			logutil.Trace("anthropic: invalid tool schema", "tool", t.Name, "err", err)
-			return api.Tool{}, false, fmt.Errorf("invalid input_schema for tool %q: %w", t.Name, err)
+			return api.Tool{}, fmt.Errorf("invalid input_schema for tool %q: %w", t.Name, err)
 		}
 	}

@@ -636,7 +451,7 @@ func convertTool(t Tool) (api.Tool, bool, error) {
 			Description: t.Description,
 			Parameters:  params,
 		},
-	}, false, nil
+	}, nil
 }

 // ToMessagesResponse converts an Ollama api.ChatResponse to an Anthropic MessagesResponse
@@ -838,19 +653,6 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			continue
 		}

-		// Close thinking block if still open (thinking → tool_use without text in between)
-		if c.thinkingStarted && !c.thinkingDone {
-			c.thinkingDone = true
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-		}
-
 		if c.textStarted {
 			events = append(events, StreamEvent{
 				Event: "content_block_stop",
@@ -868,6 +670,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			slog.Error("failed to marshal tool arguments", "error", err, "tool_id", tc.ID)
 			continue
 		}
+
 		events = append(events, StreamEvent{
 			Event: "content_block_start",
 			Data: ContentBlockStartEvent{
@@ -877,7 +680,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 					Type:  "tool_use",
 					ID:    tc.ID,
 					Name:  tc.Function.Name,
-					Input: api.NewToolCallFunctionArguments(),
+					Input: map[string]any{},
 				},
 			},
 		})
@@ -974,6 +777,15 @@ func ptr(s string) *string {
 	return &s
 }

+// mapToArgs converts a map to ToolCallFunctionArguments
+func mapToArgs(m map[string]any) api.ToolCallFunctionArguments {
+	args := api.NewToolCallFunctionArguments()
+	for k, v := range m {
+		args.Set(k, v)
+	}
+	return args
+}
+
 // CountTokensRequest represents an Anthropic count_tokens request
 type CountTokensRequest struct {
 	Model    string          `json:"model"`
@@ -1006,13 +818,17 @@ func estimateTokens(req CountTokensRequest) int {
 	var totalLen int

 	// Count system prompt
-	totalLen += countAnyContent(req.System)
+	if req.System != nil {
+		totalLen += countAnyContent(req.System)
+	}

+	// Count messages
 	for _, msg := range req.Messages {
 		// Count role (always present)
 		totalLen += len(msg.Role)
 		// Count content
-		totalLen += countAnyContent(msg.Content)
+		contentLen := countAnyContent(msg.Content)
+		totalLen += contentLen
 	}

 	for _, tool := range req.Tools {
@@ -1035,25 +851,12 @@ func countAnyContent(content any) int {
 	switch c := content.(type) {
 	case string:
 		return len(c)
-	case []ContentBlock:
+	case []any:
 		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)
@@ -1062,128 +865,37 @@ func countAnyContent(content any) int {
 	}
 }

-func countContentBlock(block ContentBlock) int {
+func countContentBlock(block any) int {
+	blockMap, ok := block.(map[string]any)
+	if !ok {
+		if s, ok := block.(string); ok {
+			return len(s)
+		}
+		return 0
+	}
+
 	total := 0
-	if block.Text != nil {
-		total += len(*block.Text)
+	blockType, _ := blockMap["type"].(string)
+
+	if text, ok := blockMap["text"].(string); ok {
+		total += len(text)
 	}
-	if block.Thinking != nil {
-		total += len(*block.Thinking)
+
+	if thinking, ok := blockMap["thinking"].(string); ok {
+		total += len(thinking)
 	}
-	if block.Type == "tool_use" || block.Type == "tool_result" {
-		if data, err := json.Marshal(block); err == nil {
+
+	if blockType == "tool_use" {
+		if data, err := json.Marshal(blockMap); 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)
+	if blockType == "tool_result" {
+		if data, err := json.Marshal(blockMap); err == nil {
+			total += len(data)
 		}
 	}
-	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
+	return total
 }
@@ -3,7 +3,6 @@ package anthropic
 import (
 	"encoding/base64"
 	"encoding/json"
-	"strings"
 	"testing"

 	"github.com/google/go-cmp/cmp"
@@ -15,16 +14,11 @@ 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 {
+// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests)
+func testArgs(m map[string]any) api.ToolCallFunctionArguments {
 	args := api.NewToolCallFunctionArguments()
-	for i := 0; i < len(kvs)-1; i += 2 {
-		args.Set(kvs[i].(string), kvs[i+1])
+	for k, v := range m {
+		args.Set(k, v)
 	}
 	return args
 }
@@ -34,7 +28,7 @@ func TestFromMessagesRequest_Basic(t *testing.T) {
 		Model:     "test-model",
 		MaxTokens: 1024,
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -66,7 +60,7 @@ func TestFromMessagesRequest_WithSystemPrompt(t *testing.T) {
 		MaxTokens: 1024,
 		System:    "You are a helpful assistant.",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -93,7 +87,7 @@ func TestFromMessagesRequest_WithSystemPromptArray(t *testing.T) {
 			map[string]any{"type": "text", "text": " Be concise."},
 		},
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -118,7 +112,7 @@ func TestFromMessagesRequest_WithOptions(t *testing.T) {
 	req := MessagesRequest{
 		Model:         "test-model",
 		MaxTokens:     2048,
-		Messages:      []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:      []MessageParam{{Role: "user", Content: "Hello"}},
 		Temperature:   &temp,
 		TopP:          &topP,
 		TopK:          &topK,
@@ -153,14 +147,14 @@ func TestFromMessagesRequest_WithImage(t *testing.T) {
 		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,
+				Content: []any{
+					map[string]any{"type": "text", "text": "What's in this image?"},
+					map[string]any{
+						"type": "image",
+						"source": map[string]any{
+							"type":       "base64",
+							"media_type": "image/png",
+							"data":       testImage,
 						},
 					},
 				},
@@ -195,15 +189,15 @@ func TestFromMessagesRequest_WithToolUse(t *testing.T) {
 		Model:     "test-model",
 		MaxTokens: 1024,
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("What's the weather in Paris?")},
+			{Role: "user", Content: "What's the weather in Paris?"},
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:  "tool_use",
-						ID:    "call_123",
-						Name:  "get_weather",
-						Input: makeArgs("location", "Paris"),
+				Content: []any{
+					map[string]any{
+						"type":  "tool_use",
+						"id":    "call_123",
+						"name":  "get_weather",
+						"input": map[string]any{"location": "Paris"},
 					},
 				},
 			},
@@ -239,11 +233,11 @@ func TestFromMessagesRequest_WithToolResult(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_123",
-						Content:   "The weather in Paris is sunny, 22°C",
+				Content: []any{
+					map[string]any{
+						"type":        "tool_result",
+						"tool_use_id": "call_123",
+						"content":     "The weather in Paris is sunny, 22°C",
 					},
 				},
 			},
@@ -275,7 +269,7 @@ func TestFromMessagesRequest_WithTools(t *testing.T) {
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Tools: []Tool{
 			{
 				Name:        "get_weather",
@@ -306,83 +300,11 @@ func TestFromMessagesRequest_WithTools(t *testing.T) {
 	}
 }

-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")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Thinking:  &ThinkingConfig{Type: "enabled", BudgetTokens: 1000},
 	}

@@ -404,13 +326,13 @@ func TestFromMessagesRequest_ThinkingOnlyBlock(t *testing.T) {
 		Model:     "test-model",
 		MaxTokens: 1024,
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:     "thinking",
-						Thinking: ptr("Let me think about this..."),
+				Content: []any{
+					map[string]any{
+						"type":     "thinking",
+						"thinking": "Let me think about this...",
 					},
 				},
 			},
@@ -439,10 +361,10 @@ func TestFromMessagesRequest_ToolUseMissingID(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type: "tool_use",
-						Name: "get_weather",
+				Content: []any{
+					map[string]any{
+						"type": "tool_use",
+						"name": "get_weather",
 					},
 				},
 			},
@@ -465,10 +387,10 @@ func TestFromMessagesRequest_ToolUseMissingName(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type: "tool_use",
-						ID:   "call_123",
+				Content: []any{
+					map[string]any{
+						"type": "tool_use",
+						"id":   "call_123",
 					},
 				},
 			},
@@ -488,7 +410,7 @@ func TestFromMessagesRequest_InvalidToolSchema(t *testing.T) {
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Tools: []Tool{
 			{
 				Name:        "bad_tool",
@@ -553,7 +475,7 @@ func TestToMessagesResponse_WithToolCalls(t *testing.T) {
 					ID: "call_123",
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: makeArgs("location", "Paris"),
+						Arguments: testArgs(map[string]any{"location": "Paris"}),
 					},
 				},
 			},
@@ -765,7 +687,7 @@ func TestStreamConverter_WithToolCalls(t *testing.T) {
 					ID: "call_123",
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: makeArgs("location", "Paris"),
+						Arguments: testArgs(map[string]any{"location": "Paris"}),
 					},
 				},
 			},
@@ -804,107 +726,6 @@ func TestStreamConverter_WithToolCalls(t *testing.T) {
 	}
 }

-// 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
@@ -970,7 +791,7 @@ func TestStreamConverter_MultipleToolCallsWithMixedValidity(t *testing.T) {
 					ID: "call_good",
 					Function: api.ToolCallFunction{
 						Name:      "good_function",
-						Arguments: makeArgs("location", "Paris"),
+						Arguments: testArgs(map[string]any{"location": "Paris"}),
 					},
 				},
 				{
@@ -1072,57 +893,6 @@ func TestContentBlockJSON_EmptyFieldsPresent(t *testing.T) {
 	}
 }

-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)
@@ -1143,9 +913,7 @@ func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
 						// 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)
-						}
+						json.Unmarshal(data, &result)
 						cb := result["content_block"].(map[string]any)
 						if _, ok := cb["text"]; !ok {
 							t.Error("content_block_start for text should include 'text' field")
@@ -1192,71 +960,13 @@ func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
 			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!")},
+			{Role: "user", Content: "Hello, world!"},
 		},
 	}

@@ -1277,7 +987,7 @@ func TestEstimateTokens_WithSystemPrompt(t *testing.T) {
 		Model:  "test-model",
 		System: "You are a helpful assistant.",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -1293,7 +1003,7 @@ func TestEstimateTokens_WithTools(t *testing.T) {
 	req := CountTokensRequest{
 		Model: "test-model",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("What's the weather?")},
+			{Role: "user", Content: "What's the weather?"},
 		},
 		Tools: []Tool{
 			{
@@ -1316,17 +1026,17 @@ func TestEstimateTokens_WithThinking(t *testing.T) {
 	req := CountTokensRequest{
 		Model: "test-model",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:     "thinking",
-						Thinking: ptr("Let me think about this carefully..."),
+				Content: []any{
+					map[string]any{
+						"type":     "thinking",
+						"thinking": "Let me think about this carefully...",
 					},
-					{
-						Type: "text",
-						Text: ptr("Here is my response."),
+					map[string]any{
+						"type": "text",
+						"text": "Here is my response.",
 					},
 				},
 			},
@@ -1353,320 +1063,3 @@ func TestEstimateTokens_EmptyContent(t *testing.T) {
 		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)
-	}
-}
@@ -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
-}
@@ -449,16 +449,6 @@ func (c *Client) Version(ctx context.Context) (string, error) {
 	return version.Version, nil
 }

-// CloudStatusExperimental returns whether cloud features are disabled on the server.
-func (c *Client) CloudStatusExperimental(ctx context.Context) (*StatusResponse, error) {
-	var status StatusResponse
-	if err := c.do(ctx, http.MethodGet, "/api/status", nil, &status); err != nil {
-		return nil, err
-	}
-
-	return &status, nil
-}
-
 // Signout will signout a client for a local ollama server.
 func (c *Client) Signout(ctx context.Context) error {
 	return c.do(ctx, http.MethodPost, "/api/signout", nil, nil)
@@ -476,3 +466,25 @@ func (c *Client) Whoami(ctx context.Context) (*UserResponse, error) {
 	}
 	return &resp, nil
 }
+
+// AliasRequest is the request body for creating or updating a model alias.
+type AliasRequest struct {
+	Alias          string `json:"alias"`
+	Target         string `json:"target"`
+	PrefixMatching bool   `json:"prefix_matching,omitempty"`
+}
+
+// SetAliasExperimental creates or updates a model alias via the experimental aliases API.
+func (c *Client) SetAliasExperimental(ctx context.Context, req *AliasRequest) error {
+	return c.do(ctx, http.MethodPost, "/api/experimental/aliases", req, nil)
+}
+
+// AliasDeleteRequest is the request body for deleting a model alias.
+type AliasDeleteRequest struct {
+	Alias string `json:"alias"`
+}
+
+// DeleteAliasExperimental deletes a model alias via the experimental aliases API.
+func (c *Client) DeleteAliasExperimental(ctx context.Context, req *AliasDeleteRequest) error {
+	return c.do(ctx, http.MethodDelete, "/api/experimental/aliases", req, nil)
+}
@@ -436,7 +436,6 @@ type ToolProperty struct {
 	Description string             `json:"description,omitempty"`
 	Enum        []any              `json:"enum,omitempty"`
 	Properties  *ToolPropertiesMap `json:"properties,omitempty"`
-	Required    []string           `json:"required,omitempty"`
 }

 // ToTypeScriptType converts a ToolProperty to a TypeScript type string
@@ -835,16 +834,6 @@ type TokenResponse struct {
 	Token string `json:"token"`
 }

-type CloudStatus struct {
-	Disabled bool   `json:"disabled"`
-	Source   string `json:"source"`
-}
-
-// StatusResponse is the response from [Client.CloudStatusExperimental].
-type StatusResponse struct {
-	Cloud CloudStatus `json:"cloud"`
-}
-
 // GenerateResponse is the response passed into [GenerateResponseFunc].
 type GenerateResponse struct {
 	// Model is the model name that generated the response.
@@ -35,7 +35,6 @@ import (
 var (
 	wv           = &Webview{}
 	uiServerPort int
-	appStore     *store.Store
 )

 var debug = strings.EqualFold(os.Getenv("OLLAMA_DEBUG"), "true") || os.Getenv("OLLAMA_DEBUG") == "1"
@@ -209,7 +208,6 @@ func main() {
 	uiServerPort = port

 	st := &store.Store{}
-	appStore = st

 	// Enable CORS in development mode
 	if devMode {
@@ -255,8 +253,6 @@ func main() {
 		done <- osrv.Run(octx)
 	}()

-	upd := &updater.Updater{Store: st}
-
 	uiServer := ui.Server{
 		Token: token,
 		Restart: func() {
@@ -271,10 +267,6 @@ func main() {
 		ToolRegistry: toolRegistry,
 		Dev:          devMode,
 		Logger:       slog.Default(),
-		Updater:      upd,
-		UpdateAvailableFunc: func() {
-			UpdateAvailable("")
-		},
 	}

 	srv := &http.Server{
@@ -292,20 +284,8 @@ func main() {
 		slog.Debug("background desktop server done")
 	}()

-	upd.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)
-
-	// Check for pending updates on startup (show tray notification if update is ready)
-	if updater.IsUpdatePending() {
-		// On Windows, the tray is initialized in osRun(). Calling UpdateAvailable
-		// before that would dereference a nil tray callback.
-		// TODO: refactor so the update check runs after platform init on all platforms.
-		if runtime.GOOS == "windows" {
-			slog.Debug("update pending on startup, deferring tray notification until tray initialization")
-		} else {
-			slog.Debug("update pending on startup, showing tray notification")
-			UpdateAvailable("")
-		}
-	}
+	updater := &updater.Updater{Store: st}
+	updater.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)

 	hasCompletedFirstRun, err := st.HasCompletedFirstRun()
 	if err != nil {
@@ -368,17 +348,6 @@ func startHiddenTasks() {
 			// CLI triggered app startup use-case
 			slog.Info("deferring pending update for fast startup")
 		} else {
-			// Check if auto-update is enabled before automatically upgrading
-			settings, err := appStore.Settings()
-			if err != nil {
-				slog.Warn("failed to load settings for upgrade check", "error", err)
-			} else if !settings.AutoUpdateEnabled {
-				slog.Info("auto-update disabled, skipping automatic upgrade at startup")
-				// Still show tray notification so user knows update is ready
-				UpdateAvailable("")
-				return
-			}
-
 			if err := updater.DoUpgradeAtStartup(); err != nil {
 				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
@@ -154,10 +154,6 @@ func handleURLSchemeRequest(urlScheme string) {
 }

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

@@ -169,14 +165,6 @@ func osRun(shutdown func(), hasCompletedFirstRun, startHidden bool) {
 		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)

@@ -41,11 +41,6 @@ type InferenceCompute struct {
 	VRAM    string
 }

-type InferenceInfo struct {
-	Computes             []InferenceCompute
-	DefaultContextLength int
-}
-
 func New(s *store.Store, devMode bool) *Server {
 	p := resolvePath("ollama")
 	return &Server{store: s, bin: p, dev: devMode}
@@ -210,11 +205,6 @@ func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
 		return nil, err
 	}

-	cloudDisabled, err := s.store.CloudDisabled()
-	if err != nil {
-		return nil, err
-	}
-
 	cmd := commandContext(ctx, s.bin, "serve")
 	cmd.Stdout, cmd.Stderr = s.log, s.log

@@ -240,11 +230,6 @@ func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
 	if settings.ContextLength > 0 {
 		env["OLLAMA_CONTEXT_LENGTH"] = strconv.Itoa(settings.ContextLength)
 	}
-	if cloudDisabled {
-		env["OLLAMA_NO_CLOUD"] = "1"
-	} else {
-		env["OLLAMA_NO_CLOUD"] = "0"
-	}
 	cmd.Env = []string{}
 	for k, v := range env {
 		cmd.Env = append(cmd.Env, k+"="+v)
@@ -277,12 +262,9 @@ func openRotatingLog() (io.WriteCloser, error) {

 // Attempt to retrieve inference compute information from the server
 // log.  Set ctx to timeout to control how long to wait for the logs to appear
-func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
-	info := &InferenceInfo{}
-	computeMarker := regexp.MustCompile(`inference compute.*library=`)
-	defaultCtxMarker := regexp.MustCompile(`vram-based default context`)
-	defaultCtxRegex := regexp.MustCompile(`default_num_ctx=(\d+)`)
-
+func GetInferenceComputer(ctx context.Context) ([]InferenceCompute, error) {
+	inference := []InferenceCompute{}
+	marker := regexp.MustCompile(`inference compute.*library=`)
 	q := `inference compute.*%s=["]([^"]*)["]`
 	nq := `inference compute.*%s=(\S+)\s`
 	type regex struct {
@@ -348,8 +330,8 @@ func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
 		scanner := bufio.NewScanner(file)
 		for scanner.Scan() {
 			line := scanner.Text()
-			// Check for inference compute lines
-			if computeMarker.MatchString(line) {
+			match := marker.FindStringSubmatch(line)
+			if len(match) > 0 {
 				ic := InferenceCompute{
 					Library: get("library", line),
 					Variant: get("variant", line),
@@ -360,25 +342,12 @@ func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
 				}

 				slog.Info("Matched", "inference compute", ic)
-				info.Computes = append(info.Computes, ic)
-				continue
-			}
-			// Check for default context length line
-			if defaultCtxMarker.MatchString(line) {
-				match := defaultCtxRegex.FindStringSubmatch(line)
-				if len(match) > 1 {
-					numCtx, err := strconv.Atoi(match[1])
-					if err == nil {
-						info.DefaultContextLength = numCtx
-						slog.Info("Matched default context length", "default_num_ctx", numCtx)
-					}
+				inference = append(inference, ic)
+			} else {
+				// Break out on first non matching line after we start matching
+				if len(inference) > 0 {
+					return inference, nil
 				}
-				return info, nil
-			}
-			// If we've found compute info but hit a non-matching line, return what we have
-			// This handles older server versions that don't log the default context line
-			if len(info.Computes) > 0 {
-				return info, nil
 			}
 		}
 		time.Sleep(100 * time.Millisecond)
@@ -111,7 +111,7 @@ func TestServerCmd(t *testing.T) {
 			for _, want := range tt.want {
 				found := false
 				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, want) {
+					if strings.Contains(env, want) {
 						found = true
 						break
 					}
@@ -123,7 +123,7 @@ func TestServerCmd(t *testing.T) {

 			for _, dont := range tt.dont {
 				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, dont) {
+					if strings.Contains(env, dont) {
 						t.Errorf("unexpected environment variable: %s", env)
 					}
 				}
@@ -136,119 +136,44 @@ func TestServerCmd(t *testing.T) {
 	}
 }

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

-func TestGetInferenceInfoTimeout(t *testing.T) {
+func TestGetInferenceComputerTimeout(t *testing.T) {
 	ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
 	defer cancel()
 	tmpDir := t.TempDir()
@@ -333,7 +239,7 @@ func TestGetInferenceInfoTimeout(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to write log file %s: %s", serverLogPath, err)
 	}
-	_, err = GetInferenceInfo(ctx)
+	_, err = GetInferenceComputer(ctx)
 	if err == nil {
 		t.Fatal("expected timeout")
 	}
@@ -1,128 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/ollama/ollama/envconfig"
-)
-
-const serverConfigFilename = "server.json"
-
-type serverConfig struct {
-	DisableOllamaCloud bool `json:"disable_ollama_cloud,omitempty"`
-}
-
-// CloudDisabled returns whether cloud features should be disabled.
-// The source of truth is: OLLAMA_NO_CLOUD OR ~/.ollama/server.json:disable_ollama_cloud.
-func (s *Store) CloudDisabled() (bool, error) {
-	disabled, _, err := s.CloudStatus()
-	return disabled, err
-}
-
-// CloudStatus returns whether cloud is disabled and the source of that decision.
-// Source is one of: "none", "env", "config", "both".
-func (s *Store) CloudStatus() (bool, string, error) {
-	if err := s.ensureDB(); err != nil {
-		return false, "", err
-	}
-
-	configDisabled, err := readServerConfigCloudDisabled()
-	if err != nil {
-		return false, "", err
-	}
-
-	envDisabled := envconfig.NoCloudEnv()
-	return envDisabled || configDisabled, cloudStatusSource(envDisabled, configDisabled), nil
-}
-
-// SetCloudEnabled writes the cloud setting to ~/.ollama/server.json.
-func (s *Store) SetCloudEnabled(enabled bool) error {
-	if err := s.ensureDB(); err != nil {
-		return err
-	}
-	return setCloudEnabled(enabled)
-}
-
-func setCloudEnabled(enabled bool) error {
-	configPath, err := serverConfigPath()
-	if err != nil {
-		return err
-	}
-
-	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
-		return fmt.Errorf("create server config directory: %w", err)
-	}
-
-	configMap := map[string]any{}
-	if data, err := os.ReadFile(configPath); err == nil {
-		if err := json.Unmarshal(data, &configMap); err != nil {
-			// If the existing file is invalid JSON, overwrite with a fresh object.
-			configMap = map[string]any{}
-		}
-	} else if !errors.Is(err, os.ErrNotExist) {
-		return fmt.Errorf("read server config: %w", err)
-	}
-
-	configMap["disable_ollama_cloud"] = !enabled
-
-	data, err := json.MarshalIndent(configMap, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal server config: %w", err)
-	}
-	data = append(data, '\n')
-
-	if err := os.WriteFile(configPath, data, 0o644); err != nil {
-		return fmt.Errorf("write server config: %w", err)
-	}
-
-	return nil
-}
-
-func readServerConfigCloudDisabled() (bool, error) {
-	configPath, err := serverConfigPath()
-	if err != nil {
-		return false, err
-	}
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return false, nil
-		}
-		return false, fmt.Errorf("read server config: %w", err)
-	}
-
-	var cfg serverConfig
-	// Invalid or unexpected JSON should not block startup; treat as default.
-	if json.Unmarshal(data, &cfg) == nil {
-		return cfg.DisableOllamaCloud, nil
-	}
-	return false, nil
-}
-
-func serverConfigPath() (string, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return "", fmt.Errorf("resolve home directory: %w", err)
-	}
-	return filepath.Join(home, ".ollama", serverConfigFilename), nil
-}
-
-func cloudStatusSource(envDisabled bool, configDisabled bool) string {
-	switch {
-	case envDisabled && configDisabled:
-		return "both"
-	case envDisabled:
-		return "env"
-	case configDisabled:
-		return "config"
-	default:
-		return "none"
-	}
-}
@@ -1,130 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestCloudDisabled(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		wantDisabled  bool
-		wantSource    string
-	}{
-		{
-			name:         "default enabled",
-			wantDisabled: false,
-			wantSource:   "none",
-		},
-		{
-			name:         "env disables cloud",
-			envValue:     "1",
-			wantDisabled: true,
-			wantSource:   "env",
-		},
-		{
-			name:          "config disables cloud",
-			configContent: `{"disable_ollama_cloud": true}`,
-			wantDisabled:  true,
-			wantSource:    "config",
-		},
-		{
-			name:          "env and config",
-			envValue:      "1",
-			configContent: `{"disable_ollama_cloud": false}`,
-			wantDisabled:  true,
-			wantSource:    "env",
-		},
-		{
-			name:          "invalid config is ignored",
-			configContent: `{bad`,
-			wantDisabled:  false,
-			wantSource:    "none",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpHome := t.TempDir()
-			setTestHome(t, tmpHome)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			if tt.configContent != "" {
-				configDir := filepath.Join(tmpHome, ".ollama")
-				if err := os.MkdirAll(configDir, 0o755); err != nil {
-					t.Fatalf("mkdir config dir: %v", err)
-				}
-				configPath := filepath.Join(configDir, serverConfigFilename)
-				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
-					t.Fatalf("write config: %v", err)
-				}
-			}
-
-			s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
-			defer s.Close()
-
-			disabled, err := s.CloudDisabled()
-			if err != nil {
-				t.Fatalf("CloudDisabled() error = %v", err)
-			}
-			if disabled != tt.wantDisabled {
-				t.Fatalf("CloudDisabled() = %v, want %v", disabled, tt.wantDisabled)
-			}
-
-			statusDisabled, source, err := s.CloudStatus()
-			if err != nil {
-				t.Fatalf("CloudStatus() error = %v", err)
-			}
-			if statusDisabled != tt.wantDisabled {
-				t.Fatalf("CloudStatus() disabled = %v, want %v", statusDisabled, tt.wantDisabled)
-			}
-			if source != tt.wantSource {
-				t.Fatalf("CloudStatus() source = %v, want %v", source, tt.wantSource)
-			}
-		})
-	}
-}
-
-func TestSetCloudEnabled(t *testing.T) {
-	tmpHome := t.TempDir()
-	setTestHome(t, tmpHome)
-
-	configDir := filepath.Join(tmpHome, ".ollama")
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
-		t.Fatalf("mkdir config dir: %v", err)
-	}
-	configPath := filepath.Join(configDir, serverConfigFilename)
-	if err := os.WriteFile(configPath, []byte(`{"another_key":"value","disable_ollama_cloud":true}`), 0o644); err != nil {
-		t.Fatalf("seed config: %v", err)
-	}
-
-	s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
-	defer s.Close()
-
-	if err := s.SetCloudEnabled(true); err != nil {
-		t.Fatalf("SetCloudEnabled(true) error = %v", err)
-	}
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal(data, &got); err != nil {
-		t.Fatalf("unmarshal config: %v", err)
-	}
-
-	if got["disable_ollama_cloud"] != false {
-		t.Fatalf("disable_ollama_cloud = %v, want false", got["disable_ollama_cloud"])
-	}
-	if got["another_key"] != "value" {
-		t.Fatalf("another_key = %v, want value", got["another_key"])
-	}
-}
@@ -9,12 +9,12 @@ import (
 	"strings"
 	"time"

-	_ "github.com/mattn/go-sqlite3"
+	sqlite3 "github.com/mattn/go-sqlite3"
 )

 // currentSchemaVersion defines the current database schema version.
 // Increment this when making schema changes that require migrations.
-const currentSchemaVersion = 16
+const currentSchemaVersion = 12

 // database wraps the SQLite connection.
 // SQLite handles its own locking for concurrent access:
@@ -73,7 +73,7 @@ func (db *database) init() error {
 		agent BOOLEAN NOT NULL DEFAULT 0,
 		tools BOOLEAN NOT NULL DEFAULT 0,
 		working_dir TEXT NOT NULL DEFAULT '',
-		context_length INTEGER NOT NULL DEFAULT 0,
+		context_length INTEGER NOT NULL DEFAULT 4096,
 		window_width INTEGER NOT NULL DEFAULT 0,
 		window_height INTEGER NOT NULL DEFAULT 0,
 		config_migrated BOOLEAN NOT NULL DEFAULT 0,
@@ -82,12 +82,9 @@ func (db *database) init() error {
 		websearch_enabled BOOLEAN NOT NULL DEFAULT 0,
 		selected_model TEXT NOT NULL DEFAULT '',
 		sidebar_open BOOLEAN NOT NULL DEFAULT 0,
-		last_home_view TEXT NOT NULL DEFAULT 'launch',
 		think_enabled BOOLEAN NOT NULL DEFAULT 0,
 		think_level TEXT NOT NULL DEFAULT '',
-		cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0,
 		remote TEXT NOT NULL DEFAULT '', -- deprecated
-		auto_update_enabled BOOLEAN NOT NULL DEFAULT 1,
 		schema_version INTEGER NOT NULL DEFAULT %d
 	);

@@ -247,30 +244,6 @@ func (db *database) migrate() error {
 				return fmt.Errorf("migrate v11 to v12: %w", err)
 			}
 			version = 12
-		case 12:
-			// add cloud_setting_migrated column to settings table
-			if err := db.migrateV12ToV13(); err != nil {
-				return fmt.Errorf("migrate v12 to v13: %w", err)
-			}
-			version = 13
-		case 13:
-			// change default context_length from 4096 to 0 (VRAM-based tiered defaults)
-			if err := db.migrateV13ToV14(); err != nil {
-				return fmt.Errorf("migrate v13 to v14: %w", err)
-			}
-			version = 14
-		case 14:
-			// add auto_update_enabled column to settings table
-			if err := db.migrateV14ToV15(); err != nil {
-				return fmt.Errorf("migrate v14 to v15: %w", err)
-			}
-			version = 15
-		case 15:
-			// add last_home_view column to settings table
-			if err := db.migrateV15ToV16(); err != nil {
-				return fmt.Errorf("migrate v15 to v16: %w", err)
-			}
-			version = 16
 		default:
 			// If we have a version we don't recognize, just set it to current
 			// This might happen during development
@@ -479,67 +452,6 @@ func (db *database) migrateV11ToV12() error {
 	return nil
 }

-// migrateV12ToV13 adds cloud_setting_migrated to settings.
-func (db *database) migrateV12ToV13() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add cloud_setting_migrated column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 13`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV13ToV14 changes the default context_length from 4096 to 0.
-// When context_length is 0, the ollama server uses VRAM-based tiered defaults.
-func (db *database) migrateV13ToV14() error {
-	_, err := db.conn.Exec(`UPDATE settings SET context_length = 0 WHERE context_length = 4096`)
-	if err != nil {
-		return fmt.Errorf("update context_length default: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 14`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV14ToV15 adds the auto_update_enabled column to the settings table
-func (db *database) migrateV14ToV15() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN auto_update_enabled BOOLEAN NOT NULL DEFAULT 1`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add auto_update_enabled column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 15`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
-// migrateV15ToV16 adds the last_home_view column to the settings table
-func (db *database) migrateV15ToV16() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN last_home_view TEXT NOT NULL DEFAULT 'launch'`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add last_home_view column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 16`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
 // cleanupOrphanedData removes orphaned records that may exist due to the foreign key bug
 func (db *database) cleanupOrphanedData() error {
 	_, err := db.conn.Exec(`
@@ -570,11 +482,19 @@ func (db *database) cleanupOrphanedData() error {
 }

 func duplicateColumnError(err error) bool {
-	return err != nil && strings.Contains(err.Error(), "duplicate column name")
+	if sqlite3Err, ok := err.(sqlite3.Error); ok {
+		return sqlite3Err.Code == sqlite3.ErrError &&
+			strings.Contains(sqlite3Err.Error(), "duplicate column name")
+	}
+	return false
 }

 func columnNotExists(err error) bool {
-	return err != nil && strings.Contains(err.Error(), "no such column")
+	if sqlite3Err, ok := err.(sqlite3.Error); ok {
+		return sqlite3Err.Code == sqlite3.ErrError &&
+			strings.Contains(sqlite3Err.Error(), "no such column")
+	}
+	return false
 }

 func (db *database) getAllChats() ([]Chat, error) {
@@ -1188,9 +1108,9 @@ func (db *database) getSettings() (Settings, error) {
 	var s Settings

 	err := db.conn.QueryRow(`
-		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, turbo_enabled, websearch_enabled, selected_model, sidebar_open, last_home_view, think_enabled, think_level, auto_update_enabled
+		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, airplane_mode, turbo_enabled, websearch_enabled, selected_model, sidebar_open, think_enabled, think_level 
 		FROM settings
-	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.LastHomeView, &s.ThinkEnabled, &s.ThinkLevel, &s.AutoUpdateEnabled)
+	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.AirplaneMode, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.ThinkEnabled, &s.ThinkLevel)
 	if err != nil {
 		return Settings{}, fmt.Errorf("get settings: %w", err)
 	}
@@ -1199,58 +1119,16 @@ func (db *database) getSettings() (Settings, error) {
 }

 func (db *database) setSettings(s Settings) error {
-	lastHomeView := strings.ToLower(strings.TrimSpace(s.LastHomeView))
-	validLaunchView := map[string]struct{}{
-		"launch":   {},
-		"openclaw": {},
-		"claude":   {},
-		"codex":    {},
-		"opencode": {},
-		"droid":    {},
-		"pi":       {},
-	}
-	if lastHomeView != "chat" {
-		if _, ok := validLaunchView[lastHomeView]; !ok {
-			lastHomeView = "launch"
-		}
-	}
-
 	_, err := db.conn.Exec(`
-		UPDATE settings
-		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, last_home_view = ?, think_enabled = ?, think_level = ?, auto_update_enabled = ?
-	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, lastHomeView, s.ThinkEnabled, s.ThinkLevel, s.AutoUpdateEnabled)
+		UPDATE settings 
+		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, airplane_mode = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, think_enabled = ?, think_level = ?
+	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.AirplaneMode, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, s.ThinkEnabled, s.ThinkLevel)
 	if err != nil {
 		return fmt.Errorf("set settings: %w", err)
 	}
 	return nil
 }

-func (db *database) isCloudSettingMigrated() (bool, error) {
-	var migrated bool
-	err := db.conn.QueryRow("SELECT cloud_setting_migrated FROM settings").Scan(&migrated)
-	if err != nil {
-		return false, fmt.Errorf("get cloud setting migration status: %w", err)
-	}
-	return migrated, nil
-}
-
-func (db *database) setCloudSettingMigrated(migrated bool) error {
-	_, err := db.conn.Exec("UPDATE settings SET cloud_setting_migrated = ?", migrated)
-	if err != nil {
-		return fmt.Errorf("set cloud setting migration status: %w", err)
-	}
-	return nil
-}
-
-func (db *database) getAirplaneMode() (bool, error) {
-	var airplaneMode bool
-	err := db.conn.QueryRow("SELECT airplane_mode FROM settings").Scan(&airplaneMode)
-	if err != nil {
-		return false, fmt.Errorf("get airplane_mode: %w", err)
-	}
-	return airplaneMode, nil
-}
-
 func (db *database) getWindowSize() (int, int, error) {
 	var width, height int
 	err := db.conn.QueryRow("SELECT window_width, window_height FROM settings").Scan(&width, &height)
@@ -98,82 +98,6 @@ func TestSchemaMigrations(t *testing.T) {
 	})
 }

-func TestMigrationV13ToV14ContextLength(t *testing.T) {
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "test.db")
-
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer db.Close()
-
-	_, err = db.conn.Exec("UPDATE settings SET context_length = 4096, schema_version = 13")
-	if err != nil {
-		t.Fatalf("failed to seed v13 settings row: %v", err)
-	}
-
-	if err := db.migrate(); err != nil {
-		t.Fatalf("migration from v13 to v14 failed: %v", err)
-	}
-
-	var contextLength int
-	if err := db.conn.QueryRow("SELECT context_length FROM settings").Scan(&contextLength); err != nil {
-		t.Fatalf("failed to read context_length: %v", err)
-	}
-
-	if contextLength != 0 {
-		t.Fatalf("expected context_length to migrate to 0, got %d", contextLength)
-	}
-
-	version, err := db.getSchemaVersion()
-	if err != nil {
-		t.Fatalf("failed to get schema version: %v", err)
-	}
-	if version != currentSchemaVersion {
-		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
-	}
-}
-
-func TestMigrationV15ToV16LastHomeViewDefaultsToLaunch(t *testing.T) {
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "test.db")
-
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer db.Close()
-
-	if _, err := db.conn.Exec(`
-		ALTER TABLE settings DROP COLUMN last_home_view;
-		UPDATE settings SET schema_version = 15;
-	`); err != nil {
-		t.Fatalf("failed to seed v15 settings row: %v", err)
-	}
-
-	if err := db.migrate(); err != nil {
-		t.Fatalf("migration from v15 to v16 failed: %v", err)
-	}
-
-	var lastHomeView string
-	if err := db.conn.QueryRow("SELECT last_home_view FROM settings").Scan(&lastHomeView); err != nil {
-		t.Fatalf("failed to read last_home_view: %v", err)
-	}
-
-	if lastHomeView != "launch" {
-		t.Fatalf("expected last_home_view to default to launch after migration, got %q", lastHomeView)
-	}
-
-	version, err := db.getSchemaVersion()
-	if err != nil {
-		t.Fatalf("failed to get schema version: %v", err)
-	}
-	if version != currentSchemaVersion {
-		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
-	}
-}
-
 func TestChatDeletionWithCascade(t *testing.T) {
 	t.Run("chat deletion cascades to related messages", func(t *testing.T) {
 		tmpDir := t.TempDir()
@@ -127,65 +127,6 @@ func TestNoConfigToMigrate(t *testing.T) {
 	}
 }

-func TestCloudMigrationFromAirplaneMode(t *testing.T) {
-	tmpHome := t.TempDir()
-	setTestHome(t, tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	dbPath := filepath.Join(tmpHome, "db.sqlite")
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-
-	if _, err := db.conn.Exec("UPDATE settings SET airplane_mode = 1, cloud_setting_migrated = 0"); err != nil {
-		db.Close()
-		t.Fatalf("failed to seed airplane migration state: %v", err)
-	}
-	db.Close()
-
-	s := Store{DBPath: dbPath}
-	defer s.Close()
-
-	// Trigger DB initialization + one-time cloud migration.
-	if _, err := s.ID(); err != nil {
-		t.Fatalf("failed to initialize store: %v", err)
-	}
-
-	disabled, err := s.CloudDisabled()
-	if err != nil {
-		t.Fatalf("CloudDisabled() error: %v", err)
-	}
-	if !disabled {
-		t.Fatal("expected cloud to be disabled after migrating airplane_mode=true")
-	}
-
-	configPath := filepath.Join(tmpHome, ".ollama", serverConfigFilename)
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatalf("failed to read migrated server config: %v", err)
-	}
-
-	var cfg map[string]any
-	if err := json.Unmarshal(data, &cfg); err != nil {
-		t.Fatalf("failed to parse migrated server config: %v", err)
-	}
-	if cfg["disable_ollama_cloud"] != true {
-		t.Fatalf("disable_ollama_cloud = %v, want true", cfg["disable_ollama_cloud"])
-	}
-
-	var airplaneMode, migrated bool
-	if err := s.db.conn.QueryRow("SELECT airplane_mode, cloud_setting_migrated FROM settings").Scan(&airplaneMode, &migrated); err != nil {
-		t.Fatalf("failed to read migration flags from DB: %v", err)
-	}
-	if !airplaneMode {
-		t.Fatal("expected legacy airplane_mode value to remain unchanged")
-	}
-	if !migrated {
-		t.Fatal("expected cloud_setting_migrated to be true")
-	}
-}
-
 const (
 	v1Schema = `
 	CREATE TABLE IF NOT EXISTS settings (
@@ -149,6 +149,9 @@ type Settings struct {
 	// ContextLength specifies the context length for the ollama server (using OLLAMA_CONTEXT_LENGTH)
 	ContextLength int

+	// AirplaneMode when true, turns off Ollama Turbo features and only uses local models
+	AirplaneMode bool
+
 	// TurboEnabled indicates if Ollama Turbo features are enabled
 	TurboEnabled bool

@@ -166,12 +169,6 @@ type Settings struct {

 	// SidebarOpen indicates if the chat sidebar is open
 	SidebarOpen bool
-
-	// LastHomeView stores the preferred home route target ("chat" or integration name)
-	LastHomeView string
-
-	// AutoUpdateEnabled indicates if automatic updates should be downloaded
-	AutoUpdateEnabled bool
 }

 type Store struct {
@@ -262,40 +259,6 @@ func (s *Store) ensureDB() error {
 		}
 	}

-	// Run one-time migration from legacy airplane_mode behavior.
-	if err := s.migrateCloudSetting(database); err != nil {
-		return fmt.Errorf("migrate cloud setting: %w", err)
-	}
-
-	return nil
-}
-
-// migrateCloudSetting migrates legacy airplane_mode into server.json exactly once.
-// After this, cloud state is sourced from server.json OR OLLAMA_NO_CLOUD.
-func (s *Store) migrateCloudSetting(database *database) error {
-	migrated, err := database.isCloudSettingMigrated()
-	if err != nil {
-		return err
-	}
-	if migrated {
-		return nil
-	}
-
-	airplaneMode, err := database.getAirplaneMode()
-	if err != nil {
-		return err
-	}
-
-	if airplaneMode {
-		if err := setCloudEnabled(false); err != nil {
-			return fmt.Errorf("migrate airplane_mode to cloud disabled: %w", err)
-		}
-	}
-
-	if err := database.setCloudSettingMigrated(true); err != nil {
-		return err
-	}
-
 	return nil
 }

@@ -392,10 +355,6 @@ func (s *Store) Settings() (Settings, error) {
 		}
 	}

-	if settings.LastHomeView == "" {
-		settings.LastHomeView = "launch"
-	}
-
 	return settings, nil
 }

@@ -81,32 +81,6 @@ func TestStore(t *testing.T) {
 		}
 	})

-	t.Run("settings default home view is launch", func(t *testing.T) {
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "launch" {
-			t.Fatalf("expected default LastHomeView to be launch, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings empty home view falls back to launch", func(t *testing.T) {
-		if err := s.SetSettings(Settings{LastHomeView: ""}); err != nil {
-			t.Fatal(err)
-		}
-
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "launch" {
-			t.Fatalf("expected empty LastHomeView to fall back to launch, got %q", loaded.LastHomeView)
-		}
-	})
-
 	t.Run("window size", func(t *testing.T) {
 		if err := s.SetWindowSize(1024, 768); err != nil {
 			t.Fatal(err)
@@ -1,11 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import "testing"
-
-func setTestHome(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-}
@@ -13,7 +13,7 @@ CREATE TABLE IF NOT EXISTS settings (
    agent BOOLEAN NOT NULL DEFAULT 0,
    tools BOOLEAN NOT NULL DEFAULT 0,
    working_dir TEXT NOT NULL DEFAULT '',
-    context_length INTEGER NOT NULL DEFAULT 0,
+    context_length INTEGER NOT NULL DEFAULT 4096,
    window_width INTEGER NOT NULL DEFAULT 0,
    window_height INTEGER NOT NULL DEFAULT 0,
    config_migrated BOOLEAN NOT NULL DEFAULT 0,
@@ -1,35 +0,0 @@
-//go:build windows || darwin
-
-package tools
-
-import (
-	"context"
-	"errors"
-
-	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-)
-
-// ensureCloudEnabledForTool checks cloud policy from the connected Ollama server.
-// If policy cannot be determined, this fails closed and blocks the operation.
-func ensureCloudEnabledForTool(ctx context.Context, operation string) error {
-	// Reuse shared message formatting; policy evaluation is still done via
-	// the connected server's /api/status endpoint below.
-	disabledMessage := internalcloud.DisabledError(operation)
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
-	}
-
-	status, err := client.CloudStatusExperimental(ctx)
-	if err != nil {
-		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
-	}
-
-	if status.Cloud.Disabled {
-		return errors.New(disabledMessage)
-	}
-
-	return nil
-}
@@ -1,73 +0,0 @@
-//go:build windows || darwin
-
-package tools
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-func TestEnsureCloudEnabledForTool(t *testing.T) {
-	const op = "web search is unavailable"
-	const disabledPrefix = "ollama cloud is disabled: web search is unavailable"
-
-	t.Run("enabled allows tool execution", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/status" {
-				http.NotFound(w, r)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			_, _ = w.Write([]byte(`{"cloud":{"disabled":false,"source":"none"}}`))
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		if err := ensureCloudEnabledForTool(context.Background(), op); err != nil {
-			t.Fatalf("expected nil error, got %v", err)
-		}
-	})
-
-	t.Run("disabled blocks tool execution", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/status" {
-				http.NotFound(w, r)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			_, _ = w.Write([]byte(`{"cloud":{"disabled":true,"source":"config"}}`))
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		err := ensureCloudEnabledForTool(context.Background(), op)
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if got := err.Error(); got != disabledPrefix {
-			t.Fatalf("unexpected error: %q", got)
-		}
-	})
-
-	t.Run("status unavailable fails closed", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			http.NotFound(w, r)
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		err := ensureCloudEnabledForTool(context.Background(), op)
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if got := err.Error(); !strings.Contains(got, disabledPrefix) {
-			t.Fatalf("expected disabled prefix, got %q", got)
-		}
-		if got := err.Error(); !strings.Contains(got, "unable to verify server cloud policy") {
-			t.Fatalf("expected verification failure detail, got %q", got)
-		}
-	})
-}
@@ -77,10 +77,6 @@ func (w *WebFetch) Execute(ctx context.Context, args map[string]any) (any, strin
 }

 func performWebFetch(ctx context.Context, targetURL string) (*FetchResponse, error) {
-	if err := ensureCloudEnabledForTool(ctx, "web fetch is unavailable"); err != nil {
-		return nil, err
-	}
-
 	reqBody := FetchRequest{URL: targetURL}
 	jsonBody, err := json.Marshal(reqBody)
 	if err != nil {
@@ -93,10 +93,6 @@ func (w *WebSearch) Execute(ctx context.Context, args map[string]any) (any, stri
 }

 func performWebSearch(ctx context.Context, query string, maxResults int) (*SearchResponse, error) {
-	if err := ensureCloudEnabledForTool(ctx, "web search is unavailable"); err != nil {
-		return nil, err
-	}
-
 	reqBody := SearchRequest{Query: query, MaxResults: maxResults}

 	jsonBody, err := json.Marshal(reqBody)
@@ -289,12 +289,10 @@ export class InferenceCompute {
 }
 export class InferenceComputeResponse {
    inferenceComputes: InferenceCompute[];
-    defaultContextLength: number;

    constructor(source: any = {}) {
        if ('string' === typeof source) source = JSON.parse(source);
        this.inferenceComputes = this.convertValues(source["inferenceComputes"], InferenceCompute);
-        this.defaultContextLength = source["defaultContextLength"];
    }

 	convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -408,14 +406,13 @@ export class Settings {
    Tools: boolean;
    WorkingDir: string;
    ContextLength: number;
+    AirplaneMode: boolean;
    TurboEnabled: boolean;
    WebSearchEnabled: boolean;
    ThinkEnabled: boolean;
    ThinkLevel: string;
    SelectedModel: string;
    SidebarOpen: boolean;
-    LastHomeView: string;
-    AutoUpdateEnabled: boolean;

    constructor(source: any = {}) {
        if ('string' === typeof source) source = JSON.parse(source);
@@ -427,14 +424,13 @@ export class Settings {
        this.Tools = source["Tools"];
        this.WorkingDir = source["WorkingDir"];
        this.ContextLength = source["ContextLength"];
+        this.AirplaneMode = source["AirplaneMode"];
        this.TurboEnabled = source["TurboEnabled"];
        this.WebSearchEnabled = source["WebSearchEnabled"];
        this.ThinkEnabled = source["ThinkEnabled"];
        this.ThinkLevel = source["ThinkLevel"];
        this.SelectedModel = source["SelectedModel"];
        this.SidebarOpen = source["SidebarOpen"];
-        this.LastHomeView = source["LastHomeView"];
-        this.AutoUpdateEnabled = source["AutoUpdateEnabled"];
    }
 }
 export class SettingsResponse {
@@ -552,12 +548,14 @@ export class Error {
    }
 }
 export class ModelUpstreamResponse {
-    stale: boolean;
+    digest?: string;
+    pushTime: number;
    error?: string;

    constructor(source: any = {}) {
        if ('string' === typeof source) source = JSON.parse(source);
-        this.stale = source["stale"];
+        this.digest = source["digest"];
+        this.pushTime = source["pushTime"];
        this.error = source["error"];
    }
 }
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated by Pixelmator Pro 3.6.17 -->
-<svg width="1200" height="1200" viewBox="0 0 1200 1200" xmlns="http://www.w3.org/2000/svg">
-    <g id="g314">
-        <path id="path147" fill="#d97757" stroke="none" d="M 233.959793 800.214905 L 468.644287 668.536987 L 472.590637 657.100647 L 468.644287 650.738403 L 457.208069 650.738403 L 417.986633 648.322144 L 283.892639 644.69812 L 167.597321 639.865845 L 54.926208 633.825623 L 26.577238 627.785339 L 3.3e-05 592.751709 L 2.73832 575.27533 L 26.577238 559.248352 L 60.724873 562.228149 L 136.187973 567.382629 L 249.422867 575.194763 L 331.570496 580.026978 L 453.261841 592.671082 L 472.590637 592.671082 L 475.328857 584.859009 L 468.724915 580.026978 L 463.570557 575.194763 L 346.389313 495.785217 L 219.543671 411.865906 L 153.100723 363.543762 L 117.181267 339.060425 L 99.060455 316.107361 L 91.248367 266.01355 L 123.865784 230.093994 L 167.677887 233.073853 L 178.872513 236.053772 L 223.248367 270.201477 L 318.040283 343.570496 L 441.825592 434.738342 L 459.946411 449.798706 L 467.194672 444.64447 L 468.080597 441.020203 L 459.946411 427.409485 L 392.617493 305.718323 L 320.778564 181.932983 L 288.80542 130.630859 L 280.348999 99.865845 C 277.369171 87.221436 275.194641 76.590698 275.194641 63.624268 L 312.322174 13.20813 L 332.8591 6.604126 L 382.389313 13.20813 L 403.248352 31.328979 L 434.013519 101.71814 L 483.865753 212.537048 L 561.181274 363.221497 L 583.812134 407.919434 L 595.892639 449.315491 L 600.40271 461.959839 L 608.214783 461.959839 L 608.214783 454.711609 L 614.577271 369.825623 L 626.335632 265.61084 L 637.771851 131.516846 L 641.718201 93.745117 L 660.402832 48.483276 L 697.530334 24.000122 L 726.52356 37.852417 L 750.362549 72 L 747.060486 94.067139 L 732.886047 186.201416 L 705.100708 330.52356 L 686.979919 427.167847 L 697.530334 427.167847 L 709.61084 415.087341 L 758.496704 350.174561 L 840.644348 247.490051 L 876.885925 206.738342 L 919.167847 161.71814 L 946.308838 140.29541 L 997.61084 140.29541 L 1035.38269 196.429626 L 1018.469849 254.416199 L 965.637634 321.422852 L 921.825562 378.201538 L 859.006714 462.765259 L 819.785278 530.41626 L 823.409424 535.812073 L 832.75177 534.92627 L 974.657776 504.724915 L 1051.328979 490.872559 L 1142.818848 475.167786 L 1184.214844 494.496582 L 1188.724854 514.147644 L 1172.456421 554.335693 L 1074.604126 578.496765 L 959.838989 601.449829 L 788.939636 641.879272 L 786.845764 643.409485 L 789.261841 646.389343 L 866.255127 653.637634 L 899.194702 655.409424 L 979.812134 655.409424 L 1129.932861 666.604187 L 1169.154419 692.537109 L 1192.671265 724.268677 L 1188.724854 748.429688 L 1128.322144 779.194641 L 1046.818848 759.865845 L 856.590759 714.604126 L 791.355774 698.335754 L 782.335693 698.335754 L 782.335693 703.731567 L 836.69812 756.885986 L 936.322205 846.845581 L 1061.073975 962.81897 L 1067.436279 991.490112 L 1051.409424 1014.120911 L 1034.496704 1011.704712 L 924.885986 929.234924 L 882.604126 892.107544 L 786.845764 811.48999 L 780.483276 811.48999 L 780.483276 819.946289 L 802.550415 852.241699 L 919.087341 1027.409424 L 925.127625 1081.127686 L 916.671204 1098.604126 L 886.469849 1109.154419 L 853.288696 1103.114136 L 785.073914 1007.355835 L 714.684631 899.516785 L 657.906067 802.872498 L 650.979858 806.81897 L 617.476624 1167.704834 L 601.771851 1186.147705 L 565.530212 1200 L 535.328857 1177.046997 L 519.302124 1139.919556 L 535.328857 1066.550537 L 554.657776 970.792053 L 570.362488 894.68457 L 584.536926 800.134277 L 592.993347 768.724976 L 592.429626 766.630859 L 585.503479 767.516968 L 514.22821 865.369263 L 405.825531 1011.865906 L 320.053711 1103.677979 L 299.516815 1111.812256 L 263.919525 1093.369263 L 267.221497 1060.429688 L 287.114136 1031.114136 L 405.825531 880.107361 L 477.422913 786.52356 L 523.651062 732.483276 L 523.328918 724.671265 L 520.590698 724.671265 L 205.288605 929.395935 L 149.154434 936.644409 L 124.993355 914.01355 L 127.973183 876.885986 L 139.409409 864.80542 L 234.201385 799.570435 L 233.879227 799.8927 Z"/>
-    </g>
-</svg>
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path fill="#fff" d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>
@@ -1,242 +0,0 @@
-<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500" width="500" height="500">
-	<style>
-		.s0 { fill: #f6f4f4 } 
-		.s1 { fill: #0b0303 } 
-		.s2 { fill: #ef0011 } 
-		.s3 { fill: #f3e2e2 } 
-		.s4 { fill: #f00212 } 
-		.s5 { fill: #ba000d } 
-		.s6 { fill: #faf1f1 } 
-		.s7 { fill: #0b0100 } 
-		.s8 { fill: #fbedee } 
-		.s9 { fill: #faeaea } 
-		.s10 { fill: #ab797d } 
-		.s11 { fill: #f8eaea } 
-		.s12 { fill: #902021 } 
-		.s13 { fill: #f9eeee } 
-		.s14 { fill: #f6ecec } 
-		.s15 { fill: #080201 } 
-		.s16 { fill: #150100 } 
-		.s17 { fill: #f2e7e7 } 
-		.s18 { fill: #fbe7e8 } 
-		.s19 { fill: #060101 } 
-		.s20 { fill: #f5e7e7 } 
-		.s21 { fill: #fa999e } 
-		.s22 { fill: #c46064 } 
-		.s23 { fill: #180300 } 
-		.s24 { fill: #f6dcdd } 
-		.s25 { fill: #f2e6e6 } 
-		.s26 { fill: #110200 } 
-		.s27 { fill: #eb0011 } 
-		.s28 { fill: #e20010 } 
-		.s29 { fill: #ea0011 } 
-		.s30 { fill: #760007 } 
-		.s31 { fill: #f00514 } 
-		.s32 { fill: #fcebeb } 
-		.s33 { fill: #ecd6d6 } 
-		.s34 { fill: #f5e3e3 } 
-		.s35 { fill: #f5e4e4 } 
-		.s36 { fill: #faf6f6 } 
-		.s37 { fill: #e50010 } 
-		.s38 { fill: #d5000f } 
-		.s39 { fill: #f2e2e3 } 
-		.s40 { fill: #ef1018 } 
-		.s41 { fill: #f4e8e9 } 
-		.s42 { fill: #ef0513 } 
-		.s43 { fill: #f5e5e5 } 
-		.s44 { fill: #f00413 } 
-		.s45 { fill: #f4e9ea } 
-		.s46 { fill: #ed0011 } 
-		.s47 { fill: #e80011 } 
-		.s48 { fill: #e60613 } 
-		.s49 { fill: #f0d6d6 } 
-		.s50 { fill: #fca9ac } 
-		.s51 { fill: #9c000c } 
-		.s52 { fill: #73393b } 
-	</style>
-	<g>
-		<path fill-rule="evenodd" class="s0" d="m166.5 52.5q3.5 0 7 0 2.75 2.99 1.5 7-21.27 45.61-20.5 96 39.99 2.76 72 26.5 7.87 6.86 13.5 15.5 42.88-56.39 103.5-92.5 47.35-25.46 101-25 14.52 0.38 23.5 11.5 3.19 7.74 2 16-1.81 7.18-4.5 14-1 0-1 1-5.04 6.05-9 13-1 0-1 1 0 0.5 0 1-12.42 12.15-28.5 19-6.02 36.27-41.5 45-0.83 2.75 0 5 19.02-12.85 41.5-9 10.85-8.09 23.5-13 15.01-6.37 31-2.5 14.09 7.43 14 23.5-2.83 23.25-15.5 43-6.42 9.92-14 19-10.04 8.8-19.5 18-72.02 48.88-156.5 27-19.63 9.6-41.5 10.5-4.59 1.27-9 3 2 1 4 2 20.09-1.11 35 12 25.46 6.95 37.5 30.5 1.26 5.69-1 11-3.38 3.79-7.5 6.5 5.74 10.07 1.5 20.5-7.55 7.47-17.5 3.5-11.01-5.34-22.5-9.5-18.26 10-38.5 13-15.5 0-31 0-26.62-4.54-51-17-4.17 1.33-8 3.5-7.23 5.87-15 11-8.62 2.58-13.5-4.5-1.82 2.32-4.5 3.5-6.06 2.24-12 3.5-7.5 0-15 0-27.42-2.56-50-18.5-18-17.25-23-41.5 0-11.5 0-23 4.12-22.7 25-33 6.95-16.67 22-26.5-20.39-20.8-14.5-49.5 7.01-26.98 28.5-44.5 7.56-5.27 15-10.5-13.09-30.88-7.5-64 3.16-15.57 14.5-26.5 6.85-2.48 8 4.5-6.59 39.53 11 75.5 7.99-0.49 16-2 2.42-34.57 14.5-67.5 8.51-22.23 27.5-36z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s1" d="m113.5 401.5q0.48-5.1-1-10-0.91 0.19-1 1-2.46 1.74-5 3.5 5.65 9.54-5 13-32.21 5.55-61-10-32.89-23.11-29.5-63.5 2.96-22.67 23.5-32 7.99-19.75 27-29.5-27.65-23.7-15.5-58.5 7.33-16.82 20.5-29.5 10.79-8.14 22-15.5-16.49-37.08-5.5-76 3.19-6.13 7.5-11.5 1.48-0.89 2 1-5.69 41.09 12.5 78.5 1 1 2 2 9.97-3.24 20.5-4 2 0 4 0 0-7.5 0-15 0.99-42.22 24.5-77 6.12-7.12 14-12-4.65 13.43-10 27-11.93 37.6-9.5 77 49.38 0.7 83.5 36 2.75 4.5 5.5 9 38.99-52.24 93-88.5 45.84-29.03 100-32.5 15.69-1.56 29 6.5 5.68 7.29 3.5 16.5-10.38 33.62-43.5 45-4.39 37.33-41 45-0.79 8.63-6 15.5 1.91 1.83 4.5 2.5 22.27-17.25 50.5-14.5 12.93-9.41 28-15 36.22-8.28 31.5 28.5-15.19 51.69-62.5 77.5-65.92 35.87-138 15.5-19.67 10.42-42 10.5-8.39 2.88-17 5 3.58 6.08 10 9 20.92-1.14 36 13 22.67 5.23 34.5 25.5 3.33 7.13-3.5 11.5-3.88 1.8-8 3 7.36 8.45 6.5 19.5-4.43 5.66-11.5 3.5-12.84-5.67-26-10.5-39.4 21.02-83 10.5-18.85-5.78-36.5-14.5-13.65 4.14-23.5 14.5-9.51 3.74-11-6.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s2" d="m153.5 173.5q24.62 1.46 46 13.5 12.11 8.1 17.5 21.5 0.74 2.45 0.5 5 0.09 0.81 1 1 1.48-4.9 1-10 5.04 10.48 1.5 22-9.81 27.86-35.5 42.5-26.17 14.97-56 19.5-2.77-0.4-2 1 2.86 1.27 6 1 25.64 1.53 48.5-10 0.34 10.08 2 20 1.08 5.76 5 10 1 1.5 0 3-31.11 20.84-68.5 17.5-23.7-5.7-32.5-28.5-4.39-9.18-3.5-19 15.41 6.23 32 4.5-20.68-6.39-39-18-34.81-27.22-12.5-65.5 11.84-14.83 29-23 4.21 7.66 11.5 12.5 3 1 6 0-26.04-34.62-29-78-0.13-8.46 2-16.5 1 6.5 2 13 3.43 39.53 24.5 73 2.03 2.28 4.5 4 0.5-1.25 1-2.5-1.27-6.54-5-12 0.5-0.75 1-1.5 9.72-3.43 20-4 0.55 10.34 8 17.5 1.94 0.74 4 0.5-17.8-64.6 16.5-122 0.98-1.79 1.5 0-28.21 56.64-13.5 118 1.08 1.43 2.5 0.5 2.21-4.98 2-10.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s3" d="m454.5 97.5q-18.37-2.97-37-1.5-16.14 2.08-32 5.5 32.38-14.09 67-7.5 1.98 1.22 2 3.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s4" d="m454.5 97.5q-1.33 11.18-8.5 20-21.81 26.28-55.5 32-1.11-0.2-2 0.5 2.31 2.82 5.5 4.5 1 2 0 4-9.56 11.3-19.5 20 19.71-8.72 31-27 2.68-0.43 5 1-14.24 30.97-48 36.5-9.93 1.71-20 1.5-6.8-0.48-13 1 5.81 6.92 14 11-10.78 16.03-27 26.5 27.16-7.4 38-33.5 4.34 1.35 9 1-9.08 23.84-33 33.5-18.45 6.41-38 7 22.59 8.92 45-1 12.05-5.52 24-11 9.01-1.79 17 2.5 5.28-4.38 11-8 12.8-6.07 27-5 0 0.5 0 1-19.34 2.69-34 15.5 0.5 0.25 1 0.5 17.79-8.09 36-15 2.71-0.79 5-2 2.5-1 5-2 5.53-4.04 11-8 11.7-4.18 24-6.5 7.78-1.36 15 1.5-2.97 18.45-13.5 34-34.92 49.37-94.5 62.5-59.27 12.45-108-23-15.53-12.52-21.5-31.5-2.47-14.26 4-27-3.15 24.41 14 42-4.92-10.28-7-22-1.97-17.63 7-33 47.28-69.5 125.5-100 15.86-3.42 32-5.5 18.63-1.47 37 1.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s5" d="m86.5 112.5q-1-6.5-2-13 0.7-5.34 3.5-10-1.8 11.32-1.5 23z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s6" d="m433.5 97.5q2.22-0.39 4 1-10 13.75-27 14-0.24-2.06 0.5-4 10.3-7.78 22.5-11z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s7" d="m407.5 101.5q2.55-0.24 5 0.5-52.87 18.31-84.5 64.5-6.94 7.95-17 11-9.38-2.38-5-11 40.38-48.62 101.5-65z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s8" d="m402.5 112.5q3 0 6 0-2.56 8.8-12 7-0.22-1.58 0.5-3 2.72-2.22 5.5-4z"/>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s9" d="m390.5 149.5q7.77 0.52 15 2-11.29 18.28-31 27 9.94-8.7 19.5-20 1-2 0-4-3.19-1.68-5.5-4.5 0.89-0.7 2-0.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s10" d="m131.5 145.5q0 7.5 0 15-2 0-4 0 1.06-1.36 3-1-0.48-7.29 1-14z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s11" d="m219.5 204.5q-1 4.5-2 9 0.24-2.55-0.5-5-5.39-13.4-17.5-21.5-21.38-12.04-46-13.5 0-2 0-4 36.7-0.86 61.5 26 3.06 4.11 4.5 9z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s12" d="m329.5 191.5q6.2-1.48 13-1-3.5 1-7 2-2.9-0.97-6-1z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s13" d="m329.5 191.5q3.1 0.03 6 1 9.55 1.31 19 3-10.84 26.1-38 33.5 16.22-10.47 27-26.5-8.19-4.08-14-11z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s14" d="m479.5 199.5q-7.22-2.86-15-1.5-12.3 2.32-24 6.5 15.6-13.11 36-11.5 3.63 2.26 3 6.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s15" d="m193.5 216.5q-12.01 1.52-22 8-2.83 1.29-5.5 3-4.79-4.57-6.5-11-5.04 2.2-9.5-1-3.47-6.4 3.5-3 4.4 0.05 8-2.5 9.22-9.73 21-16 6.3-3.24 12 1-2.9 1.22-6 1.5 2.61 5.74 4.5 12 0.75 3.97 0.5 8z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s16" d="m458.5 200.5q3.04-0.24 6 0.5-18.02 7.05-33 19-1 1-2 0 11.53-14.3 29-19.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s17" d="m178.5 202.5q6.85-0.63 4.5 6-7.6 5.09-6-4 1.08-0.82 1.5-2z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s18" d="m469.5 201.5q-2.26 13.65-14.5 22-0.47-2.11 1-4 7.08-8.82 13.5-18z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s19" d="m74.5 208.5q8.22-0.2 16 2.5 11.8 4.26 23.5 8.5 5.65-0.63 8-6 2.41 11.83-9.5 13 0.55 3.61 2 7-0.5 1-1 2-4.67-0.94-9.5-1-9.96 0.44-19.5 2.5-5.05-3.55-6.5-9.5-0.75-7.48-0.5-15-6.47 0.15-3-4z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s20" d="m429.5 212.5q-2.5 1-5 2-4 0-8 0-14.2-1.07-27 5 15.27-12.44 35-9.5 2.72 1.14 5 2.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s21" d="m219.5 204.5q0.48 5.1-1 10-0.91-0.19-1-1 1-4.5 2-9z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s22" d="m416.5 215.5q0-0.5 0-1 4 0 8 0-2.29 1.21-5 2-1.06-1.36-3-1z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s23" d="m416.5 215.5q1.94-0.36 3 1-18.21 6.91-36 15-0.5-0.25-1-0.5 14.66-12.81 34-15.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s24" d="m193.5 216.5q4.39 1.3 9 3-0.79 1.04-2 1.5-14.77-0.13-29 3.5 9.99-6.48 22-8z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s25" d="m98.5 219.5q6.09-0.98 6 5-3.04 0.24-6-0.5-1.84-2.24 0-4.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s26" d="m176.5 229.5q8.85-1.14 16 4-4.98 1.75-10 0-13.56 14.3-33 19.5-28.06 8.2-55 1 3.32-6.4 10-5.5-0.71 1.47-2 2.5 36.58 4.24 69-14 4.68-2.13 1-5 2.35-0.91 4-2.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s27" d="m231.5 238.5q1.31-0.2 2 1-3.13 28.62 15 51-16.25 6.75-27-7.5-1-1-2 0 14.73 29.34 46 18.5 1.79 0.52 0 1.5-37.63 16.82-50.5-22.5-5.1-26.48 16.5-42z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s28" d="m243.5 259.5q5.88 3.62 10.5 9 12.96 18.46 32.5 29.5-31.51-7.75-43-38.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s29" d="m203.5 266.5q1.31-0.2 2 1-2.48 22.08 12 39-6.99 1.35-14 0.5 4.59 4.08 10 7-8.71 0.28-14.5-6.5-16.98-22.76 4.5-41z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s27" d="m58.5 284.5q9.6-2.17 14.5 6 5.15 14.18-1 28-11.05-13.14-27.5-17.5 5.15-9.9 14-16.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s30" d="m129.5 288.5q2 1 4 2-3.14 0.27-6-1-0.77-1.4 2-1z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s31" d="m56.5 313.5q3.43 5.43 8 10-4.88 0.44-8 4-1.11-0.2-2 0.5 28.91 1.65 38 28.5 0.45 3.16-1 6-11.02-7.01-23-12.5-4.75-3.75-9.5-7.5 1.47 7.42 7 13 8.34 27.18 32 43 0.99 2.41-1.5 3.5-40.25 5.58-66.5-25.5-15.67-22.01-8-48 10.46-23.87 34.5-15z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s32" d="m45.5 317.5q4.03-0.25 8 0.5 2.46 4.16-2 6-6.04 2.01-9-3.5 1.26-1.85 3-3z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s33" d="m56.5 313.5q4.91 3.14 9.5 7 0.88 2.25-1.5 3-4.57-4.57-8-10z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s34" d="m198.5 319.5q-11.1 11.56-27 15.5-15.75 4.88-32 2.5 28.81-3.69 54-18.5 2.65-0.96 5 0.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s4" d="m198.5 319.5q1.44 0.68 2.5 2 2.41 8.23 6 16 1.2 2.64-0.5 5-30.65 21.41-68 18.5-25.16-6.17-32.5-30.5 6.96 4.99 15.5 6.5 8.99 0.75 18 0.5 16.25 2.38 32-2.5 15.9-3.94 27-15.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s35" d="m92.5 356.5q-9.09-26.85-38-28.5 0.89-0.7 2-0.5 25.47-4.89 35.5 19 0.75 4.98 0.5 10z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s36" d="m72.5 335.5q3.62-0.38 5 3-4.22 1.83-5-3z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s37" d="m223.5 336.5q5.59-0.48 11 1-4.04 4.16-8.5 8-5.99-3.8-2.5-9z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s38" d="m90.5 334.5q0.59-1.54 2-0.5 3.94 5.45 9 10 7 6 14 12-6.91-1.7-13-6-6.21-7.72-12-15.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s39" d="m261.5 346.5q-3.54-2.44-8-3.5-6.98-0.75-14-0.5 0.63-1.08 2-1.5 13.82-2.52 26 4-2.63 1.98-6 1.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s40" d="m239.5 342.5q7.02-0.25 14 0.5 4.46 1.06 8 3.5-5.2 2.35-10 5.5-3.88 4.65-9 7.5-9.89-3.09-9.5-13 2.36-3.63 6.5-4z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s41" d="m214.5 349.5q-21.43 15.48-48 16 22.82-5.9 43-18.5 3.64-1.12 5 2.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s42" d="m214.5 349.5q5.96 7.2 13.5 13 1 1 0 2-28.58 23.34-65.5 20.5-18.15-4.24-27.5-19.5 1.13 0.94 2.5 1.5 14.7 1.42 29-1.5 26.57-0.52 48-16z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s43" d="m302.5 373.5q-14.74-16.73-37-19-4.55 0.25-9 1 25.3-10.24 43.5 11 2.85 2.91 2.5 7z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s44" d="m302.5 373.5q0.21 2.44-2 3.5-28.69 7.6-50.5-12.5-0.06-6.71 6.5-9 4.45-0.75 9-1 22.26 2.27 37 19z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s45" d="m100.5 356.5q5.42 2.71 11 5.5-13.04 7.54-18.5 21.5-7.57-7.14-10.5-17 5.58 1.54 10 5.5 4.2 0.84 5.5-3.5 1.41-5.99 2.5-12z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s8" d="m83.5 394.5q-18.9-10.15-29.5-29-1.54-3.52-2-7 5.79 2.39 10 7 7.82 16.63 21.5 29z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s46" d="m232.5 365.5q17.6 6.19 10.5 23-10.6 10.42-25.5 11.5-25.94 3.21-49-9 36.75-1.65 64-25.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s47" d="m113.5 367.5q7.7-0.01 9.5 7-9.69 7.19-18.5 15.5-7.23 5.76-5.5-3.5 3.12-12.84 14.5-19z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s29" d="m126.5 380.5q7.88-0.4 12 6.5-8.5 7.25-17 14.5-5.62-12.55 5-21z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s48" d="m283.5 385.5q3.22 2.95 7 5.5 2.8 4.03 6 7.5 0.42 2.77-2 4-15.5-9.75-31-19.5-1.79-0.98 0-1.5 9.96 2.49 20 4z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s49" d="m283.5 385.5q8.71-1.27 11.5 7 1.22 2.9 1.5 6-3.2-3.47-6-7.5-3.78-2.55-7-5.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s50" d="m83.5 394.5q1.88-0.06 3 1.5-2.25 0.88-3-1.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s51" d="m258.5 392.5q3.51 0.41 0 2.5-2.33 1.93-5 2 2.61-2.28 5-4.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s52" d="m111.5 392.5q0.09-0.81 1-1 1.48 4.9 1 10-1-4.5-2-9z"/>
-	</g>
-</svg>
@@ -1,7 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512"><svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect width="512" height="512" fill="#131010"></rect>
-<path d="M320 224V352H192V224H320Z" fill="#5A5858"></path>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="white"></path>
-</svg><style>@media (prefers-color-scheme: light) { :root { filter: none; } }
-@media (prefers-color-scheme: dark) { :root { filter: none; } }
-</style></svg>
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
-  <rect width="800" height="800" rx="160" fill="#fff"/>
-  <path fill="#000" fill-rule="evenodd" d="
-    M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z
-    M282.65 282.65 V400 H400 V282.65 Z
-  "/>
-  <path fill="#000" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
-</svg>
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
-  <rect width="800" height="800" rx="160" fill="#000"/>
-  <path fill="#fff" fill-rule="evenodd" d="
-    M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z
-    M282.65 282.65 V400 H400 V282.65 Z
-  "/>
-  <path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
-</svg>
@@ -4,6 +4,7 @@ import {
  ChatEvent,
  DownloadEvent,
  ErrorEvent,
+  InferenceCompute,
  InferenceComputeResponse,
  ModelCapabilitiesResponse,
  Model,
@@ -26,12 +27,6 @@ declare module "@/gotypes" {
 Model.prototype.isCloud = function (): boolean {
  return this.model.endsWith("cloud");
 };
-
-export type CloudStatusSource = "env" | "config" | "both" | "none";
-export interface CloudStatusResponse {
-  disabled: boolean;
-  source: CloudStatusSource;
-}
 // Helper function to convert Uint8Array to base64
 function uint8ArrayToBase64(uint8Array: Uint8Array): string {
  const chunkSize = 0x8000; // 32KB chunks to avoid stack overflow
@@ -161,7 +156,7 @@ export async function getModels(query?: string): Promise<Model[]> {
      // Add query if it's in the registry and not already in the list
      if (!exactMatch) {
        const result = await getModelUpstreamInfo(new Model({ model: query }));
-        const existsUpstream = result.exists;
+        const existsUpstream = !!result.digest && !result.error;
        if (existsUpstream) {
          filteredModels.push(new Model({ model: query }));
        }
@@ -290,28 +285,6 @@ export async function updateSettings(settings: Settings): Promise<{
  };
 }

-export async function updateCloudSetting(
-  enabled: boolean,
-): Promise<CloudStatusResponse> {
-  const response = await fetch(`${API_BASE}/api/v1/cloud`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ enabled }),
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(error || "Failed to update cloud setting");
-  }
-
-  const data = await response.json();
-  return {
-    disabled: Boolean(data.disabled),
-    source: (data.source as CloudStatusSource) || "none",
-  };
-}
-
 export async function renameChat(chatId: string, title: string): Promise<void> {
  const response = await fetch(`${API_BASE}/api/v1/chat/${chatId}/rename`, {
    method: "PUT",
@@ -339,7 +312,7 @@ export async function deleteChat(chatId: string): Promise<void> {
 // Get upstream information for model staleness checking
 export async function getModelUpstreamInfo(
  model: Model,
-): Promise<{ stale: boolean; exists: boolean; error?: string }> {
+): Promise<{ digest?: string; pushTime: number; error?: string }> {
  try {
    const response = await fetch(`${API_BASE}/api/v1/model/upstream`, {
      method: "POST",
@@ -353,22 +326,22 @@ export async function getModelUpstreamInfo(

    if (!response.ok) {
      console.warn(
-        `Failed to check upstream for ${model.model}: ${response.status}`,
+        `Failed to check upstream digest for ${model.model}: ${response.status}`,
      );
-      return { stale: false, exists: false };
+      return { pushTime: 0 };
    }

    const data = await response.json();

    if (data.error) {
-      console.warn(`Upstream check: ${data.error}`);
-      return { stale: false, exists: false, error: data.error };
+      console.warn(`Upstream digest check: ${data.error}`);
+      return { error: data.error, pushTime: 0 };
    }

-    return { stale: !!data.stale, exists: true };
+    return { digest: data.digest, pushTime: data.pushTime || 0 };
  } catch (error) {
    console.warn(`Error checking model staleness:`, error);
-    return { stale: false, exists: false };
+    return { pushTime: 0 };
  }
 }

@@ -406,7 +379,7 @@ export async function* pullModel(
  }
 }

-export async function getInferenceCompute(): Promise<InferenceComputeResponse> {
+export async function getInferenceCompute(): Promise<InferenceCompute[]> {
  const response = await fetch(`${API_BASE}/api/v1/inference-compute`);
  if (!response.ok) {
    throw new Error(
@@ -415,7 +388,8 @@ export async function getInferenceCompute(): Promise<InferenceComputeResponse> {
  }

  const data = await response.json();
-  return new InferenceComputeResponse(data);
+  const inferenceComputeResponse = new InferenceComputeResponse(data);
+  return inferenceComputeResponse.inferenceComputes || [];
 }

 export async function fetchHealth(): Promise<boolean> {
@@ -440,16 +414,3 @@ export async function fetchHealth(): Promise<boolean> {
    return false;
  }
 }
-
-export async function getCloudStatus(): Promise<CloudStatusResponse | null> {
-  const response = await fetch(`${API_BASE}/api/v1/cloud`);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch cloud status: ${response.status}`);
-  }
-
-  const data = await response.json();
-  return {
-    disabled: Boolean(data.disabled),
-    source: (data.source as CloudStatusSource) || "none",
-  };
-}
@@ -17,15 +17,11 @@ import {
 } from "@/hooks/useChats";
 import { useNavigate } from "@tanstack/react-router";
 import { useSelectedModel } from "@/hooks/useSelectedModel";
-import {
-  useHasVisionCapability,
-  useHasToolsCapability,
-} from "@/hooks/useModelCapabilities";
+import { useHasVisionCapability } from "@/hooks/useModelCapabilities";
 import { useUser } from "@/hooks/useUser";
 import { DisplayLogin } from "@/components/DisplayLogin";
 import { ErrorEvent, Message } from "@/gotypes";
 import { useSettings } from "@/hooks/useSettings";
-import { useCloudStatus } from "@/hooks/useCloudStatus";
 import { ThinkButton } from "./ThinkButton";
 import { ErrorMessage } from "./ErrorMessage";
 import { processFiles } from "@/utils/fileValidation";
@@ -145,14 +141,19 @@ function ChatForm({
  const {
    settings: {
      webSearchEnabled,
+      airplaneMode,
      thinkEnabled,
      thinkLevel: settingsThinkLevel,
    },
    setSettings,
  } = useSettings();
-  const { cloudDisabled } = useCloudStatus();

-  const supportsWebSearch = useHasToolsCapability(selectedModel?.model);
+  // current supported models for web search
+  const modelLower = selectedModel?.model.toLowerCase() || "";
+  const supportsWebSearch =
+    modelLower.startsWith("gpt-oss") ||
+    modelLower.startsWith("qwen3") ||
+    modelLower.startsWith("deepseek-v3");
  // Use per-chat thinking level instead of global
  const thinkLevel: ThinkingLevel =
    settingsThinkLevel === "none" || !settingsThinkLevel
@@ -179,12 +180,6 @@ function ChatForm({
    setSettings,
  ]);

-  useEffect(() => {
-    if (cloudDisabled && webSearchEnabled) {
-      setSettings({ WebSearchEnabled: false });
-    }
-  }, [cloudDisabled, webSearchEnabled, setSettings]);
-
  const removeFile = (index: number) => {
    setMessage((prev) => ({
      ...prev,
@@ -239,19 +234,19 @@ function ChatForm({

  // Determine if login banner should be shown
  const shouldShowLoginBanner =
-    !cloudDisabled &&
    !isLoadingUser &&
    !isAuthenticated &&
-    ((webSearchEnabled && supportsWebSearch) || selectedModel?.isCloud());
+    ((webSearchEnabled && supportsWebSearch) ||
+      (selectedModel?.isCloud() && !airplaneMode));

  // Determine which feature to highlight in the banner
  const getActiveFeatureForBanner = () => {
-    if (cloudDisabled) return null;
    if (!isAuthenticated) {
      if (loginPromptFeature) return loginPromptFeature;
-      if (webSearchEnabled && selectedModel?.isCloud()) return "webSearch";
+      if (webSearchEnabled && selectedModel?.isCloud() && !airplaneMode)
+        return "webSearch";
      if (webSearchEnabled) return "webSearch";
-      if (selectedModel?.isCloud()) return "turbo";
+      if (selectedModel?.isCloud() && !airplaneMode) return "turbo";
    }
    return null;
  };
@@ -274,12 +269,11 @@ function ChatForm({
  useEffect(() => {
    if (
      isAuthenticated ||
-      cloudDisabled ||
-      (!webSearchEnabled && !!selectedModel?.isCloud())
+      (!webSearchEnabled && !!selectedModel?.isCloud() && !airplaneMode)
    ) {
      setLoginPromptFeature(null);
    }
-  }, [isAuthenticated, webSearchEnabled, selectedModel, cloudDisabled]);
+  }, [isAuthenticated, webSearchEnabled, selectedModel, airplaneMode]);

  // When entering edit mode, populate the composition with existing data
  useEffect(() => {
@@ -471,27 +465,20 @@ function ChatForm({
  const handleSubmit = async () => {
    if (!message.content.trim() || isStreaming || isDownloading) return;

-    if (cloudDisabled && selectedModel?.isCloud()) {
-      return;
-    }
-
    // Check if cloud mode is enabled but user is not authenticated
    if (shouldShowLoginBanner) {
      return;
    }

-    // Prepare attachments for submission, excluding unsupported images
-    const attachmentsToSend: FileAttachment[] = message.attachments
-      .filter(
-        (att) => hasVisionCapability || !isImageFile(att.filename),
-      )
-      .map((att) => ({
+    // Prepare attachments for submission
+    const attachmentsToSend: FileAttachment[] = message.attachments.map(
+      (att) => ({
        filename: att.filename,
        data: att.data || new Uint8Array(0), // Empty data for existing files
-      }));
+      }),
+    );

-    const useWebSearch =
-      supportsWebSearch && webSearchEnabled && !cloudDisabled;
+    const useWebSearch = supportsWebSearch && webSearchEnabled && !airplaneMode;
    const useThink = modelSupportsThinkingLevels
      ? thinkLevel
      : supportsThinkToggling
@@ -738,17 +725,10 @@ function ChatForm({
        )}
        {(message.attachments.length > 0 || message.fileErrors.length > 0) && (
          <div className="flex gap-2 overflow-x-auto px-3 pt pb-3 w-full scrollbar-hide">
-            {message.attachments.map((attachment, index) => {
-              const isUnsupportedImage =
-                !hasVisionCapability && isImageFile(attachment.filename);
-              return (
+            {message.attachments.map((attachment, index) => (
              <div
                key={attachment.id}
-                className={`group flex items-center gap-2 py-2 px-3 rounded-lg transition-colors flex-shrink-0 ${
-                  isUnsupportedImage
-                    ? "bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800"
-                    : "bg-neutral-50 dark:bg-neutral-700/50 hover:bg-neutral-100 dark:hover:bg-neutral-700"
-                }`}
+                className="group flex items-center gap-2 py-2 px-3 rounded-lg bg-neutral-50 dark:bg-neutral-700/50 hover:bg-neutral-100 dark:hover:bg-neutral-700 transition-colors flex-shrink-0"
              >
                {isImageFile(attachment.filename) ? (
                  <ImageThumbnail
@@ -773,16 +753,9 @@ function ChatForm({
                    />
                  </svg>
                )}
-                <div className="flex flex-col min-w-0">
-                  <span className={`text-sm max-w-36 truncate ${isUnsupportedImage ? "text-red-700 dark:text-red-300" : "text-neutral-700 dark:text-neutral-300"}`}>
-                    {attachment.filename}
-                  </span>
-                  {isUnsupportedImage && (
-                    <span className="text-xs text-red-600 dark:text-red-400 opacity-75">
-                      This model does not support images
-                    </span>
-                  )}
-                </div>
+                <span className="text-sm text-neutral-700 dark:text-neutral-300 max-w-[150px] truncate">
+                  {attachment.filename}
+                </span>
                <button
                  type="button"
                  onClick={() => removeFile(index)}
@@ -804,8 +777,7 @@ function ChatForm({
                  </svg>
                </button>
              </div>
-              );
-            })}
+            ))}
            {message.fileErrors.map((fileError, index) => (
              <div
                key={`error-${index}`}
@@ -927,7 +899,7 @@ function ChatForm({
                )}
                <WebSearchButton
                  ref={webSearchButtonRef}
-                  isVisible={supportsWebSearch && cloudDisabled === false}
+                  isVisible={supportsWebSearch && airplaneMode === false}
                  isActive={webSearchEnabled}
                  onToggle={() => {
                    if (!webSearchEnabled && !isAuthenticated) {
@@ -968,7 +940,6 @@ function ChatForm({
                !isDownloading &&
                (!message.content.trim() ||
                  shouldShowLoginBanner ||
-                  (cloudDisabled && selectedModel?.isCloud()) ||
                  message.fileErrors.length > 0)
              }
              className={`flex items-center justify-center h-9 w-9 rounded-full disabled:cursor-default cursor-pointer bg-black text-white dark:bg-white dark:text-black disabled:opacity-10 focus:outline-none focus:ring-2 focus:ring-blue-500`}
@@ -6,13 +6,12 @@ import { getChat } from "@/api";
 import { Link } from "@/components/ui/link";
 import { useState, useRef, useEffect, useCallback, useMemo } from "react";
 import { ChatsResponse } from "@/gotypes";
-import { CogIcon, RocketLaunchIcon } from "@heroicons/react/24/outline";
+import { CogIcon } from "@heroicons/react/24/outline";

 // there's a hidden debug feature to copy a chat's data to the clipboard by
 // holding shift and clicking this many times within this many seconds
 const DEBUG_SHIFT_CLICKS_REQUIRED = 5;
 const DEBUG_SHIFT_CLICK_WINDOW_MS = 7000; // 7 seconds
-const launchSidebarRequestedKey = "ollama.launchSidebarRequested";

 interface ChatSidebarProps {
  currentChatId?: string;
@@ -268,8 +267,9 @@ export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
        <Link
          href="/c/new"
          mask={{ to: "/" }}
-          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 ${currentChatId === "new" ? "bg-neutral-100 dark:bg-neutral-800" : ""
-            }`}
+          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 ${
+            currentChatId === "new" ? "bg-neutral-100 dark:bg-neutral-800" : ""
+          }`}
          draggable={false}
        >
          <svg
@@ -283,23 +283,6 @@ export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
          </svg>
          <span className="truncate">New Chat</span>
        </Link>
-        <Link
-          to="/c/$chatId"
-          params={{ chatId: "launch" }}
-          onClick={() => {
-            if (currentChatId !== "launch") {
-              sessionStorage.setItem(launchSidebarRequestedKey, "1");
-            }
-          }}
-          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 cursor-pointer ${currentChatId === "launch"
-            ? "bg-neutral-100 dark:bg-neutral-800"
-            : ""
-            }`}
-          draggable={false}
-        >
-          <RocketLaunchIcon className="h-5 w-5 stroke-current" />
-          <span className="truncate">Launch</span>
-        </Link>
        {isWindows && (
          <Link
            href="/settings"
@@ -321,18 +304,19 @@ export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
              {group.chats.map((chat) => (
                <div
                  key={chat.id}
-                  className={`allow-context-menu flex items-center relative text-sm text-neutral-800 dark:text-neutral-400 rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 ${chat.id === currentChatId
-                    ? "bg-neutral-100 text-black dark:bg-neutral-800"
-                    : ""
-                    }`}
+                  className={`allow-context-menu flex items-center relative text-sm text-neutral-800 dark:text-neutral-400 rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 ${
+                    chat.id === currentChatId
+                      ? "bg-neutral-100 text-black dark:bg-neutral-800"
+                      : ""
+                  }`}
                  onMouseEnter={() => handleMouseEnter(chat.id)}
                  onContextMenu={(e) =>
                    handleContextMenu(
                      e,
                      chat.id,
                      chat.title ||
-                      chat.userExcerpt ||
-                      chat.createdAt.toLocaleString(),
+                        chat.userExcerpt ||
+                        chat.createdAt.toLocaleString(),
                    )
                  }
                >
@@ -10,7 +10,6 @@ interface CopyButtonProps {
  showLabels?: boolean;
  className?: string;
  title?: string;
-  onCopy?: () => void;
 }

 const CopyButton: React.FC<CopyButtonProps> = ({
@@ -21,7 +20,6 @@ const CopyButton: React.FC<CopyButtonProps> = ({
  showLabels = false,
  className = "",
  title = "",
-  onCopy,
 }) => {
  const [isCopied, setIsCopied] = useState(false);

@@ -50,14 +48,12 @@ const CopyButton: React.FC<CopyButtonProps> = ({
      }

      setIsCopied(true);
-      onCopy?.();
      setTimeout(() => setIsCopied(false), 2000);
    } catch (error) {
      console.error("Clipboard API failed, falling back to plain text", error);
      try {
        await navigator.clipboard.writeText(content);
        setIsCopied(true);
-        onCopy?.();
        setTimeout(() => setIsCopied(false), 2000);
      } catch (fallbackError) {
        console.error("Fallback copy also failed:", fallbackError);
@@ -1,133 +0,0 @@
-import { useSettings } from "@/hooks/useSettings";
-import CopyButton from "@/components/CopyButton";
-
-interface LaunchCommand {
-  id: string;
-  name: string;
-  command: string;
-  description: string;
-  icon: string;
-  darkIcon?: string;
-  iconClassName?: string;
-  borderless?: boolean;
-}
-
-const LAUNCH_COMMANDS: LaunchCommand[] = [
-  {
-    id: "openclaw",
-    name: "OpenClaw",
-    command: "ollama launch openclaw",
-    description: "Personal AI with 100+ skills",
-    icon: "/launch-icons/openclaw.svg",
-  },
-  {
-    id: "claude",
-    name: "Claude",
-    command: "ollama launch claude",
-    description: "Anthropic's coding tool with subagents",
-    icon: "/launch-icons/claude.svg",
-    iconClassName: "h-7 w-7",
-  },
-  {
-    id: "codex",
-    name: "Codex",
-    command: "ollama launch codex",
-    description: "OpenAI's open-source coding agent",
-    icon: "/launch-icons/codex.svg",
-    darkIcon: "/launch-icons/codex-dark.svg",
-    iconClassName: "h-7 w-7",
-  },
-  {
-    id: "opencode",
-    name: "OpenCode",
-    command: "ollama launch opencode",
-    description: "Anomaly's open-source coding agent",
-    icon: "/launch-icons/opencode.svg",
-    iconClassName: "h-7 w-7 rounded",
-  },
-  {
-    id: "droid",
-    name: "Droid",
-    command: "ollama launch droid",
-    description: "Factory's coding agent across terminal and IDEs",
-    icon: "/launch-icons/droid.svg",
-  },
-  {
-    id: "pi",
-    name: "Pi",
-    command: "ollama launch pi",
-    description: "Minimal AI agent toolkit with plugin support",
-    icon: "/launch-icons/pi.svg",
-    darkIcon: "/launch-icons/pi-dark.svg",
-    iconClassName: "h-7 w-7",
-  },
-];
-
-export default function LaunchCommands() {
-  const isWindows = navigator.platform.toLowerCase().includes("win");
-  const { setSettings } = useSettings();
-
-  const renderCommandCard = (item: LaunchCommand) => (
-    <div key={item.command} className="w-full text-left">
-      <div className="flex items-start gap-4 sm:gap-5">
-        <div
-          aria-hidden="true"
-          className={`flex h-10 w-10 shrink-0 items-center justify-center rounded-lg overflow-hidden ${item.borderless ? "" : "border border-neutral-200 bg-white dark:border-neutral-700 dark:bg-neutral-900"}`}
-        >
-          {item.darkIcon ? (
-            <picture>
-              <source srcSet={item.darkIcon} media="(prefers-color-scheme: dark)" />
-              <img src={item.icon} alt="" className={`${item.iconClassName ?? "h-8 w-8"} rounded-sm`} />
-            </picture>
-          ) : (
-            <img src={item.icon} alt="" className={item.borderless ? "h-full w-full rounded-xl" : `${item.iconClassName ?? "h-8 w-8"} rounded-sm`} />
-          )}
-        </div>
-
-        <div className="min-w-0 flex-1">
-          <span className="text-sm font-medium text-neutral-900 dark:text-neutral-100">
-            {item.name}
-          </span>
-          <p className="mt-0.5 text-xs text-neutral-500 dark:text-neutral-400">
-            {item.description}
-          </p>
-          <div className="mt-2 flex items-center gap-2 rounded-xl border-neutral-200 dark:border-neutral-700 bg-neutral-50 dark:bg-neutral-800 px-3 py-2">
-            <code className="min-w-0 flex-1 truncate text-xs text-neutral-600 dark:text-neutral-300">
-              {item.command}
-            </code>
-            <CopyButton
-              content={item.command}
-              size="md"
-              title="Copy command to clipboard"
-              className="text-neutral-500 dark:text-neutral-400 hover:text-neutral-700 dark:hover:text-neutral-200 hover:bg-neutral-200/60 dark:hover:bg-neutral-700/70"
-              onCopy={() => {
-                setSettings({ LastHomeView: item.id }).catch(() => { });
-              }}
-            />
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-
-  return (
-    <main className="flex h-screen w-full flex-col relative">
-      <section
-        className={`flex-1 overflow-y-auto overscroll-contain relative min-h-0 ${isWindows ? "xl:pt-4" : "xl:pt-8"}`}
-      >
-        <div className="max-w-[730px] mx-auto w-full px-4 pt-4 pb-20 sm:px-6 sm:pt-6 sm:pb-24 lg:px-8 lg:pt-8 lg:pb-28">
-          <h1 className="text-xl font-semibold text-neutral-900 dark:text-neutral-100">
-            Launch
-          </h1>
-          <p className="mt-1 text-sm text-neutral-500 dark:text-neutral-400">
-            Copy a command and run it in your terminal.
-          </p>
-
-          <div className="mt-6 grid gap-7">
-            {LAUNCH_COMMANDS.map(renderCommandCard)}
-          </div>
-        </div>
-      </section>
-    </main>
-  );
-}
@@ -536,7 +536,7 @@ function ToolCallDisplay({
    let args: Record<string, unknown> | null = null;
    try {
      args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
-    } catch {
+    } catch (e) {
      args = null;
    }
    const query = args && typeof args.query === "string" ? args.query : "";
@@ -562,7 +562,7 @@ function ToolCallDisplay({
    let args: Record<string, unknown> | null = null;
    try {
      args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
-    } catch {
+    } catch (e) {
      args = null;
    }
    const url = args && typeof args.url === "string" ? args.url : "";
@@ -73,7 +73,7 @@ export default function MessageList({
                    ? String(args.url).trim()
                    : "";
              if (candidate) lastQuery = candidate;
-            } catch { /* ignored */ }
+            } catch {}
          }
        }
      }
@@ -8,7 +8,7 @@ import {
 } from "react";
 import { Model } from "@/gotypes";
 import { useSelectedModel } from "@/hooks/useSelectedModel";
-import { useCloudStatus } from "@/hooks/useCloudStatus";
+import { useSettings } from "@/hooks/useSettings";
 import { useQueryClient } from "@tanstack/react-query";
 import { getModelUpstreamInfo } from "@/api";
 import { ArrowDownTrayIcon } from "@heroicons/react/24/outline";
@@ -34,7 +34,7 @@ export const ModelPicker = forwardRef<
    chatId,
    searchQuery,
  );
-  const { cloudDisabled } = useCloudStatus();
+  const { settings } = useSettings();
  const dropdownRef = useRef<HTMLDivElement>(null);
  const searchInputRef = useRef<HTMLInputElement>(null);
  const queryClient = useQueryClient();
@@ -61,7 +61,24 @@ export const ModelPicker = forwardRef<
    try {
      const upstreamInfo = await getModelUpstreamInfo(model);

-      if (upstreamInfo.stale) {
+      // Compare local digest with upstream digest
+      let isStale =
+        model.digest &&
+        upstreamInfo.digest &&
+        model.digest !== upstreamInfo.digest;
+
+      // If the model has a modified time and upstream has a push time,
+      // check if the model was modified after the push time - if so, it's not stale
+      if (isStale && model.modified_at && upstreamInfo.pushTime > 0) {
+        const modifiedAtTime =
+          new Date(model.modified_at as string | number | Date).getTime() /
+          1000;
+        if (modifiedAtTime > upstreamInfo.pushTime) {
+          isStale = false;
+        }
+      }
+
+      if (isStale) {
        const currentStaleModels =
          queryClient.getQueryData<Map<string, boolean>>(["staleModels"]) ||
          new Map();
@@ -202,7 +219,7 @@ export const ModelPicker = forwardRef<
            models={models}
            selectedModel={selectedModel}
            onModelSelect={handleModelSelect}
-            cloudDisabled={cloudDisabled}
+            airplaneMode={settings.airplaneMode}
            isOpen={isOpen}
          />
        </div>
@@ -216,13 +233,13 @@ export const ModelList = forwardRef(function ModelList(
    models,
    selectedModel,
    onModelSelect,
-    cloudDisabled,
+    airplaneMode,
    isOpen,
  }: {
    models: Model[];
    selectedModel: Model | null;
    onModelSelect: (model: Model) => void;
-    cloudDisabled: boolean;
+    airplaneMode: boolean;
    isOpen: boolean;
  },
  ref,
@@ -331,7 +348,7 @@ export const ModelList = forwardRef(function ModelList(
                  </svg>
                )}
                {model.digest === undefined &&
-                  (cloudDisabled || !model.isCloud()) && (
+                  (airplaneMode || !model.isCloud()) && (
                    <ArrowDownTrayIcon
                      className="h-4 w-4 text-neutral-500 dark:text-neutral-400"
                      strokeWidth={1.75}
@@ -11,24 +11,15 @@ import {
  FolderIcon,
  BoltIcon,
  WrenchIcon,
-  CloudIcon,
  XMarkIcon,
  CogIcon,
  ArrowLeftIcon,
-  ArrowDownTrayIcon,
 } from "@heroicons/react/20/solid";
 import { Settings as SettingsType } from "@/gotypes";
 import { useNavigate } from "@tanstack/react-router";
 import { useUser } from "@/hooks/useUser";
-import { useCloudStatus } from "@/hooks/useCloudStatus";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import {
-  getSettings,
-  type CloudStatusResponse,
-  updateCloudSetting,
-  updateSettings,
-  getInferenceCompute,
-} from "@/api";
+import { getSettings, updateSettings } from "@/api";

 function AnimatedDots() {
  return (
@@ -62,11 +53,6 @@ export default function Settings() {
  const [connectionError, setConnectionError] = useState<string | null>(null);
  const [pollingInterval, setPollingInterval] = useState<number | null>(null);
  const navigate = useNavigate();
-  const {
-    cloudDisabled,
-    cloudStatus,
-    isLoading: cloudStatusLoading,
-  } = useCloudStatus();

  const {
    data: settingsData,
@@ -79,13 +65,6 @@ export default function Settings() {

  const settings = settingsData?.settings || null;

-  const { data: inferenceComputeResponse } = useQuery({
-    queryKey: ["inferenceCompute"],
-    queryFn: getInferenceCompute,
-  });
-
-  const defaultContextLength = inferenceComputeResponse?.defaultContextLength;
-
  const updateSettingsMutation = useMutation({
    mutationFn: updateSettings,
    onSuccess: () => {
@@ -95,50 +74,6 @@ export default function Settings() {
    },
  });

-  const updateCloudMutation = useMutation({
-    mutationFn: (enabled: boolean) => updateCloudSetting(enabled),
-    onMutate: async (enabled: boolean) => {
-      await queryClient.cancelQueries({ queryKey: ["cloudStatus"] });
-
-      const previous = queryClient.getQueryData<CloudStatusResponse | null>([
-        "cloudStatus",
-      ]);
-      const envForcesDisabled =
-        previous?.source === "env" || previous?.source === "both";
-
-      queryClient.setQueryData<CloudStatusResponse | null>(
-        ["cloudStatus"],
-        previous
-          ? {
-              ...previous,
-              disabled: !enabled || envForcesDisabled,
-            }
-          : {
-              disabled: !enabled,
-              source: "config",
-            },
-      );
-
-      return { previous };
-    },
-    onError: (_error, _enabled, context) => {
-      if (context?.previous !== undefined) {
-        queryClient.setQueryData(["cloudStatus"], context.previous);
-      }
-    },
-    onSuccess: (status) => {
-      queryClient.setQueryData<CloudStatusResponse | null>(
-        ["cloudStatus"],
-        status,
-      );
-      queryClient.invalidateQueries({ queryKey: ["models"] });
-      queryClient.invalidateQueries({ queryKey: ["cloudStatus"] });
-
-      setShowSaved(true);
-      setTimeout(() => setShowSaved(false), 1500);
-    },
-  });
-
  useEffect(() => {
    refetchUser();
  }, []); // eslint-disable-line react-hooks/exhaustive-deps
@@ -213,18 +148,13 @@ export default function Settings() {
        Models: "",
        Agent: false,
        Tools: false,
-        ContextLength: 0,
-        AutoUpdateEnabled: true,
+        ContextLength: 4096,
+        AirplaneMode: false,
      });
      updateSettingsMutation.mutate(defaultSettings);
    }
  };

-  const cloudOverriddenByEnv =
-    cloudStatus?.source === "env" || cloudStatus?.source === "both";
-  const cloudToggleDisabled =
-    cloudStatusLoading || updateCloudMutation.isPending || cloudOverriddenByEnv;
-
  const handleConnectOllamaAccount = async () => {
    setConnectionError(null);

@@ -273,10 +203,6 @@ export default function Settings() {
  }

  const isWindows = navigator.platform.toLowerCase().includes("win");
-  const handleCloseSettings = () => {
-    const chatId = settings.LastHomeView === "chat" ? "new" : "launch";
-    navigate({ to: "/c/$chatId", params: { chatId } });
-  };

  return (
    <main className="flex h-screen w-full flex-col select-none dark:bg-neutral-900">
@@ -290,7 +216,7 @@ export default function Settings() {
        >
          {isWindows && (
            <button
-              onClick={handleCloseSettings}
+              onClick={() => navigate({ to: "/" })}
              className="hover:bg-neutral-100 mr-3 dark:hover:bg-neutral-800 rounded-full p-1.5"
            >
              <ArrowLeftIcon className="w-5 h-5 dark:text-white" />
@@ -300,7 +226,7 @@ export default function Settings() {
        </h1>
        {!isWindows && (
          <button
-            onClick={handleCloseSettings}
+            onClick={() => navigate({ to: "/" })}
            className="p-1 hover:bg-neutral-100 mr-3 dark:hover:bg-neutral-800 rounded-full"
          >
            <XMarkIcon className="w-6 h-6 dark:text-white" />
@@ -311,7 +237,7 @@ export default function Settings() {
        <div className="space-y-4 max-w-2xl mx-auto">
          {/* Connect Ollama Account */}
          <div className="overflow-hidden rounded-xl bg-white dark:bg-neutral-800">
-            <div className="p-4">
+            <div className="p-4 border-b border-neutral-200 dark:border-neutral-800">
              <Field>
                {isLoading ? (
                  // Loading skeleton, this will only happen if the app started recently
@@ -418,57 +344,6 @@ export default function Settings() {
          {/* Local Configuration */}
          <div className="relative overflow-hidden rounded-xl bg-white dark:bg-neutral-800">
            <div className="space-y-4 p-4">
-              <Field>
-                <div className="flex items-start justify-between gap-4">
-                  <div className="flex items-start space-x-3 flex-1">
-                    <CloudIcon className="mt-1 h-5 w-5 flex-shrink-0 text-black dark:text-neutral-100" />
-                    <div>
-                      <Label>Cloud</Label>
-                      <Description>
-                        {cloudOverriddenByEnv
-                          ? "The OLLAMA_NO_CLOUD environment variable is currently forcing cloud off."
-                          : "Enable cloud models and web search."}
-                      </Description>
-                    </div>
-                  </div>
-                  <div className="flex-shrink-0">
-                    <Switch
-                      checked={!cloudDisabled}
-                      disabled={cloudToggleDisabled}
-                      onChange={(checked) => {
-                        if (cloudOverriddenByEnv) {
-                          return;
-                        }
-                        updateCloudMutation.mutate(checked);
-                      }}
-                    />
-                  </div>
-                </div>
-              </Field>
-
-              {/* Auto Update */}
-              <Field>
-                <div className="flex items-start justify-between gap-4">
-                  <div className="flex items-start space-x-3 flex-1">
-                    <ArrowDownTrayIcon className="mt-1 h-5 w-5 flex-shrink-0 text-black dark:text-neutral-100" />
-                    <div>
-                      <Label>Auto-download updates</Label>
-                      <Description>
-                        {settings.AutoUpdateEnabled
-                          ? "Automatically download updates when available."
-                          : "Updates will not be downloaded automatically."}
-                      </Description>
-                    </div>
-                  </div>
-                  <div className="flex-shrink-0">
-                    <Switch
-                      checked={settings.AutoUpdateEnabled}
-                      onChange={(checked) => handleChange("AutoUpdateEnabled", checked)}
-                    />
-                  </div>
-                </div>
-              </Field>
-
              {/* Expose Ollama */}
              <Field>
                <div className="flex items-start justify-between gap-4">
@@ -544,11 +419,13 @@ export default function Settings() {
                    </Description>
                    <div className="mt-3">
                      <Slider
-                        value={settings.ContextLength || defaultContextLength || 0}
+                        value={(() => {
+                          // Otherwise use the settings value
+                          return settings.ContextLength || 4096;
+                        })()}
                        onChange={(value) => {
                          handleChange("ContextLength", value);
                        }}
-                        disabled={!defaultContextLength}
                        options={[
                          { value: 4096, label: "4k" },
                          { value: 8192, label: "8k" },
@@ -563,6 +440,35 @@ export default function Settings() {
                  </div>
                </div>
              </Field>
+              {/* Airplane Mode */}
+              <Field>
+                <div className="flex items-start justify-between gap-4">
+                  <div className="flex items-start space-x-3 flex-1">
+                    <svg
+                      className="mt-1 h-5 w-5 flex-shrink-0 text-black dark:text-neutral-100"
+                      viewBox="0 0 21.5508 17.9033"
+                      fill="currentColor"
+                    >
+                      <path d="M21.5508 8.94727C21.542 7.91895 20.1445 7.17188 18.4658 7.17188L14.9238 7.17188C14.4316 7.17188 14.2471 7.09277 13.957 6.75879L8.05078 0.316406C7.86621 0.105469 7.6377 0 7.37402 0L6.35449 0C6.12598 0 5.99414 0.202148 6.1084 0.448242L9.14941 7.17188L4.68457 7.68164L3.09375 4.76367C2.97949 4.54395 2.78613 4.44727 2.49609 4.44727L2.11816 4.44727C1.88965 4.44727 1.74023 4.59668 1.74023 4.8252L1.74023 13.0693C1.74023 13.2979 1.88965 13.4385 2.11816 13.4385L2.49609 13.4385C2.78613 13.4385 2.97949 13.3418 3.09375 13.1309L4.68457 10.2129L9.14941 10.7227L6.1084 17.4463C5.99414 17.6836 6.12598 17.8945 6.35449 17.8945L7.37402 17.8945C7.6377 17.8945 7.86621 17.7803 8.05078 17.5781L13.957 11.127C14.2471 10.8018 14.4316 10.7227 14.9238 10.7227L18.4658 10.7227C20.1445 10.7227 21.542 9.9668 21.5508 8.94727Z" />
+                    </svg>
+                    <div>
+                      <Label>Airplane mode</Label>
+                      <Description>
+                        Airplane mode keeps data local, disabling cloud models
+                        and web search.
+                      </Description>
+                    </div>
+                  </div>
+                  <div className="flex-shrink-0">
+                    <Switch
+                      checked={settings.AirplaneMode}
+                      onChange={(checked) =>
+                        handleChange("AirplaneMode", checked)
+                      }
+                    />
+                  </div>
+                </div>
+              </Field>
            </div>
          </div>

@@ -65,7 +65,7 @@ export const BadgeButton = forwardRef(function BadgeButton(
    ),
  ref: React.ForwardedRef<HTMLElement>,
 ) {
-  const classes = clsx(
+  let classes = clsx(
    className,
    "group relative inline-flex rounded-md focus:not-data-focus:outline-hidden data-focus:outline-2 data-focus:outline-offset-2 data-focus:outline-blue-500",
  );
@@ -171,7 +171,7 @@ export const Button = forwardRef(function Button(
  { color, outline, plain, className, children, ...props }: ButtonProps,
  ref: React.ForwardedRef<HTMLElement>,
 ) {
-  const classes = clsx(
+  let classes = clsx(
    className,
    styles.base,
    outline
@@ -6,11 +6,10 @@ export interface SliderProps {
  value?: number;
  onChange?: (value: number) => void;
  className?: string;
-  disabled?: boolean;
 }

 const Slider = React.forwardRef<HTMLDivElement, SliderProps>(
-  ({ label, options, value = 0, onChange, disabled = false }, ref) => {
+  ({ label, options, value = 0, onChange }, ref) => {
    const [selectedValue, setSelectedValue] = React.useState(value);
    const [isDragging, setIsDragging] = React.useState(false);
    const containerRef = React.useRef<HTMLDivElement>(null);
@@ -21,7 +20,6 @@ const Slider = React.forwardRef<HTMLDivElement, SliderProps>(
    }, [value]);

    const handleClick = (optionValue: number) => {
-      if (disabled) return;
      setSelectedValue(optionValue);
      onChange?.(optionValue);
    };
@@ -41,7 +39,6 @@ const Slider = React.forwardRef<HTMLDivElement, SliderProps>(
    };

    const handleMouseDown = (e: React.MouseEvent) => {
-      if (disabled) return;
      setIsDragging(true);
      e.preventDefault();
    };
@@ -80,7 +77,7 @@ const Slider = React.forwardRef<HTMLDivElement, SliderProps>(
    }

    return (
-      <div className={`space-y-2 ${disabled ? "opacity-50" : ""}`} ref={ref}>
+      <div className="space-y-2" ref={ref}>
        {label && <label className="text-sm font-medium">{label}</label>}
        <div className="relative">
          <div className="absolute top-[9px] left-2 right-2 h-1 bg-neutral-200 dark:bg-neutral-700 pointer-events-none rounded-full" />
@@ -91,11 +88,10 @@ const Slider = React.forwardRef<HTMLDivElement, SliderProps>(
                <button
                  onClick={() => handleClick(option.value)}
                  onMouseDown={handleMouseDown}
-                  disabled={disabled}
-                  className={`relative px-3 py-6 -mx-3 -my-6 z-10 ${disabled ? "cursor-not-allowed" : "cursor-pointer"}`}
+                  className="relative px-3 py-6 -mx-3 -my-6 z-10 cursor-pointer"
                >
                  <div className="relative w-5 h-5 flex items-center justify-center">
-                    {selectedValue === option.value && !disabled && (
+                    {selectedValue === option.value && (
                      <div className="w-4 h-4 bg-white dark:bg-white border border-neutral-400 dark:border-neutral-500 rounded-full cursor-grab active:cursor-grabbing" />
                    )}
                  </div>
@@ -6,8 +6,8 @@ import { useSelectedModel } from "./useSelectedModel";
 import { createQueryBatcher } from "./useQueryBatcher";
 import { useRefetchModels } from "./useModels";
 import { useStreamingContext } from "@/contexts/StreamingContext";
+import { useSettings } from "./useSettings";
 import { getModelCapabilities } from "@/api";
-import { useCloudStatus } from "./useCloudStatus";

 export const useChats = () => {
  return useQuery({
@@ -116,9 +116,11 @@ export const useIsModelStale = (modelName: string) => {
 export const useShouldShowStaleDisplay = (model: Model | null) => {
  const isStale = useIsModelStale(model?.model || "");
  const { data: dismissedModels } = useDismissedStaleModels();
-  const { cloudDisabled } = useCloudStatus();
+  const {
+    settings: { airplaneMode },
+  } = useSettings();

-  if (model?.isCloud() && !cloudDisabled) {
+  if (model?.isCloud() && !airplaneMode) {
    return false;
  }

@@ -1,20 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { getCloudStatus, type CloudStatusResponse } from "@/api";
-
-export function useCloudStatus() {
-  const cloudQuery = useQuery<CloudStatusResponse | null>({
-    queryKey: ["cloudStatus"],
-    queryFn: getCloudStatus,
-    retry: false,
-    staleTime: 60 * 1000,
-  });
-
-  return {
-    cloudStatus: cloudQuery.data,
-    cloudDisabled: cloudQuery.data?.disabled ?? false,
-    isKnown: cloudQuery.data !== null && cloudQuery.data !== undefined,
-    isLoading: cloudQuery.isLoading,
-    isError: cloudQuery.isError,
-    error: cloudQuery.error,
-  };
-}
@@ -20,8 +20,3 @@ export function useHasVisionCapability(modelName: string | undefined) {
  const { data: capabilitiesResponse } = useModelCapabilities(modelName);
  return capabilitiesResponse?.capabilities?.includes("vision") ?? false;
 }
-
-export function useHasToolsCapability(modelName: string | undefined) {
-  const { data: capabilitiesResponse } = useModelCapabilities(modelName);
-  return capabilitiesResponse?.capabilities?.includes("tools") ?? false;
-}
@@ -2,11 +2,11 @@ import { useQuery } from "@tanstack/react-query";
 import { Model } from "@/gotypes";
 import { getModels } from "@/api";
 import { mergeModels } from "@/utils/mergeModels";
+import { useSettings } from "./useSettings";
 import { useMemo } from "react";
-import { useCloudStatus } from "./useCloudStatus";

 export function useModels(searchQuery = "") {
-  const { cloudDisabled } = useCloudStatus();
+  const { settings } = useSettings();
  const localQuery = useQuery<Model[], Error>({
    queryKey: ["models", searchQuery],
    queryFn: () => getModels(searchQuery),
@@ -20,7 +20,7 @@ export function useModels(searchQuery = "") {
  });

  const allModels = useMemo(() => {
-    const models = mergeModels(localQuery.data || [], cloudDisabled);
+    const models = mergeModels(localQuery.data || [], settings.airplaneMode);

    if (searchQuery && searchQuery.trim()) {
      const query = searchQuery.toLowerCase().trim();
@@ -40,7 +40,7 @@ export function useModels(searchQuery = "") {
    }

    return models;
-  }, [localQuery.data, searchQuery, cloudDisabled]);
+  }, [localQuery.data, searchQuery, settings.airplaneMode]);

  return {
    ...localQuery,
@@ -7,7 +7,6 @@ import { Model } from "@/gotypes";
 import { FEATURED_MODELS } from "@/utils/mergeModels";
 import { getTotalVRAM } from "@/utils/vram.ts";
 import { getInferenceCompute } from "@/api";
-import { useCloudStatus } from "./useCloudStatus";

 export function recommendDefaultModel(totalVRAM: number): string {
  const vram = Math.max(0, Number(totalVRAM) || 0);
@@ -23,19 +22,16 @@ export function recommendDefaultModel(totalVRAM: number): string {
 export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
  const { settings, setSettings } = useSettings();
  const { data: models = [], isLoading } = useModels(searchQuery || "");
-  const { cloudDisabled } = useCloudStatus();
  const { data: chatData, isLoading: isChatLoading } = useChat(
    currentChatId && currentChatId !== "new" ? currentChatId : "",
  );

-  const { data: inferenceComputeResponse } = useQuery({
-    queryKey: ["inferenceCompute"],
+  const { data: inferenceComputes = [] } = useQuery({
+    queryKey: ["inference-compute"],
    queryFn: getInferenceCompute,
    enabled: !settings.selectedModel, // Only fetch if no model is selected
  });

-  const inferenceComputes = inferenceComputeResponse?.inferenceComputes || [];
-
  const totalVRAM = useMemo(
    () => getTotalVRAM(inferenceComputes),
    [inferenceComputes],
@@ -50,11 +46,12 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
  const restoredChatRef = useRef<string | null>(null);

  const selectedModel: Model | null = useMemo(() => {
-    // If cloud is disabled and selected model ends with cloud, switch to a local default.
-    if (cloudDisabled && settings.selectedModel?.endsWith("cloud")) {
+    // if airplane mode is on and selected model ends with cloud,
+    // switch to recommended default model
+    if (settings.airplaneMode && settings.selectedModel?.endsWith("cloud")) {
      return (
        models.find((m) => m.model === recommendedModel) ||
-        models.find((m) => !m.isCloud()) ||
+        models.find((m) => m.isCloud) ||
        models.find((m) => m.digest === undefined || m.digest === "") ||
        models[0] ||
        null
@@ -71,7 +68,7 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
      "qwen3-coder:480b",
    ];
    const shouldMigrate =
-      !cloudDisabled &&
+      !settings.airplaneMode &&
      settings.turboEnabled &&
      baseModelsToMigrate.includes(settings.selectedModel);

@@ -99,18 +96,13 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
        })) ||
      null
    );
-  }, [
-    models,
-    settings.selectedModel,
-    cloudDisabled,
-    recommendedModel,
-  ]);
+  }, [models, settings.selectedModel, settings.airplaneMode, recommendedModel]);

  useEffect(() => {
    if (!selectedModel) return;

    if (
-      cloudDisabled &&
+      settings.airplaneMode &&
      settings.selectedModel?.endsWith("cloud") &&
      selectedModel.model !== settings.selectedModel
    ) {
@@ -118,17 +110,13 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
    }

    if (
-      !cloudDisabled &&
+      !settings.airplaneMode &&
      settings.turboEnabled &&
      selectedModel.model !== settings.selectedModel
    ) {
      setSettings({ SelectedModel: selectedModel.model, TurboEnabled: false });
    }
-  }, [
-    selectedModel,
-    cloudDisabled,
-    settings.selectedModel,
-  ]);
+  }, [selectedModel, settings.airplaneMode, settings.selectedModel]);

  // Set model from chat history when chat data loads
  useEffect(() => {
@@ -181,9 +169,7 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {

    const defaultModel =
      models.find((m) => m.model === recommendedModel) ||
-      (cloudDisabled
-        ? models.find((m) => !m.isCloud())
-        : models.find((m) => m.isCloud())) ||
+      models.find((m) => m.isCloud()) ||
      models.find((m) => m.digest === undefined || m.digest === "") ||
      models[0];

@@ -195,7 +181,6 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
    inferenceComputes.length,
    models.length,
    settings.selectedModel,
-    cloudDisabled,
  ]);

  // Add the selected model to the models list if it's not already there
@@ -9,7 +9,7 @@ interface SettingsState {
  webSearchEnabled: boolean;
  selectedModel: string;
  sidebarOpen: boolean;
-  lastHomeView: string;
+  airplaneMode: boolean;
  thinkEnabled: boolean;
  thinkLevel: string;
 }
@@ -22,7 +22,6 @@ type SettingsUpdate = Partial<{
  ThinkLevel: string;
  SelectedModel: string;
  SidebarOpen: boolean;
-  LastHomeView: string;
 }>;

 export function useSettings() {
@@ -52,7 +51,7 @@ export function useSettings() {
      thinkLevel: settingsData?.settings?.ThinkLevel ?? "none",
      selectedModel: settingsData?.settings?.SelectedModel ?? "",
      sidebarOpen: settingsData?.settings?.SidebarOpen ?? false,
-      lastHomeView: settingsData?.settings?.LastHomeView ?? "launch",
+      airplaneMode: settingsData?.settings?.AirplaneMode ?? false,
    }),
    [settingsData?.settings],
  );
@@ -2,7 +2,6 @@ import type { QueryClient } from "@tanstack/react-query";
 import { createRootRouteWithContext, Outlet } from "@tanstack/react-router";
 import { getSettings } from "@/api";
 import { useQuery } from "@tanstack/react-query";
-import { useCloudStatus } from "@/hooks/useCloudStatus";

 function RootComponent() {
  // This hook ensures settings are fetched on app startup
@@ -10,8 +9,6 @@ function RootComponent() {
    queryKey: ["settings"],
    queryFn: getSettings,
  });
-  // Fetch cloud status on startup (best-effort)
-  useCloudStatus();

  return (
    <div>
@@ -4,37 +4,12 @@ import Chat from "@/components/Chat";
 import { getChat } from "@/api";
 import { SidebarLayout } from "@/components/layout/layout";
 import { ChatSidebar } from "@/components/ChatSidebar";
-import LaunchCommands from "@/components/LaunchCommands";
-import { useEffect, useRef } from "react";
-import { useSettings } from "@/hooks/useSettings";
-
-const launchSidebarRequestedKey = "ollama.launchSidebarRequested";
-const launchSidebarSeenKey = "ollama.launchSidebarSeen";
-const fallbackSessionState = new Map<string, string>();
-
-function getSessionState() {
-  if (typeof sessionStorage !== "undefined") {
-    return sessionStorage;
-  }
-
-  return {
-    getItem(key: string) {
-      return fallbackSessionState.get(key) ?? null;
-    },
-    setItem(key: string, value: string) {
-      fallbackSessionState.set(key, value);
-    },
-    removeItem(key: string) {
-      fallbackSessionState.delete(key);
-    },
-  };
-}

 export const Route = createFileRoute("/c/$chatId")({
  component: RouteComponent,
  loader: async ({ context, params }) => {
-    // Skip loading for special non-chat views
-    if (params.chatId !== "new" && params.chatId !== "launch") {
+    // Skip loading for "new" chat
+    if (params.chatId !== "new") {
      context.queryClient.ensureQueryData({
        queryKey: ["chat", params.chatId],
        queryFn: () => getChat(params.chatId),
@@ -46,70 +21,13 @@ export const Route = createFileRoute("/c/$chatId")({

 function RouteComponent() {
  const { chatId } = Route.useParams();
-  const { settingsData, setSettings } = useSettings();
-  const previousChatIdRef = useRef<string | null>(null);

-  // Always call hooks at the top level - use a flag to skip data when chatId is a special view
+  // Always call hooks at the top level - use a flag to skip data when chatId is "new"
  const {
    data: chatData,
    isLoading: chatLoading,
    error: chatError,
-  } = useChat(chatId === "new" || chatId === "launch" ? "" : chatId);
-
-  useEffect(() => {
-    if (!settingsData) {
-      return;
-    }
-
-    const previousChatId = previousChatIdRef.current;
-    previousChatIdRef.current = chatId;
-
-    if (chatId === "launch") {
-      const sessionState = getSessionState();
-      const shouldOpenSidebar =
-        previousChatId !== "launch" &&
-        (() => {
-          if (sessionState.getItem(launchSidebarRequestedKey) === "1") {
-            sessionState.removeItem(launchSidebarRequestedKey);
-            sessionState.setItem(launchSidebarSeenKey, "1");
-            return true;
-          }
-
-          if (sessionState.getItem(launchSidebarSeenKey) !== "1") {
-            sessionState.setItem(launchSidebarSeenKey, "1");
-            return true;
-          }
-
-          return false;
-        })();
-      const updates: { LastHomeView?: string; SidebarOpen?: boolean } = {};
-
-      if (settingsData.LastHomeView !== "launch") {
-        updates.LastHomeView = "launch";
-      }
-
-      if (shouldOpenSidebar && !settingsData.SidebarOpen) {
-        updates.SidebarOpen = true;
-      }
-
-      if (Object.keys(updates).length === 0) {
-        return;
-      }
-
-      setSettings(updates).catch(() => {
-        // Best effort persistence for home view preference.
-      });
-      return;
-    }
-
-    if (settingsData.LastHomeView === "chat") {
-      return;
-    }
-
-    setSettings({ LastHomeView: "chat" }).catch(() => {
-      // Best effort persistence for home view preference.
-    });
-  }, [chatId, settingsData, setSettings]);
+  } = useChat(chatId === "new" ? "" : chatId);

  // Handle "new" chat case - just use Chat component which handles everything
  if (chatId === "new") {
@@ -120,14 +38,6 @@ function RouteComponent() {
    );
  }

-  if (chatId === "launch") {
-    return (
-      <SidebarLayout sidebar={<ChatSidebar currentChatId={chatId} />}>
-        <LaunchCommands />
-      </SidebarLayout>
-    );
-  }
-
  // Handle existing chat case
  if (chatLoading) {
    return (
@@ -1,18 +1,10 @@
 import { createFileRoute, redirect } from "@tanstack/react-router";
-import { getSettings } from "@/api";

 export const Route = createFileRoute("/")({
-  beforeLoad: async ({ context }) => {
-    const settingsData = await context.queryClient.ensureQueryData({
-      queryKey: ["settings"],
-      queryFn: getSettings,
-    });
-    const chatId =
-      settingsData?.settings?.LastHomeView === "chat" ? "new" : "launch";
-
+  beforeLoad: () => {
    throw redirect({
      to: "/c/$chatId",
-      params: { chatId },
+      params: { chatId: "new" },
      mask: {
        to: "/",
      },
@@ -1,57 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { copyTextToClipboard } from "./clipboard";
-
-describe("copyTextToClipboard", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("copies via Clipboard API when available", async () => {
-    const writeText = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("navigator", {
-      clipboard: {
-        writeText,
-      },
-    });
-
-    const copied = await copyTextToClipboard("ollama launch claude");
-
-    expect(copied).toBe(true);
-    expect(writeText).toHaveBeenCalledWith("ollama launch claude");
-  });
-
-  it("falls back to execCommand when Clipboard API fails", async () => {
-    const writeText = vi.fn().mockRejectedValue(new Error("not allowed"));
-    vi.stubGlobal("navigator", {
-      clipboard: {
-        writeText,
-      },
-    });
-
-    const textarea = {
-      value: "",
-      setAttribute: vi.fn(),
-      style: {} as Record<string, string>,
-      focus: vi.fn(),
-      select: vi.fn(),
-    };
-    const appendChild = vi.fn();
-    const removeChild = vi.fn();
-    const execCommand = vi.fn().mockReturnValue(true);
-    vi.stubGlobal("document", {
-      createElement: vi.fn().mockReturnValue(textarea),
-      body: {
-        appendChild,
-        removeChild,
-      },
-      execCommand,
-    });
-
-    const copied = await copyTextToClipboard("ollama launch openclaw");
-
-    expect(copied).toBe(true);
-    expect(execCommand).toHaveBeenCalledWith("copy");
-    expect(appendChild).toHaveBeenCalled();
-    expect(removeChild).toHaveBeenCalled();
-  });
-});
@@ -1,30 +0,0 @@
-export async function copyTextToClipboard(text: string): Promise<boolean> {
-  try {
-    await navigator.clipboard.writeText(text);
-    return true;
-  } catch (clipboardError) {
-    console.error(
-      "Clipboard API failed, falling back to execCommand",
-      clipboardError,
-    );
-  }
-
-  try {
-    const textarea = document.createElement("textarea");
-    textarea.value = text;
-    textarea.setAttribute("readonly", "true");
-    textarea.style.position = "fixed";
-    textarea.style.left = "-9999px";
-    textarea.style.opacity = "0";
-    document.body.appendChild(textarea);
-    textarea.focus();
-    textarea.select();
-
-    const copied = document.execCommand("copy");
-    document.body.removeChild(textarea);
-    return copied;
-  } catch (fallbackError) {
-    console.error("Fallback copy failed", fallbackError);
-    return false;
-  }
-}
@@ -29,15 +29,13 @@ describe("fileValidation", () => {
      expect(result.valid).toBe(true);
    });

-    it("should accept images regardless of vision capability", () => {
-      // Vision capability check is handled at the UI layer (ChatForm),
-      // not at validation time, so users can switch models without
-      // needing to re-upload files.
+    it("should reject WebP images when vision capability is disabled", () => {
      const file = createMockFile("test.webp", 1024, "image/webp");
      const result = validateFile(file, {
        hasVisionCapability: false,
      });
-      expect(result.valid).toBe(true);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("This model does not support images");
    });

    it("should accept PNG images when vision capability is enabled", () => {
@@ -63,6 +63,7 @@ export function validateFile(
  const {
    maxFileSize = 10,
    allowedExtensions = [...TEXT_FILE_EXTENSIONS, ...IMAGE_EXTENSIONS],
+    hasVisionCapability = false,
    customValidator,
  } = options;

@@ -82,6 +83,10 @@ export function validateFile(
    return { valid: false, error: "File type not supported" };
  }

+  if (IMAGE_EXTENSIONS.includes(fileExtension) && !hasVisionCapability) {
+    return { valid: false, error: "This model does not support images" };
+  }
+
  // File size validation
  if (file.size > MAX_FILE_SIZE) {
    return { valid: false, error: "File too large" };
@@ -41,14 +41,14 @@ describe("Model merging logic", () => {
    expect(merged.length).toBe(FEATURED_MODELS.length + 2);
  });

-  it("should hide cloud models when cloud is disabled", () => {
+  it("should hide cloud models in airplane mode", () => {
    const localModels: Model[] = [
      new Model({ model: "gpt-oss:120b-cloud" }),
      new Model({ model: "llama3:latest" }),
      new Model({ model: "mistral:latest" }),
    ];

-    const merged = mergeModels(localModels, true); // cloud disabled = true
+    const merged = mergeModels(localModels, true); // airplane mode = true

    // No cloud models should be present
    const cloudModels = merged.filter((m) => m.isCloud());
@@ -2,28 +2,27 @@ import { Model } from "@/gotypes";

 // Featured models list (in priority order)
 export const FEATURED_MODELS = [
-  "kimi-k2.5:cloud",
-  "glm-5:cloud",
-  "minimax-m2.7:cloud",
-  "gemma4:31b-cloud",
-  "qwen3.5:397b-cloud",
  "gpt-oss:120b-cloud",
  "gpt-oss:20b-cloud",
  "deepseek-v3.1:671b-cloud",
+  "qwen3-coder:480b-cloud",
+  "qwen3-vl:235b-cloud",
+  "minimax-m2:cloud",
+  "glm-4.6:cloud",
  "gpt-oss:120b",
  "gpt-oss:20b",
-  "gemma4:31b",
-  "gemma4:26b",
-  "gemma4:e4b",
-  "gemma4:e2b",
+  "gemma3:27b",
+  "gemma3:12b",
+  "gemma3:4b",
+  "gemma3:1b",
  "deepseek-r1:8b",
  "qwen3-coder:30b",
  "qwen3-vl:30b",
  "qwen3-vl:8b",
  "qwen3-vl:4b",
-  "qwen3.5:27b",
-  "qwen3.5:9b",
-  "qwen3.5:4b",
+  "qwen3:30b",
+  "qwen3:8b",
+  "qwen3:4b",
 ];

 function alphabeticalSort(a: Model, b: Model): number {
@@ -33,7 +32,7 @@ function alphabeticalSort(a: Model, b: Model): number {
 //Merges models, sorting cloud models first, then other models
 export function mergeModels(
  localModels: Model[],
-  hideCloudModels: boolean = false,
+  airplaneMode: boolean = false,
 ): Model[] {
  const allModels = (localModels || []).map((model) => model);

@@ -96,7 +95,7 @@ export function mergeModels(

  remainingModels.sort(alphabeticalSort);

-  return hideCloudModels
+  return airplaneMode
    ? [...featuredModels, ...remainingModels]
    : [...cloudModels, ...featuredModels, ...remainingModels];
 }
@@ -45,8 +45,7 @@ type InferenceCompute struct {
 }

 type InferenceComputeResponse struct {
-	InferenceComputes    []InferenceCompute `json:"inferenceComputes"`
-	DefaultContextLength int                `json:"defaultContextLength"`
+	InferenceComputes []InferenceCompute `json:"inferenceComputes"`
 }

 type ModelCapabilitiesResponse struct {
@@ -133,8 +132,9 @@ type Error struct {
 }

 type ModelUpstreamResponse struct {
-	Stale bool   `json:"stale"`
-	Error string `json:"error,omitempty"`
+	Digest   string `json:"digest,omitempty"`
+	PushTime int64  `json:"pushTime"`
+	Error    string `json:"error,omitempty"`
 }

 // Serializable data for the browser state
@@ -28,11 +28,9 @@ import (
 	"github.com/ollama/ollama/app/tools"
 	"github.com/ollama/ollama/app/types/not"
 	"github.com/ollama/ollama/app/ui/responses"
-	"github.com/ollama/ollama/app/updater"
 	"github.com/ollama/ollama/app/version"
 	ollamaAuth "github.com/ollama/ollama/auth"
 	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/manifest"
 	"github.com/ollama/ollama/types/model"
 	_ "github.com/tkrajina/typescriptify-golang-structs/typescriptify"
 )
@@ -108,10 +106,6 @@ type Server struct {

 	// Dev is true if the server is running in development mode
 	Dev bool
-
-	// Updater for checking and downloading updates
-	Updater             *updater.Updater
-	UpdateAvailableFunc func()
 }

 func (s *Server) log() *slog.Logger {
@@ -156,7 +150,7 @@ func (s *Server) ollamaProxy() http.Handler {
 					return
 				}

-				target := envconfig.ConnectableHost()
+				target := envconfig.Host()
 				s.log().Info("configuring ollama proxy", "target", target.String())

 				newProxy := httputil.NewSingleHostReverseProxy(target)
@@ -194,7 +188,7 @@ func (s *Server) Handler() http.Handler {
 			if CORS() {
 				w.Header().Set("Access-Control-Allow-Origin", "*")
 				w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-				w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, User-Agent, Accept, X-Requested-With")
+				w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
 				w.Header().Set("Access-Control-Allow-Credentials", "true")

 				// Handle preflight requests
@@ -290,15 +284,12 @@ func (s *Server) Handler() http.Handler {
 	mux.Handle("POST /api/v1/model/upstream", handle(s.modelUpstream))
 	mux.Handle("GET /api/v1/settings", handle(s.getSettings))
 	mux.Handle("POST /api/v1/settings", handle(s.settings))
-	mux.Handle("GET /api/v1/cloud", handle(s.getCloudSetting))
-	mux.Handle("POST /api/v1/cloud", handle(s.cloudSetting))

 	// Ollama proxy endpoints
 	ollamaProxy := s.ollamaProxy()
 	mux.Handle("GET /api/tags", ollamaProxy)
 	mux.Handle("POST /api/show", ollamaProxy)
 	mux.Handle("GET /api/version", ollamaProxy)
-	mux.Handle("GET /api/status", ollamaProxy)
 	mux.Handle("HEAD /api/version", ollamaProxy)
 	mux.Handle("POST /api/me", ollamaProxy)
 	mux.Handle("POST /api/signout", ollamaProxy)
@@ -319,7 +310,7 @@ func (s *Server) handleError(w http.ResponseWriter, e error) {
 	if CORS() {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, User-Agent, Accept, X-Requested-With")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
 		w.Header().Set("Access-Control-Allow-Credentials", "true")
 	}

@@ -342,18 +333,8 @@ func (t *userAgentTransport) RoundTrip(req *http.Request) (*http.Response, error

 // httpClient returns an HTTP client that automatically adds the User-Agent header
 func (s *Server) httpClient() *http.Client {
-	return userAgentHTTPClient(10 * time.Second)
-}
-
-// inferenceClient uses almost the same HTTP client, but without a timeout so
-// long requests aren't truncated
-func (s *Server) inferenceClient() *api.Client {
-	return api.NewClient(envconfig.Host(), userAgentHTTPClient(0))
-}
-
-func userAgentHTTPClient(timeout time.Duration) *http.Client {
 	return &http.Client{
-		Timeout: timeout,
+		Timeout: 10 * time.Second,
 		Transport: &userAgentTransport{
 			base: http.DefaultTransport,
 		},
@@ -731,7 +712,11 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) error {
 	_, cancelLoading := context.WithCancel(ctx)
 	loading := false

-	c := s.inferenceClient()
+	c, err := api.ClientFromEnvironment()
+	if err != nil {
+		cancelLoading()
+		return err
+	}

 	// Check if the model exists locally by trying to show it
 	// TODO (jmorganca): skip this round trip and instead just act
@@ -841,9 +826,8 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) error {

 	if !hasAttachments {
 		WebSearchEnabled := req.WebSearch != nil && *req.WebSearch
-		hasToolsCapability := slices.Contains(details.Capabilities, model.CapabilityTools)

-		if WebSearchEnabled && hasToolsCapability {
+		if WebSearchEnabled {
 			if supportsBrowserTools(req.Model) {
 				browserState, ok := s.browserState(chat)
 				if !ok {
@@ -853,7 +837,7 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) error {
 				registry.Register(tools.NewBrowserSearch(browser))
 				registry.Register(tools.NewBrowserOpen(browser))
 				registry.Register(tools.NewBrowserFind(browser))
-			} else {
+			} else if supportsWebSearchTools(req.Model) {
 				registry.Register(&tools.WebSearch{})
 				registry.Register(&tools.WebFetch{})
 			}
@@ -1433,6 +1417,11 @@ func (s *Server) getSettings(w http.ResponseWriter, r *http.Request) error {
 		settings.Models = envconfig.Models()
 	}

+	// set default context length if not set
+	if settings.ContextLength == 0 {
+		settings.ContextLength = 4096
+	}
+
 	// Include current runtime settings
 	settings.Agent = s.Agent
 	settings.Tools = s.Tools
@@ -1459,24 +1448,6 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) error {
 		return fmt.Errorf("failed to save settings: %w", err)
 	}

-	// Handle auto-update toggle changes
-	if old.AutoUpdateEnabled != settings.AutoUpdateEnabled {
-		if !settings.AutoUpdateEnabled {
-			// Auto-update disabled: cancel any ongoing download
-			if s.Updater != nil {
-				s.Updater.CancelOngoingDownload()
-			}
-		} else {
-			// Auto-update re-enabled: show notification if update is already staged, or trigger immediate check
-			if (updater.IsUpdatePending() || updater.UpdateDownloaded) && s.UpdateAvailableFunc != nil {
-				s.UpdateAvailableFunc()
-			} else if s.Updater != nil {
-				// Trigger the background checker to run immediately
-				s.Updater.TriggerImmediateCheck()
-			}
-		}
-	}
-
 	if old.ContextLength != settings.ContextLength ||
 		old.Models != settings.Models ||
 		old.Expose != settings.Expose {
@@ -1489,51 +1460,17 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) error {
 	})
 }

-func (s *Server) cloudSetting(w http.ResponseWriter, r *http.Request) error {
-	var req struct {
-		Enabled bool `json:"enabled"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		return fmt.Errorf("invalid request body: %w", err)
-	}
-
-	if err := s.Store.SetCloudEnabled(req.Enabled); err != nil {
-		return fmt.Errorf("failed to persist cloud setting: %w", err)
-	}
-
-	s.Restart()
-
-	return s.writeCloudStatus(w)
-}
-
-func (s *Server) getCloudSetting(w http.ResponseWriter, r *http.Request) error {
-	return s.writeCloudStatus(w)
-}
-
-func (s *Server) writeCloudStatus(w http.ResponseWriter) error {
-	disabled, source, err := s.Store.CloudStatus()
-	if err != nil {
-		return fmt.Errorf("failed to load cloud status: %w", err)
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	return json.NewEncoder(w).Encode(map[string]any{
-		"disabled": disabled,
-		"source":   source,
-	})
-}
-
 func (s *Server) getInferenceCompute(w http.ResponseWriter, r *http.Request) error {
 	ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)
 	defer cancel()
-	info, err := server.GetInferenceInfo(ctx)
+	serverInferenceComputes, err := server.GetInferenceComputer(ctx)
 	if err != nil {
-		s.log().Error("failed to get inference info", "error", err)
-		return fmt.Errorf("failed to get inference info: %w", err)
+		s.log().Error("failed to get inference compute", "error", err)
+		return fmt.Errorf("failed to get inference compute: %w", err)
 	}

-	inferenceComputes := make([]responses.InferenceCompute, len(info.Computes))
-	for i, ic := range info.Computes {
+	inferenceComputes := make([]responses.InferenceCompute, len(serverInferenceComputes))
+	for i, ic := range serverInferenceComputes {
 		inferenceComputes[i] = responses.InferenceCompute{
 			Library: ic.Library,
 			Variant: ic.Variant,
@@ -1545,8 +1482,7 @@ func (s *Server) getInferenceCompute(w http.ResponseWriter, r *http.Request) err
 	}

 	response := responses.InferenceComputeResponse{
-		InferenceComputes:    inferenceComputes,
-		DefaultContextLength: info.DefaultContextLength,
+		InferenceComputes: inferenceComputes,
 	}

 	w.Header().Set("Content-Type", "application/json")
@@ -1579,18 +1515,9 @@ func (s *Server) modelUpstream(w http.ResponseWriter, r *http.Request) error {
 		return json.NewEncoder(w).Encode(response)
 	}

-	n := model.ParseName(req.Model)
-	stale := true
-	if m, err := manifest.ParseNamedManifest(n); err == nil {
-		if m.Digest() == digest {
-			stale = false
-		} else if pushTime > 0 && m.FileInfo().ModTime().Unix() >= pushTime {
-			stale = false
-		}
-	}
-
 	response := responses.ModelUpstreamResponse{
-		Stale: stale,
+		Digest:   digest,
+		PushTime: pushTime,
 	}

 	w.Header().Set("Content-Type", "application/json")
@@ -1688,6 +1615,18 @@ func supportsBrowserTools(model string) bool {
 	return strings.HasPrefix(strings.ToLower(model), "gpt-oss")
 }

+// Web search tools are simpler, providing only basic web search and fetch capabilities (e.g., "web_search", "web_fetch") without simulating a browser. Currently only qwen3 and deepseek-v3 support web search tools.
+func supportsWebSearchTools(model string) bool {
+	model = strings.ToLower(model)
+	prefixes := []string{"qwen3", "deepseek-v3"}
+	for _, p := range prefixes {
+		if strings.HasPrefix(model, p) {
+			return true
+		}
+	}
+	return false
+}
+
 // buildChatRequest converts store.Chat to api.ChatRequest
 func (s *Server) buildChatRequest(chat *store.Chat, model string, think any, availableTools []map[string]any) (*api.ChatRequest, error) {
 	var msgs []api.Message
@@ -4,7 +4,6 @@ package ui

 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"io"
 	"net/http"
@@ -12,12 +11,9 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"sync/atomic"
 	"testing"

-	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/app/store"
-	"github.com/ollama/ollama/app/updater"
 )

 func TestHandlePostApiSettings(t *testing.T) {
@@ -119,107 +115,6 @@ func TestHandlePostApiSettings(t *testing.T) {
 	}
 }

-func TestHandlePostApiCloudSetting(t *testing.T) {
-	tmpHome := t.TempDir()
-	t.Setenv("HOME", tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	restartCount := 0
-	server := &Server{
-		Store: testStore,
-		Restart: func() {
-			restartCount++
-		},
-	}
-
-	for _, tc := range []struct {
-		name        string
-		body        string
-		wantEnabled bool
-	}{
-		{name: "disable cloud", body: `{"enabled": false}`, wantEnabled: false},
-		{name: "enable cloud", body: `{"enabled": true}`, wantEnabled: true},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			req := httptest.NewRequest("POST", "/api/v1/cloud", bytes.NewBufferString(tc.body))
-			req.Header.Set("Content-Type", "application/json")
-			rr := httptest.NewRecorder()
-
-			if err := server.cloudSetting(rr, req); err != nil {
-				t.Fatalf("cloudSetting() error = %v", err)
-			}
-			if rr.Code != http.StatusOK {
-				t.Fatalf("cloudSetting() status = %d, want %d", rr.Code, http.StatusOK)
-			}
-
-			var got map[string]any
-			if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil {
-				t.Fatalf("cloudSetting() invalid response JSON: %v", err)
-			}
-			if got["disabled"] != !tc.wantEnabled {
-				t.Fatalf("response disabled = %v, want %v", got["disabled"], !tc.wantEnabled)
-			}
-
-			disabled, err := testStore.CloudDisabled()
-			if err != nil {
-				t.Fatalf("CloudDisabled() error = %v", err)
-			}
-			if gotEnabled := !disabled; gotEnabled != tc.wantEnabled {
-				t.Fatalf("cloud enabled = %v, want %v", gotEnabled, tc.wantEnabled)
-			}
-		})
-	}
-
-	if restartCount != 2 {
-		t.Fatalf("Restart called %d times, want 2", restartCount)
-	}
-}
-
-func TestHandleGetApiCloudSetting(t *testing.T) {
-	tmpHome := t.TempDir()
-	t.Setenv("HOME", tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	if err := testStore.SetCloudEnabled(false); err != nil {
-		t.Fatalf("SetCloudEnabled(false) error = %v", err)
-	}
-
-	server := &Server{
-		Store:   testStore,
-		Restart: func() {},
-	}
-
-	req := httptest.NewRequest("GET", "/api/v1/cloud", nil)
-	rr := httptest.NewRecorder()
-	if err := server.getCloudSetting(rr, req); err != nil {
-		t.Fatalf("getCloudSetting() error = %v", err)
-	}
-	if rr.Code != http.StatusOK {
-		t.Fatalf("getCloudSetting() status = %d, want %d", rr.Code, http.StatusOK)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil {
-		t.Fatalf("getCloudSetting() invalid response JSON: %v", err)
-	}
-	if got["disabled"] != true {
-		t.Fatalf("response disabled = %v, want true", got["disabled"])
-	}
-	if got["source"] != "config" {
-		t.Fatalf("response source = %v, want config", got["source"])
-	}
-}
-
 func TestAuthenticationMiddleware(t *testing.T) {
 	tests := []struct {
 		name         string
@@ -526,317 +421,3 @@ func TestUserAgentTransport(t *testing.T) {

 	t.Logf("User-Agent transport successfully set: %s", receivedUA)
 }
-
-func TestInferenceClientUsesUserAgent(t *testing.T) {
-	var gotUserAgent atomic.Value
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotUserAgent.Store(r.Header.Get("User-Agent"))
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{}`))
-	}))
-	defer ts.Close()
-
-	t.Setenv("OLLAMA_HOST", ts.URL)
-
-	server := &Server{}
-	client := server.inferenceClient()
-
-	_, err := client.Show(context.Background(), &api.ShowRequest{Model: "test"})
-	if err != nil {
-		t.Fatalf("show request failed: %v", err)
-	}
-
-	receivedUA, _ := gotUserAgent.Load().(string)
-	expectedUA := userAgent()
-
-	if receivedUA != expectedUA {
-		t.Errorf("User-Agent mismatch\nExpected: %s\nReceived: %s", expectedUA, receivedUA)
-	}
-}
-
-func TestSupportsBrowserTools(t *testing.T) {
-	tests := []struct {
-		model string
-		want  bool
-	}{
-		{"gpt-oss", true},
-		{"gpt-oss-latest", true},
-		{"GPT-OSS", true},
-		{"Gpt-Oss-v2", true},
-		{"qwen3", false},
-		{"deepseek-v3", false},
-		{"llama3.3", false},
-		{"", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.model, func(t *testing.T) {
-			if got := supportsBrowserTools(tt.model); got != tt.want {
-				t.Errorf("supportsBrowserTools(%q) = %v, want %v", tt.model, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestWebSearchToolRegistration(t *testing.T) {
-	// Validates that the capability-gating logic in chat() correctly
-	// decides which tools to register based on model capabilities and
-	// the web search flag.
-	tests := []struct {
-		name             string
-		webSearchEnabled bool
-		hasToolsCap      bool
-		model            string
-		wantBrowser      bool // expects browser tools (gpt-oss)
-		wantWebSearch    bool // expects basic web search/fetch tools
-		wantNone         bool // expects no tools registered
-	}{
-		{
-			name:             "web search enabled with tools capability - browser model",
-			webSearchEnabled: true,
-			hasToolsCap:      true,
-			model:            "gpt-oss-latest",
-			wantBrowser:      true,
-		},
-		{
-			name:             "web search enabled with tools capability - non-browser model",
-			webSearchEnabled: true,
-			hasToolsCap:      true,
-			model:            "qwen3",
-			wantWebSearch:    true,
-		},
-		{
-			name:             "web search enabled without tools capability",
-			webSearchEnabled: true,
-			hasToolsCap:      false,
-			model:            "llama3.3",
-			wantNone:         true,
-		},
-		{
-			name:             "web search disabled with tools capability",
-			webSearchEnabled: false,
-			hasToolsCap:      true,
-			model:            "qwen3",
-			wantNone:         true,
-		},
-		{
-			name:             "web search disabled without tools capability",
-			webSearchEnabled: false,
-			hasToolsCap:      false,
-			model:            "llama3.3",
-			wantNone:         true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Replicate the decision logic from chat() handler
-			gotBrowser := false
-			gotWebSearch := false
-
-			if tt.webSearchEnabled && tt.hasToolsCap {
-				if supportsBrowserTools(tt.model) {
-					gotBrowser = true
-				} else {
-					gotWebSearch = true
-				}
-			}
-
-			if tt.wantBrowser && !gotBrowser {
-				t.Error("expected browser tools to be registered")
-			}
-			if tt.wantWebSearch && !gotWebSearch {
-				t.Error("expected web search tools to be registered")
-			}
-			if tt.wantNone && (gotBrowser || gotWebSearch) {
-				t.Error("expected no tools to be registered")
-			}
-			if !tt.wantBrowser && gotBrowser {
-				t.Error("unexpected browser tools registered")
-			}
-			if !tt.wantWebSearch && gotWebSearch {
-				t.Error("unexpected web search tools registered")
-			}
-		})
-	}
-}
-
-func TestSettingsToggleAutoUpdateOff_CancelsDownload(t *testing.T) {
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	// Start with auto-update enabled
-	settings, err := testStore.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = true
-	if err := testStore.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	upd := &updater.Updater{Store: &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db2.sqlite"),
-	}}
-	defer upd.Store.Close()
-
-	// We can't easily mock CancelOngoingDownload, but we can verify
-	// the full settings handler flow works without error
-	server := &Server{
-		Store:   testStore,
-		Restart: func() {},
-		Updater: upd,
-	}
-
-	// Disable auto-update via settings API
-	settings.AutoUpdateEnabled = false
-	body, err := json.Marshal(settings)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	req := httptest.NewRequest("POST", "/api/v1/settings", bytes.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-	rr := httptest.NewRecorder()
-
-	if err := server.settings(rr, req); err != nil {
-		t.Fatalf("settings() error = %v", err)
-	}
-	if rr.Code != http.StatusOK {
-		t.Fatalf("settings() status = %d, want %d", rr.Code, http.StatusOK)
-	}
-
-	// Verify settings were saved with auto-update disabled
-	saved, err := testStore.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if saved.AutoUpdateEnabled {
-		t.Fatal("expected AutoUpdateEnabled to be false after toggle off")
-	}
-}
-
-func TestSettingsToggleAutoUpdateOn_WithPendingUpdate_ShowsNotification(t *testing.T) {
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	// Start with auto-update disabled
-	settings, err := testStore.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = false
-	if err := testStore.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	// Simulate that an update was previously downloaded
-	oldVal := updater.UpdateDownloaded
-	updater.UpdateDownloaded = true
-	defer func() { updater.UpdateDownloaded = oldVal }()
-
-	var notificationCalled atomic.Bool
-	server := &Server{
-		Store:   testStore,
-		Restart: func() {},
-		UpdateAvailableFunc: func() {
-			notificationCalled.Store(true)
-		},
-	}
-
-	// Re-enable auto-update via settings API
-	settings.AutoUpdateEnabled = true
-	body, err := json.Marshal(settings)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	req := httptest.NewRequest("POST", "/api/v1/settings", bytes.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-	rr := httptest.NewRecorder()
-
-	if err := server.settings(rr, req); err != nil {
-		t.Fatalf("settings() error = %v", err)
-	}
-	if rr.Code != http.StatusOK {
-		t.Fatalf("settings() status = %d, want %d", rr.Code, http.StatusOK)
-	}
-
-	if !notificationCalled.Load() {
-		t.Fatal("expected UpdateAvailableFunc to be called when re-enabling with a downloaded update")
-	}
-}
-
-func TestSettingsToggleAutoUpdateOn_NoPendingUpdate_TriggersCheck(t *testing.T) {
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	// Start with auto-update disabled
-	settings, err := testStore.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = false
-	if err := testStore.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	// Ensure no pending update - clear both the downloaded flag and the stage dir
-	oldVal := updater.UpdateDownloaded
-	updater.UpdateDownloaded = false
-	defer func() { updater.UpdateDownloaded = oldVal }()
-
-	oldStageDir := updater.UpdateStageDir
-	updater.UpdateStageDir = t.TempDir() // empty dir means IsUpdatePending() returns false
-	defer func() { updater.UpdateStageDir = oldStageDir }()
-
-	upd := &updater.Updater{Store: &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db2.sqlite"),
-	}}
-	defer upd.Store.Close()
-
-	// Initialize the checkNow channel by starting (and immediately stopping) the checker
-	// so TriggerImmediateCheck doesn't panic on nil channel
-	ctx, cancel := context.WithCancel(t.Context())
-	upd.StartBackgroundUpdaterChecker(ctx, func(string) error { return nil })
-	defer cancel()
-
-	var notificationCalled atomic.Bool
-	server := &Server{
-		Store:   testStore,
-		Restart: func() {},
-		Updater: upd,
-		UpdateAvailableFunc: func() {
-			notificationCalled.Store(true)
-		},
-	}
-
-	// Re-enable auto-update via settings API
-	settings.AutoUpdateEnabled = true
-	body, err := json.Marshal(settings)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	req := httptest.NewRequest("POST", "/api/v1/settings", bytes.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-	rr := httptest.NewRecorder()
-
-	if err := server.settings(rr, req); err != nil {
-		t.Fatalf("settings() error = %v", err)
-	}
-	if rr.Code != http.StatusOK {
-		t.Fatalf("settings() status = %d, want %d", rr.Code, http.StatusOK)
-	}
-
-	// UpdateAvailableFunc should NOT be called since there's no pending update
-	if notificationCalled.Load() {
-		t.Fatal("UpdateAvailableFunc should not be called when there is no pending update")
-	}
-}
@@ -19,7 +19,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"sync"
 	"time"

 	"github.com/ollama/ollama/app/store"
@@ -59,8 +58,7 @@ func (u *Updater) checkForUpdate(ctx context.Context) (bool, UpdateResponse) {
 	query := requestURL.Query()
 	query.Add("os", runtime.GOOS)
 	query.Add("arch", runtime.GOARCH)
-	currentVersion := version.Version
-	query.Add("version", currentVersion)
+	query.Add("version", version.Version)
 	query.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))

 	// The original macOS app used to use the device ID
@@ -133,27 +131,15 @@ func (u *Updater) checkForUpdate(ctx context.Context) (bool, UpdateResponse) {
 }

 func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateResponse) error {
-	// Create a cancellable context for this download
-	downloadCtx, cancel := context.WithCancel(ctx)
-	u.cancelDownloadLock.Lock()
-	u.cancelDownload = cancel
-	u.cancelDownloadLock.Unlock()
-	defer func() {
-		u.cancelDownloadLock.Lock()
-		u.cancelDownload = nil
-		u.cancelDownloadLock.Unlock()
-		cancel()
-	}()
-
 	// Do a head first to check etag info
-	req, err := http.NewRequestWithContext(downloadCtx, http.MethodHead, updateResp.UpdateURL, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodHead, updateResp.UpdateURL, nil)
 	if err != nil {
 		return err
 	}

 	// In case of slow downloads, continue the update check in the background
-	bgctx, bgcancel := context.WithCancel(downloadCtx)
-	defer bgcancel()
+	bgctx, cancel := context.WithCancel(ctx)
+	defer cancel()
 	go func() {
 		for {
 			select {
@@ -190,7 +176,6 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	_, err = os.Stat(stageFilename)
 	if err == nil {
 		slog.Info("update already downloaded", "bundle", stageFilename)
-		UpdateDownloaded = true
 		return nil
 	}

@@ -259,85 +244,33 @@ func cleanupOldDownloads(stageDir string) {
 }

 type Updater struct {
-	Store              *store.Store
-	cancelDownload     context.CancelFunc
-	cancelDownloadLock sync.Mutex
-	checkNow           chan struct{}
-}
-
-// CancelOngoingDownload cancels any currently running download
-func (u *Updater) CancelOngoingDownload() {
-	u.cancelDownloadLock.Lock()
-	defer u.cancelDownloadLock.Unlock()
-	if u.cancelDownload != nil {
-		slog.Info("cancelling ongoing update download")
-		u.cancelDownload()
-		u.cancelDownload = nil
-	}
-}
-
-// TriggerImmediateCheck signals the background checker to check for updates immediately
-func (u *Updater) TriggerImmediateCheck() {
-	if u.checkNow != nil {
-		select {
-		case u.checkNow <- struct{}{}:
-		default:
-			// Check already pending, no need to queue another
-		}
-	}
+	Store *store.Store
 }

 func (u *Updater) StartBackgroundUpdaterChecker(ctx context.Context, cb func(string) error) {
-	u.checkNow = make(chan struct{}, 1)
-	u.checkNow <- struct{}{} // Trigger first check after initial delay
 	go func() {
 		// Don't blast an update message immediately after startup
 		time.Sleep(UpdateCheckInitialDelay)
 		slog.Info("beginning update checker", "interval", UpdateCheckInterval)
-		ticker := time.NewTicker(UpdateCheckInterval)
-		defer ticker.Stop()
-
 		for {
+			available, resp := u.checkForUpdate(ctx)
+			if available {
+				err := u.DownloadNewRelease(ctx, resp)
+				if err != nil {
+					slog.Error(fmt.Sprintf("failed to download new release: %s", err))
+				} else {
+					err = cb(resp.UpdateVersion)
+					if err != nil {
+						slog.Warn(fmt.Sprintf("failed to register update available with tray: %s", err))
+					}
+				}
+			}
 			select {
 			case <-ctx.Done():
 				slog.Debug("stopping background update checker")
 				return
-			case <-u.checkNow:
-				// Immediate check triggered
-			case <-ticker.C:
-				// Regular interval check
-			}
-
-			// Always check for updates
-			available, resp := u.checkForUpdate(ctx)
-			if !available {
-				continue
-			}
-
-			// Update is available - check if auto-update is enabled for downloading
-			settings, err := u.Store.Settings()
-			if err != nil {
-				slog.Error("failed to load settings", "error", err)
-				continue
-			}
-
-			if !settings.AutoUpdateEnabled {
-				// Auto-update disabled - don't download, just log
-				slog.Debug("update available but auto-update disabled", "version", resp.UpdateVersion)
-				continue
-			}
-
-			// Auto-update is enabled - download
-			err = u.DownloadNewRelease(ctx, resp)
-			if err != nil {
-				slog.Error("failed to download new release", "error", err)
-				continue
-			}
-
-			// Download successful - show tray notification
-			err = cb(resp.UpdateVersion)
-			if err != nil {
-				slog.Warn("failed to register update available with tray", "error", err)
+			default:
+				time.Sleep(UpdateCheckInterval)
 			}
 		}
 	}()
@@ -11,8 +11,6 @@ import (
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
-	"path/filepath"
-	"sync/atomic"
 	"testing"
 	"time"

@@ -35,7 +33,7 @@ func TestIsNewReleaseAvailable(t *testing.T) {
 	defer server.Close()
 	slog.Debug("server", "url", server.URL)

-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
+	updater := &Updater{Store: &store.Store{}}
 	defer updater.Store.Close() // Ensure database is closed
 	UpdateCheckURLBase = server.URL + "/update.json"
 	updatePresent, resp := updater.checkForUpdate(t.Context())
@@ -86,18 +84,8 @@ func TestBackgoundChecker(t *testing.T) {
 	defer server.Close()
 	UpdateCheckURLBase = server.URL + "/update.json"

-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
-	defer updater.Store.Close()
-
-	settings, err := updater.Store.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = true
-	if err := updater.Store.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
+	updater := &Updater{Store: &store.Store{}}
+	defer updater.Store.Close() // Ensure database is closed
 	updater.StartBackgroundUpdaterChecker(ctx, cb)
 	select {
 	case <-stallTimer.C:
@@ -111,267 +99,3 @@ func TestBackgoundChecker(t *testing.T) {
 		}
 	}
 }
-
-func TestAutoUpdateDisabledSkipsDownload(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	var downloadAttempted atomic.Bool
-	done := make(chan struct{})
-
-	ctx, cancel := context.WithCancel(t.Context())
-	defer cancel()
-	UpdateCheckInitialDelay = 5 * time.Millisecond
-	UpdateCheckInterval = 5 * time.Millisecond
-	VerifyDownload = func() error {
-		return nil
-	}
-
-	var server *httptest.Server
-	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/update.json" {
-			w.Write([]byte(
-				fmt.Sprintf(`{"version": "9.9.9", "url": "%s"}`,
-					server.URL+"/9.9.9/"+Installer)))
-		} else if r.URL.Path == "/9.9.9/"+Installer {
-			downloadAttempted.Store(true)
-			buf := &bytes.Buffer{}
-			zw := zip.NewWriter(buf)
-			zw.Close()
-			io.Copy(w, buf)
-		}
-	}))
-	defer server.Close()
-	UpdateCheckURLBase = server.URL + "/update.json"
-
-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
-	defer updater.Store.Close()
-
-	// Ensure auto-update is disabled
-	settings, err := updater.Store.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = false
-	if err := updater.Store.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	cb := func(ver string) error {
-		t.Fatal("callback should not be called when auto-update is disabled")
-		return nil
-	}
-
-	updater.StartBackgroundUpdaterChecker(ctx, cb)
-
-	// Wait enough time for multiple check cycles
-	time.Sleep(50 * time.Millisecond)
-	close(done)
-
-	if downloadAttempted.Load() {
-		t.Fatal("download should not be attempted when auto-update is disabled")
-	}
-}
-
-func TestAutoUpdateReenabledDownloadsUpdate(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	var downloadAttempted atomic.Bool
-	callbackCalled := make(chan struct{}, 1)
-
-	ctx, cancel := context.WithCancel(t.Context())
-	defer cancel()
-	UpdateCheckInitialDelay = 5 * time.Millisecond
-	UpdateCheckInterval = 5 * time.Millisecond
-	VerifyDownload = func() error {
-		return nil
-	}
-
-	var server *httptest.Server
-	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/update.json" {
-			w.Write([]byte(
-				fmt.Sprintf(`{"version": "9.9.9", "url": "%s"}`,
-					server.URL+"/9.9.9/"+Installer)))
-		} else if r.URL.Path == "/9.9.9/"+Installer {
-			downloadAttempted.Store(true)
-			buf := &bytes.Buffer{}
-			zw := zip.NewWriter(buf)
-			zw.Close()
-			io.Copy(w, buf)
-		}
-	}))
-	defer server.Close()
-	UpdateCheckURLBase = server.URL + "/update.json"
-
-	upd := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
-	defer upd.Store.Close()
-
-	// Start with auto-update disabled
-	settings, err := upd.Store.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = false
-	if err := upd.Store.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	cb := func(ver string) error {
-		select {
-		case callbackCalled <- struct{}{}:
-		default:
-		}
-		return nil
-	}
-
-	upd.StartBackgroundUpdaterChecker(ctx, cb)
-
-	// Wait for a few cycles with auto-update disabled - no download should happen
-	time.Sleep(50 * time.Millisecond)
-	if downloadAttempted.Load() {
-		t.Fatal("download should not happen while auto-update is disabled")
-	}
-
-	// Re-enable auto-update
-	settings.AutoUpdateEnabled = true
-	if err := upd.Store.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait for the checker to pick it up and download
-	select {
-	case <-callbackCalled:
-		// Success: download happened and callback was called after re-enabling
-		if !downloadAttempted.Load() {
-			t.Fatal("expected download to be attempted after re-enabling")
-		}
-	case <-time.After(5 * time.Second):
-		t.Fatal("expected download and callback after re-enabling auto-update")
-	}
-}
-
-func TestCancelOngoingDownload(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	downloadStarted := make(chan struct{})
-	downloadCancelled := make(chan struct{})
-
-	ctx := t.Context()
-	VerifyDownload = func() error {
-		return nil
-	}
-
-	var server *httptest.Server
-	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/update.json" {
-			w.Write([]byte(
-				fmt.Sprintf(`{"version": "9.9.9", "url": "%s"}`,
-					server.URL+"/9.9.9/"+Installer)))
-		} else if r.URL.Path == "/9.9.9/"+Installer {
-			if r.Method == http.MethodHead {
-				w.Header().Set("Content-Length", "1000000")
-				w.WriteHeader(http.StatusOK)
-				return
-			}
-			// Signal that download has started
-			close(downloadStarted)
-			// Wait for cancellation or timeout
-			select {
-			case <-r.Context().Done():
-				close(downloadCancelled)
-				return
-			case <-time.After(5 * time.Second):
-				t.Error("download was not cancelled in time")
-			}
-		}
-	}))
-	defer server.Close()
-	UpdateCheckURLBase = server.URL + "/update.json"
-
-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
-	defer updater.Store.Close()
-
-	_, resp := updater.checkForUpdate(ctx)
-
-	// Start download in goroutine
-	go func() {
-		_ = updater.DownloadNewRelease(ctx, resp)
-	}()
-
-	// Wait for download to start
-	select {
-	case <-downloadStarted:
-	case <-time.After(2 * time.Second):
-		t.Fatal("download did not start in time")
-	}
-
-	// Cancel the download
-	updater.CancelOngoingDownload()
-
-	// Verify cancellation was received
-	select {
-	case <-downloadCancelled:
-		// Success
-	case <-time.After(2 * time.Second):
-		t.Fatal("download cancellation was not received by server")
-	}
-}
-
-func TestTriggerImmediateCheck(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	checkCount := atomic.Int32{}
-	checkDone := make(chan struct{}, 10)
-
-	ctx, cancel := context.WithCancel(t.Context())
-	defer cancel()
-	// Set a very long interval so only TriggerImmediateCheck causes checks
-	UpdateCheckInitialDelay = 1 * time.Millisecond
-	UpdateCheckInterval = 1 * time.Hour
-	VerifyDownload = func() error {
-		return nil
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/update.json" {
-			checkCount.Add(1)
-			select {
-			case checkDone <- struct{}{}:
-			default:
-			}
-			// Return no update available
-			w.WriteHeader(http.StatusNoContent)
-		}
-	}))
-	defer server.Close()
-	UpdateCheckURLBase = server.URL + "/update.json"
-
-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
-	defer updater.Store.Close()
-
-	cb := func(ver string) error {
-		return nil
-	}
-
-	updater.StartBackgroundUpdaterChecker(ctx, cb)
-
-	// Wait for the initial check that fires after the initial delay
-	select {
-	case <-checkDone:
-	case <-time.After(2 * time.Second):
-		t.Fatal("initial check did not happen")
-	}
-
-	initialCount := checkCount.Load()
-
-	// Trigger immediate check
-	updater.TriggerImmediateCheck()
-
-	// Wait for the triggered check
-	select {
-	case <-checkDone:
-	case <-time.After(2 * time.Second):
-		t.Fatal("triggered check did not happen")
-	}
-
-	finalCount := checkCount.Load()
-	if finalCount <= initialCount {
-		t.Fatalf("TriggerImmediateCheck did not cause additional check: initial=%d, final=%d", initialCount, finalCount)
-	}
-}
@@ -369,6 +369,25 @@ func (t *winTray) addSeparatorMenuItem(menuItemId, parentId uint32) error {
 	return nil
 }

+// func (t *winTray) hideMenuItem(menuItemId, parentId uint32) error {
+// 	const ERROR_SUCCESS syscall.Errno = 0
+
+// 	t.muMenus.RLock()
+// 	menu := uintptr(t.menus[parentId])
+// 	t.muMenus.RUnlock()
+// 	res, _, err := pRemoveMenu.Call(
+// 		menu,
+// 		uintptr(menuItemId),
+// 		MF_BYCOMMAND,
+// 	)
+// 	if res == 0 && err.(syscall.Errno) != ERROR_SUCCESS {
+// 		return err
+// 	}
+// 	t.delFromVisibleItems(parentId, menuItemId)
+
+// 	return nil
+// }
+
 func (t *winTray) showMenu() error {
 	p := point{}
 	boolRet, _, err := pGetCursorPos.Call(uintptr(unsafe.Pointer(&p)))
@@ -51,6 +51,7 @@ const (
 	IMAGE_ICON          = 1          // Loads an icon
 	LR_DEFAULTSIZE      = 0x00000040 // Loads default-size icon for windows(SM_CXICON x SM_CYICON) if cx, cy are set to zero
 	LR_LOADFROMFILE     = 0x00000010 // Loads the stand-alone image from the file
+	MF_BYCOMMAND        = 0x00000000
 	MFS_DISABLED        = 0x00000003
 	MFT_SEPARATOR       = 0x00000800
 	MFT_STRING          = 0x00000000
@@ -1,13 +0,0 @@
-//go:build !windows
-
-package cmd
-
-import "syscall"
-
-// backgroundServerSysProcAttr returns SysProcAttr for running the server in the background on Unix.
-// Setpgid prevents the server from being killed when the parent process exits.
-func backgroundServerSysProcAttr() *syscall.SysProcAttr {
-	return &syscall.SysProcAttr{
-		Setpgid: true,
-	}
-}
@@ -1,12 +0,0 @@
-package cmd
-
-import "syscall"
-
-// backgroundServerSysProcAttr returns SysProcAttr for running the server in the background on Windows.
-// CREATE_NO_WINDOW (0x08000000) prevents a console window from appearing.
-func backgroundServerSysProcAttr() *syscall.SysProcAttr {
-	return &syscall.SysProcAttr{
-		CreationFlags: 0x08000000,
-		HideWindow:    true,
-	}
-}
@@ -1,31 +1,27 @@
 Ollama Benchmark Tool
 ---------------------

-A Go-based command-line tool for benchmarking Ollama models with configurable parameters, warmup phases, TTFT tracking, VRAM monitoring, and benchstat/CSV output.
+A Go-based command-line tool for benchmarking Ollama models with configurable parameters and multiple output formats.

 ## Features

 * Benchmark multiple models in a single run
 * Support for both text and image prompts
 * Configurable generation parameters (temperature, max tokens, seed, etc.)
- * Warmup phase before timed epochs to stabilize measurements
- * Time-to-first-token (TTFT) tracking per epoch
- * Model metadata display (parameter size, quantization level, family)
- * VRAM and CPU memory usage tracking via running process info
- * Controlled prompt token length for reproducible benchmarks
- * Benchstat and CSV output formats
+ * Supports benchstat and CSV output formats
+ * Detailed performance metrics (prefill, generate, load, total durations)

 ## Building from Source

 ```
-go build -o ollama-bench ./cmd/bench
-./ollama-bench -model gemma3 -epochs 6 -format csv
+go build -o ollama-bench bench.go
+./ollama-bench -model gpt-oss:20b -epochs 6 -format csv
 ```

 Using Go Run (without building)

 ```
-go run ./cmd/bench -model gemma3 -epochs 3
+go run bench.go -model gpt-oss:20b -epochs 3
 ```

 ## Usage
@@ -49,16 +45,10 @@ benchstat -col /name gemma.bench
 ./ollama-bench -model qwen3-vl -image photo.jpg -epochs 6 -max-tokens 100 -p "Describe this image"
 ```

-### Controlled Prompt Length
-
-```
-./ollama-bench -model gemma3 -epochs 6 -prompt-tokens 512
-```
-
 ### Advanced Example

 ```
-./ollama-bench -model llama3 -epochs 10 -temperature 0.7 -max-tokens 500 -seed 42 -warmup 2 -format csv -output results.csv
+./ollama-bench -model llama3 -epochs 10 -temperature 0.7 -max-tokens 500 -seed 42 -format csv -output results.csv
 ```

 ## Command Line Options
@@ -66,48 +56,41 @@ benchstat -col /name gemma.bench
 | Option  	| Description | Default |
 |----------|-------------|---------|
 | -model	| Comma-separated list of models to benchmark	| (required)		|
-| -epochs	| Number of iterations per model		| 6			|
-| -max-tokens	| Maximum tokens for model response		| 200			|
+| -epochs	| Number of iterations per model		| 1			|
+| -max-tokens	| Maximum tokens for model response		| 0 (unlimited)		|
 | -temperature	| Temperature parameter				| 0.0			|
 | -seed		| Random seed					| 0 (random)		|
 | -timeout	| Timeout in seconds				| 300			|
-| -p		| Prompt text					| (default story prompt)	|
+| -p		| Prompt text					| "Write a long story."	|
 | -image	| Image file to include in prompt		| 			|
 | -k		| Keep-alive duration in seconds		| 0			|
 | -format	| Output format (benchstat, csv)		| benchstat		|
 | -output	| Output file for results			| "" (stdout)		|
-| -warmup	| Number of warmup requests before timing	| 1			|
-| -prompt-tokens	| Generate prompt targeting ~N tokens (0 = use -p)	| 0		|
 | -v		| Verbose mode					| false			|
 | -debug	| Show debug information			| false			|

 ## Output Formats

-### Benchstat Format (default)
-
-Compatible with Go's benchstat tool for statistical analysis. Uses one value/unit pair per line, standard `ns/op` for timing metrics, and `ns/token` for throughput. Each epoch produces one set of lines -- benchstat aggregates across repeated runs to compute statistics.
+### Markdown Format

+The default markdown format is suitable for copying and pasting into a GitHub issue and will look like:
 ```
-# Model: gemma3 | Params: 4.3B | Quant: Q4_K_M | Family: gemma3 | Size: 4080218931 | VRAM: 4080218931
-BenchmarkModel/name=gemma3/step=prefill 1 78125.00 ns/token 12800.00 token/sec
-BenchmarkModel/name=gemma3/step=generate 1 19531.25 ns/token 51200.00 token/sec
-BenchmarkModel/name=gemma3/step=ttft 1 45123000 ns/op
-BenchmarkModel/name=gemma3/step=load 1 1500000000 ns/op
-BenchmarkModel/name=gemma3/step=total 1 2861047625 ns/op
+ Model | Step | Count | Duration | nsPerToken | tokensPerSec |
+|-------|------|-------|----------|------------|--------------|
+| gpt-oss:20b | prefill | 124 | 30.006458ms | 241987.56 | 4132.44 |
+| gpt-oss:20b | generate | 200 | 2.646843954s | 13234219.77 | 75.56 |
+| gpt-oss:20b | load | 1 | 121.674208ms | - | - |
+| gpt-oss:20b | total | 1 | 2.861047625s | - | - |
 ```

-Use with benchstat:
-```
-./ollama-bench -model gemma3 -epochs 6 > gemma3.bench
-benchstat -col /step gemma3.bench
-```
+### Benchstat Format
+
+Compatible with Go's benchstat tool for statistical analysis:

-Compare two runs:
 ```
-./ollama-bench -model gemma3 -epochs 6 > before.bench
-# ... make changes ...
-./ollama-bench -model gemma3 -epochs 6 > after.bench
-benchstat before.bench after.bench
+BenchmarkModel/name=gpt-oss:20b/step=prefill 128 78125.00 ns/token 12800.00 token/sec
+BenchmarkModel/name=gpt-oss:20b/step=generate 512 19531.25 ns/token 51200.00 token/sec
+BenchmarkModel/name=gpt-oss:20b/step=load 1 1500000000 ns/request
 ```

 ### CSV Format
@@ -116,28 +99,17 @@ Machine-readable comma-separated values:

 ```
 NAME,STEP,COUNT,NS_PER_COUNT,TOKEN_PER_SEC
-# Model: gemma3 | Params: 4.3B | Quant: Q4_K_M | Family: gemma3 | Size: 4080218931 | VRAM: 4080218931
-gemma3,prefill,128,78125.00,12800.00
-gemma3,generate,512,19531.25,51200.00
-gemma3,ttft,1,45123000,0
-gemma3,load,1,1500000000,0
-gemma3,total,1,2861047625,0
+gpt-oss:20b,prefill,128,78125.00,12800.00
+gpt-oss:20b,generate,512,19531.25,51200.00
+gpt-oss:20b,load,1,1500000000,0
 ```

 ## Metrics Explained

-The tool reports the following metrics for each epoch:
+The tool reports four types of metrics for each model:

- * **prefill**: Time spent processing the prompt (ns/token)
- * **generate**: Time spent generating the response (ns/token)
- * **ttft**: Time to first token -- latency from request start to first response content
- * **load**: Model loading time (one-time cost)
- * **total**: Total request duration
+ * prefill: Time spent processing the prompt
+ * generate: Time spent generating the response
+ * load: Model loading time (one-time cost)
+ * total: Total request duration

-Additionally, the model info comment line (displayed once per model before epochs) includes:
-
- * **Params**: Model parameter count (e.g., 4.3B)
- * **Quant**: Quantization level (e.g., Q4_K_M)
- * **Family**: Model family (e.g., gemma3)
- * **Size**: Total model memory in bytes
- * **VRAM**: GPU memory used by the loaded model (when Size > VRAM, the difference is CPU spill)
@@ -17,22 +17,19 @@ import (
 )

 type flagOptions struct {
-	models       *string
-	epochs       *int
-	maxTokens    *int
-	temperature  *float64
-	seed         *int
-	timeout      *int
-	prompt       *string
-	imageFile    *string
-	keepAlive    *float64
-	format       *string
-	outputFile   *string
-	debug        *bool
-	verbose      *bool
-	warmup       *int
-	promptTokens *int
-	numCtx       *int
+	models      *string
+	epochs      *int
+	maxTokens   *int
+	temperature *float64
+	seed        *int
+	timeout     *int
+	prompt      *string
+	imageFile   *string
+	keepAlive   *float64
+	format      *string
+	outputFile  *string
+	debug       *bool
+	verbose     *bool
 }

 type Metrics struct {
@@ -42,203 +39,48 @@ type Metrics struct {
 	Duration time.Duration
 }

-type ModelInfo struct {
-	Name              string
-	ParameterSize     string
-	QuantizationLevel string
-	Family            string
-	SizeBytes         int64
-	VRAMBytes         int64
-	NumCtx            int64
-}
+var once sync.Once

 const DefaultPrompt = `Please write a descriptive story about a llama named Alonso who grows up to be President of the Land of Llamas. Include details about Alonso's childhood, adolescent years, and how he grew up to be a political mover and shaker. Write the story with a sense of whimsy.`

-// Word list for generating prompts targeting a specific token count.
-var promptWordList = []string{
-	"the", "quick", "brown", "fox", "jumps", "over", "lazy", "dog",
-	"a", "bright", "sunny", "day", "in", "the", "meadow", "where",
-	"flowers", "bloom", "and", "birds", "sing", "their", "morning",
-	"songs", "while", "gentle", "breeze", "carries", "sweet", "scent",
-	"of", "pine", "trees", "across", "rolling", "hills", "toward",
-	"distant", "mountains", "covered", "with", "fresh", "snow",
-	"beneath", "clear", "blue", "sky", "children", "play", "near",
-	"old", "stone", "bridge", "that", "crosses", "winding", "river",
-}
-
-// tokensPerWord is the calibrated ratio of tokens to words for the current model.
-// Initialized with a heuristic, then updated during warmup based on actual tokenization.
-var tokensPerWord = 1.3
-
-func generatePromptForTokenCount(targetTokens int, epoch int) string {
-	targetWords := int(float64(targetTokens) / tokensPerWord)
-	if targetWords < 1 {
-		targetWords = 1
-	}
-
-	// Vary the starting offset by epoch to defeat KV cache prefix matching
-	offset := epoch * 7 // stride by a prime to get good distribution
-	n := len(promptWordList)
-	words := make([]string, targetWords)
-	for i := range words {
-		words[i] = promptWordList[((i+offset)%n+n)%n]
-	}
-	return strings.Join(words, " ")
-}
-
-// calibratePromptTokens adjusts tokensPerWord based on actual tokenization from a warmup run.
-func calibratePromptTokens(targetTokens, actualTokens, wordCount int) {
-	if actualTokens <= 0 || wordCount <= 0 {
-		return
-	}
-	tokensPerWord = float64(actualTokens) / float64(wordCount)
-	newWords := int(float64(targetTokens) / tokensPerWord)
-	fmt.Fprintf(os.Stderr, "bench: calibrated %.2f tokens/word (target=%d, got=%d, words=%d → %d)\n",
-		tokensPerWord, targetTokens, actualTokens, wordCount, newWords)
-}
-
-func buildGenerateRequest(model string, fOpt flagOptions, imgData api.ImageData, epoch int) *api.GenerateRequest {
-	options := make(map[string]interface{})
-	if *fOpt.maxTokens > 0 {
-		options["num_predict"] = *fOpt.maxTokens
-	}
-	options["temperature"] = *fOpt.temperature
-	if fOpt.seed != nil && *fOpt.seed > 0 {
-		options["seed"] = *fOpt.seed
-	}
-	if fOpt.numCtx != nil && *fOpt.numCtx > 0 {
-		options["num_ctx"] = *fOpt.numCtx
-	}
-
-	var keepAliveDuration *api.Duration
-	if *fOpt.keepAlive > 0 {
-		duration := api.Duration{Duration: time.Duration(*fOpt.keepAlive * float64(time.Second))}
-		keepAliveDuration = &duration
-	}
-
-	prompt := *fOpt.prompt
-	if *fOpt.promptTokens > 0 {
-		prompt = generatePromptForTokenCount(*fOpt.promptTokens, epoch)
-	} else {
-		// Vary the prompt per epoch to defeat KV cache prefix matching
-		prompt = fmt.Sprintf("[%d] %s", epoch, prompt)
-	}
-
-	req := &api.GenerateRequest{
-		Model:     model,
-		Prompt:    prompt,
-		Raw:       true,
-		Options:   options,
-		KeepAlive: keepAliveDuration,
-	}
-
-	if imgData != nil {
-		req.Images = []api.ImageData{imgData}
-	}
-
-	return req
-}
-
-func fetchModelInfo(ctx context.Context, client *api.Client, model string) ModelInfo {
-	info := ModelInfo{Name: model}
-	resp, err := client.Show(ctx, &api.ShowRequest{Model: model})
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "WARNING: Could not fetch model info for '%s': %v\n", model, err)
-		return info
-	}
-	info.ParameterSize = resp.Details.ParameterSize
-	info.QuantizationLevel = resp.Details.QuantizationLevel
-	info.Family = resp.Details.Family
-	return info
-}
-
-func fetchMemoryUsage(ctx context.Context, client *api.Client, model string) (size, vram int64) {
-	resp, err := client.ListRunning(ctx)
-	if err != nil {
-		if debug := os.Getenv("OLLAMA_DEBUG"); debug != "" {
-			fmt.Fprintf(os.Stderr, "WARNING: Could not fetch memory usage: %v\n", err)
-		}
-		return 0, 0
-	}
-	for _, m := range resp.Models {
-		if m.Name == model || m.Model == model {
-			return m.Size, m.SizeVRAM
-		}
-	}
-	for _, m := range resp.Models {
-		if strings.HasPrefix(m.Name, model) || strings.HasPrefix(m.Model, model) {
-			return m.Size, m.SizeVRAM
-		}
-	}
-	return 0, 0
-}
-
-func fetchContextLength(ctx context.Context, client *api.Client, model string) int64 {
-	resp, err := client.ListRunning(ctx)
-	if err != nil {
-		return 0
-	}
-	for _, m := range resp.Models {
-		if m.Name == model || m.Model == model || strings.HasPrefix(m.Name, model) || strings.HasPrefix(m.Model, model) {
-			return int64(m.ContextLength)
-		}
-	}
-	return 0
-}
-
-func outputFormatHeader(w io.Writer, format string, verbose bool) {
-	switch format {
-	case "benchstat":
-		if verbose {
-			fmt.Fprintf(w, "goos: %s\n", runtime.GOOS)
-			fmt.Fprintf(w, "goarch: %s\n", runtime.GOARCH)
-		}
-	case "csv":
-		headings := []string{"NAME", "STEP", "COUNT", "NS_PER_COUNT", "TOKEN_PER_SEC"}
-		fmt.Fprintln(w, strings.Join(headings, ","))
-	}
-}
-
-func outputModelInfo(w io.Writer, format string, info ModelInfo) {
-	params := cmp.Or(info.ParameterSize, "unknown")
-	quant := cmp.Or(info.QuantizationLevel, "unknown")
-	family := cmp.Or(info.Family, "unknown")
-
-	memStr := ""
-	if info.SizeBytes > 0 {
-		memStr = fmt.Sprintf(" | Size: %d | VRAM: %d", info.SizeBytes, info.VRAMBytes)
-	}
-	ctxStr := ""
-	if info.NumCtx > 0 {
-		ctxStr = fmt.Sprintf(" | NumCtx: %d", info.NumCtx)
-	}
-	fmt.Fprintf(w, "# Model: %s | Params: %s | Quant: %s | Family: %s%s%s\n",
-		info.Name, params, quant, family, memStr, ctxStr)
-}
-
 func OutputMetrics(w io.Writer, format string, metrics []Metrics, verbose bool) {
 	switch format {
 	case "benchstat":
+		if verbose {
+			printHeader := func() {
+				fmt.Fprintf(w, "sysname: %s\n", runtime.GOOS)
+				fmt.Fprintf(w, "machine: %s\n", runtime.GOARCH)
+			}
+			once.Do(printHeader)
+		}
 		for _, m := range metrics {
 			if m.Step == "generate" || m.Step == "prefill" {
 				if m.Count > 0 {
 					nsPerToken := float64(m.Duration.Nanoseconds()) / float64(m.Count)
 					tokensPerSec := float64(m.Count) / (float64(m.Duration.Nanoseconds()) + 1e-12) * 1e9
-					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s 1 %.2f ns/token %.2f token/sec\n",
-						m.Model, m.Step, nsPerToken, tokensPerSec)
+
+					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s %d %.2f ns/token %.2f token/sec\n",
+						m.Model, m.Step, m.Count, nsPerToken, tokensPerSec)
 				} else {
-					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s 1 0 ns/token 0 token/sec\n",
-						m.Model, m.Step)
+					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s %d 0 ns/token 0 token/sec\n",
+						m.Model, m.Step, m.Count)
 				}
-			} else if m.Step == "ttft" {
-				fmt.Fprintf(w, "BenchmarkModel/name=%s/step=ttft 1 %d ns/op\n",
-					m.Model, m.Duration.Nanoseconds())
 			} else {
-				fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s 1 %d ns/op\n",
-					m.Model, m.Step, m.Duration.Nanoseconds())
+				var suffix string
+				if m.Step == "load" {
+					suffix = "/step=load"
+				}
+				fmt.Fprintf(w, "BenchmarkModel/name=%s%s 1 %d ns/request\n",
+					m.Model, suffix, m.Duration.Nanoseconds())
 			}
 		}
 	case "csv":
+		printHeader := func() {
+			headings := []string{"NAME", "STEP", "COUNT", "NS_PER_COUNT", "TOKEN_PER_SEC"}
+			fmt.Fprintln(w, strings.Join(headings, ","))
+		}
+		once.Do(printHeader)
+
 		for _, m := range metrics {
 			if m.Step == "generate" || m.Step == "prefill" {
 				var nsPerToken float64
@@ -252,14 +94,39 @@ func OutputMetrics(w io.Writer, format string, metrics []Metrics, verbose bool)
 				fmt.Fprintf(w, "%s,%s,1,%d,0\n", m.Model, m.Step, m.Duration.Nanoseconds())
 			}
 		}
+	case "markdown":
+		printHeader := func() {
+			fmt.Fprintln(w, "| Model | Step | Count | Duration | nsPerToken | tokensPerSec |")
+			fmt.Fprintln(w, "|-------|------|-------|----------|------------|--------------|")
+		}
+		once.Do(printHeader)
+
+		for _, m := range metrics {
+			var nsPerToken, tokensPerSec float64
+			var nsPerTokenStr, tokensPerSecStr string
+
+			if m.Step == "generate" || m.Step == "prefill" {
+				nsPerToken = float64(m.Duration.Nanoseconds()) / float64(m.Count)
+				tokensPerSec = float64(m.Count) / (float64(m.Duration.Nanoseconds()) + 1e-12) * 1e9
+				nsPerTokenStr = fmt.Sprintf("%.2f", nsPerToken)
+				tokensPerSecStr = fmt.Sprintf("%.2f", tokensPerSec)
+			} else {
+				nsPerTokenStr = "-"
+				tokensPerSecStr = "-"
+			}
+
+			fmt.Fprintf(w, "| %s | %s | %d | %v | %s | %s |\n",
+				m.Model, m.Step, m.Count, m.Duration, nsPerTokenStr, tokensPerSecStr)
+		}
 	default:
 		fmt.Fprintf(os.Stderr, "Unknown output format '%s'\n", format)
 	}
 }

-func BenchmarkModel(fOpt flagOptions) error {
+func BenchmarkChat(fOpt flagOptions) error {
 	models := strings.Split(*fOpt.models, ",")

+	// todo - add multi-image support
 	var imgData api.ImageData
 	var err error
 	if *fOpt.imageFile != "" {
@@ -291,141 +158,71 @@ func BenchmarkModel(fOpt flagOptions) error {
 		out = f
 	}

-	outputFormatHeader(out, *fOpt.format, *fOpt.verbose)
-
-	// Log prompt-tokens info in debug mode
-	if *fOpt.debug && *fOpt.promptTokens > 0 {
-		prompt := generatePromptForTokenCount(*fOpt.promptTokens, 0)
-		wordCount := len(strings.Fields(prompt))
-		fmt.Fprintf(os.Stderr, "Generated prompt targeting ~%d tokens (%d words, varied per epoch)\n", *fOpt.promptTokens, wordCount)
-	}
-
 	for _, model := range models {
-		// Fetch model info
-		infoCtx, infoCancel := context.WithTimeout(context.Background(), 10*time.Second)
-		info := fetchModelInfo(infoCtx, client, model)
-		infoCancel()
+		for range *fOpt.epochs {
+			options := make(map[string]interface{})
+			if *fOpt.maxTokens > 0 {
+				options["num_predict"] = *fOpt.maxTokens
+			}
+			options["temperature"] = *fOpt.temperature
+			if fOpt.seed != nil && *fOpt.seed > 0 {
+				options["seed"] = *fOpt.seed
+			}
+
+			var keepAliveDuration *api.Duration
+			if *fOpt.keepAlive > 0 {
+				duration := api.Duration{Duration: time.Duration(*fOpt.keepAlive * float64(time.Second))}
+				keepAliveDuration = &duration
+			}
+
+			req := &api.ChatRequest{
+				Model: model,
+				Messages: []api.Message{
+					{
+						Role:    "user",
+						Content: *fOpt.prompt,
+					},
+				},
+				Options:   options,
+				KeepAlive: keepAliveDuration,
+			}
+
+			if imgData != nil {
+				req.Messages[0].Images = []api.ImageData{imgData}
+			}
+
+			var responseMetrics *api.Metrics

-		// Warmup phase (uses negative epoch numbers to avoid colliding with timed epochs)
-		for i := range *fOpt.warmup {
-			req := buildGenerateRequest(model, fOpt, imgData, -(i + 1))
 			ctx, cancel := context.WithTimeout(context.Background(), time.Duration(*fOpt.timeout)*time.Second)
+			defer cancel()
+
+			err = client.Chat(ctx, req, func(resp api.ChatResponse) error {
+				if *fOpt.debug {
+					fmt.Fprintf(os.Stderr, "%s", cmp.Or(resp.Message.Thinking, resp.Message.Content))
+				}

-			var warmupMetrics *api.Metrics
-			err = client.Generate(ctx, req, func(resp api.GenerateResponse) error {
 				if resp.Done {
-					warmupMetrics = &resp.Metrics
+					responseMetrics = &resp.Metrics
 				}
 				return nil
 			})
-			cancel()
+
+			if *fOpt.debug {
+				fmt.Fprintln(os.Stderr)
+			}

 			if err != nil {
-				fmt.Fprintf(os.Stderr, "WARNING: Warmup %d/%d for %s failed: %v\n", i+1, *fOpt.warmup, model, err)
-			} else {
-				if *fOpt.debug {
-					fmt.Fprintf(os.Stderr, "Warmup %d/%d for %s complete\n", i+1, *fOpt.warmup, model)
+				if ctx.Err() == context.DeadlineExceeded {
+					fmt.Fprintf(os.Stderr, "ERROR: Chat request timed out with model '%s' after %vs\n", model, 1)
+					continue
 				}
-				// Calibrate prompt token count on last warmup run
-				if i == *fOpt.warmup-1 && *fOpt.promptTokens > 0 && warmupMetrics != nil {
-					prompt := generatePromptForTokenCount(*fOpt.promptTokens, -(i + 1))
-					wordCount := len(strings.Fields(prompt))
-					calibratePromptTokens(*fOpt.promptTokens, warmupMetrics.PromptEvalCount, wordCount)
-				}
-			}
-		}
-
-		// Fetch memory/context info once after warmup (model is loaded and stable)
-		memCtx, memCancel := context.WithTimeout(context.Background(), 5*time.Second)
-		info.SizeBytes, info.VRAMBytes = fetchMemoryUsage(memCtx, client, model)
-		if fOpt.numCtx != nil && *fOpt.numCtx > 0 {
-			info.NumCtx = int64(*fOpt.numCtx)
-		} else {
-			info.NumCtx = fetchContextLength(memCtx, client, model)
-		}
-		memCancel()
-
-		outputModelInfo(out, *fOpt.format, info)
-
-		// Timed epoch loop
-		shortCount := 0
-		for epoch := range *fOpt.epochs {
-			var responseMetrics *api.Metrics
-			var ttft time.Duration
-			short := false
-
-			// Retry loop: if the model hits a stop token before max-tokens,
-			// retry with a different prompt (up to maxRetries times).
-			const maxRetries = 3
-			for attempt := range maxRetries + 1 {
-				responseMetrics = nil
-				ttft = 0
-				var ttftOnce sync.Once
-
-				req := buildGenerateRequest(model, fOpt, imgData, epoch+attempt*1000)
-				requestStart := time.Now()
-
-				ctx, cancel := context.WithTimeout(context.Background(), time.Duration(*fOpt.timeout)*time.Second)
-
-				err = client.Generate(ctx, req, func(resp api.GenerateResponse) error {
-					if *fOpt.debug {
-						fmt.Fprintf(os.Stderr, "%s", cmp.Or(resp.Thinking, resp.Response))
-					}
-
-					// Capture TTFT on first content
-					ttftOnce.Do(func() {
-						if resp.Response != "" || resp.Thinking != "" {
-							ttft = time.Since(requestStart)
-						}
-					})
-
-					if resp.Done {
-						responseMetrics = &resp.Metrics
-					}
-					return nil
-				})
-				cancel()
-
-				if *fOpt.debug {
-					fmt.Fprintln(os.Stderr)
-				}
-
-				if err != nil {
-					if ctx.Err() == context.DeadlineExceeded {
-						fmt.Fprintf(os.Stderr, "ERROR: Request timed out with model '%s' after %vs\n", model, *fOpt.timeout)
-					} else {
-						fmt.Fprintf(os.Stderr, "ERROR: Couldn't generate with model '%s': %v\n", model, err)
-					}
-					break
-				}
-
-				if responseMetrics == nil {
-					fmt.Fprintf(os.Stderr, "ERROR: No metrics received for model '%s'\n", model)
-					break
-				}
-
-				// Check if the response was shorter than requested
-				short = *fOpt.maxTokens > 0 && responseMetrics.EvalCount < *fOpt.maxTokens
-				if !short || attempt == maxRetries {
-					break
-				}
-
-				if *fOpt.debug {
-					fmt.Fprintf(os.Stderr, "Short response (%d/%d tokens), retrying with different prompt (attempt %d/%d)\n",
-						responseMetrics.EvalCount, *fOpt.maxTokens, attempt+1, maxRetries)
-				}
-			}
-
-			if err != nil || responseMetrics == nil {
+				fmt.Fprintf(os.Stderr, "ERROR: Couldn't chat with model '%s': %v\n", model, err)
 				continue
 			}

-			if short {
-				shortCount++
-				if *fOpt.debug {
-					fmt.Fprintf(os.Stderr, "WARNING: Short response (%d/%d tokens) after %d retries for epoch %d\n",
-						responseMetrics.EvalCount, *fOpt.maxTokens, maxRetries, epoch+1)
-				}
+			if responseMetrics == nil {
+				fmt.Fprintf(os.Stderr, "ERROR: No metrics received for model '%s'\n", model)
+				continue
 			}

 			metrics := []Metrics{
@@ -441,12 +238,6 @@ func BenchmarkModel(fOpt flagOptions) error {
 					Count:    responseMetrics.EvalCount,
 					Duration: responseMetrics.EvalDuration,
 				},
-				{
-					Model:    model,
-					Step:     "ttft",
-					Count:    1,
-					Duration: ttft,
-				},
 				{
 					Model:    model,
 					Step:     "load",
@@ -463,42 +254,15 @@ func BenchmarkModel(fOpt flagOptions) error {

 			OutputMetrics(out, *fOpt.format, metrics, *fOpt.verbose)

-			if *fOpt.debug && *fOpt.promptTokens > 0 {
-				fmt.Fprintf(os.Stderr, "Generated prompt targeting ~%d tokens (actual: %d)\n",
-					*fOpt.promptTokens, responseMetrics.PromptEvalCount)
-			}
-
 			if *fOpt.keepAlive > 0 {
 				time.Sleep(time.Duration(*fOpt.keepAlive*float64(time.Second)) + 200*time.Millisecond)
 			}
 		}
-
-		if shortCount > 0 {
-			fmt.Fprintf(os.Stderr, "WARNING: %d/%d epochs for '%s' had short responses (<%d tokens). Generation metrics may be unreliable.\n",
-				shortCount, *fOpt.epochs, model, *fOpt.maxTokens)
-		}
-
-		// Unload model before moving to the next one
-		unloadModel(client, model, *fOpt.timeout)
 	}

 	return nil
 }

-func unloadModel(client *api.Client, model string, timeout int) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	zero := api.Duration{Duration: 0}
-	req := &api.GenerateRequest{
-		Model:     model,
-		KeepAlive: &zero,
-	}
-	_ = client.Generate(ctx, req, func(resp api.GenerateResponse) error {
-		return nil
-	})
-}
-
 func readImage(filePath string) (api.ImageData, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -516,22 +280,19 @@ func readImage(filePath string) (api.ImageData, error) {

 func main() {
 	fOpt := flagOptions{
-		models:       flag.String("model", "", "Model to benchmark"),
-		epochs:       flag.Int("epochs", 6, "Number of epochs (iterations) per model"),
-		maxTokens:    flag.Int("max-tokens", 200, "Maximum tokens for model response"),
-		temperature:  flag.Float64("temperature", 0, "Temperature parameter"),
-		seed:         flag.Int("seed", 0, "Random seed"),
-		timeout:      flag.Int("timeout", 60*5, "Timeout in seconds (default 300s)"),
-		prompt:       flag.String("p", DefaultPrompt, "Prompt to use"),
-		imageFile:    flag.String("image", "", "Filename for an image to include"),
-		keepAlive:    flag.Float64("k", 0, "Keep alive duration in seconds"),
-		format:       flag.String("format", "benchstat", "Output format [benchstat|csv]"),
-		outputFile:   flag.String("output", "", "Output file for results (stdout if empty)"),
-		verbose:      flag.Bool("v", false, "Show system information"),
-		debug:        flag.Bool("debug", false, "Show debug information"),
-		warmup:       flag.Int("warmup", 1, "Number of warmup requests before timing"),
-		promptTokens: flag.Int("prompt-tokens", 0, "Generate prompt targeting ~N tokens (0 = use -p prompt)"),
-		numCtx:       flag.Int("num-ctx", 0, "Context size (0 = server default)"),
+		models:      flag.String("model", "", "Model to benchmark"),
+		epochs:      flag.Int("epochs", 6, "Number of epochs (iterations) per model"),
+		maxTokens:   flag.Int("max-tokens", 200, "Maximum tokens for model response"),
+		temperature: flag.Float64("temperature", 0, "Temperature parameter"),
+		seed:        flag.Int("seed", 0, "Random seed"),
+		timeout:     flag.Int("timeout", 60*5, "Timeout in seconds (default 300s)"),
+		prompt:      flag.String("p", DefaultPrompt, "Prompt to use"),
+		imageFile:   flag.String("image", "", "Filename for an image to include"),
+		keepAlive:   flag.Float64("k", 0, "Keep alive duration in seconds"),
+		format:      flag.String("format", "markdown", "Output format [benchstat|csv] (default benchstat)"),
+		outputFile:  flag.String("output", "", "Output file for results (stdout if empty)"),
+		verbose:     flag.Bool("v", false, "Show system information"),
+		debug:       flag.Bool("debug", false, "Show debug information"),
 	}

 	flag.Usage = func() {
@@ -541,12 +302,11 @@ func main() {
 		fmt.Fprintf(os.Stderr, "Options:\n")
 		flag.PrintDefaults()
 		fmt.Fprintf(os.Stderr, "\nExamples:\n")
-		fmt.Fprintf(os.Stderr, "  bench -model gemma3,llama3 -epochs 6\n")
-		fmt.Fprintf(os.Stderr, "  bench -model gemma3 -epochs 6 -prompt-tokens 512 -format csv\n")
+		fmt.Fprintf(os.Stderr, "  bench -model gpt-oss:20b -epochs 3 -temperature 0.7\n")
 	}
 	flag.Parse()

-	if !slices.Contains([]string{"benchstat", "csv"}, *fOpt.format) {
+	if !slices.Contains([]string{"markdown", "benchstat", "csv"}, *fOpt.format) {
 		fmt.Fprintf(os.Stderr, "ERROR: Unknown format '%s'\n", *fOpt.format)
 		os.Exit(1)
 	}
@@ -557,5 +317,5 @@ func main() {
 		return
 	}

-	BenchmarkModel(fOpt)
+	BenchmarkChat(fOpt)
 }
@@ -11,12 +11,10 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"log/slog"
 	"math"
 	"net"
 	"net/http"
 	"os"
-	"os/exec"
 	"os/signal"
 	"path/filepath"
 	"runtime"
@@ -39,12 +37,8 @@ import (

 	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/cmd/config"
-	"github.com/ollama/ollama/cmd/launch"
-	"github.com/ollama/ollama/cmd/tui"
 	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/format"
-	"github.com/ollama/ollama/internal/modelref"
-	"github.com/ollama/ollama/logutil"
 	"github.com/ollama/ollama/parser"
 	"github.com/ollama/ollama/progress"
 	"github.com/ollama/ollama/readline"
@@ -54,47 +48,11 @@ import (
 	"github.com/ollama/ollama/types/syncmap"
 	"github.com/ollama/ollama/version"
 	xcmd "github.com/ollama/ollama/x/cmd"
+	"github.com/ollama/ollama/x/create"
 	xcreateclient "github.com/ollama/ollama/x/create/client"
 	"github.com/ollama/ollama/x/imagegen"
 )

-func init() {
-	// Override default selectors to use Bubbletea TUI instead of raw terminal I/O.
-	launch.DefaultSingleSelector = func(title string, items []launch.ModelItem, current string) (string, error) {
-		if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
-			return "", fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
-		}
-		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-		result, err := tui.SelectSingle(title, tuiItems, current)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", launch.ErrCancelled
-		}
-		return result, err
-	}
-
-	launch.DefaultMultiSelector = func(title string, items []launch.ModelItem, preChecked []string) ([]string, error) {
-		if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
-			return nil, fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
-		}
-		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
-		if errors.Is(err, tui.ErrCancelled) {
-			return nil, launch.ErrCancelled
-		}
-		return result, err
-	}
-
-	launch.DefaultSignIn = func(modelName, signInURL string) (string, error) {
-		userName, err := tui.RunSignIn(modelName, signInURL)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", launch.ErrCancelled
-		}
-		return userName, err
-	}
-
-	launch.DefaultConfirmPrompt = tui.RunConfirmWithOptions
-}
-
 const ConnectInstructions = "If your browser did not open, navigate to:\n    %s\n\n"

 // ensureThinkingSupport emits a warning if the model does not advertise thinking support
@@ -134,17 +92,6 @@ func getModelfileName(cmd *cobra.Command) (string, error) {
 	return absName, nil
 }

-// isLocalhost returns true if the configured Ollama host is a loopback or unspecified address.
-func isLocalhost() bool {
-	host := envconfig.Host()
-	h, _, _ := net.SplitHostPort(host.Host)
-	if h == "localhost" {
-		return true
-	}
-	ip := net.ParseIP(h)
-	return ip != nil && (ip.IsLoopback() || ip.IsUnspecified())
-}
-
 func CreateHandler(cmd *cobra.Command, args []string) error {
 	p := progress.NewProgress(os.Stderr)
 	defer p.Stop()
@@ -157,13 +104,8 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 	}

 	// Check for --experimental flag for safetensors model creation
-	// This gates both safetensors LLM and imagegen model creation
 	experimental, _ := cmd.Flags().GetBool("experimental")
 	if experimental {
-		if !isLocalhost() {
-			return errors.New("remote safetensor model creation not yet supported")
-		}
-
 		// Get Modelfile content - either from -f flag or default to "FROM ."
 		var reader io.Reader
 		filename, err := getModelfileName(cmd)
@@ -187,9 +129,25 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 			return fmt.Errorf("failed to parse Modelfile: %w", err)
 		}

-		modelDir, mfConfig, err := xcreateclient.ConfigFromModelfile(modelfile)
-		if err != nil {
-			return err
+		// Extract FROM path and configuration
+		var modelDir string
+		mfConfig := &xcreateclient.ModelfileConfig{}
+
+		for _, cmd := range modelfile.Commands {
+			switch cmd.Name {
+			case "model":
+				modelDir = cmd.Args
+			case "template":
+				mfConfig.Template = cmd.Args
+			case "system":
+				mfConfig.System = cmd.Args
+			case "license":
+				mfConfig.License = cmd.Args
+			}
+		}
+
+		if modelDir == "" {
+			modelDir = "."
 		}

 		// Resolve relative paths based on Modelfile location
@@ -206,12 +164,20 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 		}, p)
 	}

-	// Standard Modelfile + API path
 	var reader io.Reader

 	filename, err := getModelfileName(cmd)
 	if os.IsNotExist(err) {
 		if filename == "" {
+			// No Modelfile found - check if current directory is an image gen model
+			if create.IsTensorModelDir(".") {
+				quantize, _ := cmd.Flags().GetString("quantize")
+				return xcreateclient.CreateModel(xcreateclient.CreateOptions{
+					ModelName: modelName,
+					ModelDir:  ".",
+					Quantize:  quantize,
+				}, p)
+			}
 			reader = strings.NewReader("FROM .\n")
 		} else {
 			return errModelfileNotFound
@@ -397,14 +363,12 @@ func loadOrUnloadModel(cmd *cobra.Command, opts *runOptions) error {
 		return err
 	}

-	requestedCloud := modelref.HasExplicitCloudSource(opts.Model)
-
 	if info, err := client.Show(cmd.Context(), &api.ShowRequest{Model: opts.Model}); err != nil {
 		return err
-	} else if info.RemoteHost != "" || requestedCloud {
+	} else if info.RemoteHost != "" {
 		// Cloud model, no need to load/unload

-		isCloud := requestedCloud || strings.HasPrefix(info.RemoteHost, "https://ollama.com")
+		isCloud := strings.HasPrefix(info.RemoteHost, "https://ollama.com")

 		// Check if user is signed in for ollama.com cloud models
 		if isCloud {
@@ -415,14 +379,10 @@ func loadOrUnloadModel(cmd *cobra.Command, opts *runOptions) error {

 		if opts.ShowConnect {
 			p.StopAndClear()
-			remoteModel := info.RemoteModel
-			if remoteModel == "" {
-				remoteModel = opts.Model
-			}
 			if isCloud {
-				fmt.Fprintf(os.Stderr, "Connecting to '%s' on 'ollama.com' ⚡\n", remoteModel)
+				fmt.Fprintf(os.Stderr, "Connecting to '%s' on 'ollama.com' ⚡\n", info.RemoteModel)
 			} else {
-				fmt.Fprintf(os.Stderr, "Connecting to '%s' on '%s'\n", remoteModel, info.RemoteHost)
+				fmt.Fprintf(os.Stderr, "Connecting to '%s' on '%s'\n", info.RemoteModel, info.RemoteHost)
 			}
 		}

@@ -494,64 +454,6 @@ func generateEmbedding(cmd *cobra.Command, modelName, input string, keepAlive *a
 	return nil
 }

-// TODO(parthsareen): consolidate with TUI signin flow
-func handleCloudAuthorizationError(err error) bool {
-	var authErr api.AuthorizationError
-	if errors.As(err, &authErr) && authErr.StatusCode == http.StatusUnauthorized {
-		fmt.Printf("You need to be signed in to Ollama to run Cloud models.\n\n")
-		if authErr.SigninURL != "" {
-			fmt.Printf(ConnectInstructions, authErr.SigninURL)
-		}
-		return true
-	}
-
-	return false
-}
-
-// TEMP(drifkin): To match legacy `ollama run some-model:cloud` behavior, we
-// best-effort pull cloud stub files for any explicit cloud source models.
-// Remove this once `/api/tags` is cloud-aware.
-func ensureCloudStub(ctx context.Context, client *api.Client, modelName string) {
-	if !modelref.HasExplicitCloudSource(modelName) {
-		return
-	}
-
-	normalizedName, _, err := modelref.NormalizePullName(modelName)
-	if err != nil {
-		slog.Warn("failed to normalize pull name", "model", modelName, "error", err, "normalizedName", normalizedName)
-		return
-	}
-
-	listResp, err := client.List(ctx)
-	if err != nil {
-		slog.Warn("failed to list models", "error", err)
-		return
-	}
-
-	if hasListedModelName(listResp.Models, modelName) || hasListedModelName(listResp.Models, normalizedName) {
-		return
-	}
-
-	logutil.Trace("pulling cloud stub", "model", modelName, "normalizedName", normalizedName)
-	err = client.Pull(ctx, &api.PullRequest{
-		Model: normalizedName,
-	}, func(api.ProgressResponse) error {
-		return nil
-	})
-	if err != nil {
-		slog.Warn("failed to pull cloud stub", "model", modelName, "error", err)
-	}
-}
-
-func hasListedModelName(models []api.ListModelResponse, name string) bool {
-	for _, m := range models {
-		if strings.EqualFold(m.Name, name) || strings.EqualFold(m.Model, name) {
-			return true
-		}
-	}
-	return false
-}
-
 func RunHandler(cmd *cobra.Command, args []string) error {
 	interactive := true

@@ -648,16 +550,12 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 	}

 	name := args[0]
-	requestedCloud := modelref.HasExplicitCloudSource(name)

 	info, err := func() (*api.ShowResponse, error) {
 		showReq := &api.ShowRequest{Name: name}
 		info, err := client.Show(cmd.Context(), showReq)
 		var se api.StatusError
 		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
-			if requestedCloud {
-				return nil, err
-			}
 			if err := PullHandler(cmd, []string{name}); err != nil {
 				return nil, err
 			}
@@ -666,21 +564,15 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		return info, err
 	}()
 	if err != nil {
-		if handleCloudAuthorizationError(err) {
-			return nil
-		}
 		return err
 	}

-	ensureCloudStub(cmd.Context(), client, name)
-
 	opts.Think, err = inferThinkingOption(&info.Capabilities, &opts, thinkFlag.Changed)
 	if err != nil {
 		return err
 	}

-	audioCapable := slices.Contains(info.Capabilities, model.CapabilityAudio)
-	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision) || audioCapable
+	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision)

 	// TODO: remove the projector info and vision info checks below,
 	// these are left in for backwards compatibility with older servers
@@ -695,7 +587,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		}
 	}

-	applyShowResponseToRunOptions(&opts, info)
+	opts.ParentModel = info.Details.ParentModel

 	// Check if this is an embedding model
 	isEmbeddingModel := slices.Contains(info.Capabilities, model.CapabilityEmbedding)
@@ -766,13 +658,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {

 		return generateInteractive(cmd, opts)
 	}
-	if err := generate(cmd, opts); err != nil {
-		if handleCloudAuthorizationError(err) {
-			return nil
-		}
-		return err
-	}
-	return nil
+	return generate(cmd, opts)
 }

 func SigninHandler(cmd *cobra.Command, args []string) error {
@@ -1411,30 +1297,23 @@ func PullHandler(cmd *cobra.Command, args []string) error {
 type generateContextKey string

 type runOptions struct {
-	Model          string
-	ParentModel    string
-	LoadedMessages []api.Message
-	Prompt         string
-	Messages       []api.Message
-	WordWrap       bool
-	Format         string
-	System         string
-	Images         []api.ImageData
-	Options        map[string]any
-	MultiModal     bool
-	KeepAlive      *api.Duration
-	Think          *api.ThinkValue
-	HideThinking   bool
-	ShowConnect    bool
+	Model        string
+	ParentModel  string
+	Prompt       string
+	Messages     []api.Message
+	WordWrap     bool
+	Format       string
+	System       string
+	Images       []api.ImageData
+	Options      map[string]any
+	MultiModal   bool
+	KeepAlive    *api.Duration
+	Think        *api.ThinkValue
+	HideThinking bool
+	ShowConnect  bool
 }

 func (r runOptions) Copy() runOptions {
-	var loadedMessages []api.Message
-	if r.LoadedMessages != nil {
-		loadedMessages = make([]api.Message, len(r.LoadedMessages))
-		copy(loadedMessages, r.LoadedMessages)
-	}
-
 	var messages []api.Message
 	if r.Messages != nil {
 		messages = make([]api.Message, len(r.Messages))
@@ -1462,29 +1341,23 @@ func (r runOptions) Copy() runOptions {
 	}

 	return runOptions{
-		Model:          r.Model,
-		ParentModel:    r.ParentModel,
-		LoadedMessages: loadedMessages,
-		Prompt:         r.Prompt,
-		Messages:       messages,
-		WordWrap:       r.WordWrap,
-		Format:         r.Format,
-		System:         r.System,
-		Images:         images,
-		Options:        opts,
-		MultiModal:     r.MultiModal,
-		KeepAlive:      r.KeepAlive,
-		Think:          think,
-		HideThinking:   r.HideThinking,
-		ShowConnect:    r.ShowConnect,
+		Model:        r.Model,
+		ParentModel:  r.ParentModel,
+		Prompt:       r.Prompt,
+		Messages:     messages,
+		WordWrap:     r.WordWrap,
+		Format:       r.Format,
+		System:       r.System,
+		Images:       images,
+		Options:      opts,
+		MultiModal:   r.MultiModal,
+		KeepAlive:    r.KeepAlive,
+		Think:        think,
+		HideThinking: r.HideThinking,
+		ShowConnect:  r.ShowConnect,
 	}
 }

-func applyShowResponseToRunOptions(opts *runOptions, info *api.ShowResponse) {
-	opts.ParentModel = info.Details.ParentModel
-	opts.LoadedMessages = slices.Clone(info.Messages)
-}
-
 type displayResponseState struct {
 	lineLength int
 	wordBuffer string
@@ -1492,9 +1365,6 @@ type displayResponseState struct {

 func displayResponse(content string, wordWrap bool, state *displayResponseState) {
 	termWidth, _, _ := term.GetSize(int(os.Stdout.Fd()))
-	if termWidth == 0 {
-		termWidth = 80
-	}
 	if wordWrap && termWidth >= 10 {
 		for _, ch := range content {
 			if state.lineLength+1 > termWidth-5 {
@@ -1934,148 +1804,6 @@ Environment Variables:
 	cmd.SetUsageTemplate(cmd.UsageTemplate() + envUsage)
 }

-// ensureServerRunning checks if the ollama server is running and starts it in the background if not.
-func ensureServerRunning(ctx context.Context) error {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return err
-	}
-
-	// Check if server is already running
-	if err := client.Heartbeat(ctx); err == nil {
-		return nil // server is already running
-	}
-
-	// Server not running, start it in the background
-	exe, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf("could not find executable: %w", err)
-	}
-
-	serverCmd := exec.CommandContext(ctx, exe, "serve")
-	serverCmd.Env = os.Environ()
-	serverCmd.SysProcAttr = backgroundServerSysProcAttr()
-	if err := serverCmd.Start(); err != nil {
-		return fmt.Errorf("failed to start server: %w", err)
-	}
-
-	// Wait for the server to be ready
-	for {
-		time.Sleep(500 * time.Millisecond)
-		if err := client.Heartbeat(ctx); err == nil {
-			return nil // server has started
-		}
-	}
-}
-
-func launchInteractiveModel(cmd *cobra.Command, modelName string) error {
-	opts := runOptions{
-		Model:       modelName,
-		WordWrap:    os.Getenv("TERM") == "xterm-256color",
-		Options:     map[string]any{},
-		ShowConnect: true,
-	}
-	// loadOrUnloadModel is cloud-safe here: remote/cloud models skip local preload
-	// and only validate auth/connectivity before interactive chat starts.
-	if err := loadOrUnloadModel(cmd, &opts); err != nil {
-		return fmt.Errorf("error loading model: %w", err)
-	}
-	if err := generateInteractive(cmd, opts); err != nil {
-		return fmt.Errorf("error running model: %w", err)
-	}
-	return nil
-}
-
-// runInteractiveTUI runs the main interactive TUI menu.
-func runInteractiveTUI(cmd *cobra.Command) {
-	// Ensure the server is running before showing the TUI
-	if err := ensureServerRunning(cmd.Context()); err != nil {
-		fmt.Fprintf(os.Stderr, "Error starting server: %v\n", err)
-		return
-	}
-
-	deps := launcherDeps{
-		buildState:        launch.BuildLauncherState,
-		runMenu:           tui.RunMenu,
-		resolveRunModel:   launch.ResolveRunModel,
-		launchIntegration: launch.LaunchIntegration,
-		runModel:          launchInteractiveModel,
-	}
-
-	for {
-		continueLoop, err := runInteractiveTUIStep(cmd, deps)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		}
-		if !continueLoop {
-			return
-		}
-	}
-}
-
-type launcherDeps struct {
-	buildState        func(context.Context) (*launch.LauncherState, error)
-	runMenu           func(*launch.LauncherState) (tui.TUIAction, error)
-	resolveRunModel   func(context.Context, launch.RunModelRequest) (string, error)
-	launchIntegration func(context.Context, launch.IntegrationLaunchRequest) error
-	runModel          func(*cobra.Command, string) error
-}
-
-func runInteractiveTUIStep(cmd *cobra.Command, deps launcherDeps) (bool, error) {
-	state, err := deps.buildState(cmd.Context())
-	if err != nil {
-		return false, fmt.Errorf("build launcher state: %w", err)
-	}
-
-	action, err := deps.runMenu(state)
-	if err != nil {
-		return false, fmt.Errorf("run launcher menu: %w", err)
-	}
-
-	return runLauncherAction(cmd, action, deps)
-}
-
-func saveLauncherSelection(action tui.TUIAction) {
-	// Best effort only: this affects menu recall, not launch correctness.
-	_ = config.SetLastSelection(action.LastSelection())
-}
-
-func runLauncherAction(cmd *cobra.Command, action tui.TUIAction, deps launcherDeps) (bool, error) {
-	switch action.Kind {
-	case tui.TUIActionNone:
-		return false, nil
-	case tui.TUIActionRunModel:
-		saveLauncherSelection(action)
-		modelName, err := deps.resolveRunModel(cmd.Context(), action.RunModelRequest())
-		if errors.Is(err, launch.ErrCancelled) {
-			return true, nil
-		}
-		if err != nil {
-			return true, fmt.Errorf("selecting model: %w", err)
-		}
-		if err := deps.runModel(cmd, modelName); err != nil {
-			return true, err
-		}
-		return true, nil
-	case tui.TUIActionLaunchIntegration:
-		saveLauncherSelection(action)
-		err := deps.launchIntegration(cmd.Context(), action.IntegrationLaunchRequest())
-		if errors.Is(err, launch.ErrCancelled) {
-			return true, nil
-		}
-		if err != nil {
-			return true, fmt.Errorf("launching %s: %w", action.Integration, err)
-		}
-		// VS Code is a GUI app — exit the TUI loop after launching
-		if action.Integration == "vscode" {
-			return false, nil
-		}
-		return true, nil
-	default:
-		return false, fmt.Errorf("unknown launcher action: %d", action.Kind)
-	}
-}
-
 func NewCLI() *cobra.Command {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 	cobra.EnableCommandSorting = false
@@ -2098,13 +1826,23 @@ func NewCLI() *cobra.Command {
 				return
 			}

-			runInteractiveTUI(cmd)
+			// If no args, run launch to show interactive app selector
+			if len(args) == 0 {
+				if err := checkServerHeartbeat(cmd, args); err != nil {
+					cobra.CheckErr(err)
+					return
+				}
+				if err := config.RunLaunch(cmd, args, "", false); err != nil {
+					cobra.CheckErr(err)
+				}
+				return
+			}
+
+			cmd.Print(cmd.UsageString())
 		},
 	}

 	rootCmd.Flags().BoolP("version", "v", false, "Show version information")
-	rootCmd.Flags().Bool("verbose", false, "Show timings for response")
-	rootCmd.Flags().Bool("nowordwrap", false, "Don't wrap words to the next line automatically")

 	createCmd := &cobra.Command{
 		Use:   "create MODEL",
@@ -2164,9 +1902,6 @@ func NewCLI() *cobra.Command {
 	// Image generation flags (width, height, steps, seed, etc.)
 	imagegen.RegisterFlags(runCmd)

-	runCmd.Flags().Bool("imagegen", false, "Use the imagegen runner for LLM inference")
-	runCmd.Flags().MarkHidden("imagegen")
-
 	stopCmd := &cobra.Command{
 		Use:     "stop MODEL",
 		Short:   "Stop a running model",
@@ -2211,15 +1946,6 @@ func NewCLI() *cobra.Command {
 		RunE:    SigninHandler,
 	}

-	loginCmd := &cobra.Command{
-		Use:     "login",
-		Short:   "Sign in to ollama.com",
-		Hidden:  true,
-		Args:    cobra.ExactArgs(0),
-		PreRunE: checkServerHeartbeat,
-		RunE:    SigninHandler,
-	}
-
 	signoutCmd := &cobra.Command{
 		Use:     "signout",
 		Short:   "Sign out from ollama.com",
@@ -2228,15 +1954,6 @@ func NewCLI() *cobra.Command {
 		RunE:    SignoutHandler,
 	}

-	logoutCmd := &cobra.Command{
-		Use:     "logout",
-		Short:   "Sign out from ollama.com",
-		Hidden:  true,
-		Args:    cobra.ExactArgs(0),
-		PreRunE: checkServerHeartbeat,
-		RunE:    SignoutHandler,
-	}
-
 	listCmd := &cobra.Command{
 		Use:     "list",
 		Aliases: []string{"ls"},
@@ -2299,7 +2016,7 @@ func NewCLI() *cobra.Command {
 		switch cmd {
 		case runCmd:
 			imagegen.AppendFlagsDocs(cmd)
-			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_EDITOR"], envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
+			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
 		case serveCmd:
 			appendEnvDocs(cmd, []envconfig.EnvVar{
 				envVars["OLLAMA_DEBUG"],
@@ -2310,7 +2027,6 @@ func NewCLI() *cobra.Command {
 				envVars["OLLAMA_MAX_QUEUE"],
 				envVars["OLLAMA_MODELS"],
 				envVars["OLLAMA_NUM_PARALLEL"],
-				envVars["OLLAMA_NO_CLOUD"],
 				envVars["OLLAMA_NOPRUNE"],
 				envVars["OLLAMA_ORIGINS"],
 				envVars["OLLAMA_SCHED_SPREAD"],
@@ -2334,15 +2050,13 @@ func NewCLI() *cobra.Command {
 		pullCmd,
 		pushCmd,
 		signinCmd,
-		loginCmd,
 		signoutCmd,
-		logoutCmd,
 		listCmd,
 		psCmd,
 		copyCmd,
 		deleteCmd,
 		runnerCmd,
-		launch.LaunchCmd(checkServerHeartbeat, runInteractiveTUI),
+		config.LaunchCmd(checkServerHeartbeat),
 	)

 	return rootCmd
@@ -1,270 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/ollama/ollama/cmd/config"
-	"github.com/ollama/ollama/cmd/launch"
-	"github.com/ollama/ollama/cmd/tui"
-)
-
-func setCmdTestHome(t *testing.T, dir string) {
-	t.Helper()
-	t.Setenv("HOME", dir)
-	t.Setenv("USERPROFILE", dir)
-}
-
-func unexpectedRunModelResolution(t *testing.T) func(context.Context, launch.RunModelRequest) (string, error) {
-	t.Helper()
-	return func(ctx context.Context, req launch.RunModelRequest) (string, error) {
-		t.Fatalf("did not expect run-model resolution: %+v", req)
-		return "", nil
-	}
-}
-
-func unexpectedIntegrationLaunch(t *testing.T) func(context.Context, launch.IntegrationLaunchRequest) error {
-	t.Helper()
-	return func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-		t.Fatalf("did not expect integration launch: %+v", req)
-		return nil
-	}
-}
-
-func unexpectedModelLaunch(t *testing.T) func(*cobra.Command, string) error {
-	t.Helper()
-	return func(cmd *cobra.Command, model string) error {
-		t.Fatalf("did not expect chat launch: %s", model)
-		return nil
-	}
-}
-
-func TestRunInteractiveTUI_RunModelActionsUseResolveRunModel(t *testing.T) {
-	tests := []struct {
-		name      string
-		action    tui.TUIAction
-		wantForce bool
-		wantModel string
-	}{
-		{
-			name:      "enter uses saved model flow",
-			action:    tui.TUIAction{Kind: tui.TUIActionRunModel},
-			wantModel: "qwen3:8b",
-		},
-		{
-			name:      "right forces picker",
-			action:    tui.TUIAction{Kind: tui.TUIActionRunModel, ForceConfigure: true},
-			wantForce: true,
-			wantModel: "glm-5:cloud",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			setCmdTestHome(t, t.TempDir())
-
-			var menuCalls int
-			runMenu := func(state *launch.LauncherState) (tui.TUIAction, error) {
-				menuCalls++
-				if menuCalls == 1 {
-					return tt.action, nil
-				}
-				return tui.TUIAction{Kind: tui.TUIActionNone}, nil
-			}
-
-			var gotReq launch.RunModelRequest
-			var launched string
-			deps := launcherDeps{
-				buildState: func(ctx context.Context) (*launch.LauncherState, error) {
-					return &launch.LauncherState{}, nil
-				},
-				runMenu: runMenu,
-				resolveRunModel: func(ctx context.Context, req launch.RunModelRequest) (string, error) {
-					gotReq = req
-					return tt.wantModel, nil
-				},
-				launchIntegration: unexpectedIntegrationLaunch(t),
-				runModel: func(cmd *cobra.Command, model string) error {
-					launched = model
-					return nil
-				},
-			}
-
-			cmd := &cobra.Command{}
-			cmd.SetContext(context.Background())
-			for {
-				continueLoop, err := runInteractiveTUIStep(cmd, deps)
-				if err != nil {
-					t.Fatalf("unexpected step error: %v", err)
-				}
-				if !continueLoop {
-					break
-				}
-			}
-
-			if gotReq.ForcePicker != tt.wantForce {
-				t.Fatalf("expected ForcePicker=%v, got %v", tt.wantForce, gotReq.ForcePicker)
-			}
-			if launched != tt.wantModel {
-				t.Fatalf("expected interactive launcher to run %q, got %q", tt.wantModel, launched)
-			}
-			if got := config.LastSelection(); got != "run" {
-				t.Fatalf("expected last selection to be run, got %q", got)
-			}
-		})
-	}
-}
-
-func TestRunInteractiveTUI_IntegrationActionsUseLaunchIntegration(t *testing.T) {
-	tests := []struct {
-		name      string
-		action    tui.TUIAction
-		wantForce bool
-	}{
-		{
-			name:   "enter launches integration",
-			action: tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"},
-		},
-		{
-			name:      "right forces configure",
-			action:    tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude", ForceConfigure: true},
-			wantForce: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			setCmdTestHome(t, t.TempDir())
-
-			var menuCalls int
-			runMenu := func(state *launch.LauncherState) (tui.TUIAction, error) {
-				menuCalls++
-				if menuCalls == 1 {
-					return tt.action, nil
-				}
-				return tui.TUIAction{Kind: tui.TUIActionNone}, nil
-			}
-
-			var gotReq launch.IntegrationLaunchRequest
-			deps := launcherDeps{
-				buildState: func(ctx context.Context) (*launch.LauncherState, error) {
-					return &launch.LauncherState{}, nil
-				},
-				runMenu:         runMenu,
-				resolveRunModel: unexpectedRunModelResolution(t),
-				launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-					gotReq = req
-					return nil
-				},
-				runModel: unexpectedModelLaunch(t),
-			}
-
-			cmd := &cobra.Command{}
-			cmd.SetContext(context.Background())
-			for {
-				continueLoop, err := runInteractiveTUIStep(cmd, deps)
-				if err != nil {
-					t.Fatalf("unexpected step error: %v", err)
-				}
-				if !continueLoop {
-					break
-				}
-			}
-
-			if gotReq.Name != "claude" {
-				t.Fatalf("expected integration name to be passed through, got %q", gotReq.Name)
-			}
-			if gotReq.ForceConfigure != tt.wantForce {
-				t.Fatalf("expected ForceConfigure=%v, got %v", tt.wantForce, gotReq.ForceConfigure)
-			}
-			if got := config.LastSelection(); got != "claude" {
-				t.Fatalf("expected last selection to be claude, got %q", got)
-			}
-		})
-	}
-}
-
-func TestRunLauncherAction_RunModelContinuesAfterCancellation(t *testing.T) {
-	setCmdTestHome(t, t.TempDir())
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(context.Background())
-
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionRunModel}, launcherDeps{
-		buildState: nil,
-		runMenu:    nil,
-		resolveRunModel: func(ctx context.Context, req launch.RunModelRequest) (string, error) {
-			return "", launch.ErrCancelled
-		},
-		launchIntegration: unexpectedIntegrationLaunch(t),
-		runModel:          unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error on cancellation, got %v", err)
-	}
-	if !continueLoop {
-		t.Fatal("expected cancellation to continue the menu loop")
-	}
-}
-
-func TestRunLauncherAction_VSCodeExitsTUILoop(t *testing.T) {
-	setCmdTestHome(t, t.TempDir())
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(context.Background())
-
-	// VS Code should exit the TUI loop (return false) after a successful launch.
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "vscode"}, launcherDeps{
-		resolveRunModel: unexpectedRunModelResolution(t),
-		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-			return nil
-		},
-		runModel: unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error, got %v", err)
-	}
-	if continueLoop {
-		t.Fatal("expected vscode launch to exit the TUI loop (return false)")
-	}
-
-	// Other integrations should continue the TUI loop (return true).
-	continueLoop, err = runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"}, launcherDeps{
-		resolveRunModel: unexpectedRunModelResolution(t),
-		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-			return nil
-		},
-		runModel: unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error, got %v", err)
-	}
-	if !continueLoop {
-		t.Fatal("expected non-vscode integration to continue the TUI loop (return true)")
-	}
-}
-
-func TestRunLauncherAction_IntegrationContinuesAfterCancellation(t *testing.T) {
-	setCmdTestHome(t, t.TempDir())
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(context.Background())
-
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"}, launcherDeps{
-		buildState:      nil,
-		runMenu:         nil,
-		resolveRunModel: unexpectedRunModelResolution(t),
-		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-			return launch.ErrCancelled
-		},
-		runModel: unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error on cancellation, got %v", err)
-	}
-	if !continueLoop {
-		t.Fatal("expected cancellation to continue the menu loop")
-	}
-}
@@ -301,7 +301,7 @@ Weigh anchor!
 				ParameterSize:     "7B",
 				QuantizationLevel: "FP16",
 			},
-			Requires: "0.19.0",
+			Requires: "0.14.0",
 		}, false, &b); err != nil {
 			t.Fatal(err)
 		}
@@ -310,17 +310,10 @@ Weigh anchor!
    architecture    test      
    parameters      7B        
    quantization    FP16      
-    requires        0.19.0
+    requires        0.14.0    

 `
-		trimLinePadding := func(s string) string {
-			lines := strings.Split(s, "\n")
-			for i, line := range lines {
-				lines[i] = strings.TrimRight(line, " \t\r")
-			}
-			return strings.Join(lines, "\n")
-		}
-		if diff := cmp.Diff(trimLinePadding(expect), trimLinePadding(b.String())); diff != "" {
+		if diff := cmp.Diff(expect, b.String()); diff != "" {
 			t.Errorf("unexpected output (-want +got):\n%s", diff)
 		}
 	})
@@ -712,347 +705,6 @@ func TestRunEmbeddingModelNoInput(t *testing.T) {
 	}
 }

-func TestRunHandler_CloudAuthErrorOnShow_PrintsSigninMessage(t *testing.T) {
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusUnauthorized)
-			if err := json.NewEncoder(w).Encode(map[string]string{
-				"error":      "unauthorized",
-				"signin_url": "https://ollama.com/signin",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	oldStdout := os.Stdout
-	readOut, writeOut, _ := os.Pipe()
-	os.Stdout = writeOut
-	t.Cleanup(func() { os.Stdout = oldStdout })
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-
-	_ = writeOut.Close()
-	var out bytes.Buffer
-	_, _ = io.Copy(&out, readOut)
-
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if generateCalled {
-		t.Fatal("expected run to stop before /api/generate after unauthorized /api/show")
-	}
-
-	if !strings.Contains(out.String(), "You need to be signed in to Ollama to run Cloud models.") {
-		t.Fatalf("expected sign-in guidance message, got %q", out.String())
-	}
-
-	if !strings.Contains(out.String(), "https://ollama.com/signin") {
-		t.Fatalf("expected signin_url in output, got %q", out.String())
-	}
-}
-
-func TestRunHandler_CloudAuthErrorOnGenerate_PrintsSigninMessage(t *testing.T) {
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusUnauthorized)
-			if err := json.NewEncoder(w).Encode(map[string]string{
-				"error":      "unauthorized",
-				"signin_url": "https://ollama.com/signin",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	oldStdout := os.Stdout
-	readOut, writeOut, _ := os.Pipe()
-	os.Stdout = writeOut
-	t.Cleanup(func() { os.Stdout = oldStdout })
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-
-	_ = writeOut.Close()
-	var out bytes.Buffer
-	_, _ = io.Copy(&out, readOut)
-
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if !strings.Contains(out.String(), "You need to be signed in to Ollama to run Cloud models.") {
-		t.Fatalf("expected sign-in guidance message, got %q", out.String())
-	}
-
-	if !strings.Contains(out.String(), "https://ollama.com/signin") {
-		t.Fatalf("expected signin_url in output, got %q", out.String())
-	}
-}
-
-func TestRunHandler_ExplicitCloudStubMissing_PullsNormalizedNameTEMP(t *testing.T) {
-	var pulledModel string
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-				RemoteModel:  "gpt-oss:20b",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/tags" && r.Method == http.MethodGet:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ListResponse{Models: nil}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/pull" && r.Method == http.MethodPost:
-			var req api.PullRequest
-			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-				http.Error(w, err.Error(), http.StatusBadRequest)
-				return
-			}
-			pulledModel = req.Model
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ProgressResponse{Status: "success"}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if pulledModel != "gpt-oss:20b-cloud" {
-		t.Fatalf("expected normalized pull model %q, got %q", "gpt-oss:20b-cloud", pulledModel)
-	}
-
-	if !generateCalled {
-		t.Fatal("expected /api/generate to be called")
-	}
-}
-
-func TestRunHandler_ExplicitCloudStubPresent_SkipsPullTEMP(t *testing.T) {
-	var pullCalled bool
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-				RemoteModel:  "gpt-oss:20b",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/tags" && r.Method == http.MethodGet:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ListResponse{
-				Models: []api.ListModelResponse{{Name: "gpt-oss:20b-cloud"}},
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/pull" && r.Method == http.MethodPost:
-			pullCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ProgressResponse{Status: "success"}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if pullCalled {
-		t.Fatal("expected /api/pull not to be called when cloud stub already exists")
-	}
-
-	if !generateCalled {
-		t.Fatal("expected /api/generate to be called")
-	}
-}
-
-func TestRunHandler_ExplicitCloudStubPullFailure_IsBestEffortTEMP(t *testing.T) {
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-				RemoteModel:  "gpt-oss:20b",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/tags" && r.Method == http.MethodGet:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ListResponse{Models: nil}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/pull" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusInternalServerError)
-			if err := json.NewEncoder(w).Encode(map[string]string{"error": "pull failed"}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if !generateCalled {
-		t.Fatal("expected /api/generate to be called despite pull failure")
-	}
-}
-
 func TestGetModelfileName(t *testing.T) {
 	tests := []struct {
 		name          string
@@ -1560,20 +1212,6 @@ func TestNewCreateRequest(t *testing.T) {
 				Model: "newmodel",
 			},
 		},
-		{
-			"explicit cloud model preserves source when parent lacks it",
-			"newmodel",
-			runOptions{
-				Model:       "qwen3.5:cloud",
-				ParentModel: "qwen3.5",
-				Messages:    []api.Message{},
-				WordWrap:    true,
-			},
-			&api.CreateRequest{
-				From:  "qwen3.5:cloud",
-				Model: "newmodel",
-			},
-		},
 		{
 			"parent model as filepath test",
 			"newmodel",
@@ -1655,24 +1293,6 @@ func TestNewCreateRequest(t *testing.T) {
 				},
 			},
 		},
-		{
-			"loaded messages are preserved when saving",
-			"newmodel",
-			runOptions{
-				Model:          "mymodel",
-				ParentModel:    "parentmodel",
-				LoadedMessages: []api.Message{{Role: "assistant", Content: "loaded"}},
-				Messages:       []api.Message{{Role: "user", Content: "new"}},
-			},
-			&api.CreateRequest{
-				From:  "parentmodel",
-				Model: "newmodel",
-				Messages: []api.Message{
-					{Role: "assistant", Content: "loaded"},
-					{Role: "user", Content: "new"},
-				},
-			},
-		},
 	}

 	for _, tt := range tests {
@@ -1685,43 +1305,15 @@ func TestNewCreateRequest(t *testing.T) {
 	}
 }

-func TestApplyShowResponseToRunOptions(t *testing.T) {
-	opts := runOptions{}
-	info := &api.ShowResponse{
-		Details: api.ModelDetails{
-			ParentModel: "parentmodel",
-		},
-		Messages: []api.Message{
-			{Role: "assistant", Content: "loaded"},
-		},
-	}
-
-	applyShowResponseToRunOptions(&opts, info)
-
-	if opts.ParentModel != "parentmodel" {
-		t.Fatalf("ParentModel = %q, want %q", opts.ParentModel, "parentmodel")
-	}
-
-	if !cmp.Equal(opts.LoadedMessages, info.Messages) {
-		t.Fatalf("LoadedMessages = %#v, want %#v", opts.LoadedMessages, info.Messages)
-	}
-
-	info.Messages[0].Content = "modified"
-	if opts.LoadedMessages[0].Content == "modified" {
-		t.Fatal("LoadedMessages should be copied independently from ShowResponse")
-	}
-}
-
 func TestRunOptions_Copy(t *testing.T) {
 	// Setup test data
 	originalKeepAlive := &api.Duration{Duration: 5 * time.Minute}
 	originalThink := &api.ThinkValue{Value: "test reasoning"}

 	original := runOptions{
-		Model:          "test-model",
-		ParentModel:    "parent-model",
-		LoadedMessages: []api.Message{{Role: "assistant", Content: "loaded hello"}},
-		Prompt:         "test prompt",
+		Model:       "test-model",
+		ParentModel: "parent-model",
+		Prompt:      "test prompt",
 		Messages: []api.Message{
 			{Role: "user", Content: "hello"},
 			{Role: "assistant", Content: "hi there"},
@@ -1761,7 +1353,6 @@ func TestRunOptions_Copy(t *testing.T) {
 	}{
 		{"Model", copied.Model, original.Model},
 		{"ParentModel", copied.ParentModel, original.ParentModel},
-		{"LoadedMessages", copied.LoadedMessages, original.LoadedMessages},
 		{"Prompt", copied.Prompt, original.Prompt},
 		{"WordWrap", copied.WordWrap, original.WordWrap},
 		{"Format", copied.Format, original.Format},
@@ -1866,18 +1457,13 @@ func TestRunOptions_Copy(t *testing.T) {
 func TestRunOptions_Copy_EmptySlicesAndMaps(t *testing.T) {
 	// Test with empty slices and maps
 	original := runOptions{
-		LoadedMessages: []api.Message{},
-		Messages:       []api.Message{},
-		Images:         []api.ImageData{},
-		Options:        map[string]any{},
+		Messages: []api.Message{},
+		Images:   []api.ImageData{},
+		Options:  map[string]any{},
 	}

 	copied := original.Copy()

-	if copied.LoadedMessages == nil {
-		t.Error("Empty LoadedMessages slice should remain empty, not nil")
-	}
-
 	if copied.Messages == nil {
 		t.Error("Empty Messages slice should remain empty, not nil")
 	}
@@ -1894,10 +1480,6 @@ func TestRunOptions_Copy_EmptySlicesAndMaps(t *testing.T) {
 		t.Error("Empty Messages slice should remain empty")
 	}

-	if len(copied.LoadedMessages) != 0 {
-		t.Error("Empty LoadedMessages slice should remain empty")
-	}
-
 	if len(copied.Images) != 0 {
 		t.Error("Empty Images slice should remain empty")
 	}
@@ -1975,7 +1557,7 @@ func TestShowInfoImageGen(t *testing.T) {
 			QuantizationLevel: "Q8",
 		},
 		Capabilities: []model.Capability{model.CapabilityImage},
-		Requires:     "0.19.0",
+		Requires:     "0.14.0",
 	}, false, &b)
 	if err != nil {
 		t.Fatal(err)
@@ -1985,7 +1567,7 @@ func TestShowInfoImageGen(t *testing.T) {
 		"    architecture    ZImagePipeline    \n" +
 		"    parameters      10.3B             \n" +
 		"    quantization    Q8                \n" +
-		"    requires        0.19.0            \n" +
+		"    requires        0.14.0            \n" +
 		"\n" +
 		"  Capabilities\n" +
 		"    image    \n" +
@@ -2043,20 +1625,16 @@ func TestRunOptions_Copy_Independence(t *testing.T) {
 	// Test that modifications to original don't affect copy
 	originalThink := &api.ThinkValue{Value: "original"}
 	original := runOptions{
-		Model:          "original-model",
-		LoadedMessages: []api.Message{{Role: "assistant", Content: "loaded"}},
-		Messages:       []api.Message{{Role: "user", Content: "original"}},
-		Options:        map[string]any{"key": "value"},
-		Think:          originalThink,
+		Model:    "original-model",
+		Messages: []api.Message{{Role: "user", Content: "original"}},
+		Options:  map[string]any{"key": "value"},
+		Think:    originalThink,
 	}

 	copied := original.Copy()

 	// Modify original
 	original.Model = "modified-model"
-	if len(original.LoadedMessages) > 0 {
-		original.LoadedMessages[0].Content = "modified loaded"
-	}
 	if len(original.Messages) > 0 {
 		original.Messages[0].Content = "modified"
 	}
@@ -2070,10 +1648,6 @@ func TestRunOptions_Copy_Independence(t *testing.T) {
 		t.Error("Copy Model should not be affected by original modification")
 	}

-	if len(copied.LoadedMessages) > 0 && copied.LoadedMessages[0].Content == "modified loaded" {
-		t.Error("Copy LoadedMessages should not be affected by original modification")
-	}
-
 	if len(copied.Messages) > 0 && copied.Messages[0].Content == "modified" {
 		t.Error("Copy Messages should not be affected by original modification")
 	}
@@ -2089,81 +1663,31 @@ func TestRunOptions_Copy_Independence(t *testing.T) {

 func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 	tests := []struct {
-		name            string
-		model           string
-		showStatus      int
-		remoteHost      string
-		remoteModel     string
-		whoamiStatus    int
-		whoamiResp      any
-		expectWhoami    bool
-		expectedError   string
-		expectAuthError bool
+		name          string
+		remoteHost    string
+		whoamiStatus  int
+		whoamiResp    any
+		expectedError string
 	}{
 		{
 			name:         "ollama.com cloud model - user signed in",
-			model:        "test-cloud-model",
 			remoteHost:   "https://ollama.com",
-			remoteModel:  "test-model",
 			whoamiStatus: http.StatusOK,
 			whoamiResp:   api.UserResponse{Name: "testuser"},
-			expectWhoami: true,
 		},
 		{
 			name:         "ollama.com cloud model - user not signed in",
-			model:        "test-cloud-model",
 			remoteHost:   "https://ollama.com",
-			remoteModel:  "test-model",
 			whoamiStatus: http.StatusUnauthorized,
 			whoamiResp: map[string]string{
 				"error":      "unauthorized",
 				"signin_url": "https://ollama.com/signin",
 			},
-			expectWhoami:    true,
-			expectedError:   "unauthorized",
-			expectAuthError: true,
+			expectedError: "unauthorized",
 		},
 		{
 			name:         "non-ollama.com remote - no auth check",
-			model:        "test-cloud-model",
 			remoteHost:   "https://other-remote.com",
-			remoteModel:  "test-model",
-			whoamiStatus: http.StatusUnauthorized, // should not be called
-			whoamiResp:   nil,
-		},
-		{
-			name:         "explicit :cloud model - auth check without remote metadata",
-			model:        "kimi-k2.5:cloud",
-			remoteHost:   "",
-			remoteModel:  "",
-			whoamiStatus: http.StatusOK,
-			whoamiResp:   api.UserResponse{Name: "testuser"},
-			expectWhoami: true,
-		},
-		{
-			name:            "explicit :cloud model without local stub returns not found by default",
-			model:           "minimax-m2.7:cloud",
-			showStatus:      http.StatusNotFound,
-			whoamiStatus:    http.StatusOK,
-			whoamiResp:      api.UserResponse{Name: "testuser"},
-			expectedError:   "not found",
-			expectWhoami:    false,
-			expectAuthError: false,
-		},
-		{
-			name:         "explicit -cloud model - auth check without remote metadata",
-			model:        "kimi-k2.5:latest-cloud",
-			remoteHost:   "",
-			remoteModel:  "",
-			whoamiStatus: http.StatusOK,
-			whoamiResp:   api.UserResponse{Name: "testuser"},
-			expectWhoami: true,
-		},
-		{
-			name:         "dash cloud-like name without explicit source does not require auth",
-			model:        "test-cloud-model",
-			remoteHost:   "",
-			remoteModel:  "",
 			whoamiStatus: http.StatusUnauthorized, // should not be called
 			whoamiResp:   nil,
 		},
@@ -2175,15 +1699,10 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 			mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				switch r.URL.Path {
 				case "/api/show":
-					if tt.showStatus != 0 && tt.showStatus != http.StatusOK {
-						w.WriteHeader(tt.showStatus)
-						_ = json.NewEncoder(w).Encode(map[string]string{"error": "not found"})
-						return
-					}
 					w.Header().Set("Content-Type", "application/json")
 					if err := json.NewEncoder(w).Encode(api.ShowResponse{
 						RemoteHost:  tt.remoteHost,
-						RemoteModel: tt.remoteModel,
+						RemoteModel: "test-model",
 					}); err != nil {
 						http.Error(w, err.Error(), http.StatusInternalServerError)
 					}
@@ -2196,8 +1715,6 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 							http.Error(w, err.Error(), http.StatusInternalServerError)
 						}
 					}
-				case "/api/generate":
-					w.WriteHeader(http.StatusOK)
 				default:
 					http.NotFound(w, r)
 				}
@@ -2210,28 +1727,29 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 			cmd.SetContext(t.Context())

 			opts := &runOptions{
-				Model:       tt.model,
+				Model:       "test-cloud-model",
 				ShowConnect: false,
 			}

 			err := loadOrUnloadModel(cmd, opts)

-			if whoamiCalled != tt.expectWhoami {
-				t.Errorf("whoami called = %v, want %v", whoamiCalled, tt.expectWhoami)
+			if strings.HasPrefix(tt.remoteHost, "https://ollama.com") {
+				if !whoamiCalled {
+					t.Error("expected whoami to be called for ollama.com cloud model")
+				}
+			} else {
+				if whoamiCalled {
+					t.Error("whoami should not be called for non-ollama.com remote")
+				}
 			}

 			if tt.expectedError != "" {
 				if err == nil {
 					t.Errorf("expected error containing %q, got nil", tt.expectedError)
 				} else {
-					if !tt.expectAuthError && !strings.Contains(strings.ToLower(err.Error()), strings.ToLower(tt.expectedError)) {
-						t.Errorf("expected error containing %q, got %v", tt.expectedError, err)
-					}
-					if tt.expectAuthError {
-						var authErr api.AuthorizationError
-						if !errors.As(err, &authErr) {
-							t.Errorf("expected AuthorizationError, got %T: %v", err, err)
-						}
+					var authErr api.AuthorizationError
+					if !errors.As(err, &authErr) {
+						t.Errorf("expected AuthorizationError, got %T: %v", err, err)
 					}
 				}
 			} else {
@@ -2242,38 +1760,3 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 		})
 	}
 }
-
-func TestIsLocalhost(t *testing.T) {
-	tests := []struct {
-		name     string
-		host     string
-		expected bool
-	}{
-		{"default empty", "", true},
-		{"localhost no port", "localhost", true},
-		{"localhost with port", "localhost:11435", true},
-		{"127.0.0.1 no port", "127.0.0.1", true},
-		{"127.0.0.1 with port", "127.0.0.1:11434", true},
-		{"0.0.0.0 no port", "0.0.0.0", true},
-		{"0.0.0.0 with port", "0.0.0.0:11434", true},
-		{"::1 no port", "::1", true},
-		{"[::1] with port", "[::1]:11434", true},
-		{"loopback with scheme", "http://localhost:11434", true},
-		{"remote hostname", "example.com", false},
-		{"remote hostname with port", "example.com:11434", false},
-		{"remote IP", "192.168.1.1", false},
-		{"remote IP with port", "192.168.1.1:11434", false},
-		{"remote with scheme", "http://example.com:11434", false},
-		{"https remote", "https://example.com:443", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("OLLAMA_HOST", tt.host)
-			got := isLocalhost()
-			if got != tt.expected {
-				t.Errorf("isLocalhost() with OLLAMA_HOST=%q = %v, want %v", tt.host, got, tt.expected)
-			}
-		})
-	}
-}
@@ -0,0 +1,193 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/envconfig"
+)
+
+// Claude implements Runner and AliasConfigurer for Claude Code integration
+type Claude struct{}
+
+// Compile-time check that Claude implements AliasConfigurer
+var _ AliasConfigurer = (*Claude)(nil)
+
+func (c *Claude) String() string { return "Claude Code" }
+
+func (c *Claude) args(model string, extra []string) []string {
+	var args []string
+	if model != "" {
+		args = append(args, "--model", model)
+	}
+	args = append(args, extra...)
+	return args
+}
+
+func (c *Claude) findPath() (string, error) {
+	if p, err := exec.LookPath("claude"); err == nil {
+		return p, nil
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	name := "claude"
+	if runtime.GOOS == "windows" {
+		name = "claude.exe"
+	}
+	fallback := filepath.Join(home, ".claude", "local", name)
+	if _, err := os.Stat(fallback); err != nil {
+		return "", err
+	}
+	return fallback, nil
+}
+
+func (c *Claude) Run(model string, args []string) error {
+	claudePath, err := c.findPath()
+	if err != nil {
+		return fmt.Errorf("claude is not installed, install from https://code.claude.com/docs/en/quickstart")
+	}
+
+	cmd := exec.Command(claudePath, c.args(model, args)...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	env := append(os.Environ(),
+		"ANTHROPIC_BASE_URL="+envconfig.Host().String(),
+		"ANTHROPIC_API_KEY=",
+		"ANTHROPIC_AUTH_TOKEN=ollama",
+	)
+
+	env = append(env, c.modelEnvVars(model)...)
+
+	cmd.Env = env
+	return cmd.Run()
+}
+
+// modelEnvVars returns Claude Code env vars that route all model tiers through Ollama.
+func (c *Claude) modelEnvVars(model string) []string {
+	primary := model
+	fast := model
+	if cfg, err := loadIntegration("claude"); err == nil && cfg.Aliases != nil {
+		if p := cfg.Aliases["primary"]; p != "" {
+			primary = p
+		}
+		if f := cfg.Aliases["fast"]; f != "" {
+			fast = f
+		}
+	}
+	return []string{
+		"ANTHROPIC_DEFAULT_OPUS_MODEL=" + primary,
+		"ANTHROPIC_DEFAULT_SONNET_MODEL=" + primary,
+		"ANTHROPIC_DEFAULT_HAIKU_MODEL=" + fast,
+		"CLAUDE_CODE_SUBAGENT_MODEL=" + primary,
+	}
+}
+
+// ConfigureAliases sets up model aliases for Claude Code.
+// model: the model to use (if empty, user will be prompted to select)
+// aliases: existing alias configuration to preserve/update
+// Cloud-only: subagent routing (fast model) is gated to cloud models only until
+// there is a better strategy for prompt caching on local models.
+func (c *Claude) ConfigureAliases(ctx context.Context, model string, existingAliases map[string]string, force bool) (map[string]string, bool, error) {
+	aliases := make(map[string]string)
+	for k, v := range existingAliases {
+		aliases[k] = v
+	}
+
+	if model != "" {
+		aliases["primary"] = model
+	}
+
+	if !force && aliases["primary"] != "" {
+		client, _ := api.ClientFromEnvironment()
+		if isCloudModel(ctx, client, aliases["primary"]) {
+			if isCloudModel(ctx, client, aliases["fast"]) {
+				return aliases, false, nil
+			}
+		} else {
+			delete(aliases, "fast")
+			return aliases, false, nil
+		}
+	}
+
+	items, existingModels, cloudModels, client, err := listModels(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+
+	fmt.Fprintf(os.Stderr, "\n%sModel Configuration%s\n\n", ansiBold, ansiReset)
+
+	if aliases["primary"] == "" || force {
+		primary, err := selectPrompt("Select model:", items)
+		fmt.Fprintf(os.Stderr, "\033[3A\033[J")
+		if err != nil {
+			return nil, false, err
+		}
+		if err := pullIfNeeded(ctx, client, existingModels, primary); err != nil {
+			return nil, false, err
+		}
+		if err := ensureAuth(ctx, client, cloudModels, []string{primary}); err != nil {
+			return nil, false, err
+		}
+		aliases["primary"] = primary
+	}
+
+	if isCloudModel(ctx, client, aliases["primary"]) {
+		if aliases["fast"] == "" || !isCloudModel(ctx, client, aliases["fast"]) {
+			aliases["fast"] = aliases["primary"]
+		}
+	} else {
+		delete(aliases, "fast")
+	}
+
+	return aliases, true, nil
+}
+
+// SetAliases syncs the configured aliases to the Ollama server using prefix matching.
+// Cloud-only: for local models (fast is empty), we delete any existing aliases to
+// prevent stale routing to a previous cloud model.
+func (c *Claude) SetAliases(ctx context.Context, aliases map[string]string) error {
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return err
+	}
+
+	prefixes := []string{"claude-sonnet-", "claude-haiku-"}
+
+	if aliases["fast"] == "" {
+		for _, prefix := range prefixes {
+			_ = client.DeleteAliasExperimental(ctx, &api.AliasDeleteRequest{Alias: prefix})
+		}
+		return nil
+	}
+
+	prefixAliases := map[string]string{
+		"claude-sonnet-": aliases["primary"],
+		"claude-haiku-":  aliases["fast"],
+	}
+
+	var errs []string
+	for prefix, target := range prefixAliases {
+		req := &api.AliasRequest{
+			Alias:          prefix,
+			Target:         target,
+			PrefixMatching: true,
+		}
+		if err := client.SetAliasExperimental(ctx, req); err != nil {
+			errs = append(errs, prefix)
+		}
+	}
+
+	if len(errs) > 0 {
+		return fmt.Errorf("failed to set aliases: %v", errs)
+	}
+	return nil
+}
@@ -1,4 +1,4 @@
-package launch
+package config

 import (
 	"os"
@@ -117,7 +117,10 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		return m
 	}

-	t.Run("maps all Claude model env vars to the provided model", func(t *testing.T) {
+	t.Run("falls back to model param when no aliases saved", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+
 		got := envMap(c.modelEnvVars("llama3.2"))
 		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "llama3.2" {
 			t.Errorf("OPUS = %q, want llama3.2", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
@@ -131,41 +134,65 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "llama3.2" {
 			t.Errorf("SUBAGENT = %q, want llama3.2", got["CLAUDE_CODE_SUBAGENT_MODEL"])
 		}
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want empty for local models", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
+	})
+
+	t.Run("uses primary alias for opus sonnet and subagent", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+
+		saveIntegration("claude", []string{"qwen3:8b"})
+		saveAliases("claude", map[string]string{"primary": "qwen3:8b"})
+
+		got := envMap(c.modelEnvVars("qwen3:8b"))
+		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "qwen3:8b" {
+			t.Errorf("OPUS = %q, want qwen3:8b", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
+		}
+		if got["ANTHROPIC_DEFAULT_SONNET_MODEL"] != "qwen3:8b" {
+			t.Errorf("SONNET = %q, want qwen3:8b", got["ANTHROPIC_DEFAULT_SONNET_MODEL"])
+		}
+		if got["ANTHROPIC_DEFAULT_HAIKU_MODEL"] != "qwen3:8b" {
+			t.Errorf("HAIKU = %q, want qwen3:8b (no fast alias)", got["ANTHROPIC_DEFAULT_HAIKU_MODEL"])
+		}
+		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "qwen3:8b" {
+			t.Errorf("SUBAGENT = %q, want qwen3:8b", got["CLAUDE_CODE_SUBAGENT_MODEL"])
 		}
 	})

-	t.Run("supports empty model", func(t *testing.T) {
-		got := envMap(c.modelEnvVars(""))
-		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "" {
-			t.Errorf("OPUS = %q, want empty", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
+	t.Run("uses fast alias for haiku", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+
+		saveIntegration("claude", []string{"llama3.2:70b"})
+		saveAliases("claude", map[string]string{
+			"primary": "llama3.2:70b",
+			"fast":    "llama3.2:8b",
+		})
+
+		got := envMap(c.modelEnvVars("llama3.2:70b"))
+		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "llama3.2:70b" {
+			t.Errorf("OPUS = %q, want llama3.2:70b", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
 		}
-		if got["ANTHROPIC_DEFAULT_SONNET_MODEL"] != "" {
-			t.Errorf("SONNET = %q, want empty", got["ANTHROPIC_DEFAULT_SONNET_MODEL"])
+		if got["ANTHROPIC_DEFAULT_SONNET_MODEL"] != "llama3.2:70b" {
+			t.Errorf("SONNET = %q, want llama3.2:70b", got["ANTHROPIC_DEFAULT_SONNET_MODEL"])
 		}
-		if got["ANTHROPIC_DEFAULT_HAIKU_MODEL"] != "" {
-			t.Errorf("HAIKU = %q, want empty", got["ANTHROPIC_DEFAULT_HAIKU_MODEL"])
+		if got["ANTHROPIC_DEFAULT_HAIKU_MODEL"] != "llama3.2:8b" {
+			t.Errorf("HAIKU = %q, want llama3.2:8b", got["ANTHROPIC_DEFAULT_HAIKU_MODEL"])
 		}
-		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "" {
-			t.Errorf("SUBAGENT = %q, want empty", got["CLAUDE_CODE_SUBAGENT_MODEL"])
-		}
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want empty", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
+		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "llama3.2:70b" {
+			t.Errorf("SUBAGENT = %q, want llama3.2:70b", got["CLAUDE_CODE_SUBAGENT_MODEL"])
 		}
 	})

-	t.Run("sets auto compact window for known cloud models", func(t *testing.T) {
-		got := envMap(c.modelEnvVars("glm-5:cloud"))
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "202752" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want 202752", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
-		}
-	})
+	t.Run("alias primary overrides model param", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)

-	t.Run("does not set auto compact window for unknown cloud models", func(t *testing.T) {
-		got := envMap(c.modelEnvVars("unknown-model:cloud"))
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want empty", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
+		saveIntegration("claude", []string{"saved-model"})
+		saveAliases("claude", map[string]string{"primary": "saved-model"})
+
+		got := envMap(c.modelEnvVars("different-model"))
+		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "saved-model" {
+			t.Errorf("OPUS = %q, want saved-model", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
 		}
 	})
 }
@@ -0,0 +1,62 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"golang.org/x/mod/semver"
+)
+
+// Codex implements Runner for Codex integration
+type Codex struct{}
+
+func (c *Codex) String() string { return "Codex" }
+
+func (c *Codex) args(model string, extra []string) []string {
+	args := []string{"--oss"}
+	if model != "" {
+		args = append(args, "-m", model)
+	}
+	args = append(args, extra...)
+	return args
+}
+
+func (c *Codex) Run(model string, args []string) error {
+	if err := checkCodexVersion(); err != nil {
+		return err
+	}
+
+	cmd := exec.Command("codex", c.args(model, args)...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func checkCodexVersion() error {
+	if _, err := exec.LookPath("codex"); err != nil {
+		return fmt.Errorf("codex is not installed, install with: npm install -g @openai/codex")
+	}
+
+	out, err := exec.Command("codex", "--version").Output()
+	if err != nil {
+		return fmt.Errorf("failed to get codex version: %w", err)
+	}
+
+	// Parse output like "codex-cli 0.87.0"
+	fields := strings.Fields(strings.TrimSpace(string(out)))
+	if len(fields) < 2 {
+		return fmt.Errorf("unexpected codex version output: %s", string(out))
+	}
+
+	version := "v" + fields[len(fields)-1]
+	minVersion := "v0.81.0"
+
+	if semver.Compare(version, minVersion) < 0 {
+		return fmt.Errorf("codex version %s is too old, minimum required is %s, update with: npm update -g @openai/codex", fields[len(fields)-1], "0.81.0")
+	}
+
+	return nil
+}
@@ -0,0 +1,31 @@
+package config
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestCodexArgs(t *testing.T) {
+	c := &Codex{}
+
+	tests := []struct {
+		name  string
+		model string
+		args  []string
+		want  []string
+	}{
+		{"with model", "llama3.2", nil, []string{"--oss", "-m", "llama3.2"}},
+		{"empty model", "", nil, []string{"--oss"}},
+		{"with model and profile", "qwen3-coder", []string{"-p", "myprofile"}, []string{"--oss", "-m", "qwen3-coder", "-p", "myprofile"}},
+		{"with sandbox flag", "llama3.2", []string{"--sandbox", "workspace-write"}, []string{"--oss", "-m", "llama3.2", "--sandbox", "workspace-write"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := c.args(tt.model, tt.args)
+			if !slices.Equal(got, tt.want) {
+				t.Errorf("args(%q, %v) = %v, want %v", tt.model, tt.args, got, tt.want)
+			}
+		})
+	}
+}
@@ -9,23 +9,15 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-
-	"github.com/ollama/ollama/cmd/internal/fileutil"
 )

 type integration struct {
-	Models    []string          `json:"models"`
-	Aliases   map[string]string `json:"aliases,omitempty"`
-	Onboarded bool              `json:"onboarded,omitempty"`
+	Models  []string          `json:"models"`
+	Aliases map[string]string `json:"aliases,omitempty"`
 }

-// IntegrationConfig is the persisted config for one integration.
-type IntegrationConfig = integration
-
 type config struct {
-	Integrations  map[string]*integration `json:"integrations"`
-	LastModel     string                  `json:"last_model,omitempty"`
-	LastSelection string                  `json:"last_selection,omitempty"` // "run" or integration name
+	Integrations map[string]*integration `json:"integrations"`
 }

 func configPath() (string, error) {
@@ -59,8 +51,8 @@ func migrateConfig() (bool, error) {
 		return false, err
 	}

-	// Ignore legacy files with invalid JSON and continue startup.
-	if !json.Valid(oldData) {
+	var js json.RawMessage
+	if err := json.Unmarshal(oldData, &js); err != nil {
 		return false, nil
 	}

@@ -126,10 +118,10 @@ func save(cfg *config) error {
 		return err
 	}

-	return fileutil.WriteWithBackup(path, data)
+	return writeWithBackup(path, data)
 }

-func SaveIntegration(appName string, models []string) error {
+func saveIntegration(appName string, models []string) error {
 	if appName == "" {
 		return errors.New("app name cannot be empty")
 	}
@@ -142,111 +134,33 @@ func SaveIntegration(appName string, models []string) error {
 	key := strings.ToLower(appName)
 	existing := cfg.Integrations[key]
 	var aliases map[string]string
-	var onboarded bool
-	if existing != nil {
+	if existing != nil && existing.Aliases != nil {
 		aliases = existing.Aliases
-		onboarded = existing.Onboarded
 	}

 	cfg.Integrations[key] = &integration{
-		Models:    models,
-		Aliases:   aliases,
-		Onboarded: onboarded,
+		Models:  models,
+		Aliases: aliases,
 	}

 	return save(cfg)
 }

-// MarkIntegrationOnboarded marks an integration as onboarded in Ollama's config.
-func MarkIntegrationOnboarded(appName string) error {
-	cfg, err := load()
-	if err != nil {
-		return err
-	}
-
-	key := strings.ToLower(appName)
-	existing := cfg.Integrations[key]
-	if existing == nil {
-		existing = &integration{}
-	}
-	existing.Onboarded = true
-	cfg.Integrations[key] = existing
-	return save(cfg)
-}
-
-// IntegrationModel returns the first configured model for an integration, or empty string if not configured.
-func IntegrationModel(appName string) string {
-	integrationConfig, err := LoadIntegration(appName)
-	if err != nil || len(integrationConfig.Models) == 0 {
-		return ""
-	}
-	return integrationConfig.Models[0]
-}
-
-// IntegrationModels returns all configured models for an integration, or nil.
-func IntegrationModels(appName string) []string {
-	integrationConfig, err := LoadIntegration(appName)
-	if err != nil || len(integrationConfig.Models) == 0 {
-		return nil
-	}
-	return integrationConfig.Models
-}
-
-// LastModel returns the last model that was run, or empty string if none.
-func LastModel() string {
-	cfg, err := load()
-	if err != nil {
-		return ""
-	}
-	return cfg.LastModel
-}
-
-// SetLastModel saves the last model that was run.
-func SetLastModel(model string) error {
-	cfg, err := load()
-	if err != nil {
-		return err
-	}
-	cfg.LastModel = model
-	return save(cfg)
-}
-
-// LastSelection returns the last menu selection ("run" or integration name), or empty string if none.
-func LastSelection() string {
-	cfg, err := load()
-	if err != nil {
-		return ""
-	}
-	return cfg.LastSelection
-}
-
-// SetLastSelection saves the last menu selection ("run" or integration name).
-func SetLastSelection(selection string) error {
-	cfg, err := load()
-	if err != nil {
-		return err
-	}
-	cfg.LastSelection = selection
-	return save(cfg)
-}
-
-// LoadIntegration returns the saved config for one integration.
-func LoadIntegration(appName string) (*integration, error) {
+func loadIntegration(appName string) (*integration, error) {
 	cfg, err := load()
 	if err != nil {
 		return nil, err
 	}

-	integrationConfig, ok := cfg.Integrations[strings.ToLower(appName)]
+	ic, ok := cfg.Integrations[strings.ToLower(appName)]
 	if !ok {
 		return nil, os.ErrNotExist
 	}

-	return integrationConfig, nil
+	return ic, nil
 }

-// SaveAliases replaces the saved aliases for one integration.
-func SaveAliases(appName string, aliases map[string]string) error {
+func saveAliases(appName string, aliases map[string]string) error {
 	if appName == "" {
 		return errors.New("app name cannot be empty")
 	}
@@ -276,8 +190,8 @@ func listIntegrations() ([]integration, error) {
 	}

 	result := make([]integration, 0, len(cfg.Integrations))
-	for _, integrationConfig := range cfg.Integrations {
-		result = append(result, *integrationConfig)
+	for _, ic := range cfg.Integrations {
+		result = append(result, *ic)
 	}

 	return result, nil
@@ -1,6 +1,7 @@
 package config

 import (
+	"context"
 	"errors"
 	"os"
 	"path/filepath"
@@ -44,12 +45,12 @@ func TestSaveAliases_ReplacesNotMerges(t *testing.T) {
 		"primary": "cloud-model",
 		"fast":    "cloud-model",
 	}
-	if err := SaveAliases("claude", initial); err != nil {
+	if err := saveAliases("claude", initial); err != nil {
 		t.Fatalf("failed to save initial aliases: %v", err)
 	}

 	// Verify both are saved
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -62,12 +63,12 @@ func TestSaveAliases_ReplacesNotMerges(t *testing.T) {
 		"primary": "local-model",
 		// fast intentionally missing
 	}
-	if err := SaveAliases("claude", updated); err != nil {
+	if err := saveAliases("claude", updated); err != nil {
 		t.Fatalf("failed to save updated aliases: %v", err)
 	}

 	// Verify fast is GONE (not merged/preserved)
-	loaded, err = LoadIntegration("claude")
+	loaded, err = loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load after update: %v", err)
 	}
@@ -84,18 +85,18 @@ func TestSaveAliases_PreservesModels(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// First save integration with models
-	if err := SaveIntegration("claude", []string{"model1", "model2"}); err != nil {
+	if err := saveIntegration("claude", []string{"model1", "model2"}); err != nil {
 		t.Fatalf("failed to save integration: %v", err)
 	}

 	// Then update aliases
 	aliases := map[string]string{"primary": "new-model"}
-	if err := SaveAliases("claude", aliases); err != nil {
+	if err := saveAliases("claude", aliases); err != nil {
 		t.Fatalf("failed to save aliases: %v", err)
 	}

 	// Verify models are preserved
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -110,16 +111,16 @@ func TestSaveAliases_EmptyMap(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// Save with aliases
-	if err := SaveAliases("claude", map[string]string{"primary": "model", "fast": "model"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model", "fast": "model"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

 	// Save empty map
-	if err := SaveAliases("claude", map[string]string{}); err != nil {
+	if err := saveAliases("claude", map[string]string{}); err != nil {
 		t.Fatalf("failed to save empty: %v", err)
 	}

-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -134,16 +135,16 @@ func TestSaveAliases_NilMap(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// Save with aliases first
-	if err := SaveAliases("claude", map[string]string{"primary": "model"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

 	// Save nil map - should clear aliases
-	if err := SaveAliases("claude", nil); err != nil {
+	if err := saveAliases("claude", nil); err != nil {
 		t.Fatalf("failed to save nil: %v", err)
 	}

-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -154,7 +155,7 @@ func TestSaveAliases_NilMap(t *testing.T) {

 // TestSaveAliases_EmptyAppName returns error
 func TestSaveAliases_EmptyAppName(t *testing.T) {
-	err := SaveAliases("", map[string]string{"primary": "model"})
+	err := saveAliases("", map[string]string{"primary": "model"})
 	if err == nil {
 		t.Error("expected error for empty app name")
 	}
@@ -164,12 +165,12 @@ func TestSaveAliases_CaseInsensitive(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	if err := SaveAliases("Claude", map[string]string{"primary": "model1"}); err != nil {
+	if err := saveAliases("Claude", map[string]string{"primary": "model1"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

 	// Load with different case
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -178,11 +179,11 @@ func TestSaveAliases_CaseInsensitive(t *testing.T) {
 	}

 	// Update with different case
-	if err := SaveAliases("CLAUDE", map[string]string{"primary": "model2"}); err != nil {
+	if err := saveAliases("CLAUDE", map[string]string{"primary": "model2"}); err != nil {
 		t.Fatalf("failed to update: %v", err)
 	}

-	loaded, err = LoadIntegration("claude")
+	loaded, err = loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load after update: %v", err)
 	}
@@ -197,11 +198,11 @@ func TestSaveAliases_CreatesIntegration(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// Save aliases for non-existent integration
-	if err := SaveAliases("newintegration", map[string]string{"primary": "model"}); err != nil {
+	if err := saveAliases("newintegration", map[string]string{"primary": "model"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

-	loaded, err := LoadIntegration("newintegration")
+	loaded, err := loadIntegration("newintegration")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -370,12 +371,12 @@ func TestAtomicUpdate_ServerSucceedsConfigSaved(t *testing.T) {
 		t.Fatal("server should succeed")
 	}

-	if err := SaveAliases("claude", map[string]string{"primary": "model"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model"}); err != nil {
 		t.Fatalf("saveAliases failed: %v", err)
 	}

 	// Verify it was actually saved
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -407,7 +408,7 @@ func TestConfigFile_PreservesUnknownFields(t *testing.T) {
 	os.WriteFile(configPath, []byte(initialConfig), 0o644)

 	// Update aliases
-	if err := SaveAliases("claude", map[string]string{"primary": "model2"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model2"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

@@ -439,6 +440,11 @@ func containsHelper(s, substr string) bool {
 	return false
 }

+func TestClaudeImplementsAliasConfigurer(t *testing.T) {
+	c := &Claude{}
+	var _ AliasConfigurer = c // Compile-time check
+}
+
 func TestModelNameEdgeCases(t *testing.T) {
 	testCases := []struct {
 		name  string
@@ -458,11 +464,11 @@ func TestModelNameEdgeCases(t *testing.T) {
 			setTestHome(t, tmpDir)

 			aliases := map[string]string{"primary": tc.model}
-			if err := SaveAliases("claude", aliases); err != nil {
+			if err := saveAliases("claude", aliases); err != nil {
 				t.Fatalf("failed to save model %q: %v", tc.model, err)
 			}

-			loaded, err := LoadIntegration("claude")
+			loaded, err := loadIntegration("claude")
 			if err != nil {
 				t.Fatalf("failed to load: %v", err)
 			}
@@ -479,7 +485,7 @@ func TestSwitchingScenarios(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial cloud config
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model",
 			"fast":    "cloud-model",
 		}); err != nil {
@@ -487,13 +493,13 @@ func TestSwitchingScenarios(t *testing.T) {
 		}

 		// Switch to local (no fast)
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "local-model",
 		}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["fast"] != "" {
 			t.Errorf("fast should be removed, got %q", loaded.Aliases["fast"])
 		}
@@ -507,21 +513,21 @@ func TestSwitchingScenarios(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial local config
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "local-model",
 		}); err != nil {
 			t.Fatal(err)
 		}

 		// Switch to cloud (with fast)
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model",
 			"fast":    "cloud-model",
 		}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["fast"] != "cloud-model" {
 			t.Errorf("fast should be cloud-model, got %q", loaded.Aliases["fast"])
 		}
@@ -532,7 +538,7 @@ func TestSwitchingScenarios(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial cloud config
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model-1",
 			"fast":    "cloud-model-1",
 		}); err != nil {
@@ -540,14 +546,14 @@ func TestSwitchingScenarios(t *testing.T) {
 		}

 		// Switch to different cloud
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model-2",
 			"fast":    "cloud-model-2",
 		}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["primary"] != "cloud-model-2" {
 			t.Errorf("primary should be cloud-model-2, got %q", loaded.Aliases["primary"])
 		}
@@ -557,22 +563,52 @@ func TestSwitchingScenarios(t *testing.T) {
 	})
 }

+func TestToolCapabilityFiltering(t *testing.T) {
+	t.Run("all models checked for tool capability", func(t *testing.T) {
+		// Both cloud and local models are checked for tool capability via Show API
+		// Only models with "tools" in capabilities are included
+		m := modelInfo{Name: "tool-model", Remote: false, ToolCapable: true}
+		if !m.ToolCapable {
+			t.Error("tool capable model should be marked as such")
+		}
+	})
+
+	t.Run("modelInfo includes ToolCapable field", func(t *testing.T) {
+		m := modelInfo{Name: "test", Remote: true, ToolCapable: true}
+		if !m.ToolCapable {
+			t.Error("ToolCapable field should be accessible")
+		}
+	})
+}
+
+func TestIsCloudModel_RequiresClient(t *testing.T) {
+	t.Run("nil client always returns false", func(t *testing.T) {
+		// isCloudModel now only uses Show API, no suffix detection
+		if isCloudModel(context.Background(), nil, "model:cloud") {
+			t.Error("nil client should return false regardless of suffix")
+		}
+		if isCloudModel(context.Background(), nil, "local-model") {
+			t.Error("nil client should return false")
+		}
+	})
+}
+
 func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 	t.Run("saveAliases followed by saveIntegration keeps them in sync", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)

 		// Save aliases with one model
-		if err := SaveAliases("claude", map[string]string{"primary": "model-a"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "model-a"}); err != nil {
 			t.Fatal(err)
 		}

 		// Save integration with same model (this is the pattern we use)
-		if err := SaveIntegration("claude", []string{"model-a"}); err != nil {
+		if err := saveIntegration("claude", []string{"model-a"}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["primary"] != loaded.Models[0] {
 			t.Errorf("aliases.primary (%q) != models[0] (%q)", loaded.Aliases["primary"], loaded.Models[0])
 		}
@@ -583,14 +619,14 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Simulate out-of-sync state (like manual edit or bug)
-		if err := SaveIntegration("claude", []string{"old-model"}); err != nil {
+		if err := saveIntegration("claude", []string{"old-model"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveAliases("claude", map[string]string{"primary": "new-model"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "new-model"}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")

 		// They should be different (this is the bug state)
 		if loaded.Models[0] == loaded.Aliases["primary"] {
@@ -598,11 +634,11 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		}

 		// The fix: when updating aliases, also update models
-		if err := SaveIntegration("claude", []string{loaded.Aliases["primary"]}); err != nil {
+		if err := saveIntegration("claude", []string{loaded.Aliases["primary"]}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ = LoadIntegration("claude")
+		loaded, _ = loadIntegration("claude")
 		if loaded.Models[0] != loaded.Aliases["primary"] {
 			t.Errorf("after fix: models[0] (%q) should equal aliases.primary (%q)",
 				loaded.Models[0], loaded.Aliases["primary"])
@@ -614,23 +650,23 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial state
-		if err := SaveIntegration("claude", []string{"initial-model"}); err != nil {
+		if err := saveIntegration("claude", []string{"initial-model"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveAliases("claude", map[string]string{"primary": "initial-model"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "initial-model"}); err != nil {
 			t.Fatal(err)
 		}

 		// Update aliases AND models together
 		newAliases := map[string]string{"primary": "updated-model"}
-		if err := SaveAliases("claude", newAliases); err != nil {
+		if err := saveAliases("claude", newAliases); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveIntegration("claude", []string{newAliases["primary"]}); err != nil {
+		if err := saveIntegration("claude", []string{newAliases["primary"]}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Models[0] != "updated-model" {
 			t.Errorf("models[0] should be updated-model, got %q", loaded.Models[0])
 		}
@@ -10,21 +10,28 @@ import (
 // setTestHome sets both HOME (Unix) and USERPROFILE (Windows) for cross-platform tests
 func setTestHome(t *testing.T, dir string) {
 	t.Setenv("HOME", dir)
-	t.Setenv("TMPDIR", dir)
 	t.Setenv("USERPROFILE", dir)
 }

+// editorPaths is a test helper that safely calls Paths if the runner implements Editor
+func editorPaths(r Runner) []string {
+	if editor, ok := r.(Editor); ok {
+		return editor.Paths()
+	}
+	return nil
+}
+
 func TestIntegrationConfig(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

 	t.Run("save and load round-trip", func(t *testing.T) {
 		models := []string{"llama3.2", "mistral", "qwen2.5"}
-		if err := SaveIntegration("claude", models); err != nil {
+		if err := saveIntegration("claude", models); err != nil {
 			t.Fatal(err)
 		}

-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -41,18 +48,18 @@ func TestIntegrationConfig(t *testing.T) {

 	t.Run("save and load aliases", func(t *testing.T) {
 		models := []string{"llama3.2"}
-		if err := SaveIntegration("claude", models); err != nil {
+		if err := saveIntegration("claude", models); err != nil {
 			t.Fatal(err)
 		}
 		aliases := map[string]string{
 			"primary": "llama3.2:70b",
 			"fast":    "llama3.2:8b",
 		}
-		if err := SaveAliases("claude", aliases); err != nil {
+		if err := saveAliases("claude", aliases); err != nil {
 			t.Fatal(err)
 		}

-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -67,17 +74,17 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("saveIntegration preserves aliases", func(t *testing.T) {
-		if err := SaveIntegration("claude", []string{"model-a"}); err != nil {
+		if err := saveIntegration("claude", []string{"model-a"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveAliases("claude", map[string]string{"primary": "model-a", "fast": "model-small"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "model-a", "fast": "model-small"}); err != nil {
 			t.Fatal(err)
 		}

-		if err := SaveIntegration("claude", []string{"model-b"}); err != nil {
+		if err := saveIntegration("claude", []string{"model-b"}); err != nil {
 			t.Fatal(err)
 		}
-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -87,9 +94,9 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("defaultModel returns first model", func(t *testing.T) {
-		SaveIntegration("codex", []string{"model-a", "model-b"})
+		saveIntegration("codex", []string{"model-a", "model-b"})

-		config, _ := LoadIntegration("codex")
+		config, _ := loadIntegration("codex")
 		defaultModel := ""
 		if len(config.Models) > 0 {
 			defaultModel = config.Models[0]
@@ -111,9 +118,9 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("app name is case-insensitive", func(t *testing.T) {
-		SaveIntegration("Claude", []string{"model-x"})
+		saveIntegration("Claude", []string{"model-x"})

-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -127,11 +134,11 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("multiple integrations in single file", func(t *testing.T) {
-		SaveIntegration("app1", []string{"model-1"})
-		SaveIntegration("app2", []string{"model-2"})
+		saveIntegration("app1", []string{"model-1"})
+		saveIntegration("app2", []string{"model-2"})

-		config1, _ := LoadIntegration("app1")
-		config2, _ := LoadIntegration("app2")
+		config1, _ := loadIntegration("app1")
+		config2, _ := loadIntegration("app2")

 		defaultModel1 := ""
 		if len(config1.Models) > 0 {
@@ -165,8 +172,8 @@ func TestListIntegrations(t *testing.T) {
 	})

 	t.Run("returns all saved integrations", func(t *testing.T) {
-		SaveIntegration("claude", []string{"model-1"})
-		SaveIntegration("droid", []string{"model-2"})
+		saveIntegration("claude", []string{"model-1"})
+		saveIntegration("droid", []string{"model-2"})

 		configs, err := listIntegrations()
 		if err != nil {
@@ -178,6 +185,64 @@ func TestListIntegrations(t *testing.T) {
 	})
 }

+func TestEditorPaths(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	t.Run("returns empty for claude (no Editor)", func(t *testing.T) {
+		r := integrations["claude"]
+		paths := editorPaths(r)
+		if len(paths) != 0 {
+			t.Errorf("expected no paths for claude, got %v", paths)
+		}
+	})
+
+	t.Run("returns empty for codex (no Editor)", func(t *testing.T) {
+		r := integrations["codex"]
+		paths := editorPaths(r)
+		if len(paths) != 0 {
+			t.Errorf("expected no paths for codex, got %v", paths)
+		}
+	})
+
+	t.Run("returns empty for droid when no config exists", func(t *testing.T) {
+		r := integrations["droid"]
+		paths := editorPaths(r)
+		if len(paths) != 0 {
+			t.Errorf("expected no paths, got %v", paths)
+		}
+	})
+
+	t.Run("returns path for droid when config exists", func(t *testing.T) {
+		settingsDir, _ := os.UserHomeDir()
+		settingsDir = filepath.Join(settingsDir, ".factory")
+		os.MkdirAll(settingsDir, 0o755)
+		os.WriteFile(filepath.Join(settingsDir, "settings.json"), []byte(`{}`), 0o644)
+
+		r := integrations["droid"]
+		paths := editorPaths(r)
+		if len(paths) != 1 {
+			t.Errorf("expected 1 path, got %d", len(paths))
+		}
+	})
+
+	t.Run("returns paths for opencode when configs exist", func(t *testing.T) {
+		home, _ := os.UserHomeDir()
+		configDir := filepath.Join(home, ".config", "opencode")
+		stateDir := filepath.Join(home, ".local", "state", "opencode")
+		os.MkdirAll(configDir, 0o755)
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "opencode.json"), []byte(`{}`), 0o644)
+		os.WriteFile(filepath.Join(stateDir, "model.json"), []byte(`{}`), 0o644)
+
+		r := integrations["opencode"]
+		paths := editorPaths(r)
+		if len(paths) != 2 {
+			t.Errorf("expected 2 paths, got %d: %v", len(paths), paths)
+		}
+	})
+}
+
 func TestLoadIntegration_CorruptedJSON(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)
@@ -186,7 +251,7 @@ func TestLoadIntegration_CorruptedJSON(t *testing.T) {
 	os.MkdirAll(dir, 0o755)
 	os.WriteFile(filepath.Join(dir, "config.json"), []byte(`{corrupted json`), 0o644)

-	_, err := LoadIntegration("test")
+	_, err := loadIntegration("test")
 	if err == nil {
 		t.Error("expected error for nonexistent integration in corrupted file")
 	}
@@ -196,11 +261,11 @@ func TestSaveIntegration_NilModels(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	if err := SaveIntegration("test", nil); err != nil {
+	if err := saveIntegration("test", nil); err != nil {
 		t.Fatalf("saveIntegration with nil models failed: %v", err)
 	}

-	config, err := LoadIntegration("test")
+	config, err := loadIntegration("test")
 	if err != nil {
 		t.Fatalf("loadIntegration failed: %v", err)
 	}
@@ -216,7 +281,7 @@ func TestSaveIntegration_EmptyAppName(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	err := SaveIntegration("", []string{"model"})
+	err := saveIntegration("", []string{"model"})
 	if err == nil {
 		t.Error("expected error for empty app name, got nil")
 	}
@@ -229,7 +294,7 @@ func TestLoadIntegration_NonexistentIntegration(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	_, err := LoadIntegration("nonexistent")
+	_, err := loadIntegration("nonexistent")
 	if err == nil {
 		t.Error("expected error for nonexistent integration, got nil")
 	}
@@ -446,7 +511,7 @@ func TestMigrateConfig(t *testing.T) {
 		os.WriteFile(filepath.Join(legacyDir, "config.json"), []byte(`{"integrations":{"claude":{"models":["llama3.2"]}}}`), 0o644)

 		// load triggers migration, then save should write to new path
-		if err := SaveIntegration("codex", []string{"qwen2.5"}); err != nil {
+		if err := saveIntegration("codex", []string{"qwen2.5"}); err != nil {
 			t.Fatal(err)
 		}

@@ -1,6 +1,7 @@
-package launch
+package config

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -8,7 +9,7 @@ import (
 	"path/filepath"
 	"slices"

-	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/envconfig"
 )

@@ -45,6 +46,15 @@ func (d *Droid) Run(model string, args []string) error {
 		return fmt.Errorf("droid is not installed, install from https://docs.factory.ai/cli/getting-started/quickstart")
 	}

+	// Call Edit() to ensure config is up-to-date before launch
+	models := []string{model}
+	if config, err := loadIntegration("droid"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	if err := d.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
 	cmd := exec.Command("droid", args...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -90,16 +100,6 @@ func (d *Droid) Edit(models []string) error {
 		json.Unmarshal(data, &settings) // ignore error, zero values are fine
 	}

-	settingsMap = updateDroidSettings(settingsMap, settings, models)
-
-	data, err := json.MarshalIndent(settingsMap, "", "  ")
-	if err != nil {
-		return err
-	}
-	return fileutil.WriteWithBackup(settingsPath, data)
-}
-
-func updateDroidSettings(settingsMap map[string]any, settings droidSettings, models []string) map[string]any {
 	// Keep only non-Ollama models from the raw map (preserves extra fields)
 	// Rebuild Ollama models
 	var nonOllamaModels []any
@@ -114,12 +114,13 @@ func updateDroidSettings(settingsMap map[string]any, settings droidSettings, mod
 	}

 	// Build new Ollama model entries with sequential indices (0, 1, 2, ...)
+	client, _ := api.ClientFromEnvironment()

 	var newModels []any
 	var defaultModelID string
 	for i, model := range models {
 		maxOutput := 64000
-		if isCloudModelName(model) {
+		if isCloudModel(context.Background(), client, model) {
 			if l, ok := lookupCloudModelLimit(model); ok {
 				maxOutput = l.Output
 			}
@@ -155,7 +156,12 @@ func updateDroidSettings(settingsMap map[string]any, settings droidSettings, mod
 	}

 	settingsMap["sessionDefaultSettings"] = sessionSettings
-	return settingsMap
+
+	data, err := json.MarshalIndent(settingsMap, "", "  ")
+	if err != nil {
+		return err
+	}
+	return writeWithBackup(settingsPath, data)
 }

 func (d *Droid) Models() []string {
@@ -1,4 +1,4 @@
-package launch
+package config

 import (
 	"encoding/json"
@@ -6,8 +6,6 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
-
-	"github.com/ollama/ollama/cmd/internal/fileutil"
 )

 func TestDroidIntegration(t *testing.T) {
@@ -364,7 +362,7 @@ func TestDroidEdit_DuplicateModels(t *testing.T) {
 		t.Fatalf("Edit with duplicates failed: %v", err)
 	}

-	settings, err := fileutil.ReadJSON(settingsPath)
+	settings, err := readJSONFile(settingsPath)
 	if err != nil {
 		t.Fatalf("readJSONFile failed: %v", err)
 	}
@@ -394,7 +392,7 @@ func TestDroidEdit_MalformedModelEntry(t *testing.T) {
 	}

 	// Malformed entries (non-object) are dropped - only valid model objects are preserved
-	settings, _ := fileutil.ReadJSON(settingsPath)
+	settings, _ := readJSONFile(settingsPath)
 	customModels, _ := settings["customModels"].([]any)

 	// Should have: 1 new Ollama model only (malformed entries dropped)
@@ -421,7 +419,7 @@ func TestDroidEdit_WrongTypeSessionSettings(t *testing.T) {
 	}

 	// Should create proper sessionDefaultSettings
-	settings, _ := fileutil.ReadJSON(settingsPath)
+	settings, _ := readJSONFile(settingsPath)
 	session, ok := settings["sessionDefaultSettings"].(map[string]any)
 	if !ok {
 		t.Fatalf("sessionDefaultSettings should be map after setup, got %T", settings["sessionDefaultSettings"])
@@ -1010,34 +1008,34 @@ func TestDroidEdit_ModelNamesWithSpecialCharacters(t *testing.T) {
 }

 func TestDroidEdit_MissingCustomModelsKey(t *testing.T) {
+	d := &Droid{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	settingsDir := filepath.Join(tmpDir, ".factory")
+	settingsPath := filepath.Join(settingsDir, "settings.json")
+
+	os.MkdirAll(settingsDir, 0o755)
+
 	// No customModels key at all
 	original := `{
 		"diffMode": "github",
 		"sessionDefaultSettings": {"autonomyMode": "auto-high"}
 	}`
+	os.WriteFile(settingsPath, []byte(original), 0o644)

-	var settingsStruct droidSettings
+	if err := d.Edit([]string{"model-a"}); err != nil {
+		t.Fatal(err)
+	}
+
+	data, _ := os.ReadFile(settingsPath)
 	var settings map[string]any
-	if err := json.Unmarshal([]byte(original), &settings); err != nil {
-		t.Fatal(err)
-	}
-	if err := json.Unmarshal([]byte(original), &settingsStruct); err != nil {
-		t.Fatal(err)
-	}
-
-	settings = updateDroidSettings(settings, settingsStruct, []string{"model-a"})
+	json.Unmarshal(data, &settings)

 	// Original fields preserved
 	if settings["diffMode"] != "github" {
 		t.Error("diffMode not preserved")
 	}
-	session, ok := settings["sessionDefaultSettings"].(map[string]any)
-	if !ok {
-		t.Fatal("sessionDefaultSettings not preserved")
-	}
-	if session["autonomyMode"] != "auto-high" {
-		t.Error("sessionDefaultSettings.autonomyMode not preserved")
-	}

 	// customModels created
 	models, ok := settings["customModels"].([]any)
@@ -1278,18 +1276,26 @@ func TestDroidEdit_LocalModelDefaultMaxOutput(t *testing.T) {

 func TestDroidEdit_CloudModelLimitsUsed(t *testing.T) {
 	// Verify that every cloud model in cloudModelLimits has a valid output
-	// value that would be used for maxOutputTokens when the selected model uses
-	// the explicit :cloud source tag.
+	// value that would be used for maxOutputTokens when isCloudModel returns true.
+	// :cloud suffix stripping must also work since that's how users specify them.
 	for name, expected := range cloudModelLimits {
 		t.Run(name, func(t *testing.T) {
-			cloudName := name + ":cloud"
-			l, ok := lookupCloudModelLimit(cloudName)
+			l, ok := lookupCloudModelLimit(name)
 			if !ok {
-				t.Fatalf("lookupCloudModelLimit(%q) returned false", cloudName)
+				t.Fatalf("lookupCloudModelLimit(%q) returned false", name)
 			}
 			if l.Output != expected.Output {
 				t.Errorf("output = %d, want %d", l.Output, expected.Output)
 			}
+			// Also verify :cloud suffix lookup
+			cloudName := name + ":cloud"
+			l2, ok := lookupCloudModelLimit(cloudName)
+			if !ok {
+				t.Fatalf("lookupCloudModelLimit(%q) returned false", cloudName)
+			}
+			if l2.Output != expected.Output {
+				t.Errorf(":cloud output = %d, want %d", l2.Output, expected.Output)
+			}
 		})
 	}
 }
@@ -1,6 +1,4 @@
-// Package fileutil provides small shared helpers for reading JSON files
-// and writing config files with backup-on-overwrite semantics.
-package fileutil
+package config

 import (
 	"bytes"
@@ -11,8 +9,7 @@ import (
 	"time"
 )

-// ReadJSON reads a JSON object file into a generic map.
-func ReadJSON(path string) (map[string]any, error) {
+func readJSONFile(path string) (map[string]any, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return nil, err
@@ -36,13 +33,12 @@ func copyFile(src, dst string) error {
 	return os.WriteFile(dst, data, info.Mode().Perm())
 }

-// BackupDir returns the shared backup directory used before overwriting files.
-func BackupDir() string {
+func backupDir() string {
 	return filepath.Join(os.TempDir(), "ollama-backups")
 }

 func backupToTmp(srcPath string) (string, error) {
-	dir := BackupDir()
+	dir := backupDir()
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return "", err
 	}
@@ -54,8 +50,8 @@ func backupToTmp(srcPath string) (string, error) {
 	return backupPath, nil
 }

-// WriteWithBackup writes data to path via temp file + rename, backing up any existing file first.
-func WriteWithBackup(path string, data []byte) error {
+// writeWithBackup writes data to path via temp file + rename, backing up any existing file first
+func writeWithBackup(path string, data []byte) error {
 	var backupPath string
 	// backup must be created before any writes to the target file
 	if existingContent, err := os.ReadFile(path); err == nil {
@@ -1,4 +1,4 @@
-package fileutil
+package config

 import (
 	"encoding/json"
@@ -9,21 +9,6 @@ import (
 	"testing"
 )

-func TestMain(m *testing.M) {
-	tmpRoot, err := os.MkdirTemp("", "fileutil-test-*")
-	if err != nil {
-		panic(err)
-	}
-
-	if err := os.Setenv("TMPDIR", tmpRoot); err != nil {
-		panic(err)
-	}
-
-	code := m.Run()
-	_ = os.RemoveAll(tmpRoot)
-	os.Exit(code)
-}
-
 func mustMarshal(t *testing.T, v any) []byte {
 	t.Helper()
 	data, err := json.MarshalIndent(v, "", "  ")
@@ -33,19 +18,14 @@ func mustMarshal(t *testing.T, v any) []byte {
 	return data
 }

-func isolatedTempDir(t *testing.T) string {
-	t.Helper()
-	return t.TempDir()
-}
-
 func TestWriteWithBackup(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	t.Run("creates file", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "new.json")
 		data := mustMarshal(t, map[string]string{"key": "value"})

-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

@@ -63,17 +43,17 @@ func TestWriteWithBackup(t *testing.T) {
 		}
 	})

-	t.Run("creates backup in the temp backup directory", func(t *testing.T) {
+	t.Run("creates backup in /tmp/ollama-backups", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "backup.json")

 		os.WriteFile(path, []byte(`{"original": true}`), 0o644)

 		data := mustMarshal(t, map[string]bool{"updated": true})
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries, err := os.ReadDir(BackupDir())
+		entries, err := os.ReadDir(backupDir())
 		if err != nil {
 			t.Fatal("backup directory not created")
 		}
@@ -83,7 +63,7 @@ func TestWriteWithBackup(t *testing.T) {
 			if filepath.Ext(entry.Name()) != ".json" {
 				name := entry.Name()
 				if len(name) > len("backup.json.") && name[:len("backup.json.")] == "backup.json." {
-					backupPath := filepath.Join(BackupDir(), name)
+					backupPath := filepath.Join(backupDir(), name)
 					backup, err := os.ReadFile(backupPath)
 					if err == nil {
 						var backupData map[string]bool
@@ -99,7 +79,7 @@ func TestWriteWithBackup(t *testing.T) {
 		}

 		if !foundBackup {
-			t.Error("backup file not created in backup directory")
+			t.Error("backup file not created in /tmp/ollama-backups")
 		}

 		current, _ := os.ReadFile(path)
@@ -114,11 +94,11 @@ func TestWriteWithBackup(t *testing.T) {
 		path := filepath.Join(tmpDir, "nobak.json")

 		data := mustMarshal(t, map[string]string{"new": "file"})
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries, _ := os.ReadDir(BackupDir())
+		entries, _ := os.ReadDir(backupDir())
 		for _, entry := range entries {
 			if len(entry.Name()) > len("nobak.json.") && entry.Name()[:len("nobak.json.")] == "nobak.json." {
 				t.Error("backup should not exist for new file")
@@ -131,11 +111,11 @@ func TestWriteWithBackup(t *testing.T) {

 		data := mustMarshal(t, map[string]string{"key": "value"})

-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries1, _ := os.ReadDir(BackupDir())
+		entries1, _ := os.ReadDir(backupDir())
 		countBefore := 0
 		for _, e := range entries1 {
 			if len(e.Name()) > len("unchanged.json.") && e.Name()[:len("unchanged.json.")] == "unchanged.json." {
@@ -143,11 +123,11 @@ func TestWriteWithBackup(t *testing.T) {
 			}
 		}

-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries2, _ := os.ReadDir(BackupDir())
+		entries2, _ := os.ReadDir(backupDir())
 		countAfter := 0
 		for _, e := range entries2 {
 			if len(e.Name()) > len("unchanged.json.") && e.Name()[:len("unchanged.json.")] == "unchanged.json." {
@@ -165,11 +145,11 @@ func TestWriteWithBackup(t *testing.T) {

 		os.WriteFile(path, []byte(`{"v": 1}`), 0o644)
 		data := mustMarshal(t, map[string]int{"v": 2})
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries, _ := os.ReadDir(BackupDir())
+		entries, _ := os.ReadDir(backupDir())
 		var found bool
 		for _, entry := range entries {
 			name := entry.Name()
@@ -181,7 +161,7 @@ func TestWriteWithBackup(t *testing.T) {
 					}
 				}
 				found = true
-				os.Remove(filepath.Join(BackupDir(), name))
+				os.Remove(filepath.Join(backupDir(), name))
 				break
 			}
 		}
@@ -200,7 +180,7 @@ func TestWriteWithBackup_FailsIfBackupFails(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "config.json")

 	// Create original file
@@ -208,13 +188,13 @@ func TestWriteWithBackup_FailsIfBackupFails(t *testing.T) {
 	os.WriteFile(path, originalContent, 0o644)

 	// Make backup directory read-only to force backup failure
-	backupDir := BackupDir()
+	backupDir := backupDir()
 	os.MkdirAll(backupDir, 0o755)
 	os.Chmod(backupDir, 0o444) // Read-only
 	defer os.Chmod(backupDir, 0o755)

 	newContent := []byte(`{"updated": true}`)
-	err := WriteWithBackup(path, newContent)
+	err := writeWithBackup(path, newContent)

 	// Should fail because backup couldn't be created
 	if err == nil {
@@ -235,7 +215,7 @@ func TestWriteWithBackup_PermissionDenied(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	// Create a read-only directory
 	readOnlyDir := filepath.Join(tmpDir, "readonly")
@@ -244,7 +224,7 @@ func TestWriteWithBackup_PermissionDenied(t *testing.T) {
 	defer os.Chmod(readOnlyDir, 0o755)

 	path := filepath.Join(readOnlyDir, "config.json")
-	err := WriteWithBackup(path, []byte(`{"test": true}`))
+	err := writeWithBackup(path, []byte(`{"test": true}`))

 	if err == nil {
 		t.Error("expected permission error, got nil")
@@ -254,10 +234,10 @@ func TestWriteWithBackup_PermissionDenied(t *testing.T) {
 // TestWriteWithBackup_DirectoryDoesNotExist verifies behavior when target directory doesn't exist.
 // writeWithBackup doesn't create directories - caller is responsible.
 func TestWriteWithBackup_DirectoryDoesNotExist(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "nonexistent", "subdir", "config.json")

-	err := WriteWithBackup(path, []byte(`{"test": true}`))
+	err := writeWithBackup(path, []byte(`{"test": true}`))

 	// Should fail because directory doesn't exist
 	if err == nil {
@@ -272,7 +252,7 @@ func TestWriteWithBackup_SymlinkTarget(t *testing.T) {
 		t.Skip("symlink tests may require admin on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	realFile := filepath.Join(tmpDir, "real.json")
 	symlink := filepath.Join(tmpDir, "link.json")

@@ -281,7 +261,7 @@ func TestWriteWithBackup_SymlinkTarget(t *testing.T) {
 	os.Symlink(realFile, symlink)

 	// Write through symlink
-	err := WriteWithBackup(symlink, []byte(`{"v": 2}`))
+	err := writeWithBackup(symlink, []byte(`{"v": 2}`))
 	if err != nil {
 		t.Fatalf("writeWithBackup through symlink failed: %v", err)
 	}
@@ -296,7 +276,7 @@ func TestWriteWithBackup_SymlinkTarget(t *testing.T) {
 // TestBackupToTmp_SpecialCharsInFilename verifies backup works with special characters.
 // User may have config files with unusual names.
 func TestBackupToTmp_SpecialCharsInFilename(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	// File with spaces and special chars
 	path := filepath.Join(tmpDir, "my config (backup).json")
@@ -325,7 +305,7 @@ func TestCopyFile_PreservesPermissions(t *testing.T) {
 		t.Skip("permission preservation tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	src := filepath.Join(tmpDir, "src.json")
 	dst := filepath.Join(tmpDir, "dst.json")

@@ -347,7 +327,7 @@ func TestCopyFile_PreservesPermissions(t *testing.T) {

 // TestCopyFile_SourceNotFound verifies clear error when source doesn't exist.
 func TestCopyFile_SourceNotFound(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	src := filepath.Join(tmpDir, "nonexistent.json")
 	dst := filepath.Join(tmpDir, "dst.json")

@@ -359,11 +339,11 @@ func TestCopyFile_SourceNotFound(t *testing.T) {

 // TestWriteWithBackup_TargetIsDirectory verifies error when path points to a directory.
 func TestWriteWithBackup_TargetIsDirectory(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	dirPath := filepath.Join(tmpDir, "actualdir")
 	os.MkdirAll(dirPath, 0o755)

-	err := WriteWithBackup(dirPath, []byte(`{"test": true}`))
+	err := writeWithBackup(dirPath, []byte(`{"test": true}`))
 	if err == nil {
 		t.Error("expected error when target is a directory, got nil")
 	}
@@ -371,10 +351,10 @@ func TestWriteWithBackup_TargetIsDirectory(t *testing.T) {

 // TestWriteWithBackup_EmptyData verifies writing zero bytes works correctly.
 func TestWriteWithBackup_EmptyData(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "empty.json")

-	err := WriteWithBackup(path, []byte{})
+	err := writeWithBackup(path, []byte{})
 	if err != nil {
 		t.Fatalf("writeWithBackup with empty data failed: %v", err)
 	}
@@ -395,7 +375,7 @@ func TestWriteWithBackup_FileUnreadableButDirWritable(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "unreadable.json")

 	// Create file and make it unreadable
@@ -404,7 +384,7 @@ func TestWriteWithBackup_FileUnreadableButDirWritable(t *testing.T) {
 	defer os.Chmod(path, 0o644)

 	// Should fail because we can't read the file to compare/backup
-	err := WriteWithBackup(path, []byte(`{"updated": true}`))
+	err := writeWithBackup(path, []byte(`{"updated": true}`))
 	if err == nil {
 		t.Error("expected error when file is unreadable, got nil")
 	}
@@ -413,7 +393,7 @@ func TestWriteWithBackup_FileUnreadableButDirWritable(t *testing.T) {
 // TestWriteWithBackup_RapidSuccessiveWrites verifies backup works with multiple writes
 // within the same second (timestamp collision scenario).
 func TestWriteWithBackup_RapidSuccessiveWrites(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "rapid.json")

 	// Create initial file
@@ -422,7 +402,7 @@ func TestWriteWithBackup_RapidSuccessiveWrites(t *testing.T) {
 	// Rapid successive writes
 	for i := 1; i <= 3; i++ {
 		data := []byte(fmt.Sprintf(`{"v": %d}`, i))
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatalf("write %d failed: %v", i, err)
 		}
 	}
@@ -434,7 +414,7 @@ func TestWriteWithBackup_RapidSuccessiveWrites(t *testing.T) {
 	}

 	// Verify at least one backup exists
-	entries, _ := os.ReadDir(BackupDir())
+	entries, _ := os.ReadDir(backupDir())
 	var backupCount int
 	for _, e := range entries {
 		if len(e.Name()) > len("rapid.json.") && e.Name()[:len("rapid.json.")] == "rapid.json." {
@@ -452,9 +432,8 @@ func TestWriteWithBackup_BackupDirIsFile(t *testing.T) {
 		t.Skip("test modifies system temp directory")
 	}

-	tmpDir := isolatedTempDir(t)
 	// Create a file at the backup directory path
-	backupPath := BackupDir()
+	backupPath := backupDir()
 	// Clean up any existing directory first
 	os.RemoveAll(backupPath)
 	// Create a file instead of directory
@@ -464,10 +443,11 @@ func TestWriteWithBackup_BackupDirIsFile(t *testing.T) {
 		os.MkdirAll(backupPath, 0o755)
 	}()

+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "test.json")
 	os.WriteFile(path, []byte(`{"original": true}`), 0o644)

-	err := WriteWithBackup(path, []byte(`{"updated": true}`))
+	err := writeWithBackup(path, []byte(`{"updated": true}`))
 	if err == nil {
 		t.Error("expected error when backup dir is a file, got nil")
 	}
@@ -479,7 +459,7 @@ func TestWriteWithBackup_NoOrphanTempFiles(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	// Count existing temp files
 	countTempFiles := func() int {
@@ -513,7 +493,7 @@ func TestWriteWithBackup_NoOrphanTempFiles(t *testing.T) {
 	badPath := filepath.Join(tmpDir, "isdir")
 	os.MkdirAll(badPath, 0o755)

-	_ = WriteWithBackup(badPath, []byte(`{"test": true}`))
+	_ = writeWithBackup(badPath, []byte(`{"test": true}`))

 	after := countTempFiles()
 	if after > before {
@@ -0,0 +1,751 @@
+package config
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"os"
+	"os/exec"
+	"runtime"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/progress"
+	"github.com/spf13/cobra"
+)
+
+// Runners execute the launching of a model with the integration - claude, codex
+// Editors can edit config files (supports multi-model selection) - opencode, droid
+// They are composable interfaces where in some cases an editor is also a runner - opencode, droid
+// Runner can run an integration with a model.
+
+type Runner interface {
+	Run(model string, args []string) error
+	// String returns the human-readable name of the integration
+	String() string
+}
+
+// Editor can edit config files (supports multi-model selection)
+type Editor interface {
+	// Paths returns the paths to the config files for the integration
+	Paths() []string
+	// Edit updates the config files for the integration with the given models
+	Edit(models []string) error
+	// Models returns the models currently configured for the integration
+	// TODO(parthsareen): add error return to Models()
+	Models() []string
+}
+
+// AliasConfigurer can configure model aliases (e.g., for subagent routing).
+// Integrations like Claude and Codex use this to route model requests to local models.
+type AliasConfigurer interface {
+	// ConfigureAliases prompts the user to configure aliases and returns the updated map.
+	ConfigureAliases(ctx context.Context, primaryModel string, existing map[string]string, force bool) (map[string]string, bool, error)
+	// SetAliases syncs the configured aliases to the server
+	SetAliases(ctx context.Context, aliases map[string]string) error
+}
+
+// integrations is the registry of available integrations.
+var integrations = map[string]Runner{
+	"claude":   &Claude{},
+	"clawdbot": &Openclaw{},
+	"codex":    &Codex{},
+	"moltbot":  &Openclaw{},
+	"droid":    &Droid{},
+	"opencode": &OpenCode{},
+	"openclaw": &Openclaw{},
+}
+
+// IsIntegration returns true if the given name is a valid integration.
+func IsIntegration(name string) bool {
+	_, ok := integrations[strings.ToLower(name)]
+	return ok
+}
+
+// recommendedModels are shown when the user has no models or as suggestions.
+// Order matters: local models first, then cloud models.
+var recommendedModels = []selectItem{
+	{Name: "glm-4.7-flash", Description: "Recommended (requires ~25GB VRAM)"},
+	{Name: "qwen3:8b", Description: "Recommended (requires ~11GB VRAM)"},
+	{Name: "glm-4.7:cloud", Description: "Recommended"},
+	{Name: "kimi-k2.5:cloud", Description: "Recommended"},
+}
+
+// integrationAliases are hidden from the interactive selector but work as CLI arguments.
+var integrationAliases = map[string]bool{
+	"clawdbot": true,
+	"moltbot":  true,
+}
+
+func selectIntegration() (string, error) {
+	if len(integrations) == 0 {
+		return "", fmt.Errorf("no apps available")
+	}
+
+	names := slices.Sorted(maps.Keys(integrations))
+	var items []selectItem
+	for _, name := range names {
+		if integrationAliases[name] {
+			continue
+		}
+		r := integrations[name]
+		description := r.String()
+		if conn, err := loadIntegration(name); err == nil && len(conn.Models) > 0 {
+			description = fmt.Sprintf("%s (%s)", r.String(), conn.Models[0])
+		}
+		items = append(items, selectItem{Name: name, Description: description})
+	}
+
+	return selectPrompt("Select app:", items)
+}
+
+// selectModels lets the user select models for an integration
+func selectModels(ctx context.Context, name, current string) ([]string, error) {
+	r, ok := integrations[name]
+	if !ok {
+		return nil, fmt.Errorf("unknown app: %s", name)
+	}
+
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return nil, err
+	}
+
+	models, err := client.List(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var existing []modelInfo
+	for _, m := range models.Models {
+		existing = append(existing, modelInfo{Name: m.Name, Remote: m.RemoteModel != ""})
+	}
+
+	var preChecked []string
+	if saved, err := loadIntegration(name); err == nil {
+		preChecked = saved.Models
+	} else if editor, ok := r.(Editor); ok {
+		preChecked = editor.Models()
+	}
+
+	items, preChecked, existingModels, cloudModels := buildModelList(existing, preChecked, current)
+
+	if len(items) == 0 {
+		return nil, fmt.Errorf("no models available")
+	}
+
+	var selected []string
+	if _, ok := r.(Editor); ok {
+		selected, err = multiSelectPrompt(fmt.Sprintf("Select models for %s:", r), items, preChecked)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		prompt := fmt.Sprintf("Select model for %s:", r)
+		if _, ok := r.(AliasConfigurer); ok {
+			prompt = fmt.Sprintf("Select Primary model for %s:", r)
+		}
+		model, err := selectPrompt(prompt, items)
+		if err != nil {
+			return nil, err
+		}
+		selected = []string{model}
+	}
+
+	var toPull []string
+	for _, m := range selected {
+		if !existingModels[m] {
+			toPull = append(toPull, m)
+		}
+	}
+	if len(toPull) > 0 {
+		msg := fmt.Sprintf("Download %s?", strings.Join(toPull, ", "))
+		if ok, err := confirmPrompt(msg); err != nil {
+			return nil, err
+		} else if !ok {
+			return nil, errCancelled
+		}
+		for _, m := range toPull {
+			fmt.Fprintf(os.Stderr, "\n")
+			if err := pullModel(ctx, client, m); err != nil {
+				return nil, fmt.Errorf("failed to pull %s: %w", m, err)
+			}
+		}
+	}
+
+	if err := ensureAuth(ctx, client, cloudModels, selected); err != nil {
+		return nil, err
+	}
+
+	return selected, nil
+}
+
+func pullIfNeeded(ctx context.Context, client *api.Client, existingModels map[string]bool, model string) error {
+	if existingModels[model] {
+		return nil
+	}
+	msg := fmt.Sprintf("Download %s?", model)
+	if ok, err := confirmPrompt(msg); err != nil {
+		return err
+	} else if !ok {
+		return errCancelled
+	}
+	fmt.Fprintf(os.Stderr, "\n")
+	if err := pullModel(ctx, client, model); err != nil {
+		return fmt.Errorf("failed to pull %s: %w", model, err)
+	}
+	return nil
+}
+
+// showOrPull checks if a model exists via client.Show and offers to pull it if not found.
+func showOrPull(ctx context.Context, client *api.Client, model string) error {
+	if _, err := client.Show(ctx, &api.ShowRequest{Model: model}); err == nil {
+		return nil
+	}
+	if ok, err := confirmPrompt(fmt.Sprintf("Download %s?", model)); err != nil {
+		return err
+	} else if !ok {
+		return errCancelled
+	}
+	fmt.Fprintf(os.Stderr, "\n")
+	return pullModel(ctx, client, model)
+}
+
+func listModels(ctx context.Context) ([]selectItem, map[string]bool, map[string]bool, *api.Client, error) {
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	models, err := client.List(ctx)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	var existing []modelInfo
+	for _, m := range models.Models {
+		existing = append(existing, modelInfo{
+			Name:   m.Name,
+			Remote: m.RemoteModel != "",
+		})
+	}
+
+	items, _, existingModels, cloudModels := buildModelList(existing, nil, "")
+
+	if len(items) == 0 {
+		return nil, nil, nil, nil, fmt.Errorf("no models available, run 'ollama pull <model>' first")
+	}
+
+	return items, existingModels, cloudModels, client, nil
+}
+
+func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]bool, selected []string) error {
+	var selectedCloudModels []string
+	for _, m := range selected {
+		if cloudModels[m] {
+			selectedCloudModels = append(selectedCloudModels, m)
+		}
+	}
+	if len(selectedCloudModels) == 0 {
+		return nil
+	}
+
+	user, err := client.Whoami(ctx)
+	if err == nil && user != nil && user.Name != "" {
+		return nil
+	}
+
+	var aErr api.AuthorizationError
+	if !errors.As(err, &aErr) || aErr.SigninURL == "" {
+		return err
+	}
+
+	modelList := strings.Join(selectedCloudModels, ", ")
+	yes, err := confirmPrompt(fmt.Sprintf("sign in to use %s?", modelList))
+	if err != nil || !yes {
+		return fmt.Errorf("%s requires sign in", modelList)
+	}
+
+	fmt.Fprintf(os.Stderr, "\nTo sign in, navigate to:\n    %s\n\n", aErr.SigninURL)
+
+	switch runtime.GOOS {
+	case "darwin":
+		_ = exec.Command("open", aErr.SigninURL).Start()
+	case "linux":
+		_ = exec.Command("xdg-open", aErr.SigninURL).Start()
+	case "windows":
+		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", aErr.SigninURL).Start()
+	}
+
+	spinnerFrames := []string{"|", "/", "-", "\\"}
+	frame := 0
+
+	fmt.Fprintf(os.Stderr, "\033[90mwaiting for sign in to complete... %s\033[0m", spinnerFrames[0])
+
+	ticker := time.NewTicker(200 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			fmt.Fprintf(os.Stderr, "\r\033[K")
+			return ctx.Err()
+		case <-ticker.C:
+			frame++
+			fmt.Fprintf(os.Stderr, "\r\033[90mwaiting for sign in to complete... %s\033[0m", spinnerFrames[frame%len(spinnerFrames)])
+
+			// poll every 10th frame (~2 seconds)
+			if frame%10 == 0 {
+				u, err := client.Whoami(ctx)
+				if err == nil && u != nil && u.Name != "" {
+					fmt.Fprintf(os.Stderr, "\r\033[K\033[A\r\033[K\033[1msigned in:\033[0m %s\n", u.Name)
+					return nil
+				}
+			}
+		}
+	}
+}
+
+func runIntegration(name, modelName string, args []string) error {
+	r, ok := integrations[name]
+	if !ok {
+		return fmt.Errorf("unknown app: %s", name)
+	}
+
+	fmt.Fprintf(os.Stderr, "\nLaunching %s with %s...\n", r, modelName)
+	return r.Run(modelName, args)
+}
+
+// syncAliases syncs aliases to server and saves locally for an AliasConfigurer.
+func syncAliases(ctx context.Context, client *api.Client, ac AliasConfigurer, name, model string, existing map[string]string) error {
+	aliases := make(map[string]string)
+	for k, v := range existing {
+		aliases[k] = v
+	}
+	aliases["primary"] = model
+
+	if isCloudModel(ctx, client, model) {
+		if aliases["fast"] == "" || !isCloudModel(ctx, client, aliases["fast"]) {
+			aliases["fast"] = model
+		}
+	} else {
+		delete(aliases, "fast")
+	}
+
+	if err := ac.SetAliases(ctx, aliases); err != nil {
+		return err
+	}
+	return saveAliases(name, aliases)
+}
+
+// RunLaunch executes the launch logic for the given integration and arguments.
+// This can be called directly from the root command (with empty modelFlag/configFlag)
+// or via the launch subcommand.
+func RunLaunch(cmd *cobra.Command, args []string, modelFlag string, configFlag bool) error {
+	// Extract integration name and args to pass through using -- separator
+	var name string
+	var passArgs []string
+	dashIdx := cmd.ArgsLenAtDash()
+
+	if dashIdx == -1 {
+		// No "--" separator: only allow 0 or 1 args (integration name)
+		if len(args) > 1 {
+			return fmt.Errorf("unexpected arguments: %v\nUse '--' to pass extra arguments to the app", args[1:])
+		}
+		if len(args) == 1 {
+			name = args[0]
+		}
+	} else {
+		// "--" was used: args before it = integration name, args after = passthrough
+		if dashIdx > 1 {
+			return fmt.Errorf("expected at most 1 app name before '--', got %d", dashIdx)
+		}
+		if dashIdx == 1 {
+			name = args[0]
+		}
+		passArgs = args[dashIdx:]
+	}
+
+	if name == "" {
+		var err error
+		name, err = selectIntegration()
+		if errors.Is(err, errCancelled) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	r, ok := integrations[strings.ToLower(name)]
+	if !ok {
+		return fmt.Errorf("unknown app: %s", name)
+	}
+
+	// Handle AliasConfigurer integrations (claude, codex)
+	if ac, ok := r.(AliasConfigurer); ok {
+		client, err := api.ClientFromEnvironment()
+		if err != nil {
+			return err
+		}
+
+		// Validate --model flag if provided
+		if modelFlag != "" {
+			if err := showOrPull(cmd.Context(), client, modelFlag); err != nil {
+				if errors.Is(err, errCancelled) {
+					return nil
+				}
+				return err
+			}
+		}
+
+		var model string
+		var existingAliases map[string]string
+
+		// Load saved config
+		if cfg, err := loadIntegration(name); err == nil {
+			existingAliases = cfg.Aliases
+			if len(cfg.Models) > 0 {
+				model = cfg.Models[0]
+				// AliasConfigurer integrations use single model; sanitize if multiple
+				if len(cfg.Models) > 1 {
+					_ = saveIntegration(name, []string{model})
+				}
+			}
+		}
+
+		// --model flag overrides saved model
+		if modelFlag != "" {
+			model = modelFlag
+		}
+
+		// Validate saved model still exists
+		if model != "" && modelFlag == "" {
+			if _, err := client.Show(cmd.Context(), &api.ShowRequest{Model: model}); err != nil {
+				fmt.Fprintf(os.Stderr, "%sConfigured model %q not found%s\n\n", ansiGray, model, ansiReset)
+				if err := showOrPull(cmd.Context(), client, model); err != nil {
+					model = ""
+				}
+			}
+		}
+
+		// If no valid model or --config flag, show picker
+		if model == "" || configFlag {
+			aliases, _, err := ac.ConfigureAliases(cmd.Context(), model, existingAliases, configFlag)
+			if errors.Is(err, errCancelled) {
+				return nil
+			}
+			if err != nil {
+				return err
+			}
+			model = aliases["primary"]
+			existingAliases = aliases
+		}
+
+		// Ensure cloud models are authenticated
+		if isCloudModel(cmd.Context(), client, model) {
+			if err := ensureAuth(cmd.Context(), client, map[string]bool{model: true}, []string{model}); err != nil {
+				return err
+			}
+		}
+
+		// Sync aliases and save
+		if err := syncAliases(cmd.Context(), client, ac, name, model, existingAliases); err != nil {
+			fmt.Fprintf(os.Stderr, "%sWarning: Could not sync aliases: %v%s\n", ansiGray, err, ansiReset)
+		}
+		if err := saveIntegration(name, []string{model}); err != nil {
+			return fmt.Errorf("failed to save: %w", err)
+		}
+
+		// Launch (unless --config without confirmation)
+		if configFlag {
+			if launch, _ := confirmPrompt(fmt.Sprintf("Launch %s now?", r)); launch {
+				return runIntegration(name, model, passArgs)
+			}
+			return nil
+		}
+		return runIntegration(name, model, passArgs)
+	}
+
+	// Validate --model flag for non-AliasConfigurer integrations
+	if modelFlag != "" {
+		client, err := api.ClientFromEnvironment()
+		if err != nil {
+			return err
+		}
+		if err := showOrPull(cmd.Context(), client, modelFlag); err != nil {
+			if errors.Is(err, errCancelled) {
+				return nil
+			}
+			return err
+		}
+	}
+
+	var models []string
+	if modelFlag != "" {
+		models = []string{modelFlag}
+		if existing, err := loadIntegration(name); err == nil && len(existing.Models) > 0 {
+			for _, m := range existing.Models {
+				if m != modelFlag {
+					models = append(models, m)
+				}
+			}
+		}
+	} else if saved, err := loadIntegration(name); err == nil && len(saved.Models) > 0 && !configFlag {
+		return runIntegration(name, saved.Models[0], passArgs)
+	} else {
+		var err error
+		models, err = selectModels(cmd.Context(), name, "")
+		if errors.Is(err, errCancelled) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	if editor, isEditor := r.(Editor); isEditor {
+		paths := editor.Paths()
+		if len(paths) > 0 {
+			fmt.Fprintf(os.Stderr, "This will modify your %s configuration:\n", r)
+			for _, p := range paths {
+				fmt.Fprintf(os.Stderr, "  %s\n", p)
+			}
+			fmt.Fprintf(os.Stderr, "Backups will be saved to %s/\n\n", backupDir())
+
+			if ok, _ := confirmPrompt("Proceed?"); !ok {
+				return nil
+			}
+		}
+	}
+
+	if err := saveIntegration(name, models); err != nil {
+		return fmt.Errorf("failed to save: %w", err)
+	}
+
+	if editor, isEditor := r.(Editor); isEditor {
+		if err := editor.Edit(models); err != nil {
+			return fmt.Errorf("setup failed: %w", err)
+		}
+	}
+
+	if _, isEditor := r.(Editor); isEditor {
+		if len(models) == 1 {
+			fmt.Fprintf(os.Stderr, "Added %s to %s\n", models[0], r)
+		} else {
+			fmt.Fprintf(os.Stderr, "Added %d models to %s (default: %s)\n", len(models), r, models[0])
+		}
+	}
+
+	if configFlag {
+		if launch, _ := confirmPrompt(fmt.Sprintf("\nLaunch %s now?", r)); launch {
+			return runIntegration(name, models[0], passArgs)
+		}
+		return nil
+	}
+
+	if runner, isRunner := r.(Runner); isRunner {
+		return runner.Run(models[0], passArgs)
+	}
+
+	return nil
+}
+
+// LaunchCmd returns the cobra command for launching integrations.
+func LaunchCmd(checkServerHeartbeat func(cmd *cobra.Command, args []string) error) *cobra.Command {
+	var modelFlag string
+	var configFlag bool
+
+	cmd := &cobra.Command{
+		Use:   "launch [APP] [-- [EXTRA_ARGS...]]",
+		Short: "Launch an app with Ollama",
+		Long: `Launch an app configured with Ollama models.
+
+Supported apps:
+  claude    Claude Code
+  codex     Codex
+  droid     Droid
+  opencode  OpenCode
+  openclaw  OpenClaw (aliases: clawdbot, moltbot)
+
+Examples:
+  ollama launch
+  ollama launch claude
+  ollama launch claude --model <model>
+  ollama launch droid --config (does not auto-launch)
+  ollama launch codex -- -p myprofile (pass extra args to app)
+  ollama launch codex -- --sandbox workspace-write`,
+		Args:    cobra.ArbitraryArgs,
+		PreRunE: checkServerHeartbeat,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return RunLaunch(cmd, args, modelFlag, configFlag)
+		},
+	}
+
+	cmd.Flags().StringVar(&modelFlag, "model", "", "Model to use")
+	cmd.Flags().BoolVar(&configFlag, "config", false, "Configure without launching")
+	return cmd
+}
+
+type modelInfo struct {
+	Name        string
+	Remote      bool
+	ToolCapable bool
+}
+
+// buildModelList merges existing models with recommendations, sorts them, and returns
+// the ordered items along with maps of existing and cloud model names.
+func buildModelList(existing []modelInfo, preChecked []string, current string) (items []selectItem, orderedChecked []string, existingModels, cloudModels map[string]bool) {
+	existingModels = make(map[string]bool)
+	cloudModels = make(map[string]bool)
+	recommended := make(map[string]bool)
+	var hasLocalModel, hasCloudModel bool
+
+	for _, rec := range recommendedModels {
+		recommended[rec.Name] = true
+	}
+
+	for _, m := range existing {
+		existingModels[m.Name] = true
+		if m.Remote {
+			cloudModels[m.Name] = true
+			hasCloudModel = true
+		} else {
+			hasLocalModel = true
+		}
+		displayName := strings.TrimSuffix(m.Name, ":latest")
+		existingModels[displayName] = true
+		item := selectItem{Name: displayName}
+		if recommended[displayName] {
+			item.Description = "recommended"
+		}
+		items = append(items, item)
+	}
+
+	for _, rec := range recommendedModels {
+		if existingModels[rec.Name] || existingModels[rec.Name+":latest"] {
+			continue
+		}
+		items = append(items, rec)
+		if strings.HasSuffix(rec.Name, ":cloud") {
+			cloudModels[rec.Name] = true
+		}
+	}
+
+	checked := make(map[string]bool, len(preChecked))
+	for _, n := range preChecked {
+		checked[n] = true
+	}
+
+	// Resolve current to full name (e.g., "llama3.2" -> "llama3.2:latest")
+	for _, item := range items {
+		if item.Name == current || strings.HasPrefix(item.Name, current+":") {
+			current = item.Name
+			break
+		}
+	}
+
+	if checked[current] {
+		preChecked = append([]string{current}, slices.DeleteFunc(preChecked, func(m string) bool { return m == current })...)
+	}
+
+	// Non-existing models get "install?" suffix and are pushed to the bottom.
+	// When user has no models, preserve recommended order.
+	notInstalled := make(map[string]bool)
+	for i := range items {
+		if !existingModels[items[i].Name] {
+			notInstalled[items[i].Name] = true
+			if items[i].Description != "" {
+				items[i].Description += ", install?"
+			} else {
+				items[i].Description = "install?"
+			}
+		}
+	}
+
+	if hasLocalModel || hasCloudModel {
+		slices.SortStableFunc(items, func(a, b selectItem) int {
+			ac, bc := checked[a.Name], checked[b.Name]
+			aNew, bNew := notInstalled[a.Name], notInstalled[b.Name]
+
+			if ac != bc {
+				if ac {
+					return -1
+				}
+				return 1
+			}
+			if !ac && !bc && aNew != bNew {
+				if aNew {
+					return 1
+				}
+				return -1
+			}
+			return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
+		})
+	}
+
+	return items, preChecked, existingModels, cloudModels
+}
+
+// isCloudModel checks if a model is a cloud model using the Show API.
+func isCloudModel(ctx context.Context, client *api.Client, name string) bool {
+	if client == nil {
+		return false
+	}
+	resp, err := client.Show(ctx, &api.ShowRequest{Model: name})
+	if err != nil {
+		return false
+	}
+	return resp.RemoteModel != ""
+}
+
+func pullModel(ctx context.Context, client *api.Client, model string) error {
+	p := progress.NewProgress(os.Stderr)
+	defer p.Stop()
+
+	bars := make(map[string]*progress.Bar)
+	var status string
+	var spinner *progress.Spinner
+
+	fn := func(resp api.ProgressResponse) error {
+		if resp.Digest != "" {
+			if resp.Completed == 0 {
+				return nil
+			}
+
+			if spinner != nil {
+				spinner.Stop()
+			}
+
+			bar, ok := bars[resp.Digest]
+			if !ok {
+				name, isDigest := strings.CutPrefix(resp.Digest, "sha256:")
+				name = strings.TrimSpace(name)
+				if isDigest {
+					name = name[:min(12, len(name))]
+				}
+				bar = progress.NewBar(fmt.Sprintf("pulling %s:", name), resp.Total, resp.Completed)
+				bars[resp.Digest] = bar
+				p.Add(resp.Digest, bar)
+			}
+
+			bar.Set(resp.Completed)
+		} else if status != resp.Status {
+			if spinner != nil {
+				spinner.Stop()
+			}
+
+			status = resp.Status
+			spinner = progress.NewSpinner(status)
+			p.Add(status, spinner)
+		}
+
+		return nil
+	}
+
+	request := api.PullRequest{Name: model}
+	return client.Pull(ctx, &request, fn)
+}
@@ -0,0 +1,679 @@
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/ollama/ollama/api"
+	"github.com/spf13/cobra"
+)
+
+func TestIntegrationLookup(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantFound bool
+		wantName  string
+	}{
+		{"claude lowercase", "claude", true, "Claude Code"},
+		{"claude uppercase", "CLAUDE", true, "Claude Code"},
+		{"claude mixed case", "Claude", true, "Claude Code"},
+		{"codex", "codex", true, "Codex"},
+		{"droid", "droid", true, "Droid"},
+		{"opencode", "opencode", true, "OpenCode"},
+		{"unknown integration", "unknown", false, ""},
+		{"empty string", "", false, ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r, found := integrations[strings.ToLower(tt.input)]
+			if found != tt.wantFound {
+				t.Errorf("integrations[%q] found = %v, want %v", tt.input, found, tt.wantFound)
+			}
+			if found && r.String() != tt.wantName {
+				t.Errorf("integrations[%q].String() = %q, want %q", tt.input, r.String(), tt.wantName)
+			}
+		})
+	}
+}
+
+func TestIntegrationRegistry(t *testing.T) {
+	expectedIntegrations := []string{"claude", "codex", "droid", "opencode"}
+
+	for _, name := range expectedIntegrations {
+		t.Run(name, func(t *testing.T) {
+			r, ok := integrations[name]
+			if !ok {
+				t.Fatalf("integration %q not found in registry", name)
+			}
+			if r.String() == "" {
+				t.Error("integration.String() should not be empty")
+			}
+		})
+	}
+}
+
+func TestHasLocalModel(t *testing.T) {
+	tests := []struct {
+		name   string
+		models []string
+		want   bool
+	}{
+		{"empty list", []string{}, false},
+		{"single local model", []string{"llama3.2"}, true},
+		{"single cloud model", []string{"cloud-model"}, false},
+		{"mixed models", []string{"cloud-model", "llama3.2"}, true},
+		{"multiple local models", []string{"llama3.2", "qwen2.5"}, true},
+		{"multiple cloud models", []string{"cloud-a", "cloud-b"}, false},
+		{"local model first", []string{"llama3.2", "cloud-model"}, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := slices.ContainsFunc(tt.models, func(m string) bool {
+				return !strings.Contains(m, "cloud")
+			})
+			if got != tt.want {
+				t.Errorf("hasLocalModel(%v) = %v, want %v", tt.models, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestLaunchCmd(t *testing.T) {
+	// Mock checkServerHeartbeat that always succeeds
+	mockCheck := func(cmd *cobra.Command, args []string) error {
+		return nil
+	}
+
+	cmd := LaunchCmd(mockCheck)
+
+	t.Run("command structure", func(t *testing.T) {
+		if cmd.Use != "launch [APP] [-- [EXTRA_ARGS...]]" {
+			t.Errorf("Use = %q, want %q", cmd.Use, "launch [APP] [-- [EXTRA_ARGS...]]")
+		}
+		if cmd.Short == "" {
+			t.Error("Short description should not be empty")
+		}
+		if cmd.Long == "" {
+			t.Error("Long description should not be empty")
+		}
+	})
+
+	t.Run("flags exist", func(t *testing.T) {
+		modelFlag := cmd.Flags().Lookup("model")
+		if modelFlag == nil {
+			t.Error("--model flag should exist")
+		}
+
+		configFlag := cmd.Flags().Lookup("config")
+		if configFlag == nil {
+			t.Error("--config flag should exist")
+		}
+	})
+
+	t.Run("PreRunE is set", func(t *testing.T) {
+		if cmd.PreRunE == nil {
+			t.Error("PreRunE should be set to checkServerHeartbeat")
+		}
+	})
+}
+
+func TestRunIntegration_UnknownIntegration(t *testing.T) {
+	err := runIntegration("unknown-integration", "model", nil)
+	if err == nil {
+		t.Error("expected error for unknown integration, got nil")
+	}
+	if !strings.Contains(err.Error(), "unknown app") {
+		t.Errorf("error should mention 'unknown app', got: %v", err)
+	}
+}
+
+func TestHasLocalModel_DocumentsHeuristic(t *testing.T) {
+	tests := []struct {
+		name   string
+		models []string
+		want   bool
+		reason string
+	}{
+		{"empty list", []string{}, false, "empty list has no local models"},
+		{"contains-cloud-substring", []string{"deepseek-r1:cloud"}, false, "model with 'cloud' substring is considered cloud"},
+		{"cloud-in-name", []string{"my-cloud-model"}, false, "'cloud' anywhere in name = cloud model"},
+		{"cloudless", []string{"cloudless-model"}, false, "'cloudless' still contains 'cloud'"},
+		{"local-model", []string{"llama3.2"}, true, "no 'cloud' = local"},
+		{"mixed", []string{"cloud-model", "llama3.2"}, true, "one local model = hasLocalModel true"},
+		{"all-cloud", []string{"cloud-a", "cloud-b"}, false, "all contain 'cloud'"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := slices.ContainsFunc(tt.models, func(m string) bool {
+				return !strings.Contains(m, "cloud")
+			})
+			if got != tt.want {
+				t.Errorf("hasLocalModel(%v) = %v, want %v (%s)", tt.models, got, tt.want, tt.reason)
+			}
+		})
+	}
+}
+
+func TestLaunchCmd_NilHeartbeat(t *testing.T) {
+	// This should not panic - cmd creation should work even with nil
+	cmd := LaunchCmd(nil)
+	if cmd == nil {
+		t.Fatal("LaunchCmd returned nil")
+	}
+
+	// PreRunE should be nil when passed nil
+	if cmd.PreRunE != nil {
+		t.Log("Note: PreRunE is set even when nil is passed (acceptable)")
+	}
+}
+
+func TestAllIntegrations_HaveRequiredMethods(t *testing.T) {
+	for name, r := range integrations {
+		t.Run(name, func(t *testing.T) {
+			displayName := r.String()
+			if displayName == "" {
+				t.Error("String() should not return empty")
+			}
+			var _ func(string, []string) error = r.Run
+		})
+	}
+}
+
+func TestParseArgs(t *testing.T) {
+	// Tests reflect cobra's ArgsLenAtDash() semantics:
+	// - cobra strips "--" from args
+	// - ArgsLenAtDash() returns the index where "--" was, or -1
+	tests := []struct {
+		name     string
+		args     []string // args as cobra delivers them (no "--")
+		dashIdx  int      // what ArgsLenAtDash() returns
+		wantName string
+		wantArgs []string
+		wantErr  bool
+	}{
+		{
+			name:     "no extra args, no dash",
+			args:     []string{"claude"},
+			dashIdx:  -1,
+			wantName: "claude",
+		},
+		{
+			name:     "with extra args after --",
+			args:     []string{"codex", "-p", "myprofile"},
+			dashIdx:  1,
+			wantName: "codex",
+			wantArgs: []string{"-p", "myprofile"},
+		},
+		{
+			name:     "extra args only after --",
+			args:     []string{"codex", "--sandbox", "workspace-write"},
+			dashIdx:  1,
+			wantName: "codex",
+			wantArgs: []string{"--sandbox", "workspace-write"},
+		},
+		{
+			name:     "-- at end with no args after",
+			args:     []string{"claude"},
+			dashIdx:  1,
+			wantName: "claude",
+		},
+		{
+			name:     "-- with no integration name",
+			args:     []string{"--verbose"},
+			dashIdx:  0,
+			wantName: "",
+			wantArgs: []string{"--verbose"},
+		},
+		{
+			name:    "multiple args before -- is error",
+			args:    []string{"claude", "codex", "--verbose"},
+			dashIdx: 2,
+			wantErr: true,
+		},
+		{
+			name:    "multiple args without -- is error",
+			args:    []string{"claude", "codex"},
+			dashIdx: -1,
+			wantErr: true,
+		},
+		{
+			name:     "no args, no dash",
+			args:     []string{},
+			dashIdx:  -1,
+			wantName: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Simulate the parsing logic from LaunchCmd using dashIdx
+			var name string
+			var parsedArgs []string
+			var err error
+
+			dashIdx := tt.dashIdx
+			args := tt.args
+
+			if dashIdx == -1 {
+				if len(args) > 1 {
+					err = fmt.Errorf("unexpected arguments: %v", args[1:])
+				} else if len(args) == 1 {
+					name = args[0]
+				}
+			} else {
+				if dashIdx > 1 {
+					err = fmt.Errorf("expected at most 1 integration name before '--', got %d", dashIdx)
+				} else {
+					if dashIdx == 1 {
+						name = args[0]
+					}
+					parsedArgs = args[dashIdx:]
+				}
+			}
+
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("expected error, got nil")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if name != tt.wantName {
+				t.Errorf("name = %q, want %q", name, tt.wantName)
+			}
+			if !slices.Equal(parsedArgs, tt.wantArgs) {
+				t.Errorf("args = %v, want %v", parsedArgs, tt.wantArgs)
+			}
+		})
+	}
+}
+
+func TestIsCloudModel(t *testing.T) {
+	// isCloudModel now only uses Show API, so nil client always returns false
+	t.Run("nil client returns false", func(t *testing.T) {
+		models := []string{"glm-4.7:cloud", "kimi-k2.5:cloud", "local-model"}
+		for _, model := range models {
+			if isCloudModel(context.Background(), nil, model) {
+				t.Errorf("isCloudModel(%q) with nil client should return false", model)
+			}
+		}
+	})
+}
+
+func names(items []selectItem) []string {
+	var out []string
+	for _, item := range items {
+		out = append(out, item.Name)
+	}
+	return out
+}
+
+func TestBuildModelList_NoExistingModels(t *testing.T) {
+	items, _, _, _ := buildModelList(nil, nil, "")
+
+	want := []string{"glm-4.7-flash", "qwen3:8b", "glm-4.7:cloud", "kimi-k2.5:cloud"}
+	if diff := cmp.Diff(want, names(items)); diff != "" {
+		t.Errorf("with no existing models, items should be recommended in order (-want +got):\n%s", diff)
+	}
+
+	for _, item := range items {
+		if !strings.HasSuffix(item.Description, "install?") {
+			t.Errorf("item %q should have description ending with 'install?', got %q", item.Name, item.Description)
+		}
+	}
+}
+
+func TestBuildModelList_OnlyLocalModels_CloudRecsAtBottom(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "llama3.2:latest", Remote: false},
+		{Name: "qwen2.5:latest", Remote: false},
+	}
+
+	items, _, _, _ := buildModelList(existing, nil, "")
+	got := names(items)
+
+	want := []string{"llama3.2", "qwen2.5", "glm-4.7-flash", "glm-4.7:cloud", "kimi-k2.5:cloud", "qwen3:8b"}
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Errorf("cloud recs should be at bottom (-want +got):\n%s", diff)
+	}
+}
+
+func TestBuildModelList_BothCloudAndLocal_RegularSort(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "llama3.2:latest", Remote: false},
+		{Name: "glm-4.7:cloud", Remote: true},
+	}
+
+	items, _, _, _ := buildModelList(existing, nil, "")
+	got := names(items)
+
+	want := []string{"glm-4.7:cloud", "llama3.2", "glm-4.7-flash", "kimi-k2.5:cloud", "qwen3:8b"}
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Errorf("mixed models should be alphabetical (-want +got):\n%s", diff)
+	}
+}
+
+func TestBuildModelList_PreCheckedFirst(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "llama3.2:latest", Remote: false},
+		{Name: "glm-4.7:cloud", Remote: true},
+	}
+
+	items, _, _, _ := buildModelList(existing, []string{"llama3.2"}, "")
+	got := names(items)
+
+	if got[0] != "llama3.2" {
+		t.Errorf("pre-checked model should be first, got %v", got)
+	}
+}
+
+func TestBuildModelList_ExistingRecommendedMarked(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "glm-4.7-flash", Remote: false},
+		{Name: "glm-4.7:cloud", Remote: true},
+	}
+
+	items, _, _, _ := buildModelList(existing, nil, "")
+
+	for _, item := range items {
+		switch item.Name {
+		case "glm-4.7-flash", "glm-4.7:cloud":
+			if strings.HasSuffix(item.Description, "install?") {
+				t.Errorf("installed recommended %q should not have 'install?' suffix, got %q", item.Name, item.Description)
+			}
+		case "kimi-k2.5:cloud", "qwen3:8b":
+			if !strings.HasSuffix(item.Description, "install?") {
+				t.Errorf("non-installed recommended %q should have 'install?' suffix, got %q", item.Name, item.Description)
+			}
+		}
+	}
+}
+
+func TestBuildModelList_ExistingCloudModelsNotPushedToBottom(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "glm-4.7-flash", Remote: false},
+		{Name: "glm-4.7:cloud", Remote: true},
+	}
+
+	items, _, _, _ := buildModelList(existing, nil, "")
+	got := names(items)
+
+	// glm-4.7-flash and glm-4.7:cloud are installed so they sort normally;
+	// kimi-k2.5:cloud and qwen3:8b are not installed so they go to the bottom
+	want := []string{"glm-4.7-flash", "glm-4.7:cloud", "kimi-k2.5:cloud", "qwen3:8b"}
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Errorf("existing cloud models should sort normally (-want +got):\n%s", diff)
+	}
+}
+
+func TestBuildModelList_HasRecommendedCloudModel_OnlyNonInstalledAtBottom(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "llama3.2:latest", Remote: false},
+		{Name: "kimi-k2.5:cloud", Remote: true},
+	}
+
+	items, _, _, _ := buildModelList(existing, nil, "")
+	got := names(items)
+
+	// kimi-k2.5:cloud is installed so it sorts normally;
+	// the rest of the recommendations are not installed so they go to the bottom
+	want := []string{"kimi-k2.5:cloud", "llama3.2", "glm-4.7-flash", "glm-4.7:cloud", "qwen3:8b"}
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Errorf("only non-installed models should be at bottom (-want +got):\n%s", diff)
+	}
+
+	for _, item := range items {
+		if !slices.Contains([]string{"kimi-k2.5:cloud", "llama3.2"}, item.Name) {
+			if !strings.HasSuffix(item.Description, "install?") {
+				t.Errorf("non-installed %q should have 'install?' suffix, got %q", item.Name, item.Description)
+			}
+		}
+	}
+}
+
+func TestBuildModelList_LatestTagStripped(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "glm-4.7-flash:latest", Remote: false},
+		{Name: "llama3.2:latest", Remote: false},
+	}
+
+	items, _, existingModels, _ := buildModelList(existing, nil, "")
+	got := names(items)
+
+	// :latest should be stripped from display names
+	for _, name := range got {
+		if strings.HasSuffix(name, ":latest") {
+			t.Errorf("name %q should not have :latest suffix", name)
+		}
+	}
+
+	// glm-4.7-flash should not be duplicated (existing :latest matches the recommendation)
+	count := 0
+	for _, name := range got {
+		if name == "glm-4.7-flash" {
+			count++
+		}
+	}
+	if count != 1 {
+		t.Errorf("glm-4.7-flash should appear exactly once, got %d in %v", count, got)
+	}
+
+	// Stripped name should be in existingModels so it won't be pulled
+	if !existingModels["glm-4.7-flash"] {
+		t.Error("glm-4.7-flash should be in existingModels")
+	}
+}
+
+func TestBuildModelList_ReturnsExistingAndCloudMaps(t *testing.T) {
+	existing := []modelInfo{
+		{Name: "llama3.2:latest", Remote: false},
+		{Name: "glm-4.7:cloud", Remote: true},
+	}
+
+	_, _, existingModels, cloudModels := buildModelList(existing, nil, "")
+
+	if !existingModels["llama3.2"] {
+		t.Error("llama3.2 should be in existingModels")
+	}
+	if !existingModels["glm-4.7:cloud"] {
+		t.Error("glm-4.7:cloud should be in existingModels")
+	}
+	if existingModels["glm-4.7-flash"] {
+		t.Error("glm-4.7-flash should not be in existingModels (it's a recommendation)")
+	}
+
+	if !cloudModels["glm-4.7:cloud"] {
+		t.Error("glm-4.7:cloud should be in cloudModels")
+	}
+	if !cloudModels["kimi-k2.5:cloud"] {
+		t.Error("kimi-k2.5:cloud should be in cloudModels (recommended cloud)")
+	}
+	if cloudModels["llama3.2"] {
+		t.Error("llama3.2 should not be in cloudModels")
+	}
+}
+
+func TestEditorIntegration_SavedConfigSkipsSelection(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	// Save a config for opencode so it looks like a previous launch
+	if err := saveIntegration("opencode", []string{"llama3.2"}); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify loadIntegration returns the saved models
+	saved, err := loadIntegration("opencode")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(saved.Models) == 0 {
+		t.Fatal("expected saved models")
+	}
+	if saved.Models[0] != "llama3.2" {
+		t.Errorf("expected llama3.2, got %s", saved.Models[0])
+	}
+}
+
+func TestAliasConfigurerInterface(t *testing.T) {
+	t.Run("claude implements AliasConfigurer", func(t *testing.T) {
+		claude := &Claude{}
+		if _, ok := interface{}(claude).(AliasConfigurer); !ok {
+			t.Error("Claude should implement AliasConfigurer")
+		}
+	})
+
+	t.Run("codex does not implement AliasConfigurer", func(t *testing.T) {
+		codex := &Codex{}
+		if _, ok := interface{}(codex).(AliasConfigurer); ok {
+			t.Error("Codex should not implement AliasConfigurer")
+		}
+	})
+}
+
+func TestShowOrPull_ModelExists(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/show" {
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprintf(w, `{"model":"test-model"}`)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	u, _ := url.Parse(srv.URL)
+	client := api.NewClient(u, srv.Client())
+
+	err := showOrPull(context.Background(), client, "test-model")
+	if err != nil {
+		t.Errorf("showOrPull should return nil when model exists, got: %v", err)
+	}
+}
+
+func TestShowOrPull_ModelNotFound_NoTerminal(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		fmt.Fprintf(w, `{"error":"model not found"}`)
+	}))
+	defer srv.Close()
+
+	u, _ := url.Parse(srv.URL)
+	client := api.NewClient(u, srv.Client())
+
+	// confirmPrompt will fail in test (no terminal), so showOrPull should return an error
+	err := showOrPull(context.Background(), client, "missing-model")
+	if err == nil {
+		t.Error("showOrPull should return error when model not found and no terminal available")
+	}
+}
+
+func TestShowOrPull_ShowCalledWithCorrectModel(t *testing.T) {
+	var receivedModel string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/show" {
+			var req api.ShowRequest
+			if err := json.NewDecoder(r.Body).Decode(&req); err == nil {
+				receivedModel = req.Model
+			}
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprintf(w, `{"model":"%s"}`, receivedModel)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	u, _ := url.Parse(srv.URL)
+	client := api.NewClient(u, srv.Client())
+
+	_ = showOrPull(context.Background(), client, "qwen3:8b")
+	if receivedModel != "qwen3:8b" {
+		t.Errorf("expected Show to be called with %q, got %q", "qwen3:8b", receivedModel)
+	}
+}
+
+func TestEnsureAuth_NoCloudModels(t *testing.T) {
+	// ensureAuth should be a no-op when no cloud models are selected
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Error("no API calls expected when no cloud models selected")
+	}))
+	defer srv.Close()
+
+	u, _ := url.Parse(srv.URL)
+	client := api.NewClient(u, srv.Client())
+
+	err := ensureAuth(context.Background(), client, map[string]bool{}, []string{"local-model"})
+	if err != nil {
+		t.Errorf("ensureAuth should return nil for non-cloud models, got: %v", err)
+	}
+}
+
+func TestEnsureAuth_CloudModelFilteredCorrectly(t *testing.T) {
+	// ensureAuth should only care about models in cloudModels map
+	var whoamiCalled bool
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/me" {
+			whoamiCalled = true
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprintf(w, `{"name":"testuser"}`)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	u, _ := url.Parse(srv.URL)
+	client := api.NewClient(u, srv.Client())
+
+	cloudModels := map[string]bool{"cloud-model:cloud": true}
+	selected := []string{"cloud-model:cloud", "local-model"}
+
+	err := ensureAuth(context.Background(), client, cloudModels, selected)
+	if err != nil {
+		t.Errorf("ensureAuth should succeed when user is authenticated, got: %v", err)
+	}
+	if !whoamiCalled {
+		t.Error("expected whoami to be called for cloud model")
+	}
+}
+
+func TestEnsureAuth_SkipsWhenNoCloudSelected(t *testing.T) {
+	var whoamiCalled bool
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/me" {
+			whoamiCalled = true
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	u, _ := url.Parse(srv.URL)
+	client := api.NewClient(u, srv.Client())
+
+	// cloudModels has entries but none are in selected
+	cloudModels := map[string]bool{"cloud-model:cloud": true}
+	selected := []string{"local-model"}
+
+	err := ensureAuth(context.Background(), client, cloudModels, selected)
+	if err != nil {
+		t.Errorf("expected nil error, got: %v", err)
+	}
+	if whoamiCalled {
+		t.Error("whoami should not be called when no cloud models are selected")
+	}
+}
@@ -0,0 +1,252 @@
+package config
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/ollama/ollama/envconfig"
+)
+
+type Openclaw struct{}
+
+func (c *Openclaw) String() string { return "OpenClaw" }
+
+func (c *Openclaw) Run(model string, args []string) error {
+	bin := "openclaw"
+	if _, err := exec.LookPath(bin); err != nil {
+		bin = "clawdbot"
+		if _, err := exec.LookPath(bin); err != nil {
+			return fmt.Errorf("openclaw is not installed, install from https://docs.openclaw.ai")
+		}
+	}
+
+	models := []string{model}
+	if config, err := loadIntegration("openclaw"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	} else if config, err := loadIntegration("clawdbot"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	if err := c.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
+	if !c.onboarded() {
+		// Onboarding not completed: run it (model already set via Edit)
+		// Use "ollama" as gateway token for simple local access
+		cmd := exec.Command(bin, "onboard",
+			"--auth-choice", "skip",
+			"--gateway-token", "ollama",
+		)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		return cmd.Run()
+	}
+
+	// Onboarding completed: run gateway
+	cmd := exec.Command(bin, append([]string{"gateway"}, args...)...)
+	cmd.Stdin = os.Stdin
+
+	// Capture output to detect "already running" message
+	var outputBuf bytes.Buffer
+	cmd.Stdout = io.MultiWriter(os.Stdout, &outputBuf)
+	cmd.Stderr = io.MultiWriter(os.Stderr, &outputBuf)
+
+	err := cmd.Run()
+	if err != nil && strings.Contains(outputBuf.String(), "Gateway already running") {
+		fmt.Fprintf(os.Stderr, "%sOpenClaw has been configured with Ollama. Gateway is already running.%s\n", ansiGreen, ansiReset)
+		return nil
+	}
+	return err
+}
+
+// onboarded checks if OpenClaw onboarding wizard was completed
+// by looking for the wizard.lastRunAt marker in the config
+func (c *Openclaw) onboarded() bool {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return false
+	}
+
+	configPath := filepath.Join(home, ".openclaw", "openclaw.json")
+	legacyPath := filepath.Join(home, ".clawdbot", "clawdbot.json")
+
+	config := make(map[string]any)
+	if data, err := os.ReadFile(configPath); err == nil {
+		_ = json.Unmarshal(data, &config)
+	} else if data, err := os.ReadFile(legacyPath); err == nil {
+		_ = json.Unmarshal(data, &config)
+	} else {
+		return false
+	}
+
+	// Check for wizard.lastRunAt marker (set when onboarding completes)
+	wizard, _ := config["wizard"].(map[string]any)
+	if wizard == nil {
+		return false
+	}
+	lastRunAt, _ := wizard["lastRunAt"].(string)
+	return lastRunAt != ""
+}
+
+func (c *Openclaw) Paths() []string {
+	home, _ := os.UserHomeDir()
+	p := filepath.Join(home, ".openclaw", "openclaw.json")
+	if _, err := os.Stat(p); err == nil {
+		return []string{p}
+	}
+	legacy := filepath.Join(home, ".clawdbot", "clawdbot.json")
+	if _, err := os.Stat(legacy); err == nil {
+		return []string{legacy}
+	}
+	return nil
+}
+
+func (c *Openclaw) Edit(models []string) error {
+	if len(models) == 0 {
+		return nil
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	configPath := filepath.Join(home, ".openclaw", "openclaw.json")
+	legacyPath := filepath.Join(home, ".clawdbot", "clawdbot.json")
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return err
+	}
+
+	// Read into map[string]any to preserve unknown fields
+	config := make(map[string]any)
+	if data, err := os.ReadFile(configPath); err == nil {
+		_ = json.Unmarshal(data, &config)
+	} else if data, err := os.ReadFile(legacyPath); err == nil {
+		_ = json.Unmarshal(data, &config)
+	}
+
+	// Navigate/create: models.providers.ollama (preserving other providers)
+	modelsSection, _ := config["models"].(map[string]any)
+	if modelsSection == nil {
+		modelsSection = make(map[string]any)
+	}
+	providers, _ := modelsSection["providers"].(map[string]any)
+	if providers == nil {
+		providers = make(map[string]any)
+	}
+	ollama, _ := providers["ollama"].(map[string]any)
+	if ollama == nil {
+		ollama = make(map[string]any)
+	}
+
+	ollama["baseUrl"] = envconfig.Host().String() + "/v1"
+	// needed to register provider
+	ollama["apiKey"] = "ollama-local"
+	// TODO(parthsareen): potentially move to responses
+	ollama["api"] = "openai-completions"
+
+	// Build map of existing models to preserve user customizations
+	existingModels, _ := ollama["models"].([]any)
+	existingByID := make(map[string]map[string]any)
+	for _, m := range existingModels {
+		if entry, ok := m.(map[string]any); ok {
+			if id, ok := entry["id"].(string); ok {
+				existingByID[id] = entry
+			}
+		}
+	}
+
+	var newModels []any
+	for _, model := range models {
+		entry := map[string]any{
+			"id":        model,
+			"name":      model,
+			"reasoning": false,
+			"input":     []any{"text"},
+			"cost": map[string]any{
+				"input":      0,
+				"output":     0,
+				"cacheRead":  0,
+				"cacheWrite": 0,
+			},
+			// TODO(parthsareen): get these values from API
+			"contextWindow": 131072,
+			"maxTokens":     16384,
+		}
+		// Merge existing fields (user customizations)
+		if existing, ok := existingByID[model]; ok {
+			for k, v := range existing {
+				if _, isNew := entry[k]; !isNew {
+					entry[k] = v
+				}
+			}
+		}
+		newModels = append(newModels, entry)
+	}
+	ollama["models"] = newModels
+
+	providers["ollama"] = ollama
+	modelsSection["providers"] = providers
+	config["models"] = modelsSection
+
+	// Update agents.defaults.model.primary (preserving other agent settings)
+	agents, _ := config["agents"].(map[string]any)
+	if agents == nil {
+		agents = make(map[string]any)
+	}
+	defaults, _ := agents["defaults"].(map[string]any)
+	if defaults == nil {
+		defaults = make(map[string]any)
+	}
+	modelConfig, _ := defaults["model"].(map[string]any)
+	if modelConfig == nil {
+		modelConfig = make(map[string]any)
+	}
+	modelConfig["primary"] = "ollama/" + models[0]
+	defaults["model"] = modelConfig
+	agents["defaults"] = defaults
+	config["agents"] = agents
+
+	data, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+	return writeWithBackup(configPath, data)
+}
+
+func (c *Openclaw) Models() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+
+	config, err := readJSONFile(filepath.Join(home, ".openclaw", "openclaw.json"))
+	if err != nil {
+		config, err = readJSONFile(filepath.Join(home, ".clawdbot", "clawdbot.json"))
+		if err != nil {
+			return nil
+		}
+	}
+
+	modelsSection, _ := config["models"].(map[string]any)
+	providers, _ := modelsSection["providers"].(map[string]any)
+	ollama, _ := providers["ollama"].(map[string]any)
+	modelList, _ := ollama["models"].([]any)
+
+	var result []string
+	for _, m := range modelList {
+		if entry, ok := m.(map[string]any); ok {
+			if id, ok := entry["id"].(string); ok {
+				result = append(result, id)
+			}
+		}
+	}
+	return result
+}
@@ -0,0 +1,878 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestOpenclawIntegration(t *testing.T) {
+	c := &Openclaw{}
+
+	t.Run("String", func(t *testing.T) {
+		if got := c.String(); got != "OpenClaw" {
+			t.Errorf("String() = %q, want %q", got, "OpenClaw")
+		}
+	})
+
+	t.Run("implements Runner", func(t *testing.T) {
+		var _ Runner = c
+	})
+
+	t.Run("implements Editor", func(t *testing.T) {
+		var _ Editor = c
+	})
+}
+
+func TestOpenclawEdit(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+
+	cleanup := func() { os.RemoveAll(configDir) }
+
+	t.Run("fresh install", func(t *testing.T) {
+		cleanup()
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenclawModelExists(t, configPath, "llama3.2")
+		assertOpenclawPrimaryModel(t, configPath, "ollama/llama3.2")
+	})
+
+	t.Run("multiple models - first is primary", func(t *testing.T) {
+		cleanup()
+		if err := c.Edit([]string{"llama3.2", "mistral"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenclawModelExists(t, configPath, "llama3.2")
+		assertOpenclawModelExists(t, configPath, "mistral")
+		assertOpenclawPrimaryModel(t, configPath, "ollama/llama3.2")
+	})
+
+	t.Run("preserve other providers", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":{"providers":{"anthropic":{"apiKey":"xxx"}}}}`), 0o644)
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		models := cfg["models"].(map[string]any)
+		providers := models["providers"].(map[string]any)
+		if providers["anthropic"] == nil {
+			t.Error("anthropic provider was removed")
+		}
+	})
+
+	t.Run("preserve top-level keys", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"theme":"dark","mcp":{"servers":{}}}`), 0o644)
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		if cfg["theme"] != "dark" {
+			t.Error("theme was removed")
+		}
+		if cfg["mcp"] == nil {
+			t.Error("mcp was removed")
+		}
+	})
+
+	t.Run("preserve user customizations on models", func(t *testing.T) {
+		cleanup()
+		c.Edit([]string{"llama3.2"})
+
+		// User adds custom field
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		models := cfg["models"].(map[string]any)
+		providers := models["providers"].(map[string]any)
+		ollama := providers["ollama"].(map[string]any)
+		modelList := ollama["models"].([]any)
+		entry := modelList[0].(map[string]any)
+		entry["customField"] = "user-value"
+		configData, _ := json.MarshalIndent(cfg, "", "  ")
+		os.WriteFile(configPath, configData, 0o644)
+
+		// Re-run Edit
+		c.Edit([]string{"llama3.2"})
+
+		data, _ = os.ReadFile(configPath)
+		json.Unmarshal(data, &cfg)
+		models = cfg["models"].(map[string]any)
+		providers = models["providers"].(map[string]any)
+		ollama = providers["ollama"].(map[string]any)
+		modelList = ollama["models"].([]any)
+		entry = modelList[0].(map[string]any)
+		if entry["customField"] != "user-value" {
+			t.Error("custom field was lost")
+		}
+	})
+
+	t.Run("edit replaces models list", func(t *testing.T) {
+		cleanup()
+		c.Edit([]string{"llama3.2", "mistral"})
+		c.Edit([]string{"llama3.2"})
+
+		assertOpenclawModelExists(t, configPath, "llama3.2")
+		assertOpenclawModelNotExists(t, configPath, "mistral")
+	})
+
+	t.Run("empty models is no-op", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		original := `{"existing":"data"}`
+		os.WriteFile(configPath, []byte(original), 0o644)
+
+		c.Edit([]string{})
+
+		data, _ := os.ReadFile(configPath)
+		if string(data) != original {
+			t.Error("empty models should not modify file")
+		}
+	})
+
+	t.Run("corrupted JSON treated as empty", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{corrupted`), 0o644)
+
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		if err := json.Unmarshal(data, &cfg); err != nil {
+			t.Error("result should be valid JSON")
+		}
+	})
+
+	t.Run("wrong type models section", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":"not a map"}`), 0o644)
+
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenclawModelExists(t, configPath, "llama3.2")
+	})
+}
+
+func TestOpenclawModels(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	t.Run("no config returns nil", func(t *testing.T) {
+		if models := c.Models(); len(models) > 0 {
+			t.Errorf("expected nil/empty, got %v", models)
+		}
+	})
+
+	t.Run("returns all ollama models", func(t *testing.T) {
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{
+			"models":{"providers":{"ollama":{"models":[
+				{"id":"llama3.2"},
+				{"id":"mistral"}
+			]}}}
+		}`), 0o644)
+
+		models := c.Models()
+		if len(models) != 2 {
+			t.Errorf("expected 2 models, got %v", models)
+		}
+	})
+}
+
+// Helper functions
+func assertOpenclawModelExists(t *testing.T, path, model string) {
+	t.Helper()
+	data, _ := os.ReadFile(path)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+	models := cfg["models"].(map[string]any)
+	providers := models["providers"].(map[string]any)
+	ollama := providers["ollama"].(map[string]any)
+	modelList := ollama["models"].([]any)
+	for _, m := range modelList {
+		if entry, ok := m.(map[string]any); ok {
+			if entry["id"] == model {
+				return
+			}
+		}
+	}
+	t.Errorf("model %s not found", model)
+}
+
+func assertOpenclawModelNotExists(t *testing.T, path, model string) {
+	t.Helper()
+	data, _ := os.ReadFile(path)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+	models, _ := cfg["models"].(map[string]any)
+	providers, _ := models["providers"].(map[string]any)
+	ollama, _ := providers["ollama"].(map[string]any)
+	modelList, _ := ollama["models"].([]any)
+	for _, m := range modelList {
+		if entry, ok := m.(map[string]any); ok {
+			if entry["id"] == model {
+				t.Errorf("model %s should not exist", model)
+			}
+		}
+	}
+}
+
+func assertOpenclawPrimaryModel(t *testing.T, path, expected string) {
+	t.Helper()
+	data, _ := os.ReadFile(path)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+	agents := cfg["agents"].(map[string]any)
+	defaults := agents["defaults"].(map[string]any)
+	model := defaults["model"].(map[string]any)
+	if model["primary"] != expected {
+		t.Errorf("primary model = %v, want %v", model["primary"], expected)
+	}
+}
+
+func TestOpenclawPaths(t *testing.T) {
+	c := &Openclaw{}
+
+	t.Run("returns path when config exists", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{}`), 0o644)
+
+		paths := c.Paths()
+		if len(paths) != 1 {
+			t.Errorf("expected 1 path, got %d", len(paths))
+		}
+	})
+
+	t.Run("returns nil when config missing", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		if paths := c.Paths(); paths != nil {
+			t.Errorf("expected nil, got %v", paths)
+		}
+	})
+}
+
+func TestOpenclawModelsEdgeCases(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+	cleanup := func() { os.RemoveAll(configDir) }
+
+	t.Run("corrupted JSON returns nil", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{corrupted`), 0o644)
+		if models := c.Models(); models != nil {
+			t.Errorf("expected nil, got %v", models)
+		}
+	})
+
+	t.Run("wrong type at models level", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":"string"}`), 0o644)
+		if models := c.Models(); models != nil {
+			t.Errorf("expected nil, got %v", models)
+		}
+	})
+
+	t.Run("wrong type at providers level", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":{"providers":"string"}}`), 0o644)
+		if models := c.Models(); models != nil {
+			t.Errorf("expected nil, got %v", models)
+		}
+	})
+
+	t.Run("wrong type at ollama level", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":{"providers":{"ollama":"string"}}}`), 0o644)
+		if models := c.Models(); models != nil {
+			t.Errorf("expected nil, got %v", models)
+		}
+	})
+
+	t.Run("model entry missing id", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":{"providers":{"ollama":{"models":[{"name":"test"}]}}}}`), 0o644)
+		if len(c.Models()) != 0 {
+			t.Error("expected empty for missing id")
+		}
+	})
+
+	t.Run("model id is not string", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"models":{"providers":{"ollama":{"models":[{"id":123}]}}}}`), 0o644)
+		if len(c.Models()) != 0 {
+			t.Error("expected empty for non-string id")
+		}
+	})
+}
+
+func TestOpenclawEditSchemaFields(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configPath := filepath.Join(tmpDir, ".openclaw", "openclaw.json")
+
+	if err := c.Edit([]string{"llama3.2"}); err != nil {
+		t.Fatal(err)
+	}
+
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+	models := cfg["models"].(map[string]any)
+	providers := models["providers"].(map[string]any)
+	ollama := providers["ollama"].(map[string]any)
+	modelList := ollama["models"].([]any)
+	entry := modelList[0].(map[string]any)
+
+	// Verify required schema fields
+	if entry["reasoning"] != false {
+		t.Error("reasoning should be false")
+	}
+	if entry["input"] == nil {
+		t.Error("input should be set")
+	}
+	if entry["contextWindow"] == nil {
+		t.Error("contextWindow should be set")
+	}
+	if entry["maxTokens"] == nil {
+		t.Error("maxTokens should be set")
+	}
+	cost := entry["cost"].(map[string]any)
+	if cost["cacheRead"] == nil {
+		t.Error("cost.cacheRead should be set")
+	}
+	if cost["cacheWrite"] == nil {
+		t.Error("cost.cacheWrite should be set")
+	}
+}
+
+func TestOpenclawEditModelNames(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configPath := filepath.Join(tmpDir, ".openclaw", "openclaw.json")
+	cleanup := func() { os.RemoveAll(filepath.Join(tmpDir, ".openclaw")) }
+
+	t.Run("model with colon tag", func(t *testing.T) {
+		cleanup()
+		if err := c.Edit([]string{"llama3.2:70b"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenclawModelExists(t, configPath, "llama3.2:70b")
+		assertOpenclawPrimaryModel(t, configPath, "ollama/llama3.2:70b")
+	})
+
+	t.Run("model with slash", func(t *testing.T) {
+		cleanup()
+		if err := c.Edit([]string{"library/model:tag"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenclawModelExists(t, configPath, "library/model:tag")
+		assertOpenclawPrimaryModel(t, configPath, "ollama/library/model:tag")
+	})
+
+	t.Run("model with hyphen", func(t *testing.T) {
+		cleanup()
+		if err := c.Edit([]string{"test-model"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenclawModelExists(t, configPath, "test-model")
+	})
+}
+
+func TestOpenclawEditAgentsPreservation(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+	cleanup := func() { os.RemoveAll(configDir) }
+
+	t.Run("preserve other agent defaults", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"agents":{"defaults":{"model":{"primary":"old"},"temperature":0.7}}}`), 0o644)
+
+		c.Edit([]string{"llama3.2"})
+
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		agents := cfg["agents"].(map[string]any)
+		defaults := agents["defaults"].(map[string]any)
+		if defaults["temperature"] != 0.7 {
+			t.Error("temperature setting was lost")
+		}
+	})
+
+	t.Run("preserve other agents besides defaults", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"agents":{"defaults":{},"custom-agent":{"foo":"bar"}}}`), 0o644)
+
+		c.Edit([]string{"llama3.2"})
+
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		agents := cfg["agents"].(map[string]any)
+		if agents["custom-agent"] == nil {
+			t.Error("custom-agent was lost")
+		}
+	})
+}
+
+const testOpenclawFixture = `{
+  "theme": "dark",
+  "mcp": {"servers": {"custom": {"enabled": true}}},
+  "models": {
+    "providers": {
+      "anthropic": {"apiKey": "xxx"},
+      "ollama": {
+        "baseUrl": "http://127.0.0.1:11434/v1",
+        "models": [{"id": "old-model", "customField": "preserved"}]
+      }
+    }
+  },
+  "agents": {
+    "defaults": {"model": {"primary": "old"}, "temperature": 0.7},
+    "custom-agent": {"foo": "bar"}
+  }
+}`
+
+func TestOpenclawEdit_RoundTrip(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(testOpenclawFixture), 0o644)
+
+	if err := c.Edit([]string{"llama3.2", "mistral"}); err != nil {
+		t.Fatal(err)
+	}
+
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+
+	// Verify top-level preserved
+	if cfg["theme"] != "dark" {
+		t.Error("theme not preserved")
+	}
+	mcp := cfg["mcp"].(map[string]any)
+	servers := mcp["servers"].(map[string]any)
+	if servers["custom"] == nil {
+		t.Error("mcp.servers.custom not preserved")
+	}
+
+	// Verify other providers preserved
+	models := cfg["models"].(map[string]any)
+	providers := models["providers"].(map[string]any)
+	if providers["anthropic"] == nil {
+		t.Error("anthropic provider not preserved")
+	}
+
+	// Verify agents preserved
+	agents := cfg["agents"].(map[string]any)
+	if agents["custom-agent"] == nil {
+		t.Error("custom-agent not preserved")
+	}
+	defaults := agents["defaults"].(map[string]any)
+	if defaults["temperature"] != 0.7 {
+		t.Error("temperature not preserved")
+	}
+}
+
+func TestOpenclawEdit_Idempotent(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(testOpenclawFixture), 0o644)
+
+	c.Edit([]string{"llama3.2", "mistral"})
+	firstData, _ := os.ReadFile(configPath)
+
+	c.Edit([]string{"llama3.2", "mistral"})
+	secondData, _ := os.ReadFile(configPath)
+
+	if string(firstData) != string(secondData) {
+		t.Error("repeated edits with same models produced different results")
+	}
+}
+
+func TestOpenclawEdit_MultipleConsecutiveEdits(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(testOpenclawFixture), 0o644)
+
+	for i := range 10 {
+		models := []string{"model-a", "model-b"}
+		if i%2 == 0 {
+			models = []string{"model-x", "model-y", "model-z"}
+		}
+		if err := c.Edit(models); err != nil {
+			t.Fatalf("edit %d failed: %v", i, err)
+		}
+	}
+
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("file is not valid JSON after multiple edits: %v", err)
+	}
+
+	if cfg["theme"] != "dark" {
+		t.Error("theme lost after multiple edits")
+	}
+}
+
+func TestOpenclawEdit_BackupCreated(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+	configPath := filepath.Join(configDir, "openclaw.json")
+	backupDir := filepath.Join(os.TempDir(), "ollama-backups")
+
+	os.MkdirAll(configDir, 0o755)
+	uniqueMarker := fmt.Sprintf("test-marker-%d", os.Getpid())
+	original := fmt.Sprintf(`{"theme": "%s"}`, uniqueMarker)
+	os.WriteFile(configPath, []byte(original), 0o644)
+
+	if err := c.Edit([]string{"model-a"}); err != nil {
+		t.Fatal(err)
+	}
+
+	backups, _ := filepath.Glob(filepath.Join(backupDir, "openclaw.json.*"))
+	foundBackup := false
+	for _, backup := range backups {
+		data, _ := os.ReadFile(backup)
+		if string(data) == original {
+			foundBackup = true
+			break
+		}
+	}
+
+	if !foundBackup {
+		t.Error("backup with original content not found")
+	}
+}
+
+func TestOpenclawClawdbotAlias(t *testing.T) {
+	for _, alias := range []string{"clawdbot", "moltbot"} {
+		t.Run(alias+" alias resolves to Openclaw runner", func(t *testing.T) {
+			r, ok := integrations[alias]
+			if !ok {
+				t.Fatalf("%s not found in integrations", alias)
+			}
+			if _, ok := r.(*Openclaw); !ok {
+				t.Errorf("%s integration is %T, want *Openclaw", alias, r)
+			}
+		})
+
+		t.Run(alias+" is hidden from selector", func(t *testing.T) {
+			if !integrationAliases[alias] {
+				t.Errorf("%s should be in integrationAliases", alias)
+			}
+		})
+	}
+}
+
+func TestOpenclawLegacyPaths(t *testing.T) {
+	c := &Openclaw{}
+
+	t.Run("falls back to legacy clawdbot path", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{}`), 0o644)
+
+		paths := c.Paths()
+		if len(paths) != 1 {
+			t.Fatalf("expected 1 path, got %d", len(paths))
+		}
+		if paths[0] != filepath.Join(legacyDir, "clawdbot.json") {
+			t.Errorf("expected legacy path, got %s", paths[0])
+		}
+	})
+
+	t.Run("prefers new path over legacy", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		newDir := filepath.Join(tmpDir, ".openclaw")
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(newDir, 0o755)
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(newDir, "openclaw.json"), []byte(`{}`), 0o644)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{}`), 0o644)
+
+		paths := c.Paths()
+		if len(paths) != 1 {
+			t.Fatalf("expected 1 path, got %d", len(paths))
+		}
+		if paths[0] != filepath.Join(newDir, "openclaw.json") {
+			t.Errorf("expected new path, got %s", paths[0])
+		}
+	})
+
+	t.Run("Models reads from legacy path", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{
+			"models":{"providers":{"ollama":{"models":[{"id":"llama3.2"}]}}}
+		}`), 0o644)
+
+		models := c.Models()
+		if len(models) != 1 || models[0] != "llama3.2" {
+			t.Errorf("expected [llama3.2], got %v", models)
+		}
+	})
+
+	t.Run("Models prefers new path over legacy", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		newDir := filepath.Join(tmpDir, ".openclaw")
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(newDir, 0o755)
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(newDir, "openclaw.json"), []byte(`{
+			"models":{"providers":{"ollama":{"models":[{"id":"new-model"}]}}}
+		}`), 0o644)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{
+			"models":{"providers":{"ollama":{"models":[{"id":"legacy-model"}]}}}
+		}`), 0o644)
+
+		models := c.Models()
+		if len(models) != 1 || models[0] != "new-model" {
+			t.Errorf("expected [new-model], got %v", models)
+		}
+	})
+
+	t.Run("Edit reads new path over legacy when both exist", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		newDir := filepath.Join(tmpDir, ".openclaw")
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(newDir, 0o755)
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(newDir, "openclaw.json"), []byte(`{"theme":"new"}`), 0o644)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{"theme":"legacy"}`), 0o644)
+
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		data, _ := os.ReadFile(filepath.Join(newDir, "openclaw.json"))
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		if cfg["theme"] != "new" {
+			t.Errorf("expected theme from new config, got %v", cfg["theme"])
+		}
+	})
+
+	t.Run("Edit migrates from legacy config", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{"theme":"dark"}`), 0o644)
+
+		if err := c.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		// Should write to new path
+		newPath := filepath.Join(tmpDir, ".openclaw", "openclaw.json")
+		data, err := os.ReadFile(newPath)
+		if err != nil {
+			t.Fatal("expected new config file to be created")
+		}
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		if cfg["theme"] != "dark" {
+			t.Error("legacy theme setting was not migrated")
+		}
+	})
+}
+
+func TestOpenclawEdit_CreatesDirectoryIfMissing(t *testing.T) {
+	c := &Openclaw{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	configDir := filepath.Join(tmpDir, ".openclaw")
+
+	if _, err := os.Stat(configDir); !os.IsNotExist(err) {
+		t.Fatal("directory should not exist before test")
+	}
+
+	if err := c.Edit([]string{"model-a"}); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := os.Stat(configDir); os.IsNotExist(err) {
+		t.Fatal("directory was not created")
+	}
+}
+
+func TestOpenclawOnboarded(t *testing.T) {
+	c := &Openclaw{}
+
+	t.Run("returns false when no config exists", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		if c.onboarded() {
+			t.Error("expected false when no config exists")
+		}
+	})
+
+	t.Run("returns false when config exists but no wizard section", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{"theme":"dark"}`), 0o644)
+
+		if c.onboarded() {
+			t.Error("expected false when no wizard section")
+		}
+	})
+
+	t.Run("returns false when wizard section exists but no lastRunAt", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{"wizard":{}}`), 0o644)
+
+		if c.onboarded() {
+			t.Error("expected false when wizard.lastRunAt is missing")
+		}
+	})
+
+	t.Run("returns false when wizard.lastRunAt is empty string", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{"wizard":{"lastRunAt":""}}`), 0o644)
+
+		if c.onboarded() {
+			t.Error("expected false when wizard.lastRunAt is empty")
+		}
+	})
+
+	t.Run("returns true when wizard.lastRunAt is set", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{"wizard":{"lastRunAt":"2024-01-01T00:00:00Z"}}`), 0o644)
+
+		if !c.onboarded() {
+			t.Error("expected true when wizard.lastRunAt is set")
+		}
+	})
+
+	t.Run("checks legacy clawdbot path", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(legacyDir, 0o755)
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{"wizard":{"lastRunAt":"2024-01-01T00:00:00Z"}}`), 0o644)
+
+		if !c.onboarded() {
+			t.Error("expected true when legacy config has wizard.lastRunAt")
+		}
+	})
+
+	t.Run("prefers new path over legacy", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		newDir := filepath.Join(tmpDir, ".openclaw")
+		legacyDir := filepath.Join(tmpDir, ".clawdbot")
+		os.MkdirAll(newDir, 0o755)
+		os.MkdirAll(legacyDir, 0o755)
+		// New path has no wizard marker
+		os.WriteFile(filepath.Join(newDir, "openclaw.json"), []byte(`{}`), 0o644)
+		// Legacy has wizard marker
+		os.WriteFile(filepath.Join(legacyDir, "clawdbot.json"), []byte(`{"wizard":{"lastRunAt":"2024-01-01T00:00:00Z"}}`), 0o644)
+
+		if c.onboarded() {
+			t.Error("expected false - should prefer new path which has no wizard marker")
+		}
+	})
+
+	t.Run("handles corrupted JSON gracefully", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{corrupted`), 0o644)
+
+		if c.onboarded() {
+			t.Error("expected false for corrupted JSON")
+		}
+	})
+
+	t.Run("handles wrong type for wizard section", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+		configDir := filepath.Join(tmpDir, ".openclaw")
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "openclaw.json"), []byte(`{"wizard":"not a map"}`), 0o644)
+
+		if c.onboarded() {
+			t.Error("expected false when wizard is wrong type")
+		}
+	})
+}
@@ -0,0 +1,287 @@
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"maps"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/envconfig"
+)
+
+// OpenCode implements Runner and Editor for OpenCode integration
+type OpenCode struct{}
+
+// cloudModelLimit holds context and output token limits for a cloud model.
+type cloudModelLimit struct {
+	Context int
+	Output  int
+}
+
+// cloudModelLimits maps cloud model base names to their token limits.
+// TODO(parthsareen): grab context/output limits from model info instead of hardcoding
+var cloudModelLimits = map[string]cloudModelLimit{
+	"cogito-2.1:671b":     {Context: 163_840, Output: 65_536},
+	"deepseek-v3.1:671b":  {Context: 163_840, Output: 163_840},
+	"deepseek-v3.2":       {Context: 163_840, Output: 65_536},
+	"glm-4.6":             {Context: 202_752, Output: 131_072},
+	"glm-4.7":             {Context: 202_752, Output: 131_072},
+	"gpt-oss:120b":        {Context: 131_072, Output: 131_072},
+	"gpt-oss:20b":         {Context: 131_072, Output: 131_072},
+	"kimi-k2:1t":          {Context: 262_144, Output: 262_144},
+	"kimi-k2.5":           {Context: 262_144, Output: 262_144},
+	"kimi-k2-thinking":    {Context: 262_144, Output: 262_144},
+	"nemotron-3-nano:30b": {Context: 1_048_576, Output: 131_072},
+	"qwen3-coder:480b":    {Context: 262_144, Output: 65_536},
+	"qwen3-coder-next":    {Context: 262_144, Output: 32_768},
+	"qwen3-next:80b":      {Context: 262_144, Output: 32_768},
+}
+
+// lookupCloudModelLimit returns the token limits for a cloud model.
+// It tries the exact name first, then strips the ":cloud" suffix.
+func lookupCloudModelLimit(name string) (cloudModelLimit, bool) {
+	if l, ok := cloudModelLimits[name]; ok {
+		return l, true
+	}
+	base := strings.TrimSuffix(name, ":cloud")
+	if base != name {
+		if l, ok := cloudModelLimits[base]; ok {
+			return l, true
+		}
+	}
+	return cloudModelLimit{}, false
+}
+
+func (o *OpenCode) String() string { return "OpenCode" }
+
+func (o *OpenCode) Run(model string, args []string) error {
+	if _, err := exec.LookPath("opencode"); err != nil {
+		return fmt.Errorf("opencode is not installed, install from https://opencode.ai")
+	}
+
+	// Call Edit() to ensure config is up-to-date before launch
+	models := []string{model}
+	if config, err := loadIntegration("opencode"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	if err := o.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
+	cmd := exec.Command("opencode", args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func (o *OpenCode) Paths() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+
+	var paths []string
+	p := filepath.Join(home, ".config", "opencode", "opencode.json")
+	if _, err := os.Stat(p); err == nil {
+		paths = append(paths, p)
+	}
+	sp := filepath.Join(home, ".local", "state", "opencode", "model.json")
+	if _, err := os.Stat(sp); err == nil {
+		paths = append(paths, sp)
+	}
+	return paths
+}
+
+func (o *OpenCode) Edit(modelList []string) error {
+	if len(modelList) == 0 {
+		return nil
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	configPath := filepath.Join(home, ".config", "opencode", "opencode.json")
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return err
+	}
+
+	config := make(map[string]any)
+	if data, err := os.ReadFile(configPath); err == nil {
+		_ = json.Unmarshal(data, &config) // Ignore parse errors; treat missing/corrupt files as empty
+	}
+
+	config["$schema"] = "https://opencode.ai/config.json"
+
+	provider, ok := config["provider"].(map[string]any)
+	if !ok {
+		provider = make(map[string]any)
+	}
+
+	ollama, ok := provider["ollama"].(map[string]any)
+	if !ok {
+		ollama = map[string]any{
+			"npm":  "@ai-sdk/openai-compatible",
+			"name": "Ollama (local)",
+			"options": map[string]any{
+				"baseURL": envconfig.Host().String() + "/v1",
+			},
+		}
+	}
+
+	models, ok := ollama["models"].(map[string]any)
+	if !ok {
+		models = make(map[string]any)
+	}
+
+	selectedSet := make(map[string]bool)
+	for _, m := range modelList {
+		selectedSet[m] = true
+	}
+
+	for name, cfg := range models {
+		if cfgMap, ok := cfg.(map[string]any); ok {
+			if isOllamaModel(cfgMap) && !selectedSet[name] {
+				delete(models, name)
+			}
+		}
+	}
+
+	client, _ := api.ClientFromEnvironment()
+
+	for _, model := range modelList {
+		if existing, ok := models[model].(map[string]any); ok {
+			// migrate existing models without _launch marker
+			if isOllamaModel(existing) {
+				existing["_launch"] = true
+				if name, ok := existing["name"].(string); ok {
+					existing["name"] = strings.TrimSuffix(name, " [Ollama]")
+				}
+			}
+			if isCloudModel(context.Background(), client, model) {
+				if l, ok := lookupCloudModelLimit(model); ok {
+					existing["limit"] = map[string]any{
+						"context": l.Context,
+						"output":  l.Output,
+					}
+				}
+			}
+			continue
+		}
+		entry := map[string]any{
+			"name":    model,
+			"_launch": true,
+		}
+		if isCloudModel(context.Background(), client, model) {
+			if l, ok := lookupCloudModelLimit(model); ok {
+				entry["limit"] = map[string]any{
+					"context": l.Context,
+					"output":  l.Output,
+				}
+			}
+		}
+		models[model] = entry
+	}
+
+	ollama["models"] = models
+	provider["ollama"] = ollama
+	config["provider"] = provider
+
+	configData, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+	if err := writeWithBackup(configPath, configData); err != nil {
+		return err
+	}
+
+	statePath := filepath.Join(home, ".local", "state", "opencode", "model.json")
+	if err := os.MkdirAll(filepath.Dir(statePath), 0o755); err != nil {
+		return err
+	}
+
+	state := map[string]any{
+		"recent":   []any{},
+		"favorite": []any{},
+		"variant":  map[string]any{},
+	}
+	if data, err := os.ReadFile(statePath); err == nil {
+		_ = json.Unmarshal(data, &state) // Ignore parse errors; use defaults
+	}
+
+	recent, _ := state["recent"].([]any)
+
+	modelSet := make(map[string]bool)
+	for _, m := range modelList {
+		modelSet[m] = true
+	}
+
+	// Filter out existing Ollama models we're about to re-add
+	newRecent := slices.DeleteFunc(slices.Clone(recent), func(entry any) bool {
+		e, ok := entry.(map[string]any)
+		if !ok || e["providerID"] != "ollama" {
+			return false
+		}
+		modelID, _ := e["modelID"].(string)
+		return modelSet[modelID]
+	})
+
+	// Prepend models in reverse order so first model ends up first
+	for _, model := range slices.Backward(modelList) {
+		newRecent = slices.Insert(newRecent, 0, any(map[string]any{
+			"providerID": "ollama",
+			"modelID":    model,
+		}))
+	}
+
+	const maxRecentModels = 10
+	newRecent = newRecent[:min(len(newRecent), maxRecentModels)]
+
+	state["recent"] = newRecent
+
+	stateData, err := json.MarshalIndent(state, "", "  ")
+	if err != nil {
+		return err
+	}
+	return writeWithBackup(statePath, stateData)
+}
+
+func (o *OpenCode) Models() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+	config, err := readJSONFile(filepath.Join(home, ".config", "opencode", "opencode.json"))
+	if err != nil {
+		return nil
+	}
+	provider, _ := config["provider"].(map[string]any)
+	ollama, _ := provider["ollama"].(map[string]any)
+	models, _ := ollama["models"].(map[string]any)
+	if len(models) == 0 {
+		return nil
+	}
+	keys := slices.Collect(maps.Keys(models))
+	slices.Sort(keys)
+	return keys
+}
+
+// isOllamaModel reports whether a model config entry is managed by us
+func isOllamaModel(cfg map[string]any) bool {
+	if v, ok := cfg["_launch"].(bool); ok && v {
+		return true
+	}
+	// previously used [Ollama] as a suffix for the model managed by ollama launch
+	if name, ok := cfg["name"].(string); ok {
+		return strings.HasSuffix(name, "[Ollama]")
+	}
+	return false
+}
@@ -0,0 +1,668 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestOpenCodeIntegration(t *testing.T) {
+	o := &OpenCode{}
+
+	t.Run("String", func(t *testing.T) {
+		if got := o.String(); got != "OpenCode" {
+			t.Errorf("String() = %q, want %q", got, "OpenCode")
+		}
+	})
+
+	t.Run("implements Runner", func(t *testing.T) {
+		var _ Runner = o
+	})
+
+	t.Run("implements Editor", func(t *testing.T) {
+		var _ Editor = o
+	})
+}
+
+func TestOpenCodeEdit(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+	stateDir := filepath.Join(tmpDir, ".local", "state", "opencode")
+	statePath := filepath.Join(stateDir, "model.json")
+
+	cleanup := func() {
+		os.RemoveAll(configDir)
+		os.RemoveAll(stateDir)
+	}
+
+	t.Run("fresh install", func(t *testing.T) {
+		cleanup()
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeRecentModel(t, statePath, 0, "ollama", "llama3.2")
+	})
+
+	t.Run("preserve other providers", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"provider":{"anthropic":{"apiKey":"xxx"}}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		provider := cfg["provider"].(map[string]any)
+		if provider["anthropic"] == nil {
+			t.Error("anthropic provider was removed")
+		}
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+	})
+
+	t.Run("preserve other models", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"provider":{"ollama":{"models":{"mistral":{"name":"Mistral"}}}}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenCodeModelExists(t, configPath, "mistral")
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+	})
+
+	t.Run("update existing model", func(t *testing.T) {
+		cleanup()
+		o.Edit([]string{"llama3.2"})
+		o.Edit([]string{"llama3.2"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+	})
+
+	t.Run("preserve top-level keys", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"theme":"dark","keybindings":{}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		if cfg["theme"] != "dark" {
+			t.Error("theme was removed")
+		}
+		if cfg["keybindings"] == nil {
+			t.Error("keybindings was removed")
+		}
+	})
+
+	t.Run("model state - insert at index 0", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(statePath, []byte(`{"recent":[{"providerID":"anthropic","modelID":"claude"}],"favorite":[],"variant":{}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenCodeRecentModel(t, statePath, 0, "ollama", "llama3.2")
+		assertOpenCodeRecentModel(t, statePath, 1, "anthropic", "claude")
+	})
+
+	t.Run("model state - preserve favorites and variants", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(statePath, []byte(`{"recent":[],"favorite":[{"providerID":"x","modelID":"y"}],"variant":{"a":"b"}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(statePath)
+		var state map[string]any
+		json.Unmarshal(data, &state)
+		if len(state["favorite"].([]any)) != 1 {
+			t.Error("favorite was modified")
+		}
+		if state["variant"].(map[string]any)["a"] != "b" {
+			t.Error("variant was modified")
+		}
+	})
+
+	t.Run("model state - deduplicate on re-add", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(statePath, []byte(`{"recent":[{"providerID":"ollama","modelID":"llama3.2"},{"providerID":"anthropic","modelID":"claude"}],"favorite":[],"variant":{}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(statePath)
+		var state map[string]any
+		json.Unmarshal(data, &state)
+		recent := state["recent"].([]any)
+		if len(recent) != 2 {
+			t.Errorf("expected 2 recent entries, got %d", len(recent))
+		}
+		assertOpenCodeRecentModel(t, statePath, 0, "ollama", "llama3.2")
+	})
+
+	t.Run("remove model", func(t *testing.T) {
+		cleanup()
+		// First add two models
+		o.Edit([]string{"llama3.2", "mistral"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeModelExists(t, configPath, "mistral")
+
+		// Then remove one by only selecting the other
+		o.Edit([]string{"llama3.2"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeModelNotExists(t, configPath, "mistral")
+	})
+
+	t.Run("preserve user customizations on managed models", func(t *testing.T) {
+		cleanup()
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		// Add custom fields to the model entry (simulating user edits)
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		provider := cfg["provider"].(map[string]any)
+		ollama := provider["ollama"].(map[string]any)
+		models := ollama["models"].(map[string]any)
+		entry := models["llama3.2"].(map[string]any)
+		entry["_myPref"] = "custom-value"
+		entry["_myNum"] = 42
+		configData, _ := json.MarshalIndent(cfg, "", "  ")
+		os.WriteFile(configPath, configData, 0o644)
+
+		// Re-run Edit — should preserve custom fields
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		data, _ = os.ReadFile(configPath)
+		json.Unmarshal(data, &cfg)
+		provider = cfg["provider"].(map[string]any)
+		ollama = provider["ollama"].(map[string]any)
+		models = ollama["models"].(map[string]any)
+		entry = models["llama3.2"].(map[string]any)
+
+		if entry["_myPref"] != "custom-value" {
+			t.Errorf("_myPref was lost: got %v", entry["_myPref"])
+		}
+		if entry["_myNum"] != float64(42) {
+			t.Errorf("_myNum was lost: got %v", entry["_myNum"])
+		}
+		if v, ok := entry["_launch"].(bool); !ok || !v {
+			t.Errorf("_launch marker missing or false: got %v", entry["_launch"])
+		}
+	})
+
+	t.Run("migrate legacy [Ollama] suffix entries", func(t *testing.T) {
+		cleanup()
+		// Write a config with a legacy entry (has [Ollama] suffix but no _launch marker)
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"provider":{"ollama":{"models":{"llama3.2":{"name":"llama3.2 [Ollama]"}}}}}`), 0o644)
+
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		provider := cfg["provider"].(map[string]any)
+		ollama := provider["ollama"].(map[string]any)
+		models := ollama["models"].(map[string]any)
+		entry := models["llama3.2"].(map[string]any)
+
+		// _launch marker should be added
+		if v, ok := entry["_launch"].(bool); !ok || !v {
+			t.Errorf("_launch marker not added during migration: got %v", entry["_launch"])
+		}
+		// [Ollama] suffix should be stripped
+		if name, ok := entry["name"].(string); !ok || name != "llama3.2" {
+			t.Errorf("name suffix not stripped: got %q", entry["name"])
+		}
+	})
+
+	t.Run("remove model preserves non-ollama models", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		// Add a non-Ollama model manually
+		os.WriteFile(configPath, []byte(`{"provider":{"ollama":{"models":{"external":{"name":"External Model"}}}}}`), 0o644)
+
+		o.Edit([]string{"llama3.2"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeModelExists(t, configPath, "external") // Should be preserved
+	})
+}
+
+func assertOpenCodeModelExists(t *testing.T, path, model string) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatal(err)
+	}
+	provider, ok := cfg["provider"].(map[string]any)
+	if !ok {
+		t.Fatal("provider not found")
+	}
+	ollama, ok := provider["ollama"].(map[string]any)
+	if !ok {
+		t.Fatal("ollama provider not found")
+	}
+	models, ok := ollama["models"].(map[string]any)
+	if !ok {
+		t.Fatal("models not found")
+	}
+	if models[model] == nil {
+		t.Errorf("model %s not found", model)
+	}
+}
+
+func assertOpenCodeModelNotExists(t *testing.T, path, model string) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatal(err)
+	}
+	provider, ok := cfg["provider"].(map[string]any)
+	if !ok {
+		return // No provider means no model
+	}
+	ollama, ok := provider["ollama"].(map[string]any)
+	if !ok {
+		return // No ollama means no model
+	}
+	models, ok := ollama["models"].(map[string]any)
+	if !ok {
+		return // No models means no model
+	}
+	if models[model] != nil {
+		t.Errorf("model %s should not exist but was found", model)
+	}
+}
+
+func assertOpenCodeRecentModel(t *testing.T, path string, index int, providerID, modelID string) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var state map[string]any
+	if err := json.Unmarshal(data, &state); err != nil {
+		t.Fatal(err)
+	}
+	recent, ok := state["recent"].([]any)
+	if !ok {
+		t.Fatal("recent not found")
+	}
+	if index >= len(recent) {
+		t.Fatalf("index %d out of range (len=%d)", index, len(recent))
+	}
+	entry, ok := recent[index].(map[string]any)
+	if !ok {
+		t.Fatal("entry is not a map")
+	}
+	if entry["providerID"] != providerID {
+		t.Errorf("expected providerID %s, got %s", providerID, entry["providerID"])
+	}
+	if entry["modelID"] != modelID {
+		t.Errorf("expected modelID %s, got %s", modelID, entry["modelID"])
+	}
+}
+
+// Edge case tests for opencode.go
+
+func TestOpenCodeEdit_CorruptedConfigJSON(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(`{corrupted json content`), 0o644)
+
+	// Should not panic - corrupted JSON should be treated as empty
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit failed with corrupted config: %v", err)
+	}
+
+	// Verify valid JSON was created
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Errorf("resulting config is not valid JSON: %v", err)
+	}
+}
+
+func TestOpenCodeEdit_CorruptedStateJSON(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	stateDir := filepath.Join(tmpDir, ".local", "state", "opencode")
+	statePath := filepath.Join(stateDir, "model.json")
+
+	os.MkdirAll(stateDir, 0o755)
+	os.WriteFile(statePath, []byte(`{corrupted state`), 0o644)
+
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit failed with corrupted state: %v", err)
+	}
+
+	// Verify valid state was created
+	data, _ := os.ReadFile(statePath)
+	var state map[string]any
+	if err := json.Unmarshal(data, &state); err != nil {
+		t.Errorf("resulting state is not valid JSON: %v", err)
+	}
+}
+
+func TestOpenCodeEdit_WrongTypeProvider(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(`{"provider": "not a map"}`), 0o644)
+
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit with wrong type provider failed: %v", err)
+	}
+
+	// Verify provider is now correct type
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+
+	provider, ok := cfg["provider"].(map[string]any)
+	if !ok {
+		t.Fatalf("provider should be map after setup, got %T", cfg["provider"])
+	}
+	if provider["ollama"] == nil {
+		t.Error("ollama provider should be created")
+	}
+}
+
+func TestOpenCodeEdit_WrongTypeRecent(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	stateDir := filepath.Join(tmpDir, ".local", "state", "opencode")
+	statePath := filepath.Join(stateDir, "model.json")
+
+	os.MkdirAll(stateDir, 0o755)
+	os.WriteFile(statePath, []byte(`{"recent": "not an array", "favorite": [], "variant": {}}`), 0o644)
+
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit with wrong type recent failed: %v", err)
+	}
+
+	// The function should handle this gracefully
+	data, _ := os.ReadFile(statePath)
+	var state map[string]any
+	json.Unmarshal(data, &state)
+
+	// recent should be properly set after setup
+	recent, ok := state["recent"].([]any)
+	if !ok {
+		t.Logf("Note: recent type after setup is %T (documenting behavior)", state["recent"])
+	} else if len(recent) == 0 {
+		t.Logf("Note: recent is empty (documenting behavior)")
+	}
+}
+
+func TestOpenCodeEdit_EmptyModels(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	os.MkdirAll(configDir, 0o755)
+	originalContent := `{"provider":{"ollama":{"models":{"existing":{}}}}}`
+	os.WriteFile(configPath, []byte(originalContent), 0o644)
+
+	// Empty models should be no-op
+	err := o.Edit([]string{})
+	if err != nil {
+		t.Fatalf("Edit with empty models failed: %v", err)
+	}
+
+	// Original content should be preserved (file not modified)
+	data, _ := os.ReadFile(configPath)
+	if string(data) != originalContent {
+		t.Errorf("empty models should not modify file, but content changed")
+	}
+}
+
+func TestOpenCodeEdit_SpecialCharsInModelName(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	// Model name with special characters (though unusual)
+	specialModel := `model-with-"quotes"`
+
+	err := o.Edit([]string{specialModel})
+	if err != nil {
+		t.Fatalf("Edit with special chars failed: %v", err)
+	}
+
+	// Verify it was stored correctly
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+	data, _ := os.ReadFile(configPath)
+
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("resulting config is invalid JSON: %v", err)
+	}
+
+	// Model should be accessible
+	provider, _ := cfg["provider"].(map[string]any)
+	ollama, _ := provider["ollama"].(map[string]any)
+	models, _ := ollama["models"].(map[string]any)
+
+	if models[specialModel] == nil {
+		t.Errorf("model with special chars not found in config")
+	}
+}
+
+func readOpenCodeModel(t *testing.T, configPath, model string) map[string]any {
+	t.Helper()
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+	provider := cfg["provider"].(map[string]any)
+	ollama := provider["ollama"].(map[string]any)
+	models := ollama["models"].(map[string]any)
+	entry, ok := models[model].(map[string]any)
+	if !ok {
+		t.Fatalf("model %s not found in config", model)
+	}
+	return entry
+}
+
+func TestOpenCodeEdit_LocalModelNoLimit(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configPath := filepath.Join(tmpDir, ".config", "opencode", "opencode.json")
+
+	if err := o.Edit([]string{"llama3.2"}); err != nil {
+		t.Fatal(err)
+	}
+
+	entry := readOpenCodeModel(t, configPath, "llama3.2")
+	if entry["limit"] != nil {
+		t.Errorf("local model should not have limit set, got %v", entry["limit"])
+	}
+}
+
+func TestOpenCodeEdit_PreservesUserLimit(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	// Set up a model with a user-configured limit
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(`{
+		"provider": {
+			"ollama": {
+				"models": {
+					"llama3.2": {
+						"name": "llama3.2",
+						"_launch": true,
+						"limit": {"context": 8192, "output": 4096}
+					}
+				}
+			}
+		}
+	}`), 0o644)
+
+	// Re-edit should preserve the user's limit (not delete it)
+	if err := o.Edit([]string{"llama3.2"}); err != nil {
+		t.Fatal(err)
+	}
+
+	entry := readOpenCodeModel(t, configPath, "llama3.2")
+	limit, ok := entry["limit"].(map[string]any)
+	if !ok {
+		t.Fatal("user-configured limit was removed")
+	}
+	if limit["context"] != float64(8192) {
+		t.Errorf("context limit changed: got %v, want 8192", limit["context"])
+	}
+	if limit["output"] != float64(4096) {
+		t.Errorf("output limit changed: got %v, want 4096", limit["output"])
+	}
+}
+
+func TestOpenCodeEdit_CloudModelLimitStructure(t *testing.T) {
+	// Verify that when a cloud model entry has limits set (as Edit would do),
+	// the structure matches what opencode expects and re-edit preserves them.
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	expected := cloudModelLimits["glm-4.7"]
+
+	// Simulate a cloud model that already has the limit set by a previous Edit
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(fmt.Sprintf(`{
+		"provider": {
+			"ollama": {
+				"models": {
+					"glm-4.7:cloud": {
+						"name": "glm-4.7:cloud",
+						"_launch": true,
+						"limit": {"context": %d, "output": %d}
+					}
+				}
+			}
+		}
+	}`, expected.Context, expected.Output)), 0o644)
+
+	// Re-edit should preserve the cloud model limit
+	if err := o.Edit([]string{"glm-4.7:cloud"}); err != nil {
+		t.Fatal(err)
+	}
+
+	entry := readOpenCodeModel(t, configPath, "glm-4.7:cloud")
+	limit, ok := entry["limit"].(map[string]any)
+	if !ok {
+		t.Fatal("cloud model limit was removed on re-edit")
+	}
+	if limit["context"] != float64(expected.Context) {
+		t.Errorf("context = %v, want %d", limit["context"], expected.Context)
+	}
+	if limit["output"] != float64(expected.Output) {
+		t.Errorf("output = %v, want %d", limit["output"], expected.Output)
+	}
+}
+
+func TestLookupCloudModelLimit(t *testing.T) {
+	tests := []struct {
+		name        string
+		wantOK      bool
+		wantContext int
+		wantOutput  int
+	}{
+		{"glm-4.7", true, 202_752, 131_072},
+		{"glm-4.7:cloud", true, 202_752, 131_072},
+		{"kimi-k2.5", true, 262_144, 262_144},
+		{"kimi-k2.5:cloud", true, 262_144, 262_144},
+		{"deepseek-v3.2", true, 163_840, 65_536},
+		{"deepseek-v3.2:cloud", true, 163_840, 65_536},
+		{"qwen3-coder:480b", true, 262_144, 65_536},
+		{"qwen3-coder-next:cloud", true, 262_144, 32_768},
+		{"llama3.2", false, 0, 0},
+		{"unknown-model:cloud", false, 0, 0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l, ok := lookupCloudModelLimit(tt.name)
+			if ok != tt.wantOK {
+				t.Errorf("lookupCloudModelLimit(%q) ok = %v, want %v", tt.name, ok, tt.wantOK)
+			}
+			if ok {
+				if l.Context != tt.wantContext {
+					t.Errorf("context = %d, want %d", l.Context, tt.wantContext)
+				}
+				if l.Output != tt.wantOutput {
+					t.Errorf("output = %d, want %d", l.Output, tt.wantOutput)
+				}
+			}
+		})
+	}
+}
+
+func TestOpenCodeModels_NoConfig(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	models := o.Models()
+	if len(models) > 0 {
+		t.Errorf("expected nil/empty for missing config, got %v", models)
+	}
+}
@@ -0,0 +1,513 @@
+package config
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"golang.org/x/term"
+)
+
+// ANSI escape sequences for terminal formatting.
+const (
+	ansiHideCursor = "\033[?25l"
+	ansiShowCursor = "\033[?25h"
+	ansiBold       = "\033[1m"
+	ansiReset      = "\033[0m"
+	ansiGray       = "\033[37m"
+	ansiGreen      = "\033[32m"
+	ansiClearDown  = "\033[J"
+)
+
+const maxDisplayedItems = 10
+
+var errCancelled = errors.New("cancelled")
+
+type selectItem struct {
+	Name        string
+	Description string
+}
+
+type inputEvent int
+
+const (
+	eventNone inputEvent = iota
+	eventEnter
+	eventEscape
+	eventUp
+	eventDown
+	eventTab
+	eventBackspace
+	eventChar
+)
+
+type selectState struct {
+	items        []selectItem
+	filter       string
+	selected     int
+	scrollOffset int
+}
+
+func newSelectState(items []selectItem) *selectState {
+	return &selectState{items: items}
+}
+
+func (s *selectState) filtered() []selectItem {
+	return filterItems(s.items, s.filter)
+}
+
+func (s *selectState) handleInput(event inputEvent, char byte) (done bool, result string, err error) {
+	filtered := s.filtered()
+
+	switch event {
+	case eventEnter:
+		if len(filtered) > 0 && s.selected < len(filtered) {
+			return true, filtered[s.selected].Name, nil
+		}
+	case eventEscape:
+		return true, "", errCancelled
+	case eventBackspace:
+		if len(s.filter) > 0 {
+			s.filter = s.filter[:len(s.filter)-1]
+			s.selected = 0
+			s.scrollOffset = 0
+		}
+	case eventUp:
+		if s.selected > 0 {
+			s.selected--
+			if s.selected < s.scrollOffset {
+				s.scrollOffset = s.selected
+			}
+		}
+	case eventDown:
+		if s.selected < len(filtered)-1 {
+			s.selected++
+			if s.selected >= s.scrollOffset+maxDisplayedItems {
+				s.scrollOffset = s.selected - maxDisplayedItems + 1
+			}
+		}
+	case eventChar:
+		s.filter += string(char)
+		s.selected = 0
+		s.scrollOffset = 0
+	}
+
+	return false, "", nil
+}
+
+type multiSelectState struct {
+	items         []selectItem
+	itemIndex     map[string]int
+	filter        string
+	highlighted   int
+	scrollOffset  int
+	checked       map[int]bool
+	checkOrder    []int
+	focusOnButton bool
+}
+
+func newMultiSelectState(items []selectItem, preChecked []string) *multiSelectState {
+	s := &multiSelectState{
+		items:     items,
+		itemIndex: make(map[string]int, len(items)),
+		checked:   make(map[int]bool),
+	}
+
+	for i, item := range items {
+		s.itemIndex[item.Name] = i
+	}
+
+	for _, name := range preChecked {
+		if idx, ok := s.itemIndex[name]; ok {
+			s.checked[idx] = true
+			s.checkOrder = append(s.checkOrder, idx)
+		}
+	}
+
+	return s
+}
+
+func (s *multiSelectState) filtered() []selectItem {
+	return filterItems(s.items, s.filter)
+}
+
+func (s *multiSelectState) toggleItem() {
+	filtered := s.filtered()
+	if len(filtered) == 0 || s.highlighted >= len(filtered) {
+		return
+	}
+
+	item := filtered[s.highlighted]
+	origIdx := s.itemIndex[item.Name]
+
+	if s.checked[origIdx] {
+		delete(s.checked, origIdx)
+		for i, idx := range s.checkOrder {
+			if idx == origIdx {
+				s.checkOrder = append(s.checkOrder[:i], s.checkOrder[i+1:]...)
+				break
+			}
+		}
+	} else {
+		s.checked[origIdx] = true
+		s.checkOrder = append(s.checkOrder, origIdx)
+	}
+}
+
+func (s *multiSelectState) handleInput(event inputEvent, char byte) (done bool, result []string, err error) {
+	filtered := s.filtered()
+
+	switch event {
+	case eventEnter:
+		if s.focusOnButton && len(s.checkOrder) > 0 {
+			var res []string
+			for _, idx := range s.checkOrder {
+				res = append(res, s.items[idx].Name)
+			}
+			return true, res, nil
+		} else if !s.focusOnButton {
+			s.toggleItem()
+		}
+	case eventTab:
+		if len(s.checkOrder) > 0 {
+			s.focusOnButton = !s.focusOnButton
+		}
+	case eventEscape:
+		return true, nil, errCancelled
+	case eventBackspace:
+		if len(s.filter) > 0 {
+			s.filter = s.filter[:len(s.filter)-1]
+			s.highlighted = 0
+			s.scrollOffset = 0
+			s.focusOnButton = false
+		}
+	case eventUp:
+		if s.focusOnButton {
+			s.focusOnButton = false
+		} else if s.highlighted > 0 {
+			s.highlighted--
+			if s.highlighted < s.scrollOffset {
+				s.scrollOffset = s.highlighted
+			}
+		}
+	case eventDown:
+		if s.focusOnButton {
+			s.focusOnButton = false
+		} else if s.highlighted < len(filtered)-1 {
+			s.highlighted++
+			if s.highlighted >= s.scrollOffset+maxDisplayedItems {
+				s.scrollOffset = s.highlighted - maxDisplayedItems + 1
+			}
+		}
+	case eventChar:
+		s.filter += string(char)
+		s.highlighted = 0
+		s.scrollOffset = 0
+		s.focusOnButton = false
+	}
+
+	return false, nil, nil
+}
+
+func (s *multiSelectState) selectedCount() int {
+	return len(s.checkOrder)
+}
+
+// Terminal I/O handling
+
+type terminalState struct {
+	fd       int
+	oldState *term.State
+}
+
+func enterRawMode() (*terminalState, error) {
+	fd := int(os.Stdin.Fd())
+	oldState, err := term.MakeRaw(fd)
+	if err != nil {
+		return nil, err
+	}
+	fmt.Fprint(os.Stderr, ansiHideCursor)
+	return &terminalState{fd: fd, oldState: oldState}, nil
+}
+
+func (t *terminalState) restore() {
+	fmt.Fprint(os.Stderr, ansiShowCursor)
+	term.Restore(t.fd, t.oldState)
+}
+
+func clearLines(n int) {
+	if n > 0 {
+		fmt.Fprintf(os.Stderr, "\033[%dA", n)
+		fmt.Fprint(os.Stderr, ansiClearDown)
+	}
+}
+
+func parseInput(r io.Reader) (inputEvent, byte, error) {
+	buf := make([]byte, 3)
+	n, err := r.Read(buf)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	switch {
+	case n == 1 && buf[0] == 13:
+		return eventEnter, 0, nil
+	case n == 1 && (buf[0] == 3 || buf[0] == 27):
+		return eventEscape, 0, nil
+	case n == 1 && buf[0] == 9:
+		return eventTab, 0, nil
+	case n == 1 && buf[0] == 127:
+		return eventBackspace, 0, nil
+	case n == 3 && buf[0] == 27 && buf[1] == 91 && buf[2] == 65:
+		return eventUp, 0, nil
+	case n == 3 && buf[0] == 27 && buf[1] == 91 && buf[2] == 66:
+		return eventDown, 0, nil
+	case n == 1 && buf[0] >= 32 && buf[0] < 127:
+		return eventChar, buf[0], nil
+	}
+
+	return eventNone, 0, nil
+}
+
+// Rendering
+
+func renderSelect(w io.Writer, prompt string, s *selectState) int {
+	filtered := s.filtered()
+
+	if s.filter == "" {
+		fmt.Fprintf(w, "%s %sType to filter...%s\r\n", prompt, ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(w, "%s %s\r\n", prompt, s.filter)
+	}
+	lineCount := 1
+
+	if len(filtered) == 0 {
+		fmt.Fprintf(w, "  %s(no matches)%s\r\n", ansiGray, ansiReset)
+		lineCount++
+	} else {
+		displayCount := min(len(filtered), maxDisplayedItems)
+
+		for i := range displayCount {
+			idx := s.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+			prefix := "    "
+			if idx == s.selected {
+				prefix = "  " + ansiBold + "> "
+			}
+			if item.Description != "" {
+				fmt.Fprintf(w, "%s%s%s %s- %s%s\r\n", prefix, item.Name, ansiReset, ansiGray, item.Description, ansiReset)
+			} else {
+				fmt.Fprintf(w, "%s%s%s\r\n", prefix, item.Name, ansiReset)
+			}
+			lineCount++
+		}
+
+		if remaining := len(filtered) - s.scrollOffset - displayCount; remaining > 0 {
+			fmt.Fprintf(w, "  %s... and %d more%s\r\n", ansiGray, remaining, ansiReset)
+			lineCount++
+		}
+	}
+
+	return lineCount
+}
+
+func renderMultiSelect(w io.Writer, prompt string, s *multiSelectState) int {
+	filtered := s.filtered()
+
+	if s.filter == "" {
+		fmt.Fprintf(w, "%s %sType to filter...%s\r\n", prompt, ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(w, "%s %s\r\n", prompt, s.filter)
+	}
+	lineCount := 1
+
+	if len(filtered) == 0 {
+		fmt.Fprintf(w, "  %s(no matches)%s\r\n", ansiGray, ansiReset)
+		lineCount++
+	} else {
+		displayCount := min(len(filtered), maxDisplayedItems)
+
+		for i := range displayCount {
+			idx := s.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+			origIdx := s.itemIndex[item.Name]
+
+			checkbox := "[ ]"
+			if s.checked[origIdx] {
+				checkbox = "[x]"
+			}
+
+			prefix := "  "
+			suffix := ""
+			if idx == s.highlighted && !s.focusOnButton {
+				prefix = "> "
+			}
+			if len(s.checkOrder) > 0 && s.checkOrder[0] == origIdx {
+				suffix = " " + ansiGray + "(default)" + ansiReset
+			}
+
+			desc := ""
+			if item.Description != "" {
+				desc = " " + ansiGray + "- " + item.Description + ansiReset
+			}
+
+			if idx == s.highlighted && !s.focusOnButton {
+				fmt.Fprintf(w, "  %s%s %s %s%s%s%s\r\n", ansiBold, prefix, checkbox, item.Name, ansiReset, desc, suffix)
+			} else {
+				fmt.Fprintf(w, "  %s %s %s%s%s\r\n", prefix, checkbox, item.Name, desc, suffix)
+			}
+			lineCount++
+		}
+
+		if remaining := len(filtered) - s.scrollOffset - displayCount; remaining > 0 {
+			fmt.Fprintf(w, "  %s... and %d more%s\r\n", ansiGray, remaining, ansiReset)
+			lineCount++
+		}
+	}
+
+	fmt.Fprintf(w, "\r\n")
+	lineCount++
+	count := s.selectedCount()
+	switch {
+	case count == 0:
+		fmt.Fprintf(w, "  %sSelect at least one model.%s\r\n", ansiGray, ansiReset)
+	case s.focusOnButton:
+		fmt.Fprintf(w, "  %s> [ Continue ]%s %s(%d selected)%s\r\n", ansiBold, ansiReset, ansiGray, count, ansiReset)
+	default:
+		fmt.Fprintf(w, "    %s[ Continue ] (%d selected) - press Tab%s\r\n", ansiGray, count, ansiReset)
+	}
+	lineCount++
+
+	return lineCount
+}
+
+// selectPrompt prompts the user to select a single item from a list.
+func selectPrompt(prompt string, items []selectItem) (string, error) {
+	if len(items) == 0 {
+		return "", fmt.Errorf("no items to select from")
+	}
+
+	ts, err := enterRawMode()
+	if err != nil {
+		return "", err
+	}
+	defer ts.restore()
+
+	state := newSelectState(items)
+	var lastLineCount int
+
+	render := func() {
+		clearLines(lastLineCount)
+		lastLineCount = renderSelect(os.Stderr, prompt, state)
+	}
+
+	render()
+
+	for {
+		event, char, err := parseInput(os.Stdin)
+		if err != nil {
+			return "", err
+		}
+
+		done, result, err := state.handleInput(event, char)
+		if done {
+			clearLines(lastLineCount)
+			if err != nil {
+				return "", err
+			}
+			return result, nil
+		}
+
+		render()
+	}
+}
+
+// multiSelectPrompt prompts the user to select multiple items from a list.
+func multiSelectPrompt(prompt string, items []selectItem, preChecked []string) ([]string, error) {
+	if len(items) == 0 {
+		return nil, fmt.Errorf("no items to select from")
+	}
+
+	ts, err := enterRawMode()
+	if err != nil {
+		return nil, err
+	}
+	defer ts.restore()
+
+	state := newMultiSelectState(items, preChecked)
+	var lastLineCount int
+
+	render := func() {
+		clearLines(lastLineCount)
+		lastLineCount = renderMultiSelect(os.Stderr, prompt, state)
+	}
+
+	render()
+
+	for {
+		event, char, err := parseInput(os.Stdin)
+		if err != nil {
+			return nil, err
+		}
+
+		done, result, err := state.handleInput(event, char)
+		if done {
+			clearLines(lastLineCount)
+			if err != nil {
+				return nil, err
+			}
+			return result, nil
+		}
+
+		render()
+	}
+}
+
+func confirmPrompt(prompt string) (bool, error) {
+	fd := int(os.Stdin.Fd())
+	oldState, err := term.MakeRaw(fd)
+	if err != nil {
+		return false, err
+	}
+	defer term.Restore(fd, oldState)
+
+	fmt.Fprintf(os.Stderr, "%s (\033[1my\033[0m/n) ", prompt)
+
+	buf := make([]byte, 1)
+	for {
+		if _, err := os.Stdin.Read(buf); err != nil {
+			return false, err
+		}
+
+		switch buf[0] {
+		case 'Y', 'y', 13:
+			fmt.Fprintf(os.Stderr, "yes\r\n")
+			return true, nil
+		case 'N', 'n', 27, 3:
+			fmt.Fprintf(os.Stderr, "no\r\n")
+			return false, nil
+		}
+	}
+}
+
+func filterItems(items []selectItem, filter string) []selectItem {
+	if filter == "" {
+		return items
+	}
+	var result []selectItem
+	filterLower := strings.ToLower(filter)
+	for _, item := range items {
+		if strings.Contains(strings.ToLower(item.Name), filterLower) {
+			result = append(result, item)
+		}
+	}
+	return result
+}
				`@@ -1 +0,0 @@`
				<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path fill="#fff" d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>