recursive

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

.github/workflows/dependabot_auto.yml

@@ -14,7 +14,7 @@ jobs:
     steps:
       - name: Dependabot metadata
         id: metadata
-        uses: dependabot/fetch-metadata@v2.5.0
+        uses: dependabot/fetch-metadata@v2.4.0
         with:
           github-token: "${{ secrets.GITHUB_TOKEN }}"
           skip-commit-verification: true

.github/workflows/generate_grpc_cache.yaml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - grpc-base-image: ubuntu:24.04
+          - grpc-base-image: ubuntu:22.04
             runs-on: 'ubuntu-latest'
             platforms: 'linux/amd64,linux/arm64'
     runs-on: ${{matrix.runs-on}}

.github/workflows/generate_intel_image.yaml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - base-image: intel/oneapi-basekit:2025.3.0-0-devel-ubuntu24.04
+          - base-image: intel/oneapi-basekit:2025.2.0-0-devel-ubuntu22.04
             runs-on: 'arc-runner-set'
             platforms: 'linux/amd64'
     runs-on: ${{matrix.runs-on}}
@@ -53,7 +53,7 @@ jobs:
             BASE_IMAGE=${{ matrix.base-image }}
           context: .
           file: ./Dockerfile
-          tags: quay.io/go-skynet/intel-oneapi-base:24.04
+          tags: quay.io/go-skynet/intel-oneapi-base:latest
           push: true
           target: intel
           platforms: ${{ matrix.platforms }}

.github/workflows/image-pr.yml

@@ -1,95 +1,94 @@
 ---
-  name: 'build container images tests'
-  
-  on:
-    pull_request:
-  
-  concurrency:
-    group: ci-${{ github.head_ref || github.ref }}-${{ github.repository }}
-    cancel-in-progress: true
-  
-  jobs:
-    image-build:
-      uses: ./.github/workflows/image_build.yml
-      with:
-        tag-latest: ${{ matrix.tag-latest }}
-        tag-suffix: ${{ matrix.tag-suffix }}
-        build-type: ${{ matrix.build-type }}
-        cuda-major-version: ${{ matrix.cuda-major-version }}
-        cuda-minor-version: ${{ matrix.cuda-minor-version }}
-        platforms: ${{ matrix.platforms }}
-        runs-on: ${{ matrix.runs-on }}
-        base-image: ${{ matrix.base-image }}
-        grpc-base-image: ${{ matrix.grpc-base-image }}
-        makeflags: ${{ matrix.makeflags }}
-        ubuntu-version: ${{ matrix.ubuntu-version }}
-      secrets:
-        dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-        dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-        quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-        quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-      strategy:
-        # Pushing with all jobs in parallel
-        # eats the bandwidth of all the nodes
-        max-parallel: ${{ github.event_name != 'pull_request' && 4 || 8 }}
-        fail-fast: false
-        matrix:
-          include:
-            - build-type: 'cublas'
-              cuda-major-version: "12"
-              cuda-minor-version: "9"
-              platforms: 'linux/amd64'
-              tag-latest: 'false'
-              tag-suffix: '-gpu-nvidia-cuda-12'
-              runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:24.04"
-              makeflags: "--jobs=3 --output-sync=target"
-              ubuntu-version: '2404'
-            - build-type: 'cublas'
-              cuda-major-version: "13"
-              cuda-minor-version: "0"
-              platforms: 'linux/amd64'
-              tag-latest: 'false'
-              tag-suffix: '-gpu-nvidia-cuda-13'
-              runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:22.04"
-              makeflags: "--jobs=3 --output-sync=target"
-              ubuntu-version: '2404'
-            - build-type: 'hipblas'
-              platforms: 'linux/amd64'
-              tag-latest: 'false'
-              tag-suffix: '-hipblas'
-              base-image: "rocm/dev-ubuntu-24.04:6.4.4"
-              grpc-base-image: "ubuntu:24.04"
-              runs-on: 'ubuntu-latest'
-              makeflags: "--jobs=3 --output-sync=target"
-              ubuntu-version: '2404'
-            - build-type: 'sycl'
-              platforms: 'linux/amd64'
-              tag-latest: 'false'
-              base-image: "intel/oneapi-basekit:2025.3.0-0-devel-ubuntu24.04"
-              grpc-base-image: "ubuntu:24.04"
-              tag-suffix: 'sycl'
-              runs-on: 'ubuntu-latest'
-              makeflags: "--jobs=3 --output-sync=target"
-              ubuntu-version: '2404'
-            - build-type: 'vulkan'
-              platforms: 'linux/amd64,linux/arm64'
-              tag-latest: 'false'
-              tag-suffix: '-vulkan-core'
-              runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:24.04"
-              makeflags: "--jobs=4 --output-sync=target"
-              ubuntu-version: '2404'
-            - build-type: 'cublas'
-              cuda-major-version: "13"
-              cuda-minor-version: "0"
-              platforms: 'linux/arm64'
-              tag-latest: 'false'
-              tag-suffix: '-nvidia-l4t-arm64-cuda-13'
-              base-image: "ubuntu:24.04"
-              runs-on: 'ubuntu-24.04-arm'
-              makeflags: "--jobs=4 --output-sync=target"
-              skip-drivers: 'false'
-              ubuntu-version: '2404'
-  
+name: 'build container images tests'
+
+on:
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.head_ref || github.ref }}-${{ github.repository }}
+  cancel-in-progress: true
+
+jobs:
+  image-build:
+    uses: ./.github/workflows/image_build.yml
+    with:
+      tag-latest: ${{ matrix.tag-latest }}
+      tag-suffix: ${{ matrix.tag-suffix }}
+      build-type: ${{ matrix.build-type }}
+      cuda-major-version: ${{ matrix.cuda-major-version }}
+      cuda-minor-version: ${{ matrix.cuda-minor-version }}
+      platforms: ${{ matrix.platforms }}
+      runs-on: ${{ matrix.runs-on }}
+      base-image: ${{ matrix.base-image }}
+      grpc-base-image: ${{ matrix.grpc-base-image }}
+      makeflags: ${{ matrix.makeflags }}
+      ubuntu-version: ${{ matrix.ubuntu-version }}
+    secrets:
+      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
+      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
+      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
+      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
+    strategy:
+      # Pushing with all jobs in parallel
+      # eats the bandwidth of all the nodes
+      max-parallel: ${{ github.event_name != 'pull_request' && 4 || 8 }}
+      fail-fast: false
+      matrix:
+        include:
+          - build-type: 'cublas'
+            cuda-major-version: "12"
+            cuda-minor-version: "0"
+            platforms: 'linux/amd64'
+            tag-latest: 'false'
+            tag-suffix: '-gpu-nvidia-cuda-12'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            makeflags: "--jobs=3 --output-sync=target"
+            ubuntu-version: '2204'
+          - build-type: 'cublas'
+            cuda-major-version: "13"
+            cuda-minor-version: "0"
+            platforms: 'linux/amd64'
+            tag-latest: 'false'
+            tag-suffix: '-gpu-nvidia-cuda-13'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            makeflags: "--jobs=3 --output-sync=target"
+            ubuntu-version: '2204'
+          - build-type: 'hipblas'
+            platforms: 'linux/amd64'
+            tag-latest: 'false'
+            tag-suffix: '-hipblas'
+            base-image: "rocm/dev-ubuntu-22.04:6.4.3"
+            grpc-base-image: "ubuntu:22.04"
+            runs-on: 'ubuntu-latest'
+            makeflags: "--jobs=3 --output-sync=target"
+            ubuntu-version: '2204'
+          - build-type: 'sycl'
+            platforms: 'linux/amd64'
+            tag-latest: 'false'
+            base-image: "quay.io/go-skynet/intel-oneapi-base:latest"
+            grpc-base-image: "ubuntu:22.04"
+            tag-suffix: 'sycl'
+            runs-on: 'ubuntu-latest'
+            makeflags: "--jobs=3 --output-sync=target"
+            ubuntu-version: '2204'
+          - build-type: 'vulkan'
+            platforms: 'linux/amd64'
+            tag-latest: 'false'
+            tag-suffix: '-vulkan-core'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            makeflags: "--jobs=4 --output-sync=target"
+            ubuntu-version: '2204'
+          - build-type: 'cublas'
+            cuda-major-version: "13"
+            cuda-minor-version: "0"
+            platforms: 'linux/arm64'
+            tag-latest: 'false'
+            tag-suffix: '-nvidia-l4t-arm64-cuda-13'
+            base-image: "ubuntu:24.04"
+            runs-on: 'ubuntu-24.04-arm'
+            makeflags: "--jobs=4 --output-sync=target"
+            skip-drivers: 'false'
+            ubuntu-version: '2404'

.github/workflows/image.yml

@@ -1,187 +1,187 @@
 ---
-  name: 'build container images'
-  
-  on:
-    push:
-      branches:
-        - master
-      tags:
-        - '*'
-  
-  concurrency:
-    group: ci-${{ github.head_ref || github.ref }}-${{ github.repository }}
-    cancel-in-progress: true
-  
-  jobs:
-    hipblas-jobs:
-      uses: ./.github/workflows/image_build.yml
-      with:
-        tag-latest: ${{ matrix.tag-latest }}
-        tag-suffix: ${{ matrix.tag-suffix }}
-        build-type: ${{ matrix.build-type }}
-        cuda-major-version: ${{ matrix.cuda-major-version }}
-        cuda-minor-version: ${{ matrix.cuda-minor-version }}
-        platforms: ${{ matrix.platforms }}
-        runs-on: ${{ matrix.runs-on }}
-        base-image: ${{ matrix.base-image }}
-        grpc-base-image: ${{ matrix.grpc-base-image }}
-        aio: ${{ matrix.aio }}
-        makeflags: ${{ matrix.makeflags }}
-        ubuntu-version: ${{ matrix.ubuntu-version }}
-        ubuntu-codename: ${{ matrix.ubuntu-codename }}
-      secrets:
-        dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-        dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-        quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-        quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-      strategy:
-        matrix:
-          include:
-            - build-type: 'hipblas'
-              platforms: 'linux/amd64'
-              tag-latest: 'auto'
-              tag-suffix: '-gpu-hipblas'
-              base-image: "rocm/dev-ubuntu-24.04:6.4.4"
-              grpc-base-image: "ubuntu:24.04"
-              runs-on: 'ubuntu-latest'
-              makeflags: "--jobs=3 --output-sync=target"
-              aio: "-aio-gpu-hipblas"
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-  
-    core-image-build:
-      uses: ./.github/workflows/image_build.yml
-      with:
-        tag-latest: ${{ matrix.tag-latest }}
-        tag-suffix: ${{ matrix.tag-suffix }}
-        build-type: ${{ matrix.build-type }}
-        cuda-major-version: ${{ matrix.cuda-major-version }}
-        cuda-minor-version: ${{ matrix.cuda-minor-version }}
-        platforms: ${{ matrix.platforms }}
-        runs-on: ${{ matrix.runs-on }}
-        aio: ${{ matrix.aio }}
-        base-image: ${{ matrix.base-image }}
-        grpc-base-image: ${{ matrix.grpc-base-image }}
-        makeflags: ${{ matrix.makeflags }}
-        skip-drivers: ${{ matrix.skip-drivers }}
-        ubuntu-version: ${{ matrix.ubuntu-version }}
-        ubuntu-codename: ${{ matrix.ubuntu-codename }}
-      secrets:
-        dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-        dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-        quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-        quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-      strategy:
-        #max-parallel: ${{ github.event_name != 'pull_request' && 2 || 4 }}
-        matrix:
-          include:
-            - build-type: ''
-              platforms: 'linux/amd64,linux/arm64'
-              tag-latest: 'auto'
-              tag-suffix: ''
-              base-image: "ubuntu:24.04"
-              runs-on: 'ubuntu-latest'
-              aio: "-aio-cpu"
-              makeflags: "--jobs=4 --output-sync=target"
-              skip-drivers: 'false'
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-            - build-type: 'cublas'
-              cuda-major-version: "12"
-              cuda-minor-version: "9"
-              platforms: 'linux/amd64'
-              tag-latest: 'auto'
-              tag-suffix: '-gpu-nvidia-cuda-12'
-              runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:24.04"
-              skip-drivers: 'false'
-              makeflags: "--jobs=4 --output-sync=target"
-              aio: "-aio-gpu-nvidia-cuda-12"
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-            - build-type: 'cublas'
-              cuda-major-version: "13"
-              cuda-minor-version: "0"
-              platforms: 'linux/amd64'
-              tag-latest: 'auto'
-              tag-suffix: '-gpu-nvidia-cuda-13'
-              runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:22.04"
-              skip-drivers: 'false'
-              makeflags: "--jobs=4 --output-sync=target"
-              aio: "-aio-gpu-nvidia-cuda-13"
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-            - build-type: 'vulkan'
-              platforms: 'linux/amd64,linux/arm64'
-              tag-latest: 'auto'
-              tag-suffix: '-gpu-vulkan'
-              runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:24.04"
-              skip-drivers: 'false'
-              makeflags: "--jobs=4 --output-sync=target"
-              aio: "-aio-gpu-vulkan"
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-            - build-type: 'intel'
-              platforms: 'linux/amd64'
-              tag-latest: 'auto'
-              base-image: "intel/oneapi-basekit:2025.3.0-0-devel-ubuntu24.04"
-              grpc-base-image: "ubuntu:24.04"
-              tag-suffix: '-gpu-intel'
-              runs-on: 'ubuntu-latest'
-              makeflags: "--jobs=3 --output-sync=target"
-              aio: "-aio-gpu-intel"
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-  
-    gh-runner:
-      uses: ./.github/workflows/image_build.yml
-      with:
-        tag-latest: ${{ matrix.tag-latest }}
-        tag-suffix: ${{ matrix.tag-suffix }}
-        build-type: ${{ matrix.build-type }}
-        cuda-major-version: ${{ matrix.cuda-major-version }}
-        cuda-minor-version: ${{ matrix.cuda-minor-version }}
-        platforms: ${{ matrix.platforms }}
-        runs-on: ${{ matrix.runs-on }}
-        aio: ${{ matrix.aio }}
-        base-image: ${{ matrix.base-image }}
-        grpc-base-image: ${{ matrix.grpc-base-image }}
-        makeflags: ${{ matrix.makeflags }}
-        skip-drivers: ${{ matrix.skip-drivers }}
-        ubuntu-version: ${{ matrix.ubuntu-version }}
-        ubuntu-codename: ${{ matrix.ubuntu-codename }}
-      secrets:
-        dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-        dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-        quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-        quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-      strategy:
-        matrix:
-          include:
-            - build-type: 'cublas'
-              cuda-major-version: "12"
-              cuda-minor-version: "0"
-              platforms: 'linux/arm64'
-              tag-latest: 'auto'
-              tag-suffix: '-nvidia-l4t-arm64'
-              base-image: "nvcr.io/nvidia/l4t-jetpack:r36.4.0"
-              runs-on: 'ubuntu-24.04-arm'
-              makeflags: "--jobs=4 --output-sync=target"
-              skip-drivers: 'true'
-              ubuntu-version: "2204"
-              ubuntu-codename: 'jammy'
-            - build-type: 'cublas'
-              cuda-major-version: "13"
-              cuda-minor-version: "0"
-              platforms: 'linux/arm64'
-              tag-latest: 'auto'
-              tag-suffix: '-nvidia-l4t-arm64-cuda-13'
-              base-image: "ubuntu:24.04"
-              runs-on: 'ubuntu-24.04-arm'
-              makeflags: "--jobs=4 --output-sync=target"
-              skip-drivers: 'false'
-              ubuntu-version: '2404'
-              ubuntu-codename: 'noble'
-  
+name: 'build container images'
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'
+
+concurrency:
+  group: ci-${{ github.head_ref || github.ref }}-${{ github.repository }}
+  cancel-in-progress: true
+
+jobs:
+  hipblas-jobs:
+    uses: ./.github/workflows/image_build.yml
+    with:
+      tag-latest: ${{ matrix.tag-latest }}
+      tag-suffix: ${{ matrix.tag-suffix }}
+      build-type: ${{ matrix.build-type }}
+      cuda-major-version: ${{ matrix.cuda-major-version }}
+      cuda-minor-version: ${{ matrix.cuda-minor-version }}
+      platforms: ${{ matrix.platforms }}
+      runs-on: ${{ matrix.runs-on }}
+      base-image: ${{ matrix.base-image }}
+      grpc-base-image: ${{ matrix.grpc-base-image }}
+      aio: ${{ matrix.aio }}
+      makeflags: ${{ matrix.makeflags }}
+      ubuntu-version: ${{ matrix.ubuntu-version }}
+    secrets:
+      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
+      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
+      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
+      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
+    strategy:
+      matrix:
+        include:
+          - build-type: 'hipblas'
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-hipblas'
+            base-image: "rocm/dev-ubuntu-22.04:6.4.3"
+            grpc-base-image: "ubuntu:22.04"
+            runs-on: 'ubuntu-latest'
+            makeflags: "--jobs=3 --output-sync=target"
+            aio: "-aio-gpu-hipblas"
+            ubuntu-version: '2204'
+
+  core-image-build:
+    uses: ./.github/workflows/image_build.yml
+    with:
+      tag-latest: ${{ matrix.tag-latest }}
+      tag-suffix: ${{ matrix.tag-suffix }}
+      build-type: ${{ matrix.build-type }}
+      cuda-major-version: ${{ matrix.cuda-major-version }}
+      cuda-minor-version: ${{ matrix.cuda-minor-version }}
+      platforms: ${{ matrix.platforms }}
+      runs-on: ${{ matrix.runs-on }}
+      aio: ${{ matrix.aio }}
+      base-image: ${{ matrix.base-image }}
+      grpc-base-image: ${{ matrix.grpc-base-image }}
+      makeflags: ${{ matrix.makeflags }}
+      skip-drivers: ${{ matrix.skip-drivers }}
+      ubuntu-version: ${{ matrix.ubuntu-version }}
+    secrets:
+      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
+      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
+      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
+      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
+    strategy:
+      #max-parallel: ${{ github.event_name != 'pull_request' && 2 || 4 }}
+      matrix:
+        include:
+          - build-type: ''
+            platforms: 'linux/amd64,linux/arm64'
+            tag-latest: 'auto'
+            tag-suffix: ''
+            base-image: "ubuntu:22.04"
+            runs-on: 'ubuntu-latest'
+            aio: "-aio-cpu"
+            makeflags: "--jobs=4 --output-sync=target"
+            skip-drivers: 'false'
+            ubuntu-version: '2204'
+          - build-type: 'cublas'
+            cuda-major-version: "11"
+            cuda-minor-version: "7"
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-nvidia-cuda-11'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            makeflags: "--jobs=4 --output-sync=target"
+            skip-drivers: 'false'
+            aio: "-aio-gpu-nvidia-cuda-11"
+            ubuntu-version: '2204'
+          - build-type: 'cublas'
+            cuda-major-version: "12"
+            cuda-minor-version: "0"
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-nvidia-cuda-12'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            skip-drivers: 'false'
+            makeflags: "--jobs=4 --output-sync=target"
+            aio: "-aio-gpu-nvidia-cuda-12"
+            ubuntu-version: '2204'
+          - build-type: 'cublas'
+            cuda-major-version: "13"
+            cuda-minor-version: "0"
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-nvidia-cuda-13'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            skip-drivers: 'false'
+            makeflags: "--jobs=4 --output-sync=target"
+            aio: "-aio-gpu-nvidia-cuda-13"
+            ubuntu-version: '2204'
+          - build-type: 'vulkan'
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-vulkan'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:22.04"
+            skip-drivers: 'false'
+            makeflags: "--jobs=4 --output-sync=target"
+            aio: "-aio-gpu-vulkan"
+            ubuntu-version: '2204'
+          - build-type: 'intel'
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            base-image: "quay.io/go-skynet/intel-oneapi-base:latest"
+            grpc-base-image: "ubuntu:22.04"
+            tag-suffix: '-gpu-intel'
+            runs-on: 'ubuntu-latest'
+            makeflags: "--jobs=3 --output-sync=target"
+            aio: "-aio-gpu-intel"
+            ubuntu-version: '2204'
+
+  gh-runner:
+    uses: ./.github/workflows/image_build.yml
+    with:
+      tag-latest: ${{ matrix.tag-latest }}
+      tag-suffix: ${{ matrix.tag-suffix }}
+      build-type: ${{ matrix.build-type }}
+      cuda-major-version: ${{ matrix.cuda-major-version }}
+      cuda-minor-version: ${{ matrix.cuda-minor-version }}
+      platforms: ${{ matrix.platforms }}
+      runs-on: ${{ matrix.runs-on }}
+      aio: ${{ matrix.aio }}
+      base-image: ${{ matrix.base-image }}
+      grpc-base-image: ${{ matrix.grpc-base-image }}
+      makeflags: ${{ matrix.makeflags }}
+      skip-drivers: ${{ matrix.skip-drivers }}
+      ubuntu-version: ${{ matrix.ubuntu-version }}
+    secrets:
+      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
+      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
+      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
+      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
+    strategy:
+      matrix:
+        include:
+          - build-type: 'cublas'
+            cuda-major-version: "12"
+            cuda-minor-version: "0"
+            platforms: 'linux/arm64'
+            tag-latest: 'auto'
+            tag-suffix: '-nvidia-l4t-arm64'
+            base-image: "nvcr.io/nvidia/l4t-jetpack:r36.4.0"
+            runs-on: 'ubuntu-24.04-arm'
+            makeflags: "--jobs=4 --output-sync=target"
+            skip-drivers: 'true'
+            ubuntu-version: "2204"
+          - build-type: 'cublas'
+            cuda-major-version: "13"
+            cuda-minor-version: "0"
+            platforms: 'linux/arm64'
+            tag-latest: 'auto'
+            tag-suffix: '-nvidia-l4t-arm64-cuda-13'
+            base-image: "ubuntu:24.04"
+            runs-on: 'ubuntu-24.04-arm'
+            makeflags: "--jobs=4 --output-sync=target"
+            skip-drivers: 'false'
+            ubuntu-version: '2404'

.github/workflows/image_build.yml

@@ -23,7 +23,7 @@ on:
         type: string
       cuda-minor-version:
         description: 'CUDA minor version'
-        default: "9"
+        default: "4"
         type: string
       platforms:
         description: 'Platforms'
@@ -61,11 +61,6 @@ on:
         required: false
         default: '2204'
         type: string
-      ubuntu-codename:
-        description: 'Ubuntu codename'
-        required: false
-        default: 'noble'
-        type: string
     secrets:
       dockerUsername:
         required: true
@@ -249,7 +244,6 @@ jobs:
             MAKEFLAGS=${{ inputs.makeflags }}
             SKIP_DRIVERS=${{ inputs.skip-drivers }}
             UBUNTU_VERSION=${{ inputs.ubuntu-version }}
-            UBUNTU_CODENAME=${{ inputs.ubuntu-codename }}
           context: .
           file: ./Dockerfile
           cache-from: type=gha
@@ -278,7 +272,6 @@ jobs:
             MAKEFLAGS=${{ inputs.makeflags }}
             SKIP_DRIVERS=${{ inputs.skip-drivers }}
             UBUNTU_VERSION=${{ inputs.ubuntu-version }}
-            UBUNTU_CODENAME=${{ inputs.ubuntu-codename }}
           context: .
           file: ./Dockerfile
           cache-from: type=gha

.github/workflows/test-extra.yml

@@ -247,22 +247,3 @@ jobs:
         run: |
           make --jobs=5 --output-sync=target -C backend/python/coqui
           make --jobs=5 --output-sync=target -C backend/python/coqui test
-  tests-moonshine:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Clone
-        uses: actions/checkout@v6
-        with:
-          submodules: true
-      - name: Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install build-essential ffmpeg
-          sudo apt-get install -y ca-certificates cmake curl patch python3-pip
-          # Install UV
-          curl -LsSf https://astral.sh/uv/install.sh | sh
-          pip install --user --no-cache-dir grpcio-tools==1.64.1
-      - name: Test moonshine
-        run: |
-          make --jobs=5 --output-sync=target -C backend/python/moonshine
-          make --jobs=5 --output-sync=target -C backend/python/moonshine test

.gitignore

@@ -25,7 +25,6 @@ go-bert
 # LocalAI build binary
 LocalAI
 /local-ai
-/local-ai-launcher
 # prevent above rules from omitting the helm chart
 !charts/*
 # prevent above rules from omitting the api/localai folder

AGENTS.md

@@ -2,163 +2,6 @@
 
 Building and testing the project depends on the components involved and the platform where development is taking place. Due to the amount of context required it's usually best not to try building or testing the project unless the user requests it. If you must build the project then inspect the Makefile in the project root and the Makefiles of any backends that are effected by changes you are making. In addition the workflows in .github/workflows can be used as a reference when it is unclear how to build or test a component. The primary Makefile contains targets for building inside or outside Docker, if the user has not previously specified a preference then ask which they would like to use.
 
-## Building a specified backend
-
-Let's say the user wants to build a particular backend for a given platform. For example let's say they want to build bark for ROCM/hipblas
-
-- The Makefile has targets like `docker-build-bark` created with `generate-docker-build-target` at the time of writing. Recently added backends may require a new target.
-- At a minimum we need to set the BUILD_TYPE, BASE_IMAGE build-args
-  - Use .github/workflows/backend.yml as a reference it lists the needed args in the `include` job strategy matrix
-  - l4t and cublas also requires the CUDA major and minor version
-- You can pretty print a command like `DOCKER_MAKEFLAGS=-j$(nproc --ignore=1) BUILD_TYPE=hipblas BASE_IMAGE=rocm/dev-ubuntu-24.04:6.4.4 make docker-build-bark`
-- Unless the user specifies that they want you to run the command, then just print it because not all agent frontends handle long running jobs well and the output may overflow your context
-- The user may say they want to build AMD or ROCM instead of hipblas, or Intel instead of SYCL or NVIDIA insted of l4t or cublas. Ask for confirmation if there is ambiguity.
-- Sometimes the user may need extra parameters to be added to `docker build` (e.g. `--platform` for cross-platform builds or `--progress` to view the full logs), in which case you can generate the `docker build` command directly.
-
-## Adding a New Backend
-
-When adding a new backend to LocalAI, you need to update several files to ensure the backend is properly built, tested, and registered. Here's a step-by-step guide based on the pattern used for adding backends like `moonshine`:
-
-### 1. Create Backend Directory Structure
-
-Create the backend directory under the appropriate location:
-- **Python backends**: `backend/python/<backend-name>/`
-- **Go backends**: `backend/go/<backend-name>/`
-- **C++ backends**: `backend/cpp/<backend-name>/`
-
-For Python backends, you'll typically need:
-- `backend.py` - Main gRPC server implementation
-- `Makefile` - Build configuration
-- `install.sh` - Installation script for dependencies
-- `protogen.sh` - Protocol buffer generation script
-- `requirements.txt` - Python dependencies
-- `run.sh` - Runtime script
-- `test.py` / `test.sh` - Test files
-
-### 2. Add Build Configurations to `.github/workflows/backend.yml`
-
-Add build matrix entries for each platform/GPU type you want to support. Look at similar backends (e.g., `chatterbox`, `faster-whisper`) for reference.
-
-**Placement in file:**
-- CPU builds: Add after other CPU builds (e.g., after `cpu-chatterbox`)
-- CUDA 12 builds: Add after other CUDA 12 builds (e.g., after `gpu-nvidia-cuda-12-chatterbox`)
-- CUDA 13 builds: Add after other CUDA 13 builds (e.g., after `gpu-nvidia-cuda-13-chatterbox`)
-
-**Additional build types you may need:**
-- ROCm/HIP: Use `build-type: 'hipblas'` with `base-image: "rocm/dev-ubuntu-24.04:6.4.4"`
-- Intel/SYCL: Use `build-type: 'intel'` or `build-type: 'sycl_f16'`/`sycl_f32` with `base-image: "intel/oneapi-basekit:2025.3.0-0-devel-ubuntu24.04"`
-- L4T (ARM): Use `build-type: 'l4t'` with `platforms: 'linux/arm64'` and `runs-on: 'ubuntu-24.04-arm'`
-
-### 3. Add Backend Metadata to `backend/index.yaml`
-
-**Step 3a: Add Meta Definition**
-
-Add a YAML anchor definition in the `## metas` section (around line 2-300). Look for similar backends to use as a template such as `diffusers` or `chatterbox`
-
-**Step 3b: Add Image Entries**
-
-Add image entries at the end of the file, following the pattern of similar backends such as `diffusers` or `chatterbox`. Include both `latest` (production) and `master` (development) tags.
-
-### 4. Update the Makefile
-
-The Makefile needs to be updated in several places to support building and testing the new backend:
-
-**Step 4a: Add to `.NOTPARALLEL`**
-
-Add `backends/<backend-name>` to the `.NOTPARALLEL` line (around line 2) to prevent parallel execution conflicts:
-
-```makefile
-.NOTPARALLEL: ... backends/<backend-name>
-```
-
-**Step 4b: Add to `prepare-test-extra`**
-
-Add the backend to the `prepare-test-extra` target (around line 312) to prepare it for testing:
-
-```makefile
-prepare-test-extra: protogen-python
-	...
-	$(MAKE) -C backend/python/<backend-name>
-```
-
-**Step 4c: Add to `test-extra`**
-
-Add the backend to the `test-extra` target (around line 319) to run its tests:
-
-```makefile
-test-extra: prepare-test-extra
-	...
-	$(MAKE) -C backend/python/<backend-name> test
-```
-
-**Step 4d: Add Backend Definition**
-
-Add a backend definition variable in the backend definitions section (around line 428-457). The format depends on the backend type:
-
-**For Python backends with root context** (like `faster-whisper`, `bark`):
-```makefile
-BACKEND_<BACKEND_NAME> = <backend-name>|python|.|false|true
-```
-
-**For Python backends with `./backend` context** (like `chatterbox`, `moonshine`):
-```makefile
-BACKEND_<BACKEND_NAME> = <backend-name>|python|./backend|false|true
-```
-
-**For Go backends**:
-```makefile
-BACKEND_<BACKEND_NAME> = <backend-name>|golang|.|false|true
-```
-
-**Step 4e: Generate Docker Build Target**
-
-Add an eval call to generate the docker-build target (around line 480-501):
-
-```makefile
-$(eval $(call generate-docker-build-target,$(BACKEND_<BACKEND_NAME>)))
-```
-
-**Step 4f: Add to `docker-build-backends`**
-
-Add `docker-build-<backend-name>` to the `docker-build-backends` target (around line 507):
-
-```makefile
-docker-build-backends: ... docker-build-<backend-name>
-```
-
-**Determining the Context:**
-
-- If the backend is in `backend/python/<backend-name>/` and uses `./backend` as context in the workflow file, use `./backend` context
-- If the backend is in `backend/python/<backend-name>/` but uses `.` as context in the workflow file, use `.` context
-- Check similar backends to determine the correct context
-
-### 5. Verification Checklist
-
-After adding a new backend, verify:
-
-- [ ] Backend directory structure is complete with all necessary files
-- [ ] Build configurations added to `.github/workflows/backend.yml` for all desired platforms
-- [ ] Meta definition added to `backend/index.yaml` in the `## metas` section
-- [ ] Image entries added to `backend/index.yaml` for all build variants (latest + development)
-- [ ] Tag suffixes match between workflow file and index.yaml
-- [ ] Makefile updated with all 6 required changes (`.NOTPARALLEL`, `prepare-test-extra`, `test-extra`, backend definition, docker-build target eval, `docker-build-backends`)
-- [ ] No YAML syntax errors (check with linter)
-- [ ] No Makefile syntax errors (check with linter)
-- [ ] Follows the same pattern as similar backends (e.g., if it's a transcription backend, follow `faster-whisper` pattern)
-
-### 6. Example: Adding a Python Backend
-
-For reference, when `moonshine` was added:
-- **Files created**: `backend/python/moonshine/{backend.py, Makefile, install.sh, protogen.sh, requirements.txt, run.sh, test.py, test.sh}`
-- **Workflow entries**: 3 build configurations (CPU, CUDA 12, CUDA 13)
-- **Index entries**: 1 meta definition + 6 image entries (cpu, cuda12, cuda13 × latest/development)
-- **Makefile updates**: 
-  - Added to `.NOTPARALLEL` line
-  - Added to `prepare-test-extra` and `test-extra` targets
-  - Added `BACKEND_MOONSHINE = moonshine|python|./backend|false|true`
-  - Added eval for docker-build target generation
-  - Added `docker-build-moonshine` to `docker-build-backends`
-
 # Coding style
 
 - The project has the following .editorconfig
@@ -234,49 +77,3 @@ When fixing compilation errors after upstream changes:
 - HTTP server uses `server_routes` with HTTP handlers
 - Both use the same `server_context` and task queue infrastructure
 - gRPC methods: `LoadModel`, `Predict`, `PredictStream`, `Embedding`, `Rerank`, `TokenizeString`, `GetMetrics`, `Health`
-
-## Tool Call Parsing Maintenance
-
-When working on JSON/XML tool call parsing functionality, always check llama.cpp for reference implementation and updates:
-
-### Checking for XML Parsing Changes
-
-1. **Review XML Format Definitions**: Check `llama.cpp/common/chat-parser-xml-toolcall.h` for `xml_tool_call_format` struct changes
-2. **Review Parsing Logic**: Check `llama.cpp/common/chat-parser-xml-toolcall.cpp` for parsing algorithm updates
-3. **Review Format Presets**: Check `llama.cpp/common/chat-parser.cpp` for new XML format presets (search for `xml_tool_call_format form`)
-4. **Review Model Lists**: Check `llama.cpp/common/chat.h` for `COMMON_CHAT_FORMAT_*` enum values that use XML parsing:
-   - `COMMON_CHAT_FORMAT_GLM_4_5`
-   - `COMMON_CHAT_FORMAT_MINIMAX_M2`
-   - `COMMON_CHAT_FORMAT_KIMI_K2`
-   - `COMMON_CHAT_FORMAT_QWEN3_CODER_XML`
-   - `COMMON_CHAT_FORMAT_APRIEL_1_5`
-   - `COMMON_CHAT_FORMAT_XIAOMI_MIMO`
-   - Any new formats added
-
-### Model Configuration Options
-
-Always check `llama.cpp` for new model configuration options that should be supported in LocalAI:
-
-1. **Check Server Context**: Review `llama.cpp/tools/server/server-context.cpp` for new parameters
-2. **Check Chat Params**: Review `llama.cpp/common/chat.h` for `common_chat_params` struct changes
-3. **Check Server Options**: Review `llama.cpp/tools/server/server.cpp` for command-line argument changes
-4. **Examples of options to check**:
-   - `ctx_shift` - Context shifting support
-   - `parallel_tool_calls` - Parallel tool calling
-   - `reasoning_format` - Reasoning format options
-   - Any new flags or parameters
-
-### Implementation Guidelines
-
-1. **Feature Parity**: Always aim for feature parity with llama.cpp's implementation
-2. **Test Coverage**: Add tests for new features matching llama.cpp's behavior
-3. **Documentation**: Update relevant documentation when adding new formats or options
-4. **Backward Compatibility**: Ensure changes don't break existing functionality
-
-### Files to Monitor
-
-- `llama.cpp/common/chat-parser-xml-toolcall.h` - Format definitions
-- `llama.cpp/common/chat-parser-xml-toolcall.cpp` - Parsing logic
-- `llama.cpp/common/chat-parser.cpp` - Format presets and model-specific handlers
-- `llama.cpp/common/chat.h` - Format enums and parameter structures
-- `llama.cpp/tools/server/server-context.cpp` - Server configuration options

CONTRIBUTING.md

@@ -78,20 +78,6 @@ LOCALAI_IMAGE_TAG=test LOCALAI_IMAGE=local-ai-aio make run-e2e-aio
 
 We are welcome the contribution of the documents, please open new PR or create a new issue. The documentation is available under `docs/` https://github.com/mudler/LocalAI/tree/master/docs
 
-### Gallery YAML Schema
-
-LocalAI provides a JSON Schema for gallery model YAML files at:
-
-`core/schema/gallery-model.schema.json`
-
-This schema mirrors the internal gallery model configuration and can be used by editors (such as VS Code) to enable autocomplete, validation, and inline documentation when creating or modifying gallery files.
-
-To use it with the YAML language server, add the following comment at the top of a gallery YAML file:
-
-```yaml
-# yaml-language-server: $schema=../core/schema/gallery-model.schema.json
-```
-
 ## Community and Communication
 
 - You can reach out via the Github issue tracker.

Dockerfile

@@ -1,7 +1,6 @@
-ARG BASE_IMAGE=ubuntu:24.04
+ARG BASE_IMAGE=ubuntu:22.04
 ARG GRPC_BASE_IMAGE=${BASE_IMAGE}
 ARG INTEL_BASE_IMAGE=${BASE_IMAGE}
-ARG UBUNTU_CODENAME=noble
 
 FROM ${BASE_IMAGE} AS requirements
 
@@ -10,7 +9,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
         ca-certificates curl wget espeak-ng libgomp1 \
-        ffmpeg libopenblas0 libopenblas-dev && \
+        ffmpeg && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
@@ -24,7 +23,7 @@ ARG SKIP_DRIVERS=false
 ARG TARGETARCH
 ARG TARGETVARIANT
 ENV BUILD_TYPE=${BUILD_TYPE}
-ARG UBUNTU_VERSION=2404
+ARG UBUNTU_VERSION=2204
 
 RUN mkdir -p /run/localai
 RUN echo "default" > /run/localai/capability
@@ -35,45 +34,11 @@ RUN <<EOT bash
         apt-get update && \
         apt-get install -y  --no-install-recommends \
             software-properties-common pciutils wget gpg-agent && \
-        apt-get install -y libglm-dev cmake libxcb-dri3-0 libxcb-present0 libpciaccess0 \
-            libpng-dev libxcb-keysyms1-dev libxcb-dri3-dev libx11-dev g++ gcc \
-            libwayland-dev libxrandr-dev libxcb-randr0-dev libxcb-ewmh-dev \
-            git python-is-python3 bison libx11-xcb-dev liblz4-dev libzstd-dev \
-            ocaml-core ninja-build pkg-config libxml2-dev wayland-protocols python3-jsonschema \
-            clang-format qtbase5-dev qt6-base-dev libxcb-glx0-dev sudo xz-utils mesa-vulkan-drivers
-        if [ "amd64" = "$TARGETARCH" ]; then
-            wget "https://sdk.lunarg.com/sdk/download/1.4.328.1/linux/vulkansdk-linux-x86_64-1.4.328.1.tar.xz" && \
-            tar -xf vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            rm vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            mkdir -p /opt/vulkan-sdk && \
-            mv 1.4.328.1 /opt/vulkan-sdk/ && \
-            cd /opt/vulkan-sdk/1.4.328.1 && \
-            ./vulkansdk --no-deps --maxjobs \
-                vulkan-loader \
-                vulkan-validationlayers \
-                vulkan-extensionlayer \
-                vulkan-tools \
-                shaderc && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/bin/* /usr/bin/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/lib/* /usr/lib/x86_64-linux-gnu/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/include/* /usr/include/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/share/* /usr/share/ && \
-            rm -rf /opt/vulkan-sdk
-        fi
-        if [ "arm64" = "$TARGETARCH" ]; then
-            mkdir vulkan && cd vulkan && \
-            curl -L -o vulkan-sdk.tar.xz https://github.com/mudler/vulkan-sdk-arm/releases/download/1.4.335.0/vulkansdk-ubuntu-24.04-arm-1.4.335.0.tar.xz && \
-            tar -xvf vulkan-sdk.tar.xz && \
-            rm vulkan-sdk.tar.xz && \
-            cd 1.4.335.0 && \
-            cp -rfv aarch64/bin/* /usr/bin/ && \
-            cp -rfv aarch64/lib/* /usr/lib/aarch64-linux-gnu/ && \
-            cp -rfv aarch64/include/* /usr/include/ && \
-            cp -rfv aarch64/share/* /usr/share/ && \
-            cd ../.. && \
-            rm -rf vulkan
-        fi
-        ldconfig && \
+        wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | apt-key add - && \
+        wget -qO /etc/apt/sources.list.d/lunarg-vulkan-jammy.list https://packages.lunarg.com/vulkan/lunarg-vulkan-jammy.list && \
+        apt-get update && \
+        apt-get install -y \
+            vulkan-sdk && \
         apt-get clean && \
         rm -rf /var/lib/apt/lists/* && \
         echo "vulkan" > /run/localai/capability
@@ -176,12 +141,13 @@ ENV PATH=/opt/rocm/bin:${PATH}
 # The requirements-core target is common to all images.  It should not be placed in requirements-core unless every single build will use it.
 FROM requirements-drivers AS build-requirements
 
-ARG GO_VERSION=1.25.4
-ARG CMAKE_VERSION=3.31.10
+ARG GO_VERSION=1.22.6
+ARG CMAKE_VERSION=3.26.4
 ARG CMAKE_FROM_SOURCE=false
 ARG TARGETARCH
 ARG TARGETVARIANT
 
+
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
         build-essential \
@@ -238,10 +204,9 @@ WORKDIR /build
 # https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/APT-Repository-not-working-signatures-invalid/m-p/1599436/highlight/true#M36143
 # This is a temporary workaround until Intel fixes their repository
 FROM ${INTEL_BASE_IMAGE} AS intel
-ARG UBUNTU_CODENAME=noble
 RUN wget -qO - https://repositories.intel.com/gpu/intel-graphics.key | \
 gpg --yes --dearmor --output /usr/share/keyrings/intel-graphics.gpg
-RUN echo "deb [arch=amd64 signed-by=/usr/share/keyrings/intel-graphics.gpg] https://repositories.intel.com/gpu/ubuntu ${UBUNTU_CODENAME}/lts/2350 unified" > /etc/apt/sources.list.d/intel-graphics.list
+RUN echo "deb [arch=amd64 signed-by=/usr/share/keyrings/intel-graphics.gpg] https://repositories.intel.com/gpu/ubuntu jammy/lts/2350 unified" > /etc/apt/sources.list.d/intel-graphics.list
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
         intel-oneapi-runtime-libs && \

Dockerfile.aio

@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=ubuntu:24.04
+ARG BASE_IMAGE=ubuntu:22.04
 
 FROM ${BASE_IMAGE} 
 

Makefile

@@ -1,6 +1,3 @@
-# Disable parallel execution for backend builds
-.NOTPARALLEL: backends/diffusers backends/llama-cpp backends/piper backends/stablediffusion-ggml backends/whisper backends/faster-whisper backends/silero-vad backends/local-store backends/huggingface backends/rfdetr backends/kitten-tts backends/kokoro backends/chatterbox backends/llama-cpp-darwin backends/neutts build-darwin-python-backend build-darwin-go-backend backends/mlx backends/diffuser-darwin backends/mlx-vlm backends/mlx-audio backends/stablediffusion-ggml-darwin backends/vllm backends/moonshine
-
 GOCMD=go
 GOTEST=$(GOCMD) test
 GOVET=$(GOCMD) vet
@@ -10,13 +7,10 @@ LAUNCHER_BINARY_NAME=local-ai-launcher
 CUDA_MAJOR_VERSION?=13
 CUDA_MINOR_VERSION?=0
 UBUNTU_VERSION?=2204
-UBUNTU_CODENAME?=noble
 
 GORELEASER?=
 
 export BUILD_TYPE?=
-export CUDA_MAJOR_VERSION?=12
-export CUDA_MINOR_VERSION?=9
 
 GO_TAGS?=
 BUILD_ID?=
@@ -170,7 +164,6 @@ docker-build-aio:
 		--build-arg CUDA_MAJOR_VERSION=$(CUDA_MAJOR_VERSION) \
 		--build-arg CUDA_MINOR_VERSION=$(CUDA_MINOR_VERSION) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
 		--build-arg GO_TAGS="$(GO_TAGS)" \
 		-t local-ai:tests -f Dockerfile .
 	BASE_IMAGE=local-ai:tests DOCKER_AIO_IMAGE=local-ai-aio:test $(MAKE) docker-aio
@@ -201,7 +194,6 @@ prepare-e2e:
 		--build-arg CUDA_MAJOR_VERSION=$(CUDA_MAJOR_VERSION) \
 		--build-arg CUDA_MINOR_VERSION=$(CUDA_MINOR_VERSION) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
 		--build-arg GO_TAGS="$(GO_TAGS)" \
 		--build-arg MAKEFLAGS="$(DOCKER_MAKEFLAGS)" \
 		-t localai-tests .
@@ -315,7 +307,6 @@ prepare-test-extra: protogen-python
 	$(MAKE) -C backend/python/chatterbox
 	$(MAKE) -C backend/python/vllm
 	$(MAKE) -C backend/python/vibevoice
-	$(MAKE) -C backend/python/moonshine
 
 test-extra: prepare-test-extra
 	$(MAKE) -C backend/python/transformers test
@@ -323,12 +314,11 @@ test-extra: prepare-test-extra
 	$(MAKE) -C backend/python/chatterbox test
 	$(MAKE) -C backend/python/vllm test
 	$(MAKE) -C backend/python/vibevoice test
-	$(MAKE) -C backend/python/moonshine test
 
 DOCKER_IMAGE?=local-ai
 DOCKER_AIO_IMAGE?=local-ai-aio
 IMAGE_TYPE?=core
-BASE_IMAGE?=ubuntu:24.04
+BASE_IMAGE?=ubuntu:22.04
 
 docker:
 	docker build \
@@ -340,21 +330,19 @@ docker:
 		--build-arg CUDA_MAJOR_VERSION=$(CUDA_MAJOR_VERSION) \
 		--build-arg CUDA_MINOR_VERSION=$(CUDA_MINOR_VERSION) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
 		-t $(DOCKER_IMAGE) .
 
-docker-cuda12:
+docker-cuda11:
 	docker build \
-		--build-arg CUDA_MAJOR_VERSION=${CUDA_MAJOR_VERSION} \
-		--build-arg CUDA_MINOR_VERSION=${CUDA_MINOR_VERSION} \
+		--build-arg CUDA_MAJOR_VERSION=11 \
+		--build-arg CUDA_MINOR_VERSION=8 \
 		--build-arg BASE_IMAGE=$(BASE_IMAGE) \
 		--build-arg IMAGE_TYPE=$(IMAGE_TYPE) \
 		--build-arg GO_TAGS="$(GO_TAGS)" \
 		--build-arg MAKEFLAGS="$(DOCKER_MAKEFLAGS)" \
 		--build-arg BUILD_TYPE=$(BUILD_TYPE) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
-		-t $(DOCKER_IMAGE)-cuda-12 .
+		-t $(DOCKER_IMAGE)-cuda-11 .
 
 docker-aio:
 	@echo "Building AIO image with base $(BASE_IMAGE) as $(DOCKER_AIO_IMAGE)"
@@ -364,7 +352,6 @@ docker-aio:
 		--build-arg CUDA_MAJOR_VERSION=$(CUDA_MAJOR_VERSION) \
 		--build-arg CUDA_MINOR_VERSION=$(CUDA_MINOR_VERSION) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
 		-t $(DOCKER_AIO_IMAGE) -f Dockerfile.aio .
 
 docker-aio-all:
@@ -373,7 +360,7 @@ docker-aio-all:
 
 docker-image-intel:
 	docker build \
-		--build-arg BASE_IMAGE=intel/oneapi-basekit:2025.3.0-0-devel-ubuntu24.04 \
+		--build-arg BASE_IMAGE=quay.io/go-skynet/intel-oneapi-base:latest \
 		--build-arg IMAGE_TYPE=$(IMAGE_TYPE) \
 		--build-arg GO_TAGS="$(GO_TAGS)" \
 		--build-arg MAKEFLAGS="$(DOCKER_MAKEFLAGS)" \
@@ -381,7 +368,6 @@ docker-image-intel:
 		--build-arg CUDA_MAJOR_VERSION=$(CUDA_MAJOR_VERSION) \
 		--build-arg CUDA_MINOR_VERSION=$(CUDA_MINOR_VERSION) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
 		-t $(DOCKER_IMAGE) .
 
 ########################################################
@@ -457,7 +443,6 @@ BACKEND_VLLM = vllm|python|./backend|false|true
 BACKEND_DIFFUSERS = diffusers|python|./backend|--progress=plain|true
 BACKEND_CHATTERBOX = chatterbox|python|./backend|false|true
 BACKEND_VIBEVOICE = vibevoice|python|./backend|--progress=plain|true
-BACKEND_MOONSHINE = moonshine|python|./backend|false|true
 
 # Helper function to build docker image for a backend
 # Usage: $(call docker-build-backend,BACKEND_NAME,DOCKERFILE_TYPE,BUILD_CONTEXT,PROGRESS_FLAG,NEEDS_BACKEND_ARG)
@@ -468,7 +453,6 @@ define docker-build-backend
 		--build-arg CUDA_MAJOR_VERSION=$(CUDA_MAJOR_VERSION) \
 		--build-arg CUDA_MINOR_VERSION=$(CUDA_MINOR_VERSION) \
 		--build-arg UBUNTU_VERSION=$(UBUNTU_VERSION) \
-		--build-arg UBUNTU_CODENAME=$(UBUNTU_CODENAME) \
 		$(if $(filter true,$(5)),--build-arg BACKEND=$(1)) \
 		-t local-ai-backend:$(1) -f backend/Dockerfile.$(2) $(3)
 endef
@@ -502,13 +486,12 @@ $(eval $(call generate-docker-build-target,$(BACKEND_VLLM)))
 $(eval $(call generate-docker-build-target,$(BACKEND_DIFFUSERS)))
 $(eval $(call generate-docker-build-target,$(BACKEND_CHATTERBOX)))
 $(eval $(call generate-docker-build-target,$(BACKEND_VIBEVOICE)))
-$(eval $(call generate-docker-build-target,$(BACKEND_MOONSHINE)))
 
 # Pattern rule for docker-save targets
 docker-save-%: backend-images
 	docker save local-ai-backend:$* -o backend-images/$*.tar
 
-docker-build-backends: docker-build-llama-cpp docker-build-rerankers docker-build-vllm docker-build-transformers docker-build-diffusers docker-build-kokoro docker-build-faster-whisper docker-build-coqui docker-build-bark docker-build-chatterbox docker-build-vibevoice docker-build-exllama2 docker-build-moonshine
+docker-build-backends: docker-build-llama-cpp docker-build-rerankers docker-build-vllm docker-build-transformers docker-build-diffusers docker-build-kokoro docker-build-faster-whisper docker-build-coqui docker-build-bark docker-build-chatterbox docker-build-vibevoice docker-build-exllama2
 
 ########################################################
 ### END Backends

README.md

@@ -152,6 +152,9 @@ docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gp
 # CUDA 12.0
 docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gpu-nvidia-cuda-12
 
+# CUDA 11.7
+docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gpu-nvidia-cuda-11
+
 # NVIDIA Jetson (L4T) ARM64
 # CUDA 12 (for Nvidia AGX Orin and similar platforms)
 docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-nvidia-l4t-arm64
@@ -190,6 +193,9 @@ docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-ai
 # NVIDIA CUDA 12 version
 docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-aio-gpu-nvidia-cuda-12
 
+# NVIDIA CUDA 11 version
+docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-aio-gpu-nvidia-cuda-11
+
 # Intel GPU version
 docker run -ti --name local-ai -p 8080:8080 localai/localai:latest-aio-gpu-intel
 
@@ -273,9 +279,9 @@ LocalAI supports a comprehensive range of AI backends with multiple acceleration
 ### Text Generation & Language Models
 | Backend | Description | Acceleration Support |
 |---------|-------------|---------------------|
-| **llama.cpp** | LLM inference in C/C++ | CUDA 12/13, ROCm, Intel SYCL, Vulkan, Metal, CPU |
+| **llama.cpp** | LLM inference in C/C++ | CUDA 11/12/13, ROCm, Intel SYCL, Vulkan, Metal, CPU |
 | **vLLM** | Fast LLM inference with PagedAttention | CUDA 12/13, ROCm, Intel |
-| **transformers** | HuggingFace transformers framework | CUDA 12/13, ROCm, Intel, CPU |
+| **transformers** | HuggingFace transformers framework | CUDA 11/12/13, ROCm, Intel, CPU |
 | **exllama2** | GPTQ inference library | CUDA 12/13 |
 | **MLX** | Apple Silicon LLM inference | Metal (M1/M2/M3+) |
 | **MLX-VLM** | Apple Silicon Vision-Language Models | Metal (M1/M2/M3+) |
@@ -289,7 +295,7 @@ LocalAI supports a comprehensive range of AI backends with multiple acceleration
 | **bark-cpp** | C++ implementation of Bark | CUDA, Metal, CPU |
 | **coqui** | Advanced TTS with 1100+ languages | CUDA 12/13, ROCm, Intel, CPU |
 | **kokoro** | Lightweight TTS model | CUDA 12/13, ROCm, Intel, CPU |
-| **chatterbox** | Production-grade TTS | CUDA 12/13, CPU |
+| **chatterbox** | Production-grade TTS | CUDA 11/12/13, CPU |
 | **piper** | Fast neural TTS system | CPU |
 | **kitten-tts** | Kitten TTS models | CPU |
 | **silero-vad** | Voice Activity Detection | CPU |
@@ -300,13 +306,13 @@ LocalAI supports a comprehensive range of AI backends with multiple acceleration
 | Backend | Description | Acceleration Support |
 |---------|-------------|---------------------|
 | **stablediffusion.cpp** | Stable Diffusion in C/C++ | CUDA 12/13, Intel SYCL, Vulkan, CPU |
-| **diffusers** | HuggingFace diffusion models | CUDA 12/13, ROCm, Intel, Metal, CPU |
+| **diffusers** | HuggingFace diffusion models | CUDA 11/12/13, ROCm, Intel, Metal, CPU |
 
 ### Specialized AI Tasks
 | Backend | Description | Acceleration Support |
 |---------|-------------|---------------------|
 | **rfdetr** | Real-time object detection | CUDA 12/13, Intel, CPU |
-| **rerankers** | Document reranking API | CUDA 12/13, ROCm, Intel, CPU |
+| **rerankers** | Document reranking API | CUDA 11/12/13, ROCm, Intel, CPU |
 | **local-store** | Vector database | CPU |
 | **huggingface** | HuggingFace API integration | API-based |
 
@@ -314,6 +320,7 @@ LocalAI supports a comprehensive range of AI backends with multiple acceleration
 
 | Acceleration Type | Supported Backends | Hardware Support |
 |-------------------|-------------------|------------------|
+| **NVIDIA CUDA 11** | llama.cpp, whisper, stablediffusion, diffusers, rerankers, bark, chatterbox | Nvidia hardware |
 | **NVIDIA CUDA 12** | All CUDA-compatible backends | Nvidia hardware |
 | **NVIDIA CUDA 13** | All CUDA-compatible backends | Nvidia hardware |
 | **AMD ROCm** | llama.cpp, whisper, vllm, transformers, diffusers, rerankers, coqui, kokoro, bark, neutts, vibevoice | AMD Graphics |

backend/Dockerfile.golang

@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=ubuntu:24.04
+ARG BASE_IMAGE=ubuntu:22.04
 
 FROM ${BASE_IMAGE} AS builder
 ARG BACKEND=rerankers
@@ -12,8 +12,8 @@ ENV CUDA_MINOR_VERSION=${CUDA_MINOR_VERSION}
 ENV DEBIAN_FRONTEND=noninteractive
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG GO_VERSION=1.25.4
-ARG UBUNTU_VERSION=2404
+ARG GO_VERSION=1.22.6
+ARG UBUNTU_VERSION=2204
 
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
@@ -40,45 +40,11 @@ RUN <<EOT bash
         apt-get update && \
         apt-get install -y  --no-install-recommends \
             software-properties-common pciutils wget gpg-agent && \
-        apt-get install -y libglm-dev cmake libxcb-dri3-0 libxcb-present0 libpciaccess0 \
-            libpng-dev libxcb-keysyms1-dev libxcb-dri3-dev libx11-dev g++ gcc \
-            libwayland-dev libxrandr-dev libxcb-randr0-dev libxcb-ewmh-dev \
-            git python-is-python3 bison libx11-xcb-dev liblz4-dev libzstd-dev \
-            ocaml-core ninja-build pkg-config libxml2-dev wayland-protocols python3-jsonschema \
-            clang-format qtbase5-dev qt6-base-dev libxcb-glx0-dev sudo xz-utils
-        if [ "amd64" = "$TARGETARCH" ]; then
-            wget "https://sdk.lunarg.com/sdk/download/1.4.328.1/linux/vulkansdk-linux-x86_64-1.4.328.1.tar.xz" && \
-            tar -xf vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            rm vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            mkdir -p /opt/vulkan-sdk && \
-            mv 1.4.328.1 /opt/vulkan-sdk/ && \
-            cd /opt/vulkan-sdk/1.4.328.1 && \
-            ./vulkansdk --no-deps --maxjobs \
-                vulkan-loader \
-                vulkan-validationlayers \
-                vulkan-extensionlayer \
-                vulkan-tools \
-                shaderc && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/bin/* /usr/bin/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/lib/* /usr/lib/x86_64-linux-gnu/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/include/* /usr/include/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/share/* /usr/share/ && \
-            rm -rf /opt/vulkan-sdk
-        fi
-        if [ "arm64" = "$TARGETARCH" ]; then
-            mkdir vulkan && cd vulkan && \
-            curl -L -o vulkan-sdk.tar.xz https://github.com/mudler/vulkan-sdk-arm/releases/download/1.4.335.0/vulkansdk-ubuntu-24.04-arm-1.4.335.0.tar.xz && \
-            tar -xvf vulkan-sdk.tar.xz && \
-            rm vulkan-sdk.tar.xz && \
-            cd 1.4.335.0 && \
-            cp -rfv aarch64/bin/* /usr/bin/ && \
-            cp -rfv aarch64/lib/* /usr/lib/aarch64-linux-gnu/ && \
-            cp -rfv aarch64/include/* /usr/include/ && \
-            cp -rfv aarch64/share/* /usr/share/ && \
-            cd ../.. && \
-            rm -rf vulkan
-        fi
-        ldconfig && \
+        wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | apt-key add - && \
+        wget -qO /etc/apt/sources.list.d/lunarg-vulkan-jammy.list https://packages.lunarg.com/vulkan/lunarg-vulkan-jammy.list && \
+        apt-get update && \
+        apt-get install -y \
+            vulkan-sdk && \
         apt-get clean && \
         rm -rf /var/lib/apt/lists/*
     fi
@@ -182,8 +148,6 @@ EOT
 
 COPY . /LocalAI
 
-RUN git config --global --add safe.directory /LocalAI
-
 RUN cd /LocalAI && make protogen-go && make -C /LocalAI/backend/go/${BACKEND} build
 
 FROM scratch

backend/Dockerfile.llama-cpp

@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=ubuntu:24.04
+ARG BASE_IMAGE=ubuntu:22.04
 ARG GRPC_BASE_IMAGE=${BASE_IMAGE}
 
 
@@ -10,8 +10,7 @@ FROM ${GRPC_BASE_IMAGE} AS grpc
 ARG GRPC_MAKEFLAGS="-j4 -Otarget"
 ARG GRPC_VERSION=v1.65.0
 ARG CMAKE_FROM_SOURCE=false
-# CUDA Toolkit 13.x compatibility: CMake 3.31.9+ fixes toolchain detection/arch table issues
-ARG CMAKE_VERSION=3.31.10
+ARG CMAKE_VERSION=3.26.4
 
 ENV MAKEFLAGS=${GRPC_MAKEFLAGS}
 
@@ -27,7 +26,7 @@ RUN apt-get update && \
 
 # Install CMake (the version in 22.04 is too old)
 RUN <<EOT bash
-    if [ "${CMAKE_FROM_SOURCE}" = "true" ]; then
+    if [ "${CMAKE_FROM_SOURCE}}" = "true" ]; then
         curl -L -s https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}.tar.gz -o cmake.tar.gz && tar xvf cmake.tar.gz && cd cmake-${CMAKE_VERSION} && ./configure && make && make install
     else
         apt-get update && \
@@ -51,13 +50,6 @@ RUN git clone --recurse-submodules --jobs 4 -b ${GRPC_VERSION} --depth 1 --shall
     rm -rf /build
 
 FROM ${BASE_IMAGE} AS builder
-ARG CMAKE_FROM_SOURCE=false
-ARG CMAKE_VERSION=3.31.10
-# We can target specific CUDA ARCHITECTURES like --build-arg CUDA_DOCKER_ARCH='75;86;89;120'
-ARG CUDA_DOCKER_ARCH
-ENV CUDA_DOCKER_ARCH=${CUDA_DOCKER_ARCH}
-ARG CMAKE_ARGS
-ENV CMAKE_ARGS=${CMAKE_ARGS}
 ARG BACKEND=rerankers
 ARG BUILD_TYPE
 ENV BUILD_TYPE=${BUILD_TYPE}
@@ -69,8 +61,8 @@ ENV CUDA_MINOR_VERSION=${CUDA_MINOR_VERSION}
 ENV DEBIAN_FRONTEND=noninteractive
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG GO_VERSION=1.25.4
-ARG UBUNTU_VERSION=2404
+ARG GO_VERSION=1.22.6
+ARG UBUNTU_VERSION=2204
 
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
@@ -78,7 +70,6 @@ RUN apt-get update && \
         ccache git \
         ca-certificates \
         make \
-        pkg-config libcurl4-openssl-dev \
         curl unzip \
         libssl-dev wget && \
     apt-get clean && \
@@ -97,45 +88,11 @@ RUN <<EOT bash
         apt-get update && \
         apt-get install -y  --no-install-recommends \
             software-properties-common pciutils wget gpg-agent && \
-        apt-get install -y libglm-dev cmake libxcb-dri3-0 libxcb-present0 libpciaccess0 \
-            libpng-dev libxcb-keysyms1-dev libxcb-dri3-dev libx11-dev g++ gcc \
-            libwayland-dev libxrandr-dev libxcb-randr0-dev libxcb-ewmh-dev \
-            git python-is-python3 bison libx11-xcb-dev liblz4-dev libzstd-dev \
-            ocaml-core ninja-build pkg-config libxml2-dev wayland-protocols python3-jsonschema \
-            clang-format qtbase5-dev qt6-base-dev libxcb-glx0-dev sudo xz-utils
-        if [ "amd64" = "$TARGETARCH" ]; then
-            wget "https://sdk.lunarg.com/sdk/download/1.4.328.1/linux/vulkansdk-linux-x86_64-1.4.328.1.tar.xz" && \
-            tar -xf vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            rm vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            mkdir -p /opt/vulkan-sdk && \
-            mv 1.4.328.1 /opt/vulkan-sdk/ && \
-            cd /opt/vulkan-sdk/1.4.328.1 && \
-            ./vulkansdk --no-deps --maxjobs \
-                vulkan-loader \
-                vulkan-validationlayers \
-                vulkan-extensionlayer \
-                vulkan-tools \
-                shaderc && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/bin/* /usr/bin/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/lib/* /usr/lib/x86_64-linux-gnu/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/include/* /usr/include/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/share/* /usr/share/ && \
-            rm -rf /opt/vulkan-sdk
-        fi
-        if [ "arm64" = "$TARGETARCH" ]; then
-            mkdir vulkan && cd vulkan && \
-            curl -L -o vulkan-sdk.tar.xz https://github.com/mudler/vulkan-sdk-arm/releases/download/1.4.335.0/vulkansdk-ubuntu-24.04-arm-1.4.335.0.tar.xz && \
-            tar -xvf vulkan-sdk.tar.xz && \
-            rm vulkan-sdk.tar.xz && \
-            cd 1.4.335.0 && \
-            cp -rfv aarch64/bin/* /usr/bin/ && \
-            cp -rfv aarch64/lib/* /usr/lib/aarch64-linux-gnu/ && \
-            cp -rfv aarch64/include/* /usr/include/ && \
-            cp -rfv aarch64/share/* /usr/share/ && \
-            cd ../.. && \
-            rm -rf vulkan
-        fi
-        ldconfig && \
+        wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | apt-key add - && \
+        wget -qO /etc/apt/sources.list.d/lunarg-vulkan-jammy.list https://packages.lunarg.com/vulkan/lunarg-vulkan-jammy.list && \
+        apt-get update && \
+        apt-get install -y \
+            vulkan-sdk && \
         apt-get clean && \
         rm -rf /var/lib/apt/lists/*
     fi
@@ -232,7 +189,7 @@ EOT
 
 # Install CMake (the version in 22.04 is too old)
 RUN <<EOT bash
-    if [ "${CMAKE_FROM_SOURCE}" = "true" ]; then
+    if [ "${CMAKE_FROM_SOURCE}}" = "true" ]; then
         curl -L -s https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}.tar.gz -o cmake.tar.gz && tar xvf cmake.tar.gz && cd cmake-${CMAKE_VERSION} && ./configure && make && make install
     else
         apt-get update && \
@@ -248,30 +205,19 @@ COPY --from=grpc /opt/grpc /usr/local
 
 COPY . /LocalAI
 
-RUN <<'EOT' bash
-set -euxo pipefail
-
-if [[ -n "${CUDA_DOCKER_ARCH:-}" ]]; then
-  CUDA_ARCH_ESC="${CUDA_DOCKER_ARCH//;/\\;}"
-  export CMAKE_ARGS="${CMAKE_ARGS:-} -DCMAKE_CUDA_ARCHITECTURES=${CUDA_ARCH_ESC}"
-  echo "CMAKE_ARGS(env) = ${CMAKE_ARGS}"
-  rm -rf /LocalAI/backend/cpp/llama-cpp-*-build
-fi
-
-if [ "${TARGETARCH}" = "arm64" ] || [ "${BUILD_TYPE}" = "hipblas" ]; then
-  cd /LocalAI/backend/cpp/llama-cpp
-  make llama-cpp-fallback
-  make llama-cpp-grpc
-  make llama-cpp-rpc-server
-else
-  cd /LocalAI/backend/cpp/llama-cpp
-  make llama-cpp-avx
-  make llama-cpp-avx2
-  make llama-cpp-avx512
-  make llama-cpp-fallback
-  make llama-cpp-grpc
-  make llama-cpp-rpc-server
-fi
+## Otherwise just run the normal build
+RUN <<EOT bash
+if [ "${TARGETARCH}" = "arm64" ] || [ "${BUILD_TYPE}" = "hipblas" ]; then \
+        cd /LocalAI/backend/cpp/llama-cpp && make llama-cpp-fallback && \
+        make llama-cpp-grpc && make llama-cpp-rpc-server; \
+    else \
+        cd /LocalAI/backend/cpp/llama-cpp && make llama-cpp-avx && \
+        make llama-cpp-avx2 && \
+        make llama-cpp-avx512 && \
+        make llama-cpp-fallback && \
+        make llama-cpp-grpc && \
+        make llama-cpp-rpc-server; \
+    fi  
 EOT
 
 

backend/Dockerfile.python

@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=ubuntu:24.04
+ARG BASE_IMAGE=ubuntu:22.04
 
 FROM ${BASE_IMAGE} AS builder
 ARG BACKEND=rerankers
@@ -12,7 +12,7 @@ ENV CUDA_MINOR_VERSION=${CUDA_MINOR_VERSION}
 ENV DEBIAN_FRONTEND=noninteractive
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG UBUNTU_VERSION=2404
+ARG UBUNTU_VERSION=2204
 
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
@@ -54,45 +54,11 @@ RUN <<EOT bash
         apt-get update && \
         apt-get install -y  --no-install-recommends \
             software-properties-common pciutils wget gpg-agent && \
-        apt-get install -y libglm-dev cmake libxcb-dri3-0 libxcb-present0 libpciaccess0 \
-            libpng-dev libxcb-keysyms1-dev libxcb-dri3-dev libx11-dev g++ gcc \
-            libwayland-dev libxrandr-dev libxcb-randr0-dev libxcb-ewmh-dev \
-            git python-is-python3 bison libx11-xcb-dev liblz4-dev libzstd-dev \
-            ocaml-core ninja-build pkg-config libxml2-dev wayland-protocols python3-jsonschema \
-            clang-format qtbase5-dev qt6-base-dev libxcb-glx0-dev sudo xz-utils
-        if [ "amd64" = "$TARGETARCH" ]; then
-            wget "https://sdk.lunarg.com/sdk/download/1.4.328.1/linux/vulkansdk-linux-x86_64-1.4.328.1.tar.xz" && \
-            tar -xf vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            rm vulkansdk-linux-x86_64-1.4.328.1.tar.xz && \
-            mkdir -p /opt/vulkan-sdk && \
-            mv 1.4.328.1 /opt/vulkan-sdk/ && \
-            cd /opt/vulkan-sdk/1.4.328.1 && \
-            ./vulkansdk --no-deps --maxjobs \
-                vulkan-loader \
-                vulkan-validationlayers \
-                vulkan-extensionlayer \
-                vulkan-tools \
-                shaderc && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/bin/* /usr/bin/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/lib/* /usr/lib/x86_64-linux-gnu/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/include/* /usr/include/ && \
-            cp -rfv /opt/vulkan-sdk/1.4.328.1/x86_64/share/* /usr/share/ && \
-            rm -rf /opt/vulkan-sdk
-        fi
-        if [ "arm64" = "$TARGETARCH" ]; then
-            mkdir vulkan && cd vulkan && \
-            curl -L -o vulkan-sdk.tar.xz https://github.com/mudler/vulkan-sdk-arm/releases/download/1.4.335.0/vulkansdk-ubuntu-24.04-arm-1.4.335.0.tar.xz && \
-            tar -xvf vulkan-sdk.tar.xz && \
-            rm vulkan-sdk.tar.xz && \
-            cd 1.4.335.0 && \
-            cp -rfv aarch64/bin/* /usr/bin/ && \
-            cp -rfv aarch64/lib/* /usr/lib/aarch64-linux-gnu/ && \
-            cp -rfv aarch64/include/* /usr/include/ && \
-            cp -rfv aarch64/share/* /usr/share/ && \
-            cd ../.. && \
-            rm -rf vulkan
-        fi
-        ldconfig && \
+        wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | apt-key add - && \
+        wget -qO /etc/apt/sources.list.d/lunarg-vulkan-jammy.list https://packages.lunarg.com/vulkan/lunarg-vulkan-jammy.list && \
+        apt-get update && \
+        apt-get install -y \
+            vulkan-sdk && \
         apt-get clean && \
         rm -rf /var/lib/apt/lists/*
     fi
@@ -176,8 +142,7 @@ RUN if [ "${BUILD_TYPE}" = "hipblas" ]; then \
 # Install uv as a system package
 RUN curl -LsSf https://astral.sh/uv/install.sh | UV_INSTALL_DIR=/usr/bin sh
 ENV PATH="/root/.cargo/bin:${PATH}"
-# Increase timeout for uv installs behind slow networks
-ENV UV_HTTP_TIMEOUT=180
+
 RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 
 # Install grpcio-tools (the version in 22.04 is too old)
@@ -190,18 +155,12 @@ RUN <<EOT bash
 EOT
 
 
-COPY backend/python/${BACKEND} /${BACKEND}
-COPY backend/backend.proto /${BACKEND}/backend.proto
-COPY backend/python/common/ /${BACKEND}/common
-COPY scripts/build/package-gpu-libs.sh /package-gpu-libs.sh
+COPY python/${BACKEND} /${BACKEND}
+COPY backend.proto /${BACKEND}/backend.proto
+COPY python/common/ /${BACKEND}/common
 
 RUN cd /${BACKEND} && PORTABLE_PYTHON=true make
 
-# Package GPU libraries into the backend's lib directory
-RUN mkdir -p /${BACKEND}/lib && \
-    TARGET_LIB_DIR="/${BACKEND}/lib" BUILD_TYPE="${BUILD_TYPE}" CUDA_MAJOR_VERSION="${CUDA_MAJOR_VERSION}" \
-    bash /package-gpu-libs.sh "/${BACKEND}/lib"
-
 FROM scratch
 ARG BACKEND=rerankers
 COPY --from=builder /${BACKEND}/ /

backend/README.md

@@ -65,7 +65,7 @@ The backend system provides language-specific Dockerfiles that handle the build
 ## Hardware Acceleration Support
 
 ### CUDA (NVIDIA)
-- **Versions**: CUDA 12.x, 13.x
+- **Versions**: CUDA 11.x, 12.x
 - **Features**: cuBLAS, cuDNN, TensorRT optimization
 - **Targets**: x86_64, ARM64 (Jetson)
 
@@ -132,7 +132,8 @@ For ARM64/Mac builds, docker can't be used, and the makefile in the respective b
 ### Build Types
 
 - **`cpu`**: CPU-only optimization
-- **`cublas12`**, **`cublas13`**: CUDA 12.x, 13.x with cuBLAS
+- **`cublas11`**: CUDA 11.x with cuBLAS
+- **`cublas12`**: CUDA 12.x with cuBLAS
 - **`hipblas`**: ROCm with rocBLAS
 - **`intel`**: Intel oneAPI optimization
 - **`vulkan`**: Vulkan-based acceleration
@@ -209,4 +210,4 @@ When contributing to the backend system:
 2. **Add Tests**: Include comprehensive test coverage
 3. **Document**: Provide clear usage examples
 4. **Optimize**: Consider performance and resource usage
-5. **Validate**: Test across different hardware targets
+5. **Validate**: Test across different hardware targets

backend/cpp/llama-cpp/CMakeLists.txt

@@ -70,4 +70,4 @@ target_link_libraries(${TARGET} PRIVATE common llama mtmd ${CMAKE_THREAD_LIBS_IN
 target_compile_features(${TARGET} PRIVATE cxx_std_11)
 if(TARGET BUILD_INFO)
   add_dependencies(${TARGET} BUILD_INFO)
-endif()
+endif()

backend/cpp/llama-cpp/Makefile

@@ -1,5 +1,5 @@
 
-LLAMA_VERSION?=593da7fa49503b68f9f01700be9f508f1e528992
+LLAMA_VERSION?=e57f52334b2e8436a94f7e332462dfc63a08f995
 LLAMA_REPO?=https://github.com/ggerganov/llama.cpp
 
 CMAKE_ARGS?=
@@ -7,7 +7,7 @@ BUILD_TYPE?=
 NATIVE?=false
 ONEAPI_VARS?=/opt/intel/oneapi/setvars.sh
 TARGET?=--target grpc-server
-JOBS?=$(shell nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1)
+JOBS?=$(shell nproc)
 ARCH?=$(shell uname -m)
 
 # Disable Shared libs as we are linking on static gRPC and we can't mix shared and static
@@ -107,21 +107,39 @@ llama-cpp-avx: llama.cpp
 	cp -rf $(CURRENT_MAKEFILE_DIR)/../llama-cpp $(CURRENT_MAKEFILE_DIR)/../llama-cpp-avx-build
 	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../llama-cpp-avx-build purge
 	$(info ${GREEN}I llama-cpp build info:avx${RESET})
-	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=on -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_BMI2=off" $(MAKE) VARIANT="llama-cpp-avx-build" build-llama-cpp-grpc-server
+ifeq ($(OS),Darwin)
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=on -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off" $(MAKE) VARIANT="llama-cpp-avx-build" build-llama-cpp-grpc-server
+else ifeq ($(ARCH),$(filter $(ARCH),aarch64 arm64))
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=on -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off" $(MAKE) VARIANT="llama-cpp-avx-build" build-llama-cpp-grpc-server
+else
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=on -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DCMAKE_C_FLAGS=-mno-bmi2 -DCMAKE_CXX_FLAGS=-mno-bmi2" $(MAKE) VARIANT="llama-cpp-avx-build" build-llama-cpp-grpc-server
+endif
 	cp -rfv $(CURRENT_MAKEFILE_DIR)/../llama-cpp-avx-build/grpc-server llama-cpp-avx
 
 llama-cpp-fallback: llama.cpp
 	cp -rf $(CURRENT_MAKEFILE_DIR)/../llama-cpp $(CURRENT_MAKEFILE_DIR)/../llama-cpp-fallback-build
 	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../llama-cpp-fallback-build purge
 	$(info ${GREEN}I llama-cpp build info:fallback${RESET})
-	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_BMI2=off" $(MAKE) VARIANT="llama-cpp-fallback-build" build-llama-cpp-grpc-server
+ifeq ($(OS),Darwin)
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off" $(MAKE) VARIANT="llama-cpp-fallback-build" build-llama-cpp-grpc-server
+else ifeq ($(ARCH),$(filter $(ARCH),aarch64 arm64))
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off" $(MAKE) VARIANT="llama-cpp-fallback-build" build-llama-cpp-grpc-server
+else
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DCMAKE_C_FLAGS='-mno-bmi -mno-bmi2' -DCMAKE_CXX_FLAGS='-mno-bmi -mno-bmi2'" $(MAKE) VARIANT="llama-cpp-fallback-build" build-llama-cpp-grpc-server
+endif
 	cp -rfv $(CURRENT_MAKEFILE_DIR)/../llama-cpp-fallback-build/grpc-server llama-cpp-fallback
 
 llama-cpp-grpc: llama.cpp
 	cp -rf $(CURRENT_MAKEFILE_DIR)/../llama-cpp $(CURRENT_MAKEFILE_DIR)/../llama-cpp-grpc-build
 	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../llama-cpp-grpc-build purge
 	$(info ${GREEN}I llama-cpp build info:grpc${RESET})
-	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_RPC=ON -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_BMI2=off" TARGET="--target grpc-server --target rpc-server" $(MAKE) VARIANT="llama-cpp-grpc-build" build-llama-cpp-grpc-server
+ifeq ($(OS),Darwin)
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_RPC=ON -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off" TARGET="--target grpc-server --target rpc-server" $(MAKE) VARIANT="llama-cpp-grpc-build" build-llama-cpp-grpc-server
+else ifeq ($(ARCH),$(filter $(ARCH),aarch64 arm64))
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_RPC=ON -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off" TARGET="--target grpc-server --target rpc-server" $(MAKE) VARIANT="llama-cpp-grpc-build" build-llama-cpp-grpc-server
+else
+	CMAKE_ARGS="$(CMAKE_ARGS) -DGGML_RPC=ON -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DCMAKE_C_FLAGS='-mno-bmi -mno-bmi2' -DCMAKE_CXX_FLAGS='-mno-bmi -mno-bmi2'" TARGET="--target grpc-server --target rpc-server" $(MAKE) VARIANT="llama-cpp-grpc-build" build-llama-cpp-grpc-server
+endif
 	cp -rfv $(CURRENT_MAKEFILE_DIR)/../llama-cpp-grpc-build/grpc-server llama-cpp-grpc
 
 llama-cpp-rpc-server: llama-cpp-grpc

backend/cpp/llama-cpp/grpc-server.cpp

@@ -23,7 +23,6 @@
 #include <grpcpp/health_check_service_interface.h>
 #include <regex>
 #include <atomic>
-#include <mutex>
 #include <signal.h>
 #include <thread>
 
@@ -294,6 +293,8 @@ json parse_options(bool streaming, const backend::PredictOptions* predict, const
     return data;
 }
 
+// Sanitize tools JSON to remove null values from tool.parameters.properties
+// This prevents Jinja template errors when processing tools with malformed parameter schemas
 
 const std::vector<ggml_type> kv_cache_types = {
     GGML_TYPE_F32,
@@ -391,9 +392,8 @@ static void params_parse(server_context& /*ctx_server*/, const backend::ModelOpt
     // Initialize fit_params options (can be overridden by options)
     // fit_params: whether to auto-adjust params to fit device memory (default: true as in llama.cpp)
     params.fit_params = true;
-    // fit_params_target: target margin per device in bytes (default: 1GB per device)
-    // Initialize as vector with default value for all devices
-    params.fit_params_target = std::vector<size_t>(llama_max_devices(), 1024 * 1024 * 1024);
+    // fit_params_target: target margin per device in bytes (default: 1GB)
+    params.fit_params_target = 1024 * 1024 * 1024;
     // fit_params_min_ctx: minimum context size for fit (default: 4096)
     params.fit_params_min_ctx = 4096;
 
@@ -470,28 +470,10 @@ static void params_parse(server_context& /*ctx_server*/, const backend::ModelOpt
         } else if (!strcmp(optname, "fit_params_target") || !strcmp(optname, "fit_target")) {
             if (optval != NULL) {
                 try {
-                    // Value is in MiB, can be comma-separated list for multiple devices
-                    // Single value is broadcast across all devices
-                    std::string arg_next = optval_str;
-                    const std::regex regex{ R"([,/]+)" };
-                    std::sregex_token_iterator it{ arg_next.begin(), arg_next.end(), regex, -1 };
-                    std::vector<std::string> split_arg{ it, {} };
-                    if (split_arg.size() >= llama_max_devices()) {
-                        // Too many values provided
-                        continue;
-                    }
-                    if (split_arg.size() == 1) {
-                        // Single value: broadcast to all devices
-                        size_t value_mib = std::stoul(split_arg[0]);
-                        std::fill(params.fit_params_target.begin(), params.fit_params_target.end(), value_mib * 1024 * 1024);
-                    } else {
-                        // Multiple values: set per device
-                        for (size_t i = 0; i < split_arg.size() && i < params.fit_params_target.size(); i++) {
-                            params.fit_params_target[i] = std::stoul(split_arg[i]) * 1024 * 1024;
-                        }
-                    }
+                    // Value is in MiB, convert to bytes
+                    params.fit_params_target = static_cast<size_t>(std::stoi(optval_str)) * 1024 * 1024;
                 } catch (const std::exception& e) {
-                    // If conversion fails, keep default value (1GB per device)
+                    // If conversion fails, keep default value (1GB)
                 }
             }
         } else if (!strcmp(optname, "fit_params_min_ctx") || !strcmp(optname, "fit_ctx")) {
@@ -706,13 +688,13 @@ private:
 public:
     BackendServiceImpl(server_context& ctx) : ctx_server(ctx) {}
 
-    grpc::Status Health(ServerContext* /*context*/, const backend::HealthMessage* /*request*/, backend::Reply* reply) override {
+    grpc::Status Health(ServerContext* /*context*/, const backend::HealthMessage* /*request*/, backend::Reply* reply) {
         // Implement Health RPC
         reply->set_message("OK");
         return Status::OK;
     }
 
-    grpc::Status LoadModel(ServerContext* /*context*/, const backend::ModelOptions* request, backend::Result* result) override {
+    grpc::Status LoadModel(ServerContext* /*context*/, const backend::ModelOptions* request, backend::Result* result) {
         // Implement LoadModel RPC
         common_params params;
         params_parse(ctx_server, request, params);
@@ -729,72 +711,11 @@ public:
         LOG_INF("\n");
         LOG_INF("%s\n", common_params_get_system_info(params).c_str());
         LOG_INF("\n");
-        
-        // Capture error messages during model loading
-        struct error_capture {
-            std::string captured_error;
-            std::mutex error_mutex;
-            ggml_log_callback original_callback;
-            void* original_user_data;
-        } error_capture_data;
-        
-        // Get original log callback
-        llama_log_get(&error_capture_data.original_callback, &error_capture_data.original_user_data);
-        
-        // Set custom callback to capture errors
-        llama_log_set([](ggml_log_level level, const char * text, void * user_data) {
-            auto* capture = static_cast<error_capture*>(user_data);
-            
-            // Capture error messages
-            if (level == GGML_LOG_LEVEL_ERROR) {
-                std::lock_guard<std::mutex> lock(capture->error_mutex);
-                // Append error message, removing trailing newlines
-                std::string msg(text);
-                while (!msg.empty() && (msg.back() == '\n' || msg.back() == '\r')) {
-                    msg.pop_back();
-                }
-                if (!msg.empty()) {
-                    if (!capture->captured_error.empty()) {
-                        capture->captured_error.append("; ");
-                    }
-                    capture->captured_error.append(msg);
-                }
-            }
-            
-            // Also call original callback to preserve logging
-            if (capture->original_callback) {
-                capture->original_callback(level, text, capture->original_user_data);
-            }
-        }, &error_capture_data);
-        
         // load the model
-        bool load_success = ctx_server.load_model(params);
-        
-        // Restore original log callback
-        llama_log_set(error_capture_data.original_callback, error_capture_data.original_user_data);
-        
-        if (!load_success) {
-            std::string error_msg = "Failed to load model: " + params.model.path;
-            if (!params.mmproj.path.empty()) {
-                error_msg += " (with mmproj: " + params.mmproj.path + ")";
-            }
-            if (params.has_speculative() && !params.speculative.model.path.empty()) {
-                error_msg += " (with draft model: " + params.speculative.model.path + ")";
-            }
-            
-            // Add captured error details if available
-            {
-                std::lock_guard<std::mutex> lock(error_capture_data.error_mutex);
-                if (!error_capture_data.captured_error.empty()) {
-                    error_msg += ". Error: " + error_capture_data.captured_error;
-                } else {
-                    error_msg += ". Model file may not exist or be invalid.";
-                }
-            }
-            
-            result->set_message(error_msg);
+        if (!ctx_server.load_model(params)) {
+            result->set_message("Failed loading model");
             result->set_success(false);
-            return grpc::Status(grpc::StatusCode::INTERNAL, error_msg);
+            return Status::CANCELLED;
         }
 
         // Process grammar triggers now that vocab is available
@@ -1573,7 +1494,7 @@ public:
         return grpc::Status::OK;
     }
 
-    grpc::Status Predict(ServerContext* context, const backend::PredictOptions* request, backend::Reply* reply) override {
+    grpc::Status Predict(ServerContext* context, const backend::PredictOptions* request, backend::Reply* reply) {
          if (params_base.model.path.empty()) {
              return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "Model not loaded");
          }
@@ -2244,7 +2165,7 @@ public:
         return grpc::Status::OK;
     }
 
-    grpc::Status Embedding(ServerContext* context, const backend::PredictOptions* request, backend::EmbeddingResult* embeddingResult) override {
+    grpc::Status Embedding(ServerContext* context, const backend::PredictOptions* request, backend::EmbeddingResult* embeddingResult) {
         if (params_base.model.path.empty()) {
             return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "Model not loaded");
         }
@@ -2339,7 +2260,7 @@ public:
         return grpc::Status::OK;
     }
 
-    grpc::Status Rerank(ServerContext* context, const backend::RerankRequest* request, backend::RerankResult* rerankResult) override {
+    grpc::Status Rerank(ServerContext* context, const backend::RerankRequest* request, backend::RerankResult* rerankResult) {
         if (!params_base.embedding || params_base.pooling_type != LLAMA_POOLING_TYPE_RANK) {
             return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "This server does not support reranking. Start it with `--reranking` and without `--embedding`");
         }
@@ -2425,7 +2346,7 @@ public:
         return grpc::Status::OK;
     }
 
-    grpc::Status TokenizeString(ServerContext* /*context*/, const backend::PredictOptions* request, backend::TokenizationResponse* response) override {
+    grpc::Status TokenizeString(ServerContext* /*context*/, const backend::PredictOptions* request, backend::TokenizationResponse* response) {
         if (params_base.model.path.empty()) {
             return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "Model not loaded");
         }
@@ -2448,7 +2369,7 @@ public:
         return grpc::Status::OK;
     }
 
-    grpc::Status GetMetrics(ServerContext* /*context*/, const backend::MetricsRequest* /*request*/, backend::MetricsResponse* response) override {
+    grpc::Status GetMetrics(ServerContext* /*context*/, const backend::MetricsRequest* /*request*/, backend::MetricsResponse* response) {
 
 // request slots data using task queue
         auto rd = ctx_server.get_response_reader();

backend/cpp/llama-cpp/package.sh

@@ -6,7 +6,6 @@
 set -e
 
 CURDIR=$(dirname "$(realpath $0)")
-REPO_ROOT="${CURDIR}/../../.."
 
 # Create lib directory
 mkdir -p $CURDIR/package/lib
@@ -38,15 +37,6 @@ else
     exit 1
 fi
 
-# Package GPU libraries based on BUILD_TYPE
-# The GPU library packaging script will detect BUILD_TYPE and copy appropriate GPU libraries
-GPU_LIB_SCRIPT="${REPO_ROOT}/scripts/build/package-gpu-libs.sh"
-if [ -f "$GPU_LIB_SCRIPT" ]; then
-    echo "Packaging GPU libraries for BUILD_TYPE=${BUILD_TYPE:-cpu}..."
-    source "$GPU_LIB_SCRIPT" "$CURDIR/package/lib"
-    package_gpu_libs
-fi
-
 echo "Packaging completed successfully" 
 ls -liah $CURDIR/package/
 ls -liah $CURDIR/package/lib/

backend/go/stablediffusion-ggml/Makefile

@@ -8,7 +8,7 @@ JOBS?=$(shell nproc --ignore=1)
 
 # stablediffusion.cpp (ggml)
 STABLEDIFFUSION_GGML_REPO?=https://github.com/leejet/stable-diffusion.cpp
-STABLEDIFFUSION_GGML_VERSION?=0e52afc6513cc2dea9a1a017afc4a008d5acf2b0
+STABLEDIFFUSION_GGML_VERSION?=4ff2c8c74bd17c2cfffe3a01be77743fb3efba2f
 
 CMAKE_ARGS+=-DGGML_MAX_NAME=128
 
@@ -28,12 +28,7 @@ else ifeq ($(BUILD_TYPE),clblas)
 	CMAKE_ARGS+=-DGGML_CLBLAST=ON -DCLBlast_DIR=/some/path
 # If it's hipblas we do have also to set CC=/opt/rocm/llvm/bin/clang CXX=/opt/rocm/llvm/bin/clang++
 else ifeq ($(BUILD_TYPE),hipblas)
-	ROCM_HOME ?= /opt/rocm
-	ROCM_PATH ?= /opt/rocm
-	export CXX=$(ROCM_HOME)/llvm/bin/clang++
-	export CC=$(ROCM_HOME)/llvm/bin/clang
-	AMDGPU_TARGETS?=gfx803,gfx900,gfx906,gfx908,gfx90a,gfx942,gfx1010,gfx1030,gfx1032,gfx1100,gfx1101,gfx1102,gfx1200,gfx1201
-	CMAKE_ARGS+=-DSD_HIPBLAS=ON -DGGML_HIPBLAS=ON -DAMDGPU_TARGETS=$(AMDGPU_TARGETS)
+	CMAKE_ARGS+=-DSD_HIPBLAS=ON -DGGML_HIPBLAS=ON
 else ifeq ($(BUILD_TYPE),vulkan)
 	CMAKE_ARGS+=-DSD_VULKAN=ON -DGGML_VULKAN=ON
 else ifeq ($(OS),Darwin)

backend/go/stablediffusion-ggml/package.sh

@@ -6,7 +6,6 @@
 set -e
 
 CURDIR=$(dirname "$(realpath $0)")
-REPO_ROOT="${CURDIR}/../../.."
 
 # Create lib directory
 mkdir -p $CURDIR/package/lib
@@ -51,15 +50,6 @@ else
     exit 1
 fi
 
-# Package GPU libraries based on BUILD_TYPE
-# The GPU library packaging script will detect BUILD_TYPE and copy appropriate GPU libraries
-GPU_LIB_SCRIPT="${REPO_ROOT}/scripts/build/package-gpu-libs.sh"
-if [ -f "$GPU_LIB_SCRIPT" ]; then
-    echo "Packaging GPU libraries for BUILD_TYPE=${BUILD_TYPE:-cpu}..."
-    source "$GPU_LIB_SCRIPT" "$CURDIR/package/lib"
-    package_gpu_libs
-fi
-
 echo "Packaging completed successfully"
 ls -liah $CURDIR/package/
 ls -liah $CURDIR/package/lib/

backend/go/whisper/Makefile

@@ -8,7 +8,7 @@ JOBS?=$(shell nproc --ignore=1)
 
 # whisper.cpp version
 WHISPER_REPO?=https://github.com/ggml-org/whisper.cpp
-WHISPER_CPP_VERSION?=679bdb53dbcbfb3e42685f50c7ff367949fd4d48
+WHISPER_CPP_VERSION?=e9898ddfb908ffaa7026c66852a023889a5a7202
 SO_TARGET?=libgowhisper.so
 
 CMAKE_ARGS+=-DBUILD_SHARED_LIBS=OFF

backend/go/whisper/package.sh

@@ -6,7 +6,6 @@
 set -e
 
 CURDIR=$(dirname "$(realpath $0)")
-REPO_ROOT="${CURDIR}/../../.."
 
 # Create lib directory
 mkdir -p $CURDIR/package/lib
@@ -51,15 +50,6 @@ else
     exit 1
 fi
 
-# Package GPU libraries based on BUILD_TYPE
-# The GPU library packaging script will detect BUILD_TYPE and copy appropriate GPU libraries
-GPU_LIB_SCRIPT="${REPO_ROOT}/scripts/build/package-gpu-libs.sh"
-if [ -f "$GPU_LIB_SCRIPT" ]; then
-    echo "Packaging GPU libraries for BUILD_TYPE=${BUILD_TYPE:-cpu}..."
-    source "$GPU_LIB_SCRIPT" "$CURDIR/package/lib"
-    package_gpu_libs
-fi
-
 echo "Packaging completed successfully"
 ls -liah $CURDIR/package/
 ls -liah $CURDIR/package/lib/

backend/index.yaml

@@ -275,24 +275,6 @@
     amd: "rocm-faster-whisper"
     nvidia-cuda-13: "cuda13-faster-whisper"
     nvidia-cuda-12: "cuda12-faster-whisper"
-- &moonshine
-  description: |
-    Moonshine is a fast, accurate, and efficient speech-to-text transcription model using ONNX Runtime.
-    It provides real-time transcription capabilities with support for multiple model sizes and GPU acceleration.
-  urls:
-    - https://github.com/moonshine-ai/moonshine
-  tags:
-    - speech-to-text
-    - transcription
-    - ONNX
-  license: MIT
-  name: "moonshine"
-  alias: "moonshine"
-  capabilities:
-    nvidia: "cuda12-moonshine"
-    default: "cpu-moonshine"
-    nvidia-cuda-13: "cuda13-moonshine"
-    nvidia-cuda-12: "cuda12-moonshine"
 - &kokoro
   icon: https://avatars.githubusercontent.com/u/166769057?v=4
   description: |
@@ -652,6 +634,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-cpu-llama-cpp"
   mirrors:
     - localai/localai-backends:master-cpu-llama-cpp
+- !!merge <<: *llamacpp
+  name: "cuda11-llama-cpp"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-llama-cpp"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-llama-cpp
 - !!merge <<: *llamacpp
   name: "cuda12-llama-cpp"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-llama-cpp"
@@ -692,6 +679,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-metal-darwin-arm64-llama-cpp"
   mirrors:
     - localai/localai-backends:master-metal-darwin-arm64-llama-cpp
+- !!merge <<: *llamacpp
+  name: "cuda11-llama-cpp-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-llama-cpp"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-llama-cpp
 - !!merge <<: *llamacpp
   name: "cuda12-llama-cpp-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-llama-cpp"
@@ -763,6 +755,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-cpu-whisper"
   mirrors:
     - localai/localai-backends:master-cpu-whisper
+- !!merge <<: *whispercpp
+  name: "cuda11-whisper"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-whisper"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-whisper
 - !!merge <<: *whispercpp
   name: "cuda12-whisper"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-whisper"
@@ -803,6 +800,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-metal-darwin-arm64-whisper"
   mirrors:
     - localai/localai-backends:master-metal-darwin-arm64-whisper
+- !!merge <<: *whispercpp
+  name: "cuda11-whisper-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-whisper"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-whisper
 - !!merge <<: *whispercpp
   name: "cuda12-whisper-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-whisper"
@@ -877,6 +879,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-intel-sycl-f16-stablediffusion-ggml"
   mirrors:
     - localai/localai-backends:latest-gpu-intel-sycl-f16-stablediffusion-ggml
+- !!merge <<: *stablediffusionggml
+  name: "cuda11-stablediffusion-ggml"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-stablediffusion-ggml"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-stablediffusion-ggml
 - !!merge <<: *stablediffusionggml
   name: "cuda12-stablediffusion-ggml-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-stablediffusion-ggml"
@@ -892,6 +899,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-intel-sycl-f16-stablediffusion-ggml"
   mirrors:
     - localai/localai-backends:master-gpu-intel-sycl-f16-stablediffusion-ggml
+- !!merge <<: *stablediffusionggml
+  name: "cuda11-stablediffusion-ggml-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-stablediffusion-ggml"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-stablediffusion-ggml
 - !!merge <<: *stablediffusionggml
   name: "nvidia-l4t-arm64-stablediffusion-ggml-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-nvidia-l4t-arm64-stablediffusion-ggml"
@@ -1042,6 +1054,11 @@
     intel: "intel-rerankers-development"
     amd: "rocm-rerankers-development"
     nvidia-cuda-13: "cuda13-rerankers-development"
+- !!merge <<: *rerankers
+  name: "cuda11-rerankers"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-rerankers"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-rerankers
 - !!merge <<: *rerankers
   name: "cuda12-rerankers"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-rerankers"
@@ -1057,6 +1074,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-rocm-hipblas-rerankers"
   mirrors:
     - localai/localai-backends:latest-gpu-rocm-hipblas-rerankers
+- !!merge <<: *rerankers
+  name: "cuda11-rerankers-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-rerankers"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-rerankers
 - !!merge <<: *rerankers
   name: "cuda12-rerankers-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-rerankers"
@@ -1105,6 +1127,16 @@
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-intel-transformers"
   mirrors:
     - localai/localai-backends:latest-gpu-intel-transformers
+- !!merge <<: *transformers
+  name: "cuda11-transformers-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-transformers"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-transformers
+- !!merge <<: *transformers
+  name: "cuda11-transformers"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-transformers"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-transformers
 - !!merge <<: *transformers
   name: "cuda12-transformers-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-transformers"
@@ -1181,11 +1213,21 @@
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-rocm-hipblas-diffusers"
   mirrors:
     - localai/localai-backends:latest-gpu-rocm-hipblas-diffusers
+- !!merge <<: *diffusers
+  name: "cuda11-diffusers"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-diffusers"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-diffusers
 - !!merge <<: *diffusers
   name: "intel-diffusers"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-intel-diffusers"
   mirrors:
     - localai/localai-backends:latest-gpu-intel-diffusers
+- !!merge <<: *diffusers
+  name: "cuda11-diffusers-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-diffusers"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-diffusers
 - !!merge <<: *diffusers
   name: "cuda12-diffusers-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-diffusers"
@@ -1227,11 +1269,21 @@
   capabilities:
     nvidia: "cuda12-exllama2-development"
     intel: "intel-exllama2-development"
+- !!merge <<: *exllama2
+  name: "cuda11-exllama2"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-exllama2"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-exllama2
 - !!merge <<: *exllama2
   name: "cuda12-exllama2"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-exllama2"
   mirrors:
     - localai/localai-backends:latest-gpu-nvidia-cuda-12-exllama2
+- !!merge <<: *exllama2
+  name: "cuda11-exllama2-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-exllama2"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-exllama2
 - !!merge <<: *exllama2
   name: "cuda12-exllama2-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-exllama2"
@@ -1245,6 +1297,11 @@
     intel: "intel-kokoro-development"
     amd: "rocm-kokoro-development"
     nvidia-l4t: "nvidia-l4t-kokoro-development"
+- !!merge <<: *kokoro
+  name: "cuda11-kokoro-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-kokoro"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-kokoro
 - !!merge <<: *kokoro
   name: "cuda12-kokoro-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-kokoro"
@@ -1275,6 +1332,11 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-nvidia-l4t-kokoro"
   mirrors:
     - localai/localai-backends:master-nvidia-l4t-kokoro
+- !!merge <<: *kokoro
+  name: "cuda11-kokoro"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-kokoro"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-kokoro
 - !!merge <<: *kokoro
   name: "cuda12-kokoro"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-kokoro"
@@ -1303,6 +1365,11 @@
     intel: "intel-faster-whisper-development"
     amd: "rocm-faster-whisper-development"
     nvidia-cuda-13: "cuda13-faster-whisper-development"
+- !!merge <<: *faster-whisper
+  name: "cuda11-faster-whisper"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-faster-whisper"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-faster-whisper
 - !!merge <<: *faster-whisper
   name: "cuda12-faster-whisper-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-faster-whisper"
@@ -1333,44 +1400,6 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-13-faster-whisper"
   mirrors:
     - localai/localai-backends:master-gpu-nvidia-cuda-13-faster-whisper
-## moonshine
-- !!merge <<: *moonshine
-  name: "moonshine-development"
-  capabilities:
-    nvidia: "cuda12-moonshine-development"
-    default: "cpu-moonshine-development"
-    nvidia-cuda-13: "cuda13-moonshine-development"
-    nvidia-cuda-12: "cuda12-moonshine-development"
-- !!merge <<: *moonshine
-  name: "cpu-moonshine"
-  uri: "quay.io/go-skynet/local-ai-backends:latest-cpu-moonshine"
-  mirrors:
-    - localai/localai-backends:latest-cpu-moonshine
-- !!merge <<: *moonshine
-  name: "cpu-moonshine-development"
-  uri: "quay.io/go-skynet/local-ai-backends:master-cpu-moonshine"
-  mirrors:
-    - localai/localai-backends:master-cpu-moonshine
-- !!merge <<: *moonshine
-  name: "cuda12-moonshine"
-  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-moonshine"
-  mirrors:
-    - localai/localai-backends:latest-gpu-nvidia-cuda-12-moonshine
-- !!merge <<: *moonshine
-  name: "cuda12-moonshine-development"
-  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-moonshine"
-  mirrors:
-    - localai/localai-backends:master-gpu-nvidia-cuda-12-moonshine
-- !!merge <<: *moonshine
-  name: "cuda13-moonshine"
-  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-13-moonshine"
-  mirrors:
-    - localai/localai-backends:latest-gpu-nvidia-cuda-13-moonshine
-- !!merge <<: *moonshine
-  name: "cuda13-moonshine-development"
-  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-13-moonshine"
-  mirrors:
-    - localai/localai-backends:master-gpu-nvidia-cuda-13-moonshine
 ## coqui
 
 - !!merge <<: *coqui
@@ -1379,11 +1408,21 @@
     nvidia: "cuda12-coqui-development"
     intel: "intel-coqui-development"
     amd: "rocm-coqui-development"
+- !!merge <<: *coqui
+  name: "cuda11-coqui"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-coqui"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-coqui
 - !!merge <<: *coqui
   name: "cuda12-coqui"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-coqui"
   mirrors:
     - localai/localai-backends:latest-gpu-nvidia-cuda-12-coqui
+- !!merge <<: *coqui
+  name: "cuda11-coqui-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-coqui"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-coqui
 - !!merge <<: *coqui
   name: "cuda12-coqui-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-coqui"
@@ -1416,6 +1455,16 @@
     nvidia: "cuda12-bark-development"
     intel: "intel-bark-development"
     amd: "rocm-bark-development"
+- !!merge <<: *bark
+  name: "cuda11-bark-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-bark"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-bark
+- !!merge <<: *bark
+  name: "cuda11-bark"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-bark"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-bark
 - !!merge <<: *bark
   name: "rocm-bark-development"
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-rocm-hipblas-bark"
@@ -1497,6 +1546,16 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-chatterbox"
   mirrors:
     - localai/localai-backends:master-gpu-nvidia-cuda-12-chatterbox
+- !!merge <<: *chatterbox
+  name: "cuda11-chatterbox"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-11-chatterbox"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-11-chatterbox
+- !!merge <<: *chatterbox
+  name: "cuda11-chatterbox-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-11-chatterbox"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-11-chatterbox
 - !!merge <<: *chatterbox
   name: "cuda12-chatterbox"
   uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-chatterbox"

backend/python/README.md

@@ -85,7 +85,7 @@ runUnittests
 The build system automatically detects and configures for different hardware:
 
 - **CPU** - Standard CPU-only builds
-- **CUDA** - NVIDIA GPU acceleration (supports CUDA 12/13)
+- **CUDA** - NVIDIA GPU acceleration (supports CUDA 11/12)
 - **Intel** - Intel XPU/GPU optimization
 - **MLX** - Apple Silicon (M1/M2/M3) optimization
 - **HIP** - AMD GPU acceleration
@@ -95,8 +95,8 @@ The build system automatically detects and configures for different hardware:
 Backends can specify hardware-specific dependencies:
 - `requirements.txt` - Base requirements
 - `requirements-cpu.txt` - CPU-specific packages
+- `requirements-cublas11.txt` - CUDA 11 packages
 - `requirements-cublas12.txt` - CUDA 12 packages
-- `requirements-cublas13.txt` - CUDA 13 packages
 - `requirements-intel.txt` - Intel-optimized packages
 - `requirements-mps.txt` - Apple Silicon packages
 

backend/python/bark/requirements-cublas11.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.4.1+cu118
+torchaudio==2.4.1+cu118
+transformers
+accelerate

backend/python/bark/requirements-hipblas.txt

@@ -1,5 +1,5 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
-torchaudio==2.8.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.0
+torch==2.4.1+rocm6.0
+torchaudio==2.4.1+rocm6.0
 transformers
 accelerate

backend/python/chatterbox/requirements-cublas11.txt

@@ -0,0 +1,8 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.6.0+cu118
+torchaudio==2.6.0+cu118
+transformers==4.46.3
+numpy>=1.24.0,<1.26.0
+# https://github.com/mudler/LocalAI/pull/6240#issuecomment-3329518289
+chatterbox-tts@git+https://git@github.com/mudler/chatterbox.git@faster
+accelerate

backend/python/chatterbox/requirements-hipblas.txt

@@ -1,6 +1,6 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.9.1+rocm6.4
-torchaudio==2.9.1+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.0
+torch==2.6.0+rocm6.1
+torchaudio==2.6.0+rocm6.1
 transformers
 numpy>=1.24.0,<1.26.0
 # https://github.com/mudler/LocalAI/pull/6240#issuecomment-3329518289

backend/python/common/libbackend.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-#
+# 
 # use the library by adding the following line to a script:
 # source $(dirname $0)/../common/libbackend.sh
 #
@@ -206,8 +206,8 @@ function init() {
 
 # getBuildProfile will inspect the system to determine which build profile is appropriate:
 # returns one of the following:
+# - cublas11
 # - cublas12
-# - cublas13
 # - hipblas
 # - intel
 function getBuildProfile() {
@@ -392,7 +392,7 @@ function runProtogen() {
 #  - requirements-${BUILD_TYPE}.txt
 #  - requirements-${BUILD_PROFILE}.txt
 #
-# BUILD_PROFILE is a more specific version of BUILD_TYPE, ex: cuda-12 or cuda-13
+# BUILD_PROFILE is a more specific version of BUILD_TYPE, ex: cuda-11 or cuda-12
 # it can also include some options that we do not have BUILD_TYPES for, ex: intel
 #
 # NOTE: for BUILD_PROFILE==intel, this function does NOT automatically use the Intel python package index.
@@ -465,14 +465,6 @@ function startBackend() {
     if [ "x${PORTABLE_PYTHON}" == "xtrue" ] || [ -x "$(_portable_python)" ]; then
         _makeVenvPortable --update-pyvenv-cfg
     fi
-
-    # Set up GPU library paths if a lib directory exists
-    # This allows backends to include their own GPU libraries (CUDA, ROCm, etc.)
-    if [ -d "${EDIR}/lib" ]; then
-        export LD_LIBRARY_PATH="${EDIR}/lib:${LD_LIBRARY_PATH:-}"
-        echo "Added ${EDIR}/lib to LD_LIBRARY_PATH for GPU libraries"
-    fi
-
     if [ ! -z "${BACKEND_FILE:-}" ]; then
         exec "${EDIR}/venv/bin/python" "${BACKEND_FILE}" "$@"
     elif [ -e "${MY_DIR}/server.py" ]; then

backend/python/common/template/requirements-hipblas.txt

@@ -1,2 +1,2 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.0
 torch

backend/python/coqui/requirements-cublas11.txt

@@ -0,0 +1,6 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.4.1+cu118
+torchaudio==2.4.1+cu118
+transformers==4.48.3
+accelerate
+coqui-tts

backend/python/coqui/requirements-hipblas.txt

@@ -1,6 +1,6 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
-torchaudio==2.8.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.0
+torch==2.4.1+rocm6.0
+torchaudio==2.4.1+rocm6.0
 transformers==4.48.3
 accelerate
 coqui-tts

backend/python/diffusers/install.sh

@@ -17,7 +17,7 @@ if [ "x${BUILD_PROFILE}" == "xintel" ]; then
 fi
 
 # Use python 3.12 for l4t
-if [ "x${BUILD_PROFILE}" == "xl4t13" ]; then
+if [ "x${BUILD_PROFILE}" == "xl4t12" ] || [ "x${BUILD_PROFILE}" == "xl4t13" ]; then
   PYTHON_VERSION="3.12"
   PYTHON_PATCH="12"
   PY_STANDALONE_TAG="20251120"

backend/python/diffusers/requirements-cublas11.txt

@@ -0,0 +1,12 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+git+https://github.com/huggingface/diffusers
+opencv-python
+transformers
+torchvision==0.22.1
+accelerate
+compel
+peft
+sentencepiece
+torch==2.7.1
+optimum-quanto
+ftfy

backend/python/diffusers/requirements-hipblas.txt

@@ -1,6 +1,6 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
-torchvision==0.23.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.3
+torch==2.7.1+rocm6.3
+torchvision==0.22.1+rocm6.3
 git+https://github.com/huggingface/diffusers
 opencv-python
 transformers

backend/python/exllama2/requirements-cublas11.txt

@@ -0,0 +1,4 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.4.1+cu118
+transformers
+accelerate

backend/python/faster-whisper/requirements-cublas11.txt

@@ -0,0 +1,9 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.4.1+cu118
+faster-whisper
+opencv-python
+accelerate
+compel
+peft
+sentencepiece
+optimum-quanto

backend/python/faster-whisper/requirements-hipblas.txt

@@ -1,3 +1,3 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.0
 torch
 faster-whisper

backend/python/kokoro/requirements-cublas11.txt

@@ -0,0 +1,7 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.7.1+cu118
+torchaudio==2.7.1+cu118
+transformers
+accelerate
+kokoro
+soundfile

backend/python/kokoro/requirements-hipblas.txt

@@ -1,6 +1,6 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
-torchaudio==2.8.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.3
+torch==2.7.1+rocm6.3
+torchaudio==2.7.1+rocm6.3
 transformers
 accelerate
 kokoro

backend/python/moonshine/Makefile

@@ -1,16 +0,0 @@
-.DEFAULT_GOAL := install
-
-.PHONY: install
-install:
-	bash install.sh
-
-.PHONY: protogen-clean
-protogen-clean:
-	$(RM) backend_pb2_grpc.py backend_pb2.py
-
-.PHONY: clean
-clean: protogen-clean
-	rm -rf venv __pycache__
-
-test: install
-	bash test.sh

backend/python/moonshine/backend.py

@@ -1,113 +0,0 @@
-#!/usr/bin/env python3
-"""
-This is an extra gRPC server of LocalAI for Moonshine transcription
-"""
-from concurrent import futures
-import time
-import argparse
-import signal
-import sys
-import os
-import backend_pb2
-import backend_pb2_grpc
-import moonshine_onnx
-
-import grpc
-
-
-_ONE_DAY_IN_SECONDS = 60 * 60 * 24
-
-# If MAX_WORKERS are specified in the environment use it, otherwise default to 1
-MAX_WORKERS = int(os.environ.get('PYTHON_GRPC_MAX_WORKERS', '1'))
-
-# Implement the BackendServicer class with the service methods
-class BackendServicer(backend_pb2_grpc.BackendServicer):
-    """
-    BackendServicer is the class that implements the gRPC service
-    """
-    def Health(self, request, context):
-        return backend_pb2.Reply(message=bytes("OK", 'utf-8'))
-    
-    def LoadModel(self, request, context):
-        try:
-            print("Preparing models, please wait", file=sys.stderr)
-            # Store the model name for use in transcription
-            # Model name format: e.g., "moonshine/tiny"
-            self.model_name = request.Model
-            print(f"Model name set to: {self.model_name}", file=sys.stderr)
-        except Exception as err:
-            return backend_pb2.Result(success=False, message=f"Unexpected {err=}, {type(err)=}")
-        return backend_pb2.Result(message="Model loaded successfully", success=True)
-
-    def AudioTranscription(self, request, context):
-        resultSegments = []
-        text = ""
-        try:
-            # moonshine_onnx.transcribe returns a list of strings
-            transcriptions = moonshine_onnx.transcribe(request.dst, self.model_name)
-            
-            # Combine all transcriptions into a single text
-            if isinstance(transcriptions, list):
-                text = " ".join(transcriptions)
-                # Create segments for each transcription in the list
-                for id, trans in enumerate(transcriptions):
-                    # Since moonshine doesn't provide timing info, we'll create a single segment
-                    # with id and text, using approximate timing
-                    resultSegments.append(backend_pb2.TranscriptSegment(
-                        id=id, 
-                        start=0, 
-                        end=0, 
-                        text=trans
-                    ))
-            else:
-                # Handle case where it's not a list (shouldn't happen, but be safe)
-                text = str(transcriptions)
-                resultSegments.append(backend_pb2.TranscriptSegment(
-                    id=0,
-                    start=0,
-                    end=0,
-                    text=text
-                ))
-        except Exception as err:
-            print(f"Unexpected {err=}, {type(err)=}", file=sys.stderr)
-            return backend_pb2.TranscriptResult(segments=[], text="")
-
-        return backend_pb2.TranscriptResult(segments=resultSegments, text=text)
-
-def serve(address):
-    server = grpc.server(futures.ThreadPoolExecutor(max_workers=MAX_WORKERS),
-        options=[
-            ('grpc.max_message_length', 50 * 1024 * 1024),  # 50MB
-            ('grpc.max_send_message_length', 50 * 1024 * 1024),  # 50MB
-            ('grpc.max_receive_message_length', 50 * 1024 * 1024),  # 50MB
-        ])
-    backend_pb2_grpc.add_BackendServicer_to_server(BackendServicer(), server)
-    server.add_insecure_port(address)
-    server.start()
-    print("Server started. Listening on: " + address, file=sys.stderr)
-
-    # Define the signal handler function
-    def signal_handler(sig, frame):
-        print("Received termination signal. Shutting down...")
-        server.stop(0)
-        sys.exit(0)
-
-    # Set the signal handlers for SIGINT and SIGTERM
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-
-    try:
-        while True:
-            time.sleep(_ONE_DAY_IN_SECONDS)
-    except KeyboardInterrupt:
-        server.stop(0)
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Run the gRPC server.")
-    parser.add_argument(
-        "--addr", default="localhost:50051", help="The address to bind the server to."
-    )
-    args = parser.parse_args()
-
-    serve(args.addr)
-

backend/python/moonshine/install.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-set -e
-
-backend_dir=$(dirname $0)
-if [ -d $backend_dir/common ]; then
-    source $backend_dir/common/libbackend.sh
-else
-    source $backend_dir/../common/libbackend.sh
-fi
-
-installRequirements
-

backend/python/moonshine/protogen.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-set -e
-
-backend_dir=$(dirname $0)
-if [ -d $backend_dir/common ]; then
-    source $backend_dir/common/libbackend.sh
-else
-    source $backend_dir/../common/libbackend.sh
-fi
-
-python3 -m grpc_tools.protoc -I../.. -I./ --python_out=. --grpc_python_out=. backend.proto
-

backend/python/moonshine/requirements.txt

@@ -1,4 +0,0 @@
-grpcio==1.71.0
-protobuf
-grpcio-tools
-useful-moonshine-onnx@git+https://git@github.com/moonshine-ai/moonshine.git#subdirectory=moonshine-onnx

backend/python/moonshine/run.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-backend_dir=$(dirname $0)
-if [ -d $backend_dir/common ]; then
-    source $backend_dir/common/libbackend.sh
-else
-    source $backend_dir/../common/libbackend.sh
-fi
-
-startBackend $@
-

backend/python/moonshine/test.py

@@ -1,139 +0,0 @@
-"""
-A test script to test the gRPC service for Moonshine transcription
-"""
-import unittest
-import subprocess
-import time
-import os
-import tempfile
-import shutil
-import backend_pb2
-import backend_pb2_grpc
-
-import grpc
-
-
-class TestBackendServicer(unittest.TestCase):
-    """
-    TestBackendServicer is the class that tests the gRPC service
-    """
-    def setUp(self):
-        """
-        This method sets up the gRPC service by starting the server
-        """
-        self.service = subprocess.Popen(["python3", "backend.py", "--addr", "localhost:50051"])
-        time.sleep(10)
-
-    def tearDown(self) -> None:
-        """
-        This method tears down the gRPC service by terminating the server
-        """
-        self.service.terminate()
-        self.service.wait()
-
-    def test_server_startup(self):
-        """
-        This method tests if the server starts up successfully
-        """
-        try:
-            self.setUp()
-            with grpc.insecure_channel("localhost:50051") as channel:
-                stub = backend_pb2_grpc.BackendStub(channel)
-                response = stub.Health(backend_pb2.HealthMessage())
-                self.assertEqual(response.message, b'OK')
-        except Exception as err:
-            print(err)
-            self.fail("Server failed to start")
-        finally:
-            self.tearDown()
-
-    def test_load_model(self):
-        """
-        This method tests if the model is loaded successfully
-        """
-        try:
-            self.setUp()
-            with grpc.insecure_channel("localhost:50051") as channel:
-                stub = backend_pb2_grpc.BackendStub(channel)
-                response = stub.LoadModel(backend_pb2.ModelOptions(Model="moonshine/tiny"))
-                self.assertTrue(response.success)
-                self.assertEqual(response.message, "Model loaded successfully")
-        except Exception as err:
-            print(err)
-            self.fail("LoadModel service failed")
-        finally:
-            self.tearDown()
-
-    def test_audio_transcription(self):
-        """
-        This method tests if audio transcription works successfully
-        """
-        # Create a temporary directory for the audio file
-        temp_dir = tempfile.mkdtemp()
-        audio_file = os.path.join(temp_dir, 'audio.wav')
-        
-        try:
-            # Download the audio file to the temporary directory
-            print(f"Downloading audio file to {audio_file}...")
-            url = "https://cdn.openai.com/whisper/draft-20220913a/micro-machines.wav"
-            result = subprocess.run(
-                ["wget", "-q", url, "-O", audio_file],
-                capture_output=True,
-                text=True
-            )
-            if result.returncode != 0:
-                self.fail(f"Failed to download audio file: {result.stderr}")
-            
-            # Verify the file was downloaded
-            if not os.path.exists(audio_file):
-                self.fail(f"Audio file was not downloaded to {audio_file}")
-            
-            self.setUp()
-            with grpc.insecure_channel("localhost:50051") as channel:
-                stub = backend_pb2_grpc.BackendStub(channel)
-                # Load the model first
-                load_response = stub.LoadModel(backend_pb2.ModelOptions(Model="moonshine/tiny"))
-                self.assertTrue(load_response.success)
-                
-                # Perform transcription
-                transcript_request = backend_pb2.TranscriptRequest(dst=audio_file)
-                transcript_response = stub.AudioTranscription(transcript_request)
-                
-                # Print the transcribed text for debugging
-                print(f"Transcribed text: {transcript_response.text}")
-                print(f"Number of segments: {len(transcript_response.segments)}")
-                
-                # Verify response structure
-                self.assertIsNotNone(transcript_response)
-                self.assertIsNotNone(transcript_response.text)
-                # Protobuf repeated fields return a sequence, not a list
-                self.assertIsNotNone(transcript_response.segments)
-                # Check if segments is iterable (has length)
-                self.assertGreaterEqual(len(transcript_response.segments), 0)
-                
-                # Verify the transcription contains the expected text
-                expected_text = "This is the micro machine man presenting the most midget miniature"
-                self.assertIn(
-                    expected_text.lower(),
-                    transcript_response.text.lower(),
-                    f"Expected text '{expected_text}' not found in transcription: '{transcript_response.text}'"
-                )
-                
-                # If we got segments, verify they have the expected structure
-                if len(transcript_response.segments) > 0:
-                    segment = transcript_response.segments[0]
-                    self.assertIsNotNone(segment.text)
-                    self.assertIsInstance(segment.id, int)
-                else:
-                    # Even if no segments, we should have text
-                    self.assertIsNotNone(transcript_response.text)
-                    self.assertGreater(len(transcript_response.text), 0)
-        except Exception as err:
-            print(err)
-            self.fail("AudioTranscription service failed")
-        finally:
-            self.tearDown()
-            # Clean up the temporary directory
-            if os.path.exists(temp_dir):
-                shutil.rmtree(temp_dir)
-

backend/python/moonshine/test.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-set -e
-
-backend_dir=$(dirname $0)
-if [ -d $backend_dir/common ]; then
-    source $backend_dir/common/libbackend.sh
-else
-    source $backend_dir/../common/libbackend.sh
-fi
-
-runUnittests
-

backend/python/neutts/requirements-hipblas.txt

@@ -1,5 +1,5 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.3
+torch==2.8.0+rocm6.3
 transformers==4.56.1
 accelerate
 librosa==0.11.0

backend/python/rerankers/requirements-cublas11.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+transformers
+accelerate
+torch==2.4.1+cu118
+rerankers[transformers]

backend/python/rerankers/requirements-hipblas.txt

@@ -1,5 +1,5 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.0
 transformers
 accelerate
-torch==2.8.0+rocm6.4
+torch==2.4.1+rocm6.0
 rerankers[transformers]

backend/python/rfdetr/requirements-cublas11.txt

@@ -0,0 +1,8 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.7.1+cu118
+rfdetr
+opencv-python
+accelerate
+inference
+peft
+optimum-quanto

backend/python/rfdetr/requirements-hipblas.txt

@@ -1,6 +1,6 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
-torchvision==0.23.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.3
+torch==2.7.1+rocm6.3
+torchvision==0.22.1+rocm6.3
 rfdetr
 opencv-python
 accelerate

backend/python/transformers/requirements-cublas11.txt

@@ -0,0 +1,10 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.7.1+cu118
+llvmlite==0.43.0
+numba==0.60.0
+accelerate
+transformers
+bitsandbytes
+outetts
+sentence-transformers==5.2.0
+protobuf==6.33.2

backend/python/transformers/requirements-hipblas.txt

@@ -1,5 +1,5 @@
---extra-index-url https://download.pytorch.org/whl/rocm6.4
-torch==2.8.0+rocm6.4
+--extra-index-url https://download.pytorch.org/whl/rocm6.3
+torch==2.7.1+rocm6.3
 accelerate
 transformers
 llvmlite==0.43.0

backend/python/vibevoice/install.sh

@@ -17,7 +17,7 @@ if [ "x${BUILD_PROFILE}" == "xintel" ]; then
 fi
 
 # Use python 3.12 for l4t
-if [ "x${BUILD_PROFILE}" == "xl4t13" ]; then
+if [ "x${BUILD_PROFILE}" == "xl4t12" ] || [ "x${BUILD_PROFILE}" == "xl4t13" ]; then
   PYTHON_VERSION="3.12"
   PYTHON_PATCH="12"
   PY_STANDALONE_TAG="20251120"

backend/python/vibevoice/requirements-cublas11.txt

@@ -0,0 +1,22 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+git+https://github.com/huggingface/diffusers
+opencv-python
+transformers==4.51.3
+torchvision==0.22.1
+accelerate
+compel
+peft
+sentencepiece
+torch==2.7.1
+optimum-quanto
+ftfy
+llvmlite>=0.40.0
+numba>=0.57.0
+tqdm
+numpy
+scipy
+librosa
+ml-collections
+absl-py
+gradio
+av

backend/python/vllm/install.sh

@@ -28,7 +28,7 @@ fi
 
 # We don't embed this into the images as it is a large dependency and not always needed.
 # Besides, the speed inference are not actually usable in the current state for production use-cases.
-if [ "x${BUILD_TYPE}" == "x" ] && [ "x${FROM_SOURCE:-}" == "xtrue" ]; then
+if [ "x${BUILD_TYPE}" == "x" ] && [ "x${FROM_SOURCE}" == "xtrue" ]; then
         ensureVenv
         # https://docs.vllm.ai/en/v0.6.1/getting_started/cpu-installation.html
         if [ ! -d vllm ]; then

backend/python/vllm/requirements-cublas11-after.txt

@@ -0,0 +1 @@
+flash-attn

backend/python/vllm/requirements-cublas11.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+accelerate
+torch==2.7.0+cu118
+transformers
+bitsandbytes

backend/python/vllm/requirements-hipblas.txt

@@ -1,4 +1,4 @@
---extra-index-url https://download.pytorch.org/whl/nightly/rocm6.4
+--extra-index-url https://download.pytorch.org/whl/nightly/rocm6.3
 accelerate
 torch
 transformers

core/http/app.go

@@ -205,7 +205,6 @@ func API(application *application.Application) (*echo.Echo, error) {
 
 	routes.RegisterLocalAIRoutes(e, requestExtractor, application.ModelConfigLoader(), application.ModelLoader(), application.ApplicationConfig(), application.GalleryService(), opcache, application.TemplatesEvaluator(), application)
 	routes.RegisterOpenAIRoutes(e, requestExtractor, application)
-	routes.RegisterAnthropicRoutes(e, requestExtractor, application)
 	if !application.ApplicationConfig().DisableWebUI {
 		routes.RegisterUIAPIRoutes(e, application.ModelConfigLoader(), application.ModelLoader(), application.ApplicationConfig(), application.GalleryService(), opcache, application)
 		routes.RegisterUIRoutes(e, application.ModelConfigLoader(), application.ModelLoader(), application.ApplicationConfig(), application.GalleryService())

core/http/endpoints/anthropic/messages.go

@@ -1,537 +0,0 @@
-package anthropic
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/google/uuid"
-	"github.com/labstack/echo/v4"
-	"github.com/mudler/LocalAI/core/backend"
-	"github.com/mudler/LocalAI/core/config"
-	"github.com/mudler/LocalAI/core/http/middleware"
-	"github.com/mudler/LocalAI/core/schema"
-	"github.com/mudler/LocalAI/core/templates"
-	"github.com/mudler/LocalAI/pkg/functions"
-	"github.com/mudler/LocalAI/pkg/model"
-	"github.com/mudler/xlog"
-)
-
-// MessagesEndpoint is the Anthropic Messages API endpoint
-// https://docs.anthropic.com/claude/reference/messages_post
-// @Summary Generate a message response for the given messages and model.
-// @Param request body schema.AnthropicRequest true "query params"
-// @Success 200 {object} schema.AnthropicResponse "Response"
-// @Router /v1/messages [post]
-func MessagesEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator *templates.Evaluator, appConfig *config.ApplicationConfig) echo.HandlerFunc {
-	return func(c echo.Context) error {
-		id := uuid.New().String()
-
-		input, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_LOCALAI_REQUEST).(*schema.AnthropicRequest)
-		if !ok || input.Model == "" {
-			return sendAnthropicError(c, 400, "invalid_request_error", "model is required")
-		}
-
-		cfg, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_MODEL_CONFIG).(*config.ModelConfig)
-		if !ok || cfg == nil {
-			return sendAnthropicError(c, 400, "invalid_request_error", "model configuration not found")
-		}
-
-		if input.MaxTokens <= 0 {
-			return sendAnthropicError(c, 400, "invalid_request_error", "max_tokens is required and must be greater than 0")
-		}
-
-		xlog.Debug("Anthropic Messages endpoint configuration read", "config", cfg)
-
-		// Convert Anthropic messages to OpenAI format for internal processing
-		openAIMessages := convertAnthropicToOpenAIMessages(input)
-
-		// Convert Anthropic tools to internal Functions format
-		funcs, shouldUseFn := convertAnthropicTools(input, cfg)
-
-		// Create an OpenAI-compatible request for internal processing
-		openAIReq := &schema.OpenAIRequest{
-			PredictionOptions: schema.PredictionOptions{
-				BasicModelRequest: schema.BasicModelRequest{Model: input.Model},
-				Temperature:       input.Temperature,
-				TopK:              input.TopK,
-				TopP:              input.TopP,
-				Maxtokens:         &input.MaxTokens,
-			},
-			Messages: openAIMessages,
-			Stream:   input.Stream,
-			Context:  input.Context,
-			Cancel:   input.Cancel,
-		}
-
-		// Set stop sequences
-		if len(input.StopSequences) > 0 {
-			openAIReq.Stop = input.StopSequences
-		}
-
-		// Merge config settings
-		if input.Temperature != nil {
-			cfg.Temperature = input.Temperature
-		}
-		if input.TopK != nil {
-			cfg.TopK = input.TopK
-		}
-		if input.TopP != nil {
-			cfg.TopP = input.TopP
-		}
-		cfg.Maxtokens = &input.MaxTokens
-		if len(input.StopSequences) > 0 {
-			cfg.StopWords = append(cfg.StopWords, input.StopSequences...)
-		}
-
-		// Template the prompt with tools if available
-		predInput := evaluator.TemplateMessages(*openAIReq, openAIReq.Messages, cfg, funcs, shouldUseFn)
-		xlog.Debug("Anthropic Messages - Prompt (after templating)", "prompt", predInput)
-
-		if input.Stream {
-			return handleAnthropicStream(c, id, input, cfg, ml, predInput, openAIReq, funcs, shouldUseFn)
-		}
-
-		return handleAnthropicNonStream(c, id, input, cfg, ml, predInput, openAIReq, funcs, shouldUseFn)
-	}
-}
-
-func handleAnthropicNonStream(c echo.Context, id string, input *schema.AnthropicRequest, cfg *config.ModelConfig, ml *model.ModelLoader, predInput string, openAIReq *schema.OpenAIRequest, funcs functions.Functions, shouldUseFn bool) error {
-	images := []string{}
-	for _, m := range openAIReq.Messages {
-		images = append(images, m.StringImages...)
-	}
-
-	predFunc, err := backend.ModelInference(
-		input.Context, predInput, openAIReq.Messages, images, nil, nil, ml, cfg, nil, nil, nil, "", "", nil, nil, nil)
-	if err != nil {
-		xlog.Error("Anthropic model inference failed", "error", err)
-		return sendAnthropicError(c, 500, "api_error", fmt.Sprintf("model inference failed: %v", err))
-	}
-
-	prediction, err := predFunc()
-	if err != nil {
-		xlog.Error("Anthropic prediction failed", "error", err)
-		return sendAnthropicError(c, 500, "api_error", fmt.Sprintf("prediction failed: %v", err))
-	}
-
-	result := backend.Finetune(*cfg, predInput, prediction.Response)
-	
-	// Check if the result contains tool calls
-	toolCalls := functions.ParseFunctionCall(result, cfg.FunctionsConfig)
-	
-	var contentBlocks []schema.AnthropicContentBlock
-	var stopReason string
-	
-	if shouldUseFn && len(toolCalls) > 0 {
-		// Model wants to use tools
-		stopReason = "tool_use"
-		for _, tc := range toolCalls {
-			// Parse arguments as JSON
-			var inputArgs map[string]interface{}
-			if err := json.Unmarshal([]byte(tc.Arguments), &inputArgs); err != nil {
-				xlog.Warn("Failed to parse tool call arguments as JSON", "error", err, "args", tc.Arguments)
-				inputArgs = map[string]interface{}{"raw": tc.Arguments}
-			}
-			
-			contentBlocks = append(contentBlocks, schema.AnthropicContentBlock{
-				Type:  "tool_use",
-				ID:    fmt.Sprintf("toolu_%s_%d", id, len(contentBlocks)),
-				Name:  tc.Name,
-				Input: inputArgs,
-			})
-		}
-		
-		// Add any text content before the tool calls
-		textContent := functions.ParseTextContent(result, cfg.FunctionsConfig)
-		if textContent != "" {
-			// Prepend text block
-			contentBlocks = append([]schema.AnthropicContentBlock{{Type: "text", Text: textContent}}, contentBlocks...)
-		}
-	} else {
-		// Normal text response
-		stopReason = "end_turn"
-		contentBlocks = []schema.AnthropicContentBlock{
-			{Type: "text", Text: result},
-		}
-	}
-
-	resp := &schema.AnthropicResponse{
-		ID:         fmt.Sprintf("msg_%s", id),
-		Type:       "message",
-		Role:       "assistant",
-		Model:      input.Model,
-		StopReason: &stopReason,
-		Content:    contentBlocks,
-		Usage: schema.AnthropicUsage{
-			InputTokens:  prediction.Usage.Prompt,
-			OutputTokens: prediction.Usage.Completion,
-		},
-	}
-
-	if respData, err := json.Marshal(resp); err == nil {
-		xlog.Debug("Anthropic Response", "response", string(respData))
-	}
-
-	return c.JSON(200, resp)
-}
-
-func handleAnthropicStream(c echo.Context, id string, input *schema.AnthropicRequest, cfg *config.ModelConfig, ml *model.ModelLoader, predInput string, openAIReq *schema.OpenAIRequest, funcs functions.Functions, shouldUseFn bool) error {
-	c.Response().Header().Set("Content-Type", "text/event-stream")
-	c.Response().Header().Set("Cache-Control", "no-cache")
-	c.Response().Header().Set("Connection", "keep-alive")
-
-	// Create OpenAI messages for inference
-	openAIMessages := openAIReq.Messages
-
-	images := []string{}
-	for _, m := range openAIMessages {
-		images = append(images, m.StringImages...)
-	}
-
-	// Send message_start event
-	messageStart := schema.AnthropicStreamEvent{
-		Type: "message_start",
-		Message: &schema.AnthropicStreamMessage{
-			ID:      fmt.Sprintf("msg_%s", id),
-			Type:    "message",
-			Role:    "assistant",
-			Content: []schema.AnthropicContentBlock{},
-			Model:   input.Model,
-			Usage:   schema.AnthropicUsage{InputTokens: 0, OutputTokens: 0},
-		},
-	}
-	sendAnthropicSSE(c, messageStart)
-
-	// Track accumulated content for tool call detection
-	accumulatedContent := ""
-	currentBlockIndex := 0
-	inToolCall := false
-	toolCallsEmitted := 0
-	
-	// Send initial content_block_start event
-	contentBlockStart := schema.AnthropicStreamEvent{
-		Type:         "content_block_start",
-		Index:        currentBlockIndex,
-		ContentBlock: &schema.AnthropicContentBlock{Type: "text", Text: ""},
-	}
-	sendAnthropicSSE(c, contentBlockStart)
-
-	// Stream content deltas
-	tokenCallback := func(token string, usage backend.TokenUsage) bool {
-		accumulatedContent += token
-		
-		// If we're using functions, try to detect tool calls incrementally
-		if shouldUseFn {
-			cleanedResult := functions.CleanupLLMResult(accumulatedContent, cfg.FunctionsConfig)
-			
-			// Try parsing for tool calls
-			toolCalls := functions.ParseFunctionCall(cleanedResult, cfg.FunctionsConfig)
-			
-			// If we detected new tool calls and haven't emitted them yet
-			if len(toolCalls) > toolCallsEmitted {
-				// Stop the current text block if we were in one
-				if !inToolCall && currentBlockIndex == 0 {
-					sendAnthropicSSE(c, schema.AnthropicStreamEvent{
-						Type:  "content_block_stop",
-						Index: currentBlockIndex,
-					})
-					currentBlockIndex++
-					inToolCall = true
-				}
-				
-				// Emit new tool calls
-				for i := toolCallsEmitted; i < len(toolCalls); i++ {
-					tc := toolCalls[i]
-					
-					// Send content_block_start for tool_use
-					sendAnthropicSSE(c, schema.AnthropicStreamEvent{
-						Type:  "content_block_start",
-						Index: currentBlockIndex,
-						ContentBlock: &schema.AnthropicContentBlock{
-							Type: "tool_use",
-							ID:   fmt.Sprintf("toolu_%s_%d", id, i),
-							Name: tc.Name,
-						},
-					})
-					
-					// Send input_json_delta with the arguments
-					sendAnthropicSSE(c, schema.AnthropicStreamEvent{
-						Type:  "content_block_delta",
-						Index: currentBlockIndex,
-						Delta: &schema.AnthropicStreamDelta{
-							Type:        "input_json_delta",
-							PartialJSON: tc.Arguments,
-						},
-					})
-					
-					// Send content_block_stop
-					sendAnthropicSSE(c, schema.AnthropicStreamEvent{
-						Type:  "content_block_stop",
-						Index: currentBlockIndex,
-					})
-					
-					currentBlockIndex++
-				}
-				toolCallsEmitted = len(toolCalls)
-				return true
-			}
-		}
-		
-		// Send regular text delta if not in tool call mode
-		if !inToolCall {
-			delta := schema.AnthropicStreamEvent{
-				Type:  "content_block_delta",
-				Index: 0,
-				Delta: &schema.AnthropicStreamDelta{
-					Type: "text_delta",
-					Text: token,
-				},
-			}
-			sendAnthropicSSE(c, delta)
-		}
-		return true
-	}
-
-	predFunc, err := backend.ModelInference(
-		input.Context, predInput, openAIMessages, images, nil, nil, ml, cfg, nil, nil, tokenCallback, "", "", nil, nil, nil)
-	if err != nil {
-		xlog.Error("Anthropic stream model inference failed", "error", err)
-		return sendAnthropicError(c, 500, "api_error", fmt.Sprintf("model inference failed: %v", err))
-	}
-
-	prediction, err := predFunc()
-	if err != nil {
-		xlog.Error("Anthropic stream prediction failed", "error", err)
-		return sendAnthropicError(c, 500, "api_error", fmt.Sprintf("prediction failed: %v", err))
-	}
-
-	// Send content_block_stop event for last block if we didn't close it yet
-	if !inToolCall {
-		contentBlockStop := schema.AnthropicStreamEvent{
-			Type:  "content_block_stop",
-			Index: 0,
-		}
-		sendAnthropicSSE(c, contentBlockStop)
-	}
-
-	// Determine stop reason
-	stopReason := "end_turn"
-	if toolCallsEmitted > 0 {
-		stopReason = "tool_use"
-	}
-
-	// Send message_delta event with stop_reason
-	messageDelta := schema.AnthropicStreamEvent{
-		Type: "message_delta",
-		Delta: &schema.AnthropicStreamDelta{
-			StopReason: &stopReason,
-		},
-		Usage: &schema.AnthropicUsage{
-			OutputTokens: prediction.Usage.Completion,
-		},
-	}
-	sendAnthropicSSE(c, messageDelta)
-
-	// Send message_stop event
-	messageStop := schema.AnthropicStreamEvent{
-		Type: "message_stop",
-	}
-	sendAnthropicSSE(c, messageStop)
-
-	return nil
-}
-
-func sendAnthropicSSE(c echo.Context, event schema.AnthropicStreamEvent) {
-	data, err := json.Marshal(event)
-	if err != nil {
-		xlog.Error("Failed to marshal SSE event", "error", err)
-		return
-	}
-	fmt.Fprintf(c.Response().Writer, "event: %s\ndata: %s\n\n", event.Type, string(data))
-	c.Response().Flush()
-}
-
-func sendAnthropicError(c echo.Context, statusCode int, errorType, message string) error {
-	resp := schema.AnthropicErrorResponse{
-		Type: "error",
-		Error: schema.AnthropicError{
-			Type:    errorType,
-			Message: message,
-		},
-	}
-	return c.JSON(statusCode, resp)
-}
-
-func convertAnthropicToOpenAIMessages(input *schema.AnthropicRequest) []schema.Message {
-	var messages []schema.Message
-
-	// Add system message if present
-	if input.System != "" {
-		messages = append(messages, schema.Message{
-			Role:          "system",
-			StringContent: input.System,
-			Content:       input.System,
-		})
-	}
-
-	// Convert Anthropic messages to OpenAI format
-	for _, msg := range input.Messages {
-		openAIMsg := schema.Message{
-			Role: msg.Role,
-		}
-
-		// Handle content (can be string or array of content blocks)
-		switch content := msg.Content.(type) {
-		case string:
-			openAIMsg.StringContent = content
-			openAIMsg.Content = content
-		case []interface{}:
-			// Handle array of content blocks
-			var textContent string
-			var stringImages []string
-			var toolCalls []schema.ToolCall
-			toolCallIndex := 0
-
-			for _, block := range content {
-				if blockMap, ok := block.(map[string]interface{}); ok {
-					blockType, _ := blockMap["type"].(string)
-					switch blockType {
-					case "text":
-						if text, ok := blockMap["text"].(string); ok {
-							textContent += text
-						}
-					case "image":
-						// Handle image content
-						if source, ok := blockMap["source"].(map[string]interface{}); ok {
-							if sourceType, ok := source["type"].(string); ok && sourceType == "base64" {
-								if data, ok := source["data"].(string); ok {
-									mediaType, _ := source["media_type"].(string)
-									// Format as data URI
-									dataURI := fmt.Sprintf("data:%s;base64,%s", mediaType, data)
-									stringImages = append(stringImages, dataURI)
-								}
-							}
-						}
-					case "tool_use":
-						// Convert tool_use to ToolCall format
-						toolID, _ := blockMap["id"].(string)
-						toolName, _ := blockMap["name"].(string)
-						toolInput := blockMap["input"]
-						
-						// Serialize input to JSON string
-						inputJSON, err := json.Marshal(toolInput)
-						if err != nil {
-							xlog.Warn("Failed to marshal tool input", "error", err)
-							inputJSON = []byte("{}")
-						}
-						
-						toolCalls = append(toolCalls, schema.ToolCall{
-							Index: toolCallIndex,
-							ID:    toolID,
-							Type:  "function",
-							FunctionCall: schema.FunctionCall{
-								Name:      toolName,
-								Arguments: string(inputJSON),
-							},
-						})
-						toolCallIndex++
-					case "tool_result":
-						// Convert tool_result to a message with role "tool"
-						// This is handled by creating a separate message after this block
-						// For now, we'll add it as text content
-						toolUseID, _ := blockMap["tool_use_id"].(string)
-						isError := false
-						if isErrorPtr, ok := blockMap["is_error"].(*bool); ok && isErrorPtr != nil {
-							isError = *isErrorPtr
-						}
-						
-						var resultText string
-						if resultContent, ok := blockMap["content"]; ok {
-							switch rc := resultContent.(type) {
-							case string:
-								resultText = rc
-							case []interface{}:
-								// Array of content blocks
-								for _, cb := range rc {
-									if cbMap, ok := cb.(map[string]interface{}); ok {
-										if cbMap["type"] == "text" {
-											if text, ok := cbMap["text"].(string); ok {
-												resultText += text
-											}
-										}
-									}
-								}
-							}
-						}
-						
-						// Add tool result as a tool role message
-						// We need to handle this differently - create a new message
-						if msg.Role == "user" {
-							// Store tool result info for creating separate message
-							prefix := ""
-							if isError {
-								prefix = "Error: "
-							}
-							textContent += fmt.Sprintf("\n[Tool Result for %s]: %s%s", toolUseID, prefix, resultText)
-						}
-					}
-				}
-			}
-			openAIMsg.StringContent = textContent
-			openAIMsg.Content = textContent
-			openAIMsg.StringImages = stringImages
-			
-			// Add tool calls if present
-			if len(toolCalls) > 0 {
-				openAIMsg.ToolCalls = toolCalls
-			}
-		}
-
-		messages = append(messages, openAIMsg)
-	}
-
-	return messages
-}
-
-// convertAnthropicTools converts Anthropic tools to internal Functions format
-func convertAnthropicTools(input *schema.AnthropicRequest, cfg *config.ModelConfig) (functions.Functions, bool) {
-	if len(input.Tools) == 0 {
-		return nil, false
-	}
-	
-	var funcs functions.Functions
-	for _, tool := range input.Tools {
-		f := functions.Function{
-			Name:        tool.Name,
-			Description: tool.Description,
-			Parameters:  tool.InputSchema,
-		}
-		funcs = append(funcs, f)
-	}
-	
-	// Handle tool_choice
-	if input.ToolChoice != nil {
-		switch tc := input.ToolChoice.(type) {
-		case string:
-			// "auto", "any", or "none"
-			if tc == "any" {
-				// Force the model to use one of the tools
-				cfg.SetFunctionCallString("required")
-			} else if tc == "none" {
-				// Don't use tools
-				return nil, false
-			}
-			// "auto" is the default - let model decide
-		case map[string]interface{}:
-			// Specific tool selection: {"type": "tool", "name": "tool_name"}
-			if tcType, ok := tc["type"].(string); ok && tcType == "tool" {
-				if name, ok := tc["name"].(string); ok {
-					// Force specific tool
-					cfg.SetFunctionCallString(name)
-				}
-			}
-		}
-	}
-	
-	return funcs, len(funcs) > 0 && cfg.ShouldUseFunctions()
-}

core/http/endpoints/openai/chat.go

@@ -3,7 +3,6 @@ package openai
 import (
 	"encoding/json"
 	"fmt"
-	"strings"
 	"time"
 
 	"github.com/google/uuid"
@@ -35,54 +34,11 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 			Created: created,
 			Model:   req.Model, // we have to return what the user sent here, due to OpenAI spec.
 			Choices: []schema.Choice{{Delta: &schema.Message{Role: "assistant"}, Index: 0, FinishReason: nil}},
+			Object:  "chat.completion.chunk",
 		}
 		responses <- initialMessage
 
-		// Track accumulated content for reasoning extraction
-		accumulatedContent := ""
-		lastEmittedReasoning := ""
-		lastEmittedCleanedContent := ""
-
 		_, _, err := ComputeChoices(req, s, config, cl, startupOptions, loader, func(s string, c *[]schema.Choice) {}, func(s string, tokenUsage backend.TokenUsage) bool {
-			accumulatedContent += s
-			// Extract reasoning from accumulated content
-			currentReasoning, cleanedContent := functions.ExtractReasoning(accumulatedContent)
-
-			// Calculate new reasoning delta (what we haven't emitted yet)
-			var reasoningDelta *string
-			if currentReasoning != lastEmittedReasoning {
-				// Extract only the new part
-				if len(currentReasoning) > len(lastEmittedReasoning) && strings.HasPrefix(currentReasoning, lastEmittedReasoning) {
-					newReasoning := currentReasoning[len(lastEmittedReasoning):]
-					reasoningDelta = &newReasoning
-					lastEmittedReasoning = currentReasoning
-				} else if currentReasoning != "" {
-					// If reasoning changed in a non-append way, emit the full current reasoning
-					reasoningDelta = &currentReasoning
-					lastEmittedReasoning = currentReasoning
-				}
-			}
-
-			// Calculate content delta from cleaned content
-			var deltaContent string
-			if len(cleanedContent) > len(lastEmittedCleanedContent) && strings.HasPrefix(cleanedContent, lastEmittedCleanedContent) {
-				deltaContent = cleanedContent[len(lastEmittedCleanedContent):]
-				lastEmittedCleanedContent = cleanedContent
-			} else if cleanedContent != lastEmittedCleanedContent {
-				// If cleaned content changed but not in a simple append, extract delta from cleaned content
-				// This handles cases where thinking tags are removed mid-stream
-				if lastEmittedCleanedContent == "" {
-					deltaContent = cleanedContent
-					lastEmittedCleanedContent = cleanedContent
-				} else {
-					// Content changed in non-append way, use the new cleaned content
-					deltaContent = cleanedContent
-					lastEmittedCleanedContent = cleanedContent
-				}
-			}
-			// Only emit content if there's actual content (not just thinking tags)
-			// If deltaContent is empty, we still emit the response but with empty content
-
 			usage := schema.OpenAIUsage{
 				PromptTokens:     tokenUsage.Prompt,
 				CompletionTokens: tokenUsage.Completion,
@@ -93,20 +49,11 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 				usage.TimingPromptProcessing = tokenUsage.TimingPromptProcessing
 			}
 
-			delta := &schema.Message{}
-			// Only include content if there's actual content (not just thinking tags)
-			if deltaContent != "" {
-				delta.Content = &deltaContent
-			}
-			if reasoningDelta != nil && *reasoningDelta != "" {
-				delta.Reasoning = reasoningDelta
-			}
-
 			resp := schema.OpenAIResponse{
 				ID:      id,
 				Created: created,
 				Model:   req.Model, // we have to return what the user sent here, due to OpenAI spec.
-				Choices: []schema.Choice{{Delta: delta, Index: 0, FinishReason: nil}},
+				Choices: []schema.Choice{{Delta: &schema.Message{Content: &s}, Index: 0, FinishReason: nil}},
 				Object:  "chat.completion.chunk",
 				Usage:   usage,
 			}
@@ -119,120 +66,15 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 	}
 	processTools := func(noAction string, prompt string, req *schema.OpenAIRequest, config *config.ModelConfig, loader *model.ModelLoader, responses chan schema.OpenAIResponse, extraUsage bool) error {
 		result := ""
-		lastEmittedCount := 0
 		_, tokenUsage, err := ComputeChoices(req, prompt, config, cl, startupOptions, loader, func(s string, c *[]schema.Choice) {}, func(s string, usage backend.TokenUsage) bool {
 			result += s
-			// Try incremental XML parsing for streaming support using iterative parser
-			// This allows emitting partial tool calls as they're being generated
-			cleanedResult := functions.CleanupLLMResult(result, config.FunctionsConfig)
-
-			// Determine XML format from config
-			var xmlFormat *functions.XMLToolCallFormat
-			if config.FunctionsConfig.XMLFormat != nil {
-				xmlFormat = config.FunctionsConfig.XMLFormat
-			} else if config.FunctionsConfig.XMLFormatPreset != "" {
-				xmlFormat = functions.GetXMLFormatPreset(config.FunctionsConfig.XMLFormatPreset)
-			}
-
-			// Use iterative parser for streaming (partial parsing enabled)
-			// Try XML parsing first
-			partialResults, parseErr := functions.ParseXMLIterative(cleanedResult, xmlFormat, true)
-			if parseErr == nil && len(partialResults) > 0 {
-				// Emit new XML tool calls that weren't emitted before
-				if len(partialResults) > lastEmittedCount {
-					for i := lastEmittedCount; i < len(partialResults); i++ {
-						toolCall := partialResults[i]
-						initialMessage := schema.OpenAIResponse{
-							ID:      id,
-							Created: created,
-							Model:   req.Model,
-							Choices: []schema.Choice{{
-								Delta: &schema.Message{
-									Role: "assistant",
-									ToolCalls: []schema.ToolCall{
-										{
-											Index: i,
-											ID:    id,
-											Type:  "function",
-											FunctionCall: schema.FunctionCall{
-												Name: toolCall.Name,
-											},
-										},
-									},
-								},
-								Index:        0,
-								FinishReason: nil,
-							}},
-							Object: "chat.completion.chunk",
-						}
-						select {
-						case responses <- initialMessage:
-						default:
-						}
-					}
-					lastEmittedCount = len(partialResults)
-				}
-			} else {
-				// Try JSON tool call parsing for streaming
-				// Check if the result looks like JSON tool calls
-				jsonResults, jsonErr := functions.ParseJSONIterative(cleanedResult, true)
-				if jsonErr == nil && len(jsonResults) > 0 {
-					// Check if these are tool calls (have "name" and optionally "arguments")
-					for _, jsonObj := range jsonResults {
-						if name, ok := jsonObj["name"].(string); ok && name != "" {
-							// This looks like a tool call
-							args := "{}"
-							if argsVal, ok := jsonObj["arguments"]; ok {
-								if argsStr, ok := argsVal.(string); ok {
-									args = argsStr
-								} else {
-									argsBytes, _ := json.Marshal(argsVal)
-									args = string(argsBytes)
-								}
-							}
-							// Emit tool call
-							initialMessage := schema.OpenAIResponse{
-								ID:      id,
-								Created: created,
-								Model:   req.Model,
-								Choices: []schema.Choice{{
-									Delta: &schema.Message{
-										Role: "assistant",
-										ToolCalls: []schema.ToolCall{
-											{
-												Index: lastEmittedCount,
-												ID:    id,
-												Type:  "function",
-												FunctionCall: schema.FunctionCall{
-													Name:      name,
-													Arguments: args,
-												},
-											},
-										},
-									},
-									Index:        0,
-									FinishReason: nil,
-								}},
-								Object: "chat.completion.chunk",
-							}
-							select {
-							case responses <- initialMessage:
-							default:
-							}
-							lastEmittedCount++
-						}
-					}
-				}
-			}
+			// TODO: Change generated BNF grammar to be compliant with the schema so we can
+			// stream the result token by token here.
 			return true
 		})
 		if err != nil {
 			return err
 		}
-		// Extract reasoning before processing tool calls
-		reasoning, cleanedResult := functions.ExtractReasoning(result)
-		result = cleanedResult
-
 		textContentToReturn = functions.ParseTextContent(result, config.FunctionsConfig)
 		result = functions.CleanupLLMResult(result, config.FunctionsConfig)
 		functionResults := functions.ParseFunctionCall(result, config.FunctionsConfig)
@@ -265,20 +107,11 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 				usage.TimingPromptProcessing = tokenUsage.TimingPromptProcessing
 			}
 
-			var deltaReasoning *string
-			if reasoning != "" {
-				deltaReasoning = &reasoning
-			}
-			delta := &schema.Message{Content: &result}
-			if deltaReasoning != nil {
-				delta.Reasoning = deltaReasoning
-			}
-
 			resp := schema.OpenAIResponse{
 				ID:      id,
 				Created: created,
 				Model:   req.Model, // we have to return what the user sent here, due to OpenAI spec.
-				Choices: []schema.Choice{{Delta: delta, Index: 0, FinishReason: nil}},
+				Choices: []schema.Choice{{Delta: &schema.Message{Content: &result}, Index: 0, FinishReason: nil}},
 				Object:  "chat.completion.chunk",
 				Usage:   usage,
 			}
@@ -619,18 +452,10 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 		default:
 
 			tokenCallback := func(s string, c *[]schema.Choice) {
-				// Extract reasoning from the response
-				reasoning, cleanedS := functions.ExtractReasoning(s)
-				s = cleanedS
-
 				if !shouldUseFn {
 					// no function is called, just reply and use stop as finish reason
 					stopReason := FinishReasonStop
-					message := &schema.Message{Role: "assistant", Content: &s}
-					if reasoning != "" {
-						message.Reasoning = &reasoning
-					}
-					*c = append(*c, schema.Choice{FinishReason: &stopReason, Index: 0, Message: message})
+					*c = append(*c, schema.Choice{FinishReason: &stopReason, Index: 0, Message: &schema.Message{Role: "assistant", Content: &s}})
 					return
 				}
 
@@ -649,13 +474,9 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 					}
 
 					stopReason := FinishReasonStop
-					message := &schema.Message{Role: "assistant", Content: &result}
-					if reasoning != "" {
-						message.Reasoning = &reasoning
-					}
 					*c = append(*c, schema.Choice{
 						FinishReason: &stopReason,
-						Message:      message})
+						Message:      &schema.Message{Role: "assistant", Content: &result}})
 				default:
 					toolCallsReason := FinishReasonToolCalls
 					toolChoice := schema.Choice{
@@ -664,9 +485,6 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 							Role: "assistant",
 						},
 					}
-					if reasoning != "" {
-						toolChoice.Message.Reasoning = &reasoning
-					}
 
 					for _, ss := range results {
 						name, args := ss.Name, ss.Arguments
@@ -687,20 +505,16 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 						} else {
 							// otherwise we return more choices directly (deprecated)
 							functionCallReason := FinishReasonFunctionCall
-							message := &schema.Message{
-								Role:    "assistant",
-								Content: &textContentToReturn,
-								FunctionCall: map[string]interface{}{
-									"name":      name,
-									"arguments": args,
-								},
-							}
-							if reasoning != "" {
-								message.Reasoning = &reasoning
-							}
 							*c = append(*c, schema.Choice{
 								FinishReason: &functionCallReason,
-								Message:      message,
+								Message: &schema.Message{
+									Role:    "assistant",
+									Content: &textContentToReturn,
+									FunctionCall: map[string]interface{}{
+										"name":      name,
+										"arguments": args,
+									},
+								},
 							})
 						}
 					}
@@ -808,7 +622,9 @@ func handleQuestion(config *config.ModelConfig, cl *config.ModelConfigLoader, in
 	// Serialize tools and tool_choice to JSON strings
 	toolsJSON := ""
 	if len(input.Tools) > 0 {
-		toolsBytes, err := json.Marshal(input.Tools)
+		// Sanitize tools to remove null values from parameters.properties
+		sanitizedTools := functions.SanitizeTools(input.Tools)
+		toolsBytes, err := json.Marshal(sanitizedTools)
 		if err == nil {
 			toolsJSON = string(toolsBytes)
 		}

core/http/endpoints/openai/inference.go

@@ -7,6 +7,7 @@ import (
 	"github.com/mudler/LocalAI/core/config"
 
 	"github.com/mudler/LocalAI/core/schema"
+	"github.com/mudler/LocalAI/pkg/functions"
 	model "github.com/mudler/LocalAI/pkg/model"
 )
 
@@ -42,7 +43,9 @@ func ComputeChoices(
 	// Serialize tools and tool_choice to JSON strings
 	toolsJSON := ""
 	if len(req.Tools) > 0 {
-		toolsBytes, err := json.Marshal(req.Tools)
+		// Sanitize tools to remove null values from parameters.properties
+		sanitizedTools := functions.SanitizeTools(req.Tools)
+		toolsBytes, err := json.Marshal(sanitizedTools)
 		if err == nil {
 			toolsJSON = string(toolsBytes)
 		}

core/http/routes/anthropic.go

@@ -1,108 +0,0 @@
-package routes
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-
-	"github.com/google/uuid"
-	"github.com/labstack/echo/v4"
-	"github.com/mudler/LocalAI/core/application"
-	"github.com/mudler/LocalAI/core/config"
-	"github.com/mudler/LocalAI/core/http/endpoints/anthropic"
-	"github.com/mudler/LocalAI/core/http/middleware"
-	"github.com/mudler/LocalAI/core/schema"
-	"github.com/mudler/xlog"
-)
-
-func RegisterAnthropicRoutes(app *echo.Echo,
-	re *middleware.RequestExtractor,
-	application *application.Application) {
-
-	// Anthropic Messages API endpoint
-	messagesHandler := anthropic.MessagesEndpoint(
-		application.ModelConfigLoader(),
-		application.ModelLoader(),
-		application.TemplatesEvaluator(),
-		application.ApplicationConfig(),
-	)
-
-	messagesMiddleware := []echo.MiddlewareFunc{
-		middleware.TraceMiddleware(application),
-		re.BuildFilteredFirstAvailableDefaultModel(config.BuildUsecaseFilterFn(config.FLAG_CHAT)),
-		re.SetModelAndConfig(func() schema.LocalAIRequest { return new(schema.AnthropicRequest) }),
-		setAnthropicRequestContext(application.ApplicationConfig()),
-	}
-
-	// Main Anthropic endpoint
-	app.POST("/v1/messages", messagesHandler, messagesMiddleware...)
-
-	// Also support without version prefix for compatibility
-	app.POST("/messages", messagesHandler, messagesMiddleware...)
-}
-
-// setAnthropicRequestContext sets up the context and cancel function for Anthropic requests
-func setAnthropicRequestContext(appConfig *config.ApplicationConfig) echo.MiddlewareFunc {
-	return func(next echo.HandlerFunc) echo.HandlerFunc {
-		return func(c echo.Context) error {
-			input, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_LOCALAI_REQUEST).(*schema.AnthropicRequest)
-			if !ok || input.Model == "" {
-				return echo.NewHTTPError(http.StatusBadRequest, "model is required")
-			}
-
-			cfg, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_MODEL_CONFIG).(*config.ModelConfig)
-			if !ok || cfg == nil {
-				return echo.NewHTTPError(http.StatusBadRequest, "model configuration not found")
-			}
-
-			// Extract or generate the correlation ID
-			// Anthropic uses x-request-id header
-			correlationID := c.Request().Header.Get("x-request-id")
-			if correlationID == "" {
-				correlationID = uuid.New().String()
-			}
-			c.Response().Header().Set("x-request-id", correlationID)
-
-			// Set up context with cancellation
-			reqCtx := c.Request().Context()
-			c1, cancel := context.WithCancel(appConfig.Context)
-
-			// Cancel when request context is cancelled (client disconnects)
-			go func() {
-				select {
-				case <-reqCtx.Done():
-					cancel()
-				case <-c1.Done():
-					// Already cancelled
-				}
-			}()
-
-			// Add the correlation ID to the new context
-			ctxWithCorrelationID := context.WithValue(c1, middleware.CorrelationIDKey, correlationID)
-
-			input.Context = ctxWithCorrelationID
-			input.Cancel = cancel
-
-			if cfg.Model == "" {
-				xlog.Debug("replacing empty cfg.Model with input value", "input.Model", input.Model)
-				cfg.Model = input.Model
-			}
-
-			c.Set(middleware.CONTEXT_LOCALS_KEY_LOCALAI_REQUEST, input)
-			c.Set(middleware.CONTEXT_LOCALS_KEY_MODEL_CONFIG, cfg)
-
-			// Log the Anthropic API version if provided
-			anthropicVersion := c.Request().Header.Get("anthropic-version")
-			if anthropicVersion != "" {
-				xlog.Debug("Anthropic API version", "version", anthropicVersion)
-			}
-
-			// Validate max_tokens is provided
-			if input.MaxTokens <= 0 {
-				return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("max_tokens is required and must be greater than 0"))
-			}
-
-			return next(c)
-		}
-	}
-}

core/http/static/chat.js

@@ -1368,7 +1368,6 @@ async function promptGPT(systemPrompt, input) {
     let lastAssistantMessageIndex = -1;
     let lastThinkingMessageIndex = -1;
     let lastThinkingScrollTime = 0;
-    let hasReasoningFromAPI = false; // Track if we're receiving reasoning from API (skip tag-based detection)
     const THINKING_SCROLL_THROTTLE = 200; // Throttle scrolling to every 200ms
 
     try {
@@ -1402,24 +1401,19 @@ async function promptGPT(systemPrompt, input) {
               // Handle different event types
               switch (eventData.type) {
                 case "reasoning":
-                  hasReasoningFromAPI = true; // Mark that we're receiving reasoning from API
                   if (eventData.content) {
-                    const currentChat = chatStore.getChat(chatId);
-                    if (!currentChat) break; // Chat was deleted
-                    const isMCPMode = currentChat.mcpMode || false;
-                    const shouldExpand = !isMCPMode; // Expanded in non-MCP mode, collapsed in MCP mode
-                    // Insert thinking before assistant message if it exists (always use "thinking" role)
+                    // Insert reasoning before assistant message if it exists
                     if (lastAssistantMessageIndex >= 0 && targetHistory[lastAssistantMessageIndex]?.role === "assistant") {
                       targetHistory.splice(lastAssistantMessageIndex, 0, {
-                        role: "thinking",
+                        role: "reasoning",
                         content: eventData.content,
                         html: DOMPurify.sanitize(marked.parse(eventData.content)),
                         image: [],
                         audio: [],
-                        expanded: shouldExpand
+                        expanded: false // Reasoning is always collapsed
                       });
                       lastAssistantMessageIndex++; // Adjust index since we inserted
-                      // Scroll smoothly after adding thinking
+                      // Scroll smoothly after adding reasoning
                       setTimeout(() => {
                         const chatContainer = document.getElementById('chat');
                         if (chatContainer) {
@@ -1431,7 +1425,7 @@ async function promptGPT(systemPrompt, input) {
                       }, 100);
                     } else {
                       // No assistant message yet, just add normally
-                      chatStore.add("thinking", eventData.content, null, null, chatId);
+                      chatStore.add("reasoning", eventData.content, null, null, chatId);
                     }
                   }
                   break;
@@ -1497,17 +1491,14 @@ async function promptGPT(systemPrompt, input) {
                     // Only update display if this is the active chat (interval will handle it)
                     // Don't call updateTokensPerSecond here to avoid unnecessary updates
                     
-                    // Only check for thinking tags if we're NOT receiving reasoning from API
-                    // This prevents duplicate thinking/reasoning messages
-                    if (!hasReasoningFromAPI) {
-                      // Check for thinking tags in the chunk (incremental detection)
-                      if (contentChunk.includes("<thinking>") || contentChunk.includes("<think>")) {
-                        isThinking = true;
-                        thinkingContent = "";
-                        lastThinkingMessageIndex = -1;
-                      }
-                      
-                      if (contentChunk.includes("</thinking>") || contentChunk.includes("</think>")) {
+                    // Check for thinking tags in the chunk (incremental detection)
+                    if (contentChunk.includes("<thinking>") || contentChunk.includes("<think>")) {
+                      isThinking = true;
+                      thinkingContent = "";
+                      lastThinkingMessageIndex = -1;
+                    }
+                    
+                    if (contentChunk.includes("</thinking>") || contentChunk.includes("</think>")) {
                       isThinking = false;
                       // When closing tag is detected, process the accumulated thinking content
                       if (thinkingContent.trim()) {
@@ -1561,11 +1552,10 @@ async function promptGPT(systemPrompt, input) {
                         }
                         thinkingContent = "";
                       }
-                      }
                     }
                     
-                    // Handle content based on thinking state (only if not receiving reasoning from API)
-                    if (!hasReasoningFromAPI && isThinking) {
+                    // Handle content based on thinking state
+                    if (isThinking) {
                       thinkingContent += contentChunk;
                       const currentChat = chatStore.getChat(chatId);
                       if (!currentChat) break; // Chat was deleted
@@ -1647,10 +1637,7 @@ async function promptGPT(systemPrompt, input) {
           
           // Process any thinking tags that might be in the accumulated content
           // This handles cases where tags are split across chunks
-          // Only process if we're NOT receiving reasoning from API (to avoid duplicates)
-          const { regularContent: processedRegular, thinkingContent: processedThinking } = hasReasoningFromAPI
-            ? { regularContent: regularContent, thinkingContent: "" }
-            : processThinkingTags(regularContent);
+          const { regularContent: processedRegular, thinkingContent: processedThinking } = processThinkingTags(regularContent);
           
           // Update or create assistant message with processed regular content
           const currentChat = chatStore.getChat(chatId);
@@ -1658,10 +1645,10 @@ async function promptGPT(systemPrompt, input) {
           const request = activeRequests.get(chatId);
           const requestModel = request?.model || null;
           if (lastAssistantMessageIndex === -1) {
-            // Create assistant message if we have any content (even if empty string after processing)
-            // This ensures the message is created and can be updated with more content later
-            chatStore.add("assistant", processedRegular || "", null, null, chatId, requestModel);
-            lastAssistantMessageIndex = targetHistory.length - 1;
+            if (processedRegular && processedRegular.trim()) {
+              chatStore.add("assistant", processedRegular, null, null, chatId, requestModel);
+              lastAssistantMessageIndex = targetHistory.length - 1;
+            }
           } else {
             const lastMessage = targetHistory[lastAssistantMessageIndex];
             if (lastMessage && lastMessage.role === "assistant") {
@@ -1699,10 +1686,7 @@ async function promptGPT(systemPrompt, input) {
       if (assistantContentBuffer.length > 0) {
         const regularContent = assistantContentBuffer.join("");
         // Process any remaining thinking tags that might be in the buffer
-        // Only process if we're NOT receiving reasoning from API (to avoid duplicates)
-        const { regularContent: processedRegular, thinkingContent: processedThinking } = hasReasoningFromAPI
-          ? { regularContent: regularContent, thinkingContent: "" }
-          : processThinkingTags(regularContent);
+        const { regularContent: processedRegular, thinkingContent: processedThinking } = processThinkingTags(regularContent);
         
         const currentChat = chatStore.getChat(chatId);
         if (!currentChat) {
@@ -1735,26 +1719,23 @@ async function promptGPT(systemPrompt, input) {
         }
         
         // Then update or create assistant message
-        // Always create/update assistant message if we have any content
         if (lastAssistantMessageIndex !== -1) {
           const lastMessage = targetHistory[lastAssistantMessageIndex];
           if (lastMessage && lastMessage.role === "assistant") {
             lastMessage.content = (lastMessage.content || "") + (processedRegular || "");
             lastMessage.html = DOMPurify.sanitize(marked.parse(lastMessage.content));
           }
-        } else {
-          // Create assistant message (even if empty, so it can be updated with more content)
+        } else if (processedRegular && processedRegular.trim()) {
           const request = activeRequests.get(chatId);
           const requestModel = request?.model || null;
-          chatStore.add("assistant", processedRegular || "", null, null, chatId, requestModel);
+          chatStore.add("assistant", processedRegular, null, null, chatId, requestModel);
           lastAssistantMessageIndex = targetHistory.length - 1;
         }
       }
       
       // Final thinking content flush if any data remains (from incremental detection)
-      // Only process if we're NOT receiving reasoning from API (to avoid duplicates)
       const finalChat = chatStore.getChat(chatId);
-      if (finalChat && !hasReasoningFromAPI && thinkingContent.trim() && lastThinkingMessageIndex === -1) {
+      if (finalChat && thinkingContent.trim() && lastThinkingMessageIndex === -1) {
         const finalHistory = finalChat.history;
         // Extract thinking content if tags are present
         const thinkingMatch = thinkingContent.match(/<(?:thinking|redacted_reasoning)>(.*?)<\/(?:thinking|redacted_reasoning)>/s);
@@ -1910,13 +1891,9 @@ async function promptGPT(systemPrompt, input) {
     let buffer = "";
     let contentBuffer = [];
     let thinkingContent = "";
-    let reasoningContent = ""; // Track reasoning from API reasoning field
     let isThinking = false;
     let lastThinkingMessageIndex = -1;
-    let lastReasoningMessageIndex = -1; // Track reasoning message separately
-    let lastAssistantMessageIndex = -1; // Track assistant message for reasoning placement
     let lastThinkingScrollTime = 0;
-    let hasReasoningFromAPI = false; // Track if we're receiving reasoning from API (skip tag-based detection)
     const THINKING_SCROLL_THROTTLE = 200; // Throttle scrolling to every 200ms
 
     try {
@@ -1952,100 +1929,30 @@ async function promptGPT(systemPrompt, input) {
                 chatStore.updateTokenUsage(jsonData.usage, chatId);
               }
               
-              const token = jsonData.choices?.[0]?.delta?.content;
-              const reasoningDelta = jsonData.choices?.[0]?.delta?.reasoning;
+              const token = jsonData.choices[0].delta.content;
 
-              // Handle reasoning from API reasoning field - always use "thinking" role
-              if (reasoningDelta && reasoningDelta.trim() !== "") {
-                hasReasoningFromAPI = true; // Mark that we're receiving reasoning from API
-                reasoningContent += reasoningDelta;
-                const currentChat = chatStore.getChat(chatId);
-                if (!currentChat) {
-                  // Chat was deleted, skip this line
+              if (token) {
+                // Check for thinking tags
+                if (token.includes("<thinking>") || token.includes("<think>")) {
+                  isThinking = true;
+                  thinkingContent = "";
+                  lastThinkingMessageIndex = -1;
                   return;
                 }
-                const isMCPMode = currentChat.mcpMode || false;
-                const shouldExpand = !isMCPMode; // Expanded in non-MCP mode, collapsed in MCP mode
-                
-                // Only create/update thinking message if we have actual content
-                if (reasoningContent.trim() !== "") {
-                  // Update or create thinking message (always use "thinking" role, not "reasoning")
-                  if (lastReasoningMessageIndex === -1) {
-                    // Find the last assistant message index to insert thinking before it
-                    const targetHistory = currentChat.history;
-                    const assistantIndex = targetHistory.length - 1;
-                    if (assistantIndex >= 0 && targetHistory[assistantIndex]?.role === "assistant") {
-                      // Insert thinking before assistant message
-                      targetHistory.splice(assistantIndex, 0, {
-                        role: "thinking",
-                        content: reasoningContent,
-                        html: DOMPurify.sanitize(marked.parse(reasoningContent)),
-                        image: [],
-                        audio: [],
-                        expanded: shouldExpand
-                      });
-                      lastReasoningMessageIndex = assistantIndex;
-                      lastAssistantMessageIndex = assistantIndex + 1; // Adjust for inserted thinking
-                    } else {
-                      // No assistant message yet, just add normally
-                      chatStore.add("thinking", reasoningContent, null, null, chatId);
-                      lastReasoningMessageIndex = currentChat.history.length - 1;
-                    }
-                  } else {
-                    // Update existing thinking message
-                    const targetHistory = currentChat.history;
-                    if (lastReasoningMessageIndex >= 0 && lastReasoningMessageIndex < targetHistory.length) {
-                      const thinkingMessage = targetHistory[lastReasoningMessageIndex];
-                      if (thinkingMessage && thinkingMessage.role === "thinking") {
-                        thinkingMessage.content = reasoningContent;
-                        thinkingMessage.html = DOMPurify.sanitize(marked.parse(reasoningContent));
-                      }
+                if (token.includes("</thinking>") || token.includes("</think>")) {
+                  isThinking = false;
+                  if (thinkingContent.trim()) {
+                    // Only add the final thinking message if we don't already have one
+                    if (lastThinkingMessageIndex === -1) {
+                      chatStore.add("thinking", thinkingContent, null, null, chatId);
                     }
                   }
+                  return;
                 }
-                
-                // Scroll when reasoning is updated (throttled)
-                const now = Date.now();
-                if (now - lastThinkingScrollTime > THINKING_SCROLL_THROTTLE) {
-                  lastThinkingScrollTime = now;
-                  setTimeout(() => {
-                    const chatContainer = document.getElementById('chat');
-                    if (chatContainer) {
-                      chatContainer.scrollTo({
-                        top: chatContainer.scrollHeight,
-                        behavior: 'smooth'
-                      });
-                    }
-                    scrollThinkingBoxToBottom();
-                  }, 100);
-                }
-              }
 
-              if (token && token.trim() !== "") {
-                // Only check for thinking tags if we're NOT receiving reasoning from API
-                // This prevents duplicate thinking/reasoning messages
-                if (!hasReasoningFromAPI) {
-                  // Check for thinking tags (legacy support - models that output tags directly)
-                  if (token.includes("<thinking>") || token.includes("<think>")) {
-                    isThinking = true;
-                    thinkingContent = "";
-                    lastThinkingMessageIndex = -1;
-                    return;
-                  }
-                  if (token.includes("</thinking>") || token.includes("</think>")) {
-                    isThinking = false;
-                    if (thinkingContent.trim()) {
-                      // Only add the final thinking message if we don't already have one
-                      if (lastThinkingMessageIndex === -1) {
-                        chatStore.add("thinking", thinkingContent, null, null, chatId);
-                      }
-                    }
-                    return;
-                  }
-
-                  // Handle content based on thinking state
-                  if (isThinking) {
-                    thinkingContent += token;
+                // Handle content based on thinking state
+                if (isThinking) {
+                  thinkingContent += token;
                   // Count tokens for rate calculation (per chat)
                   const request = activeRequests.get(chatId);
                   if (request) {
@@ -2088,42 +1995,7 @@ async function promptGPT(systemPrompt, input) {
                     }, 100);
                   }
                 } else {
-                  // Not in thinking state, add to content buffer
                   contentBuffer.push(token);
-                  // Track assistant message index for reasoning placement
-                  if (lastAssistantMessageIndex === -1) {
-                    const currentChat = chatStore.getChat(chatId);
-                    if (currentChat) {
-                      const targetHistory = currentChat.history;
-                      // Find or create assistant message index
-                      for (let i = targetHistory.length - 1; i >= 0; i--) {
-                        if (targetHistory[i].role === "assistant") {
-                          lastAssistantMessageIndex = i;
-                          break;
-                        }
-                      }
-                      // If no assistant message yet, it will be created when we flush contentBuffer
-                    }
-                  }
-                }
-                } else {
-                  // Receiving reasoning from API, just add token to content buffer
-                  contentBuffer.push(token);
-                  // Track assistant message index for reasoning placement
-                  if (lastAssistantMessageIndex === -1) {
-                    const currentChat = chatStore.getChat(chatId);
-                    if (currentChat) {
-                      const targetHistory = currentChat.history;
-                      // Find or create assistant message index
-                      for (let i = targetHistory.length - 1; i >= 0; i--) {
-                        if (targetHistory[i].role === "assistant") {
-                          lastAssistantMessageIndex = i;
-                          break;
-                        }
-                      }
-                      // If no assistant message yet, it will be created when we flush contentBuffer
-                    }
-                  }
                 }
               }
             } catch (error) {
@@ -2135,17 +2007,6 @@ async function promptGPT(systemPrompt, input) {
         // Efficiently update the chat in batch
         if (contentBuffer.length > 0) {
           addToChat(contentBuffer.join(""));
-          // Update assistant message index after adding content
-          const currentChat = chatStore.getChat(chatId);
-          if (currentChat) {
-            const targetHistory = currentChat.history;
-            for (let i = targetHistory.length - 1; i >= 0; i--) {
-              if (targetHistory[i].role === "assistant") {
-                lastAssistantMessageIndex = i;
-                break;
-              }
-            }
-          }
           contentBuffer = [];
           // Scroll when assistant content is updated (this will also show thinking messages above)
           setTimeout(() => {
@@ -2164,30 +2025,7 @@ async function promptGPT(systemPrompt, input) {
       if (contentBuffer.length > 0) {
         addToChat(contentBuffer.join(""));
       }
-      
-      // Final reasoning flush if any data remains - always use "thinking" role
       const finalChat = chatStore.getChat(chatId);
-      if (finalChat && reasoningContent.trim() && lastReasoningMessageIndex === -1) {
-        const isMCPMode = finalChat.mcpMode || false;
-        const shouldExpand = !isMCPMode;
-        const targetHistory = finalChat.history;
-        // Find assistant message to insert before
-        const assistantIndex = targetHistory.length - 1;
-        if (assistantIndex >= 0 && targetHistory[assistantIndex]?.role === "assistant") {
-          targetHistory.splice(assistantIndex, 0, {
-            role: "thinking",
-            content: reasoningContent,
-            html: DOMPurify.sanitize(marked.parse(reasoningContent)),
-            image: [],
-            audio: [],
-            expanded: shouldExpand
-          });
-        } else {
-          chatStore.add("thinking", reasoningContent, null, null, chatId);
-        }
-      }
-      
-      // Final thinking content flush (legacy tag-based thinking)
       if (finalChat && thinkingContent.trim() && lastThinkingMessageIndex === -1) {
         chatStore.add("thinking", thinkingContent, null, null, chatId);
       }

core/http/static/image.js

@@ -154,7 +154,7 @@ async function promptDallE() {
     if (json.data && json.data.length > 0) {
       json.data.forEach((item, index) => {
         const imageContainer = document.createElement("div");
-        imageContainer.className = "flex flex-col";
+        imageContainer.className = "mb-4 bg-[var(--color-bg-primary)]/50 border border-[#1E293B] rounded-lg p-2";
 
         // Create image element
         const img = document.createElement("img");
@@ -166,23 +166,23 @@ async function promptDallE() {
           return; // Skip invalid items
         }
         img.alt = prompt;
-        img.className = "w-full h-auto rounded-lg";
+        img.className = "w-full h-auto rounded-lg mb-2";
         imageContainer.appendChild(img);
 
-        // Create caption container (optional, can be collapsed or shown on hover)
+        // Create caption container
         const captionDiv = document.createElement("div");
-        captionDiv.className = "mt-2 p-2 bg-[var(--color-bg-secondary)] rounded-lg text-xs";
+        captionDiv.className = "mt-2 p-2 bg-[var(--color-bg-secondary)] rounded-lg";
 
         // Prompt caption
         const promptCaption = document.createElement("p");
-        promptCaption.className = "text-[var(--color-text-primary)] mb-1.5 break-words";
+        promptCaption.className = "text-xs text-[var(--color-text-primary)] mb-1.5";
         promptCaption.innerHTML = '<strong>Prompt:</strong> ' + escapeHtml(prompt);
         captionDiv.appendChild(promptCaption);
 
         // Negative prompt if provided
         if (negativePrompt) {
           const negativeCaption = document.createElement("p");
-          negativeCaption.className = "text-[var(--color-text-secondary)] mb-1.5 break-words";
+          negativeCaption.className = "text-xs text-[var(--color-text-secondary)] mb-1.5";
           negativeCaption.innerHTML = '<strong>Negative Prompt:</strong> ' + escapeHtml(negativePrompt);
           captionDiv.appendChild(negativeCaption);
         }

core/http/views/chat.html

@@ -41,7 +41,7 @@ SOFTWARE.
     __chatContextSize = {{ .ContextSize }};
     {{ end }}
 
-    // Store gallery configs for header icon display and model info modal
+    // Store gallery configs for header icon display
     window.__galleryConfigs = {};
     {{ $allGalleryConfigs:=.GalleryConfig }}
     {{ range $modelName, $galleryConfig := $allGalleryConfigs }}
@@ -49,16 +49,6 @@ SOFTWARE.
     {{ if $galleryConfig.Icon }}
     window.__galleryConfigs["{{$modelName}}"].Icon = "{{$galleryConfig.Icon}}";
     {{ end }}
-    {{ if $galleryConfig.Description }}
-    window.__galleryConfigs["{{$modelName}}"].Description = {{ printf "%q" $galleryConfig.Description }};
-    {{ end }}
-    {{ if $galleryConfig.URLs }}
-    window.__galleryConfigs["{{$modelName}}"].URLs = [
-      {{ range $idx, $url := $galleryConfig.URLs }}
-      {{ if $idx }},{{ end }}{{ printf "%q" $url }}
-      {{ end }}
-    ];
-    {{ end }}
     {{ end }}
 
     // Function to initialize store
@@ -336,10 +326,10 @@ SOFTWARE.
                 c += DOMPurify.sanitize(marked.parse(line));
               });
             }
-            // Set expanded state: thinking and reasoning are expanded by default in non-MCP mode, collapsed in MCP mode
-            // tool_call and tool_result are always collapsed by default
+            // Set expanded state: thinking is expanded by default in non-MCP mode, collapsed in MCP mode
+            // Reasoning, tool_call, and tool_result are always collapsed by default
             const isMCPMode = chat.mcpMode || false;
-            const shouldExpand = ((role === "thinking" || role === "reasoning") && !isMCPMode) || false;
+            const shouldExpand = (role === "thinking" && !isMCPMode) || false;
             chat.history.push({ role, content, html: c, image, audio, expanded: shouldExpand, model: messageModel });
             
             // Auto-name chat from first user message
@@ -507,11 +497,6 @@ SOFTWARE.
       activeChat.model = modelName;
       activeChat.updatedAt = Date.now();
       
-      // Update model info modal with new model
-      if (window.updateModelInfoModal) {
-        window.updateModelInfoModal(modelName);
-      }
-      
       // Get context size from data attribute
       let contextSize = null;
       if (selectedOption.dataset.contextSize) {
@@ -551,23 +536,18 @@ SOFTWARE.
       }
       
       // Update model selector to reflect the change (ensure it stays in sync)
-      // Note: We don't dispatch a change event here to avoid infinite loop
-      // The selector is already updated via user interaction or programmatic change
       const modelSelector = document.getElementById('modelSelector');
       if (modelSelector) {
         // Find and select the option matching the model
         const optionValue = 'chat/' + modelName;
         for (let i = 0; i < modelSelector.options.length; i++) {
           if (modelSelector.options[i].value === optionValue) {
-            // Only update if it's different to avoid unnecessary updates
-            if (modelSelector.selectedIndex !== i) {
-              modelSelector.selectedIndex = i;
-            }
+            modelSelector.selectedIndex = i;
             break;
           }
         }
-        // Don't dispatch change event here - it would cause infinite recursion
-        // The selector is already in sync with the model
+        // Trigger Alpine reactivity by dispatching change event
+        modelSelector.dispatchEvent(new Event('change', { bubbles: true }));
       }
       
       // Trigger MCP availability check in Alpine component
@@ -623,52 +603,27 @@ SOFTWARE.
             <div class="flex items-center justify-between gap-2">
               <label class="text-xs font-medium text-[var(--color-text-secondary)] uppercase tracking-wide flex-shrink-0">Model</label>
               <div class="flex items-center gap-1 flex-shrink-0">
-                <!-- Info button - reactive to active chat model -->
-                <template x-if="$store.chat.activeChat() && $store.chat.activeChat().model && window.__galleryConfigs && window.__galleryConfigs[$store.chat.activeChat().model]">
-                  <button 
-                    data-twe-ripple-init 
-                    data-twe-ripple-color="light" 
-                    class="text-[var(--color-text-secondary)] hover:text-[var(--color-primary)] transition-colors text-xs p-1 rounded hover:bg-[var(--color-bg-primary)]" 
-                    data-modal-target="model-info-modal" 
-                    data-modal-toggle="model-info-modal"
-                    :data-model-name="$store.chat.activeChat().model"
-                    @click="if (window.updateModelInfoModal) { window.updateModelInfoModal($store.chat.activeChat().model, true); }"
-                    title="Model Information">
-                    <i class="fas fa-info-circle"></i>
-                  </button>
-                </template>
-                <!-- Fallback info button for initial model from server -->
-                <template x-if="(!$store.chat.activeChat() || !$store.chat.activeChat().model) && window.__galleryConfigs && window.__galleryConfigs['{{$model}}']">
-                  <button 
-                    data-twe-ripple-init 
-                    data-twe-ripple-color="light" 
-                    class="text-[var(--color-text-secondary)] hover:text-[var(--color-primary)] transition-colors text-xs p-1 rounded hover:bg-[var(--color-bg-primary)]" 
-                    data-modal-target="model-info-modal" 
-                    data-modal-toggle="model-info-modal"
-                    data-model-name="{{$model}}"
-                    @click="if (window.updateModelInfoModal) { window.updateModelInfoModal('{{$model}}', true); }"
-                    title="Model Information">
-                    <i class="fas fa-info-circle"></i>
-                  </button>
-                </template>
-                <!-- Edit button - reactive to active chat model -->
-                <template x-if="$store.chat.activeChat() && $store.chat.activeChat().model">
-                  <a :href="'/models/edit/' + $store.chat.activeChat().model" 
-                     class="text-[var(--color-text-secondary)] hover:text-[var(--color-warning)] transition-colors text-xs p-1 rounded hover:bg-[var(--color-bg-primary)]" 
-                     title="Edit Model Configuration">
-                    <i class="fas fa-edit"></i>
-                  </a>
-                </template>
-                <!-- Fallback edit button for initial model from server -->
-                <template x-if="!$store.chat.activeChat() || !$store.chat.activeChat().model">
-                  {{ if $model }}
-                  <a href="/models/edit/{{$model}}" 
-                     class="text-[var(--color-text-secondary)] hover:text-[var(--color-warning)] transition-colors text-xs p-1 rounded hover:bg-[var(--color-bg-primary)]" 
-                     title="Edit Model Configuration">
-                    <i class="fas fa-edit"></i>
-                  </a>
-                  {{ end }}
-                </template>
+                {{ if $model }}
+                {{ $galleryConfig:= index $allGalleryConfigs $model}}
+                {{ if $galleryConfig }}
+                <button 
+                  data-twe-ripple-init 
+                  data-twe-ripple-color="light" 
+                  class="text-[var(--color-text-secondary)] hover:text-[var(--color-primary)] transition-colors text-xs p-1 rounded hover:bg-[var(--color-bg-primary)]" 
+                  data-modal-target="model-info-modal" 
+                  data-modal-toggle="model-info-modal"
+                  title="Model Information">
+                  <i class="fas fa-info-circle"></i>
+                </button>
+                {{ end }}
+                {{ end }}
+                {{ if $model }}
+                <a href="/models/edit/{{$model}}" 
+                   class="text-[var(--color-text-secondary)] hover:text-[var(--color-warning)] transition-colors text-xs p-1 rounded hover:bg-[var(--color-bg-primary)]" 
+                   title="Edit Model Configuration">
+                  <i class="fas fa-edit"></i>
+                </a>
+                {{ end }}
               </div>
             </div>
             <select
@@ -1533,14 +1488,17 @@ SOFTWARE.
       </div>
     </div>
 
-    <!-- Modal moved outside of sidebar to appear in center of page - Always available, content updated dynamically -->
-    <div id="model-info-modal" tabindex="-1" aria-hidden="true" class="hidden overflow-y-auto overflow-x-hidden fixed top-0 right-0 left-0 z-50 flex justify-center items-center w-full h-full md:inset-0 max-h-full" style="padding: 1rem;">
+    <!-- Modal moved outside of sidebar to appear in center of page -->
+    {{ if $model }}
+    {{ $galleryConfig:= index $allGalleryConfigs $model}}
+    {{ if $galleryConfig }}
+    <div id="model-info-modal" tabindex="-1" aria-hidden="true" class="hidden overflow-y-auto overflow-x-hidden fixed top-0 right-0 left-0 z-50 flex justify-center items-center w-full md:inset-0 h-[calc(100%-1rem)] max-h-full">
       <div class="relative p-4 w-full max-w-2xl max-h-full">
         <div class="relative p-4 w-full max-w-2xl max-h-full bg-white rounded-lg shadow dark:bg-gray-700">
           <!-- Header -->
           <div class="flex items-center justify-between p-4 md:p-5 border-b rounded-t dark:border-gray-600">
-            <h3 id="model-info-modal-title" class="text-xl font-semibold text-gray-900 dark:text-white">{{ if $model }}{{ $model }}{{ end }}</h3>
-            <button class="text-gray-400 bg-transparent hover:bg-gray-200 hover:text-gray-900 rounded-lg text-sm w-8 h-8 ms-auto inline-flex justify-center items-center dark:hover:bg-gray-600 dark:hover:text-white" data-modal-hide="model-info-modal" @click="if (window.closeModelInfoModal) { window.closeModelInfoModal(); }">
+            <h3 class="text-xl font-semibold text-gray-900 dark:text-white">{{ $model }}</h3>
+            <button class="text-gray-400 bg-transparent hover:bg-gray-200 hover:text-gray-900 rounded-lg text-sm w-8 h-8 ms-auto inline-flex justify-center items-center dark:hover:bg-gray-600 dark:hover:text-white" data-modal-hide="model-info-modal">
               <svg class="w-3 h-3" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 14 14">
                 <path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="m1 1 6 6m0 0 6 6M7 7l6-6M7 7l-6 6"/>
               </svg>
@@ -1551,24 +1509,29 @@ SOFTWARE.
           <!-- Body -->
           <div class="p-4 md:p-5 space-y-4">
             <div class="flex justify-center items-center">
-              <img id="model-info-modal-icon" class="lazy rounded-t-lg max-h-48 max-w-96 object-cover mt-3 entered loaded" style="display: none;" loading="lazy"/>
+              {{ if $galleryConfig.Icon }}<img class="lazy rounded-t-lg max-h-48 max-w-96 object-cover mt-3 entered loaded" src="{{$galleryConfig.Icon}}" loading="lazy"/>{{end}}
             </div>
-            <div id="model-info-description" class="text-base leading-relaxed text-gray-500 dark:text-gray-400 break-words max-w-full"></div>
+            <div id="model-info-description" class="text-base leading-relaxed text-gray-500 dark:text-gray-400 break-words max-w-full">{{ $galleryConfig.Description }}</div>
             <hr>
             <p class="text-sm font-semibold text-gray-900 dark:text-white">Links</p>
-            <ul id="model-info-links">
+            <ul>
+              {{range $galleryConfig.URLs}}
+              <li><a href="{{ . }}" target="_blank">{{ . }}</a></li>
+              {{end}}
             </ul>
           </div>
 
           <!-- Footer -->
           <div class="flex items-center p-4 md:p-5 border-t border-gray-200 rounded-b dark:border-gray-600">
-            <button data-modal-hide="model-info-modal" class="py-2.5 px-5 ms-3 text-sm font-medium text-gray-900 focus:outline-none bg-white rounded-lg border border-gray-200 hover:bg-gray-100 hover:text-blue-700 focus:z-10 focus:ring-4 focus:ring-gray-100 dark:focus:ring-gray-700 dark:bg-gray-800 dark:text-gray-400 dark:border-gray-600 dark:hover:text-white dark:hover:bg-gray-700" @click="if (window.closeModelInfoModal) { window.closeModelInfoModal(); }">
+            <button data-modal-hide="model-info-modal" class="py-2.5 px-5 ms-3 text-sm font-medium text-gray-900 focus:outline-none bg-white rounded-lg border border-gray-200 hover:bg-gray-100 hover:text-blue-700 focus:z-10 focus:ring-4 focus:ring-gray-100 dark:focus:ring-gray-700 dark:bg-gray-800 dark:text-gray-400 dark:border-gray-600 dark:hover:text-white dark:hover:bg-gray-700">
               Close
             </button>
           </div>
         </div>
       </div>
     </div>
+    {{ end }}
+    {{ end }}
 
     <!-- Alpine store initialization and utilities -->
     <script>
@@ -1779,20 +1742,10 @@ SOFTWARE.
         });
 
         // Also listen for click events on modal toggle buttons
-        // Use event delegation to handle dynamically created buttons
-        document.addEventListener('click', (e) => {
-          const button = e.target.closest('[data-modal-toggle="model-info-modal"]');
-          if (button) {
-            // Update modal with current model before showing
-            if (window.Alpine && window.Alpine.store("chat")) {
-              const activeChat = window.Alpine.store("chat").activeChat();
-              const modelName = activeChat ? activeChat.model : (button.dataset.modelName || (document.getElementById("chat-model") ? document.getElementById("chat-model").value : null));
-              if (modelName && window.updateModelInfoModal) {
-                window.updateModelInfoModal(modelName, true);
-              }
-            }
+        document.querySelectorAll('[data-modal-toggle="model-info-modal"]').forEach(button => {
+          button.addEventListener('click', () => {
             setTimeout(processMarkdown, 300);
-          }
+          });
         });
 
         // Process on initial load if libraries are ready
@@ -1833,176 +1786,12 @@ SOFTWARE.
         syncModelSelectorOnLoad();
       }
 
-      // Function to update model info modal with current model
-      // Set openModal to true to actually open the modal, false to just update content
-      window.updateModelInfoModal = function(modelName, openModal = false) {
-        if (!modelName) {
-          return;
-        }
-        if (!window.__galleryConfigs) {
-          return;
-        }
-        
-        const galleryConfig = window.__galleryConfigs[modelName];
-        // Check if galleryConfig exists and has at least one property
-        if (!galleryConfig || Object.keys(galleryConfig).length === 0) {
-          // Still update the modal title even if no config, so user can see which model they clicked
-          const titleEl = document.getElementById('model-info-modal-title');
-          if (titleEl) {
-            titleEl.textContent = modelName;
-          }
-          // Show message that no info is available
-          const descEl = document.getElementById('model-info-description');
-          if (descEl) {
-            descEl.textContent = 'No additional information available for this model.';
-          }
-          const linksEl = document.getElementById('model-info-links');
-          if (linksEl) {
-            linksEl.innerHTML = '';
-          }
-          const iconEl = document.getElementById('model-info-modal-icon');
-          if (iconEl) {
-            iconEl.style.display = 'none';
-          }
-          // Only open the modal if explicitly requested
-          if (openModal) {
-            const modalElement = document.getElementById('model-info-modal');
-            if (modalElement) {
-              modalElement.classList.remove('hidden');
-              modalElement.setAttribute('aria-hidden', 'false');
-              // Add backdrop
-              let backdrop = document.querySelector('.modal-backdrop');
-              if (!backdrop) {
-                backdrop = document.createElement('div');
-                backdrop.className = 'modal-backdrop fixed inset-0 bg-gray-900 bg-opacity-50 dark:bg-opacity-80 z-40';
-                document.body.appendChild(backdrop);
-                backdrop.addEventListener('click', () => {
-                  closeModelInfoModal();
-                });
-              }
-            }
-          }
-          return;
-        }
-        
-        // Update modal title
-        const titleEl = document.getElementById('model-info-modal-title');
-        if (titleEl) {
-          titleEl.textContent = modelName;
-        }
-        
-        // Update icon
-        const iconEl = document.getElementById('model-info-modal-icon');
-        if (iconEl) {
-          if (galleryConfig.Icon) {
-            iconEl.src = galleryConfig.Icon;
-            iconEl.style.display = 'block';
-          } else {
-            iconEl.style.display = 'none';
-          }
-        }
-        
-        // Update description
-        const descEl = document.getElementById('model-info-description');
-        if (descEl) {
-          descEl.textContent = galleryConfig.Description || 'No description available.';
-        }
-        
-        // Update links
-        const linksEl = document.getElementById('model-info-links');
-        if (linksEl && galleryConfig.URLs && Array.isArray(galleryConfig.URLs) && galleryConfig.URLs.length > 0) {
-          linksEl.innerHTML = '';
-          galleryConfig.URLs.forEach(url => {
-            const li = document.createElement('li');
-            const a = document.createElement('a');
-            a.href = url;
-            a.target = '_blank';
-            a.textContent = url;
-            li.appendChild(a);
-            linksEl.appendChild(li);
-          });
-        } else if (linksEl) {
-          linksEl.innerHTML = '<li>No links available</li>';
-        }
-        
-        // Only open the modal if explicitly requested
-        if (openModal) {
-          const modalElement = document.getElementById('model-info-modal');
-          if (modalElement) {
-            // Ensure positioning classes are present (they might have been removed)
-            if (!modalElement.classList.contains('flex')) {
-              modalElement.classList.add('flex');
-            }
-            if (!modalElement.classList.contains('justify-center')) {
-              modalElement.classList.add('justify-center');
-            }
-            if (!modalElement.classList.contains('items-center')) {
-              modalElement.classList.add('items-center');
-            }
-            // Ensure fixed positioning
-            if (!modalElement.classList.contains('fixed')) {
-              modalElement.classList.add('fixed');
-            }
-            // Ensure full width and height
-            if (!modalElement.classList.contains('w-full')) {
-              modalElement.classList.add('w-full');
-            }
-            if (!modalElement.classList.contains('h-full')) {
-              modalElement.classList.add('h-full');
-            }
-            // Ensure padding is set
-            if (!modalElement.style.padding) {
-              modalElement.style.padding = '1rem';
-            }
-            // Remove hidden class if present
-            modalElement.classList.remove('hidden');
-            // Set aria-hidden to false
-            modalElement.setAttribute('aria-hidden', 'false');
-            // Add backdrop if needed
-            let backdrop = document.querySelector('.modal-backdrop');
-            if (!backdrop) {
-              backdrop = document.createElement('div');
-              backdrop.className = 'modal-backdrop fixed inset-0 bg-gray-900 bg-opacity-50 dark:bg-opacity-80 z-40';
-              document.body.appendChild(backdrop);
-              backdrop.addEventListener('click', () => {
-                window.closeModelInfoModal();
-              });
-            }
-          }
-        }
-      };
-      
-      // Function to close the model info modal
-      window.closeModelInfoModal = function() {
-        const modalElement = document.getElementById('model-info-modal');
-        if (modalElement) {
-          modalElement.classList.add('hidden');
-          modalElement.setAttribute('aria-hidden', 'true');
-        }
-        const backdrop = document.querySelector('.modal-backdrop');
-        if (backdrop) {
-          backdrop.remove();
-        }
-      };
-
       // Also sync after Alpine initializes (in case it runs after DOMContentLoaded)
-      function initializeModelInfo() {
-        syncModelSelectorOnLoad();
-        // Initialize model info modal content with current model (but don't open it)
-        if (window.updateModelInfoModal && window.Alpine && window.Alpine.store("chat")) {
-          const activeChat = window.Alpine.store("chat").activeChat();
-          const modelName = activeChat ? activeChat.model : (document.getElementById("chat-model") ? document.getElementById("chat-model").value : null);
-          if (modelName) {
-            window.updateModelInfoModal(modelName, false); // false = don't open, just update content
-          }
-        }
-      }
-      
       if (window.Alpine) {
-        Alpine.nextTick(initializeModelInfo);
+        Alpine.nextTick(syncModelSelectorOnLoad);
       } else {
         document.addEventListener('alpine:init', () => {
-          Alpine.nextTick(initializeModelInfo);
+          Alpine.nextTick(syncModelSelectorOnLoad);
         });
       }
     </script>

core/http/views/partials/navbar.html

@@ -40,7 +40,7 @@
                 <a href="traces/" class="text-[var(--color-text-secondary)] hover:text-[var(--color-text-primary)] px-2 py-2 rounded-lg transition duration-300 ease-in-out hover:bg-[var(--color-bg-secondary)] flex items-center group text-sm">
                     <i class="fas fa-chart-line text-[var(--color-primary)] mr-1.5 text-sm group-hover:scale-110 transition-transform"></i>Traces
                 </a>
-                <a href="swagger/index.html" class="text-[var(--color-text-secondary)] hover:text-[var(--color-text-primary)] px-2 py-2 rounded-lg transition duration-300 ease-in-out hover:bg-[var(--color-bg-secondary)] flex items-center group text-sm">
+                <a href="swagger/" class="text-[var(--color-text-secondary)] hover:text-[var(--color-text-primary)] px-2 py-2 rounded-lg transition duration-300 ease-in-out hover:bg-[var(--color-bg-secondary)] flex items-center group text-sm">
                     <i class="fas fa-code text-[var(--color-primary)] mr-1.5 text-sm group-hover:scale-110 transition-transform"></i>API
                 </a>
                 
@@ -100,7 +100,7 @@
                 <a href="traces/" class="block text-[var(--color-text-secondary)] hover:text-[var(--color-text-primary)] hover:bg-[var(--color-bg-secondary)] px-3 py-2 rounded-lg transition duration-300 ease-in-out flex items-center text-sm">
                     <i class="fas fa-chart-line text-[var(--color-primary)] mr-3 w-5 text-center text-sm"></i>Traces
                 </a>
-                <a href="swagger/index.html" class="block text-[var(--color-text-secondary)] hover:text-[var(--color-text-primary)] hover:bg-[var(--color-bg-secondary)] px-3 py-2 rounded-lg transition duration-300 ease-in-out flex items-center text-sm">
+                <a href="swagger/" class="block text-[var(--color-text-secondary)] hover:text-[var(--color-text-primary)] hover:bg-[var(--color-bg-secondary)] px-3 py-2 rounded-lg transition duration-300 ease-in-out flex items-center text-sm">
                     <i class="fas fa-code text-[var(--color-primary)] mr-3 w-5 text-center text-sm"></i>API
                 </a>
                 

core/http/views/text2image.html

@@ -215,23 +215,26 @@
 
             <!-- Right Column: Image Preview -->
             <div class="flex-grow lg:w-3/4 flex flex-col min-h-0">
-                <div class="relative flex-1 min-h-0 overflow-y-auto">
-                    <!-- Loading Animation -->
-                    <div id="loader" class="hidden absolute inset-0 flex items-center justify-center bg-[var(--color-bg-primary)]/80 rounded-xl z-10">
-                        <div class="text-center">
-                            <svg class="animate-spin h-10 w-10 text-[var(--color-primary)] mx-auto mb-3" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
-                                <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
-                                <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
-                            </svg>
-                            <p class="text-xs text-[var(--color-text-secondary)]">Generating image...</p>
+                <div class="card p-3 flex flex-col flex-1 min-h-0">
+                    <h3 class="text-sm font-semibold text-[var(--color-text-primary)] mb-3 flex-shrink-0">Generated Images</h3>
+                    <div class="relative flex-1 min-h-0 overflow-y-auto">
+                        <!-- Loading Animation -->
+                        <div id="loader" class="hidden absolute inset-0 flex items-center justify-center bg-[var(--color-bg-primary)]/80 rounded-xl z-10">
+                            <div class="text-center">
+                                <svg class="animate-spin h-10 w-10 text-[var(--color-primary)] mx-auto mb-3" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                                    <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                                </svg>
+                                <p class="text-xs text-[var(--color-text-secondary)]">Generating image...</p>
+                            </div>
                         </div>
+                        <!-- Placeholder when no images -->
+                        <div id="result-placeholder" class="bg-[var(--color-bg-primary)]/50 border border-[#1E293B] rounded-xl p-6 min-h-[400px] flex items-center justify-center flex-shrink-0">
+                            <p class="text-xs text-[var(--color-text-secondary)] italic text-center">Your generated images will appear here</p>
+                        </div>
+                        <!-- Results container -->
+                        <div id="result" class="space-y-4 pb-4"></div>
                     </div>
-                    <!-- Placeholder when no images -->
-                    <div id="result-placeholder" class="min-h-[400px] flex items-center justify-center flex-shrink-0">
-                        <p class="text-xs text-[var(--color-text-secondary)] italic text-center">Your generated images will appear here</p>
-                    </div>
-                    <!-- Results container -->
-                    <div id="result" class="grid grid-cols-1 sm:grid-cols-2 gap-4 pb-4"></div>
                 </div>
             </div>
         </div>

core/schema/anthropic.go

@@ -1,176 +0,0 @@
-package schema
-
-import (
-	"context"
-	"encoding/json"
-)
-
-// AnthropicRequest represents a request to the Anthropic Messages API
-// https://docs.anthropic.com/claude/reference/messages_post
-type AnthropicRequest struct {
-	Model         string             `json:"model"`
-	Messages      []AnthropicMessage `json:"messages"`
-	MaxTokens     int                `json:"max_tokens"`
-	Metadata      map[string]string  `json:"metadata,omitempty"`
-	StopSequences []string           `json:"stop_sequences,omitempty"`
-	Stream        bool               `json:"stream,omitempty"`
-	System        string             `json:"system,omitempty"`
-	Temperature   *float64           `json:"temperature,omitempty"`
-	TopK          *int               `json:"top_k,omitempty"`
-	TopP          *float64           `json:"top_p,omitempty"`
-	Tools         []AnthropicTool    `json:"tools,omitempty"`
-	ToolChoice    interface{}        `json:"tool_choice,omitempty"`
-
-	// Internal fields for request handling
-	Context context.Context    `json:"-"`
-	Cancel  context.CancelFunc `json:"-"`
-}
-
-// ModelName implements the LocalAIRequest interface
-func (ar *AnthropicRequest) ModelName(s *string) string {
-	if s != nil {
-		ar.Model = *s
-	}
-	return ar.Model
-}
-
-// AnthropicTool represents a tool definition in the Anthropic format
-type AnthropicTool struct {
-	Name        string                 `json:"name"`
-	Description string                 `json:"description,omitempty"`
-	InputSchema map[string]interface{} `json:"input_schema"`
-}
-
-// AnthropicMessage represents a message in the Anthropic format
-type AnthropicMessage struct {
-	Role    string      `json:"role"`
-	Content interface{} `json:"content"`
-}
-
-// AnthropicContentBlock represents a content block in an Anthropic message
-type AnthropicContentBlock struct {
-	Type       string                 `json:"type"`
-	Text       string                 `json:"text,omitempty"`
-	Source     *AnthropicImageSource  `json:"source,omitempty"`
-	ID         string                 `json:"id,omitempty"`
-	Name       string                 `json:"name,omitempty"`
-	Input      map[string]interface{} `json:"input,omitempty"`
-	ToolUseID  string                 `json:"tool_use_id,omitempty"`
-	Content    interface{}            `json:"content,omitempty"`
-	IsError    *bool                  `json:"is_error,omitempty"`
-}
-
-// AnthropicImageSource represents an image source in Anthropic format
-type AnthropicImageSource struct {
-	Type      string `json:"type"`
-	MediaType string `json:"media_type"`
-	Data      string `json:"data"`
-}
-
-// AnthropicResponse represents a response from the Anthropic Messages API
-type AnthropicResponse struct {
-	ID           string                  `json:"id"`
-	Type         string                  `json:"type"`
-	Role         string                  `json:"role"`
-	Content      []AnthropicContentBlock `json:"content"`
-	Model        string                  `json:"model"`
-	StopReason   *string                 `json:"stop_reason"`
-	StopSequence *string                 `json:"stop_sequence,omitempty"`
-	Usage        AnthropicUsage          `json:"usage"`
-}
-
-// AnthropicUsage represents token usage in Anthropic format
-type AnthropicUsage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-}
-
-// AnthropicStreamEvent represents a streaming event from the Anthropic API
-type AnthropicStreamEvent struct {
-	Type         string                  `json:"type"`
-	Index        int                     `json:"index,omitempty"`
-	ContentBlock *AnthropicContentBlock  `json:"content_block,omitempty"`
-	Delta        *AnthropicStreamDelta   `json:"delta,omitempty"`
-	Message      *AnthropicStreamMessage `json:"message,omitempty"`
-	Usage        *AnthropicUsage         `json:"usage,omitempty"`
-}
-
-// AnthropicStreamDelta represents the delta in a streaming response
-type AnthropicStreamDelta struct {
-	Type         string  `json:"type,omitempty"`
-	Text         string  `json:"text,omitempty"`
-	PartialJSON  string  `json:"partial_json,omitempty"`
-	StopReason   *string `json:"stop_reason,omitempty"`
-	StopSequence *string `json:"stop_sequence,omitempty"`
-}
-
-// AnthropicStreamMessage represents the message object in streaming events
-type AnthropicStreamMessage struct {
-	ID           string                  `json:"id"`
-	Type         string                  `json:"type"`
-	Role         string                  `json:"role"`
-	Content      []AnthropicContentBlock `json:"content"`
-	Model        string                  `json:"model"`
-	StopReason   *string                 `json:"stop_reason"`
-	StopSequence *string                 `json:"stop_sequence,omitempty"`
-	Usage        AnthropicUsage          `json:"usage"`
-}
-
-// AnthropicErrorResponse represents an error response from the Anthropic API
-type AnthropicErrorResponse struct {
-	Type  string         `json:"type"`
-	Error AnthropicError `json:"error"`
-}
-
-// AnthropicError represents an error in the Anthropic format
-type AnthropicError struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-}
-
-// GetStringContent extracts the string content from an AnthropicMessage
-// Content can be either a string or an array of content blocks
-func (m *AnthropicMessage) GetStringContent() string {
-	switch content := m.Content.(type) {
-	case string:
-		return content
-	case []interface{}:
-		var result string
-		for _, block := range content {
-			if blockMap, ok := block.(map[string]interface{}); ok {
-				if blockMap["type"] == "text" {
-					if text, ok := blockMap["text"].(string); ok {
-						result += text
-					}
-				}
-			}
-		}
-		return result
-	}
-	return ""
-}
-
-// GetContentBlocks extracts content blocks from an AnthropicMessage
-func (m *AnthropicMessage) GetContentBlocks() []AnthropicContentBlock {
-	switch content := m.Content.(type) {
-	case string:
-		return []AnthropicContentBlock{{Type: "text", Text: content}}
-	case []interface{}:
-		var blocks []AnthropicContentBlock
-		for _, block := range content {
-			if blockMap, ok := block.(map[string]interface{}); ok {
-				cb := AnthropicContentBlock{}
-				data, err := json.Marshal(blockMap)
-				if err != nil {
-					continue
-				}
-				if err := json.Unmarshal(data, &cb); err != nil {
-					continue
-				}
-				blocks = append(blocks, cb)
-			}
-		}
-		return blocks
-	}
-	return nil
-}

core/schema/anthropic_test.go

@@ -1,216 +0,0 @@
-package schema_test
-
-import (
-	"encoding/json"
-
-	"github.com/mudler/LocalAI/core/schema"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Anthropic Schema", func() {
-	Describe("AnthropicRequest", func() {
-		It("should unmarshal a valid request", func() {
-			jsonData := `{
-				"model": "claude-3-sonnet-20240229",
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "user", "content": "Hello, world!"}
-				],
-				"system": "You are a helpful assistant.",
-				"temperature": 0.7
-			}`
-
-			var req schema.AnthropicRequest
-			err := json.Unmarshal([]byte(jsonData), &req)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(req.Model).To(Equal("claude-3-sonnet-20240229"))
-			Expect(req.MaxTokens).To(Equal(1024))
-			Expect(len(req.Messages)).To(Equal(1))
-			Expect(req.System).To(Equal("You are a helpful assistant."))
-			Expect(*req.Temperature).To(Equal(0.7))
-		})
-
-		It("should unmarshal a request with tools", func() {
-			jsonData := `{
-				"model": "claude-3-sonnet-20240229",
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "user", "content": "What's the weather?"}
-				],
-				"tools": [
-					{
-						"name": "get_weather",
-						"description": "Get the current weather",
-						"input_schema": {
-							"type": "object",
-							"properties": {
-								"location": {"type": "string"}
-							}
-						}
-					}
-				],
-				"tool_choice": {"type": "tool", "name": "get_weather"}
-			}`
-
-			var req schema.AnthropicRequest
-			err := json.Unmarshal([]byte(jsonData), &req)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(req.Tools)).To(Equal(1))
-			Expect(req.Tools[0].Name).To(Equal("get_weather"))
-			Expect(req.Tools[0].Description).To(Equal("Get the current weather"))
-			Expect(req.ToolChoice).ToNot(BeNil())
-		})
-
-		It("should implement LocalAIRequest interface", func() {
-			req := &schema.AnthropicRequest{Model: "test-model"}
-			Expect(req.ModelName(nil)).To(Equal("test-model"))
-
-			newModel := "new-model"
-			Expect(req.ModelName(&newModel)).To(Equal("new-model"))
-			Expect(req.Model).To(Equal("new-model"))
-		})
-	})
-
-	Describe("AnthropicMessage", func() {
-		It("should get string content from string content", func() {
-			msg := schema.AnthropicMessage{
-				Role:    "user",
-				Content: "Hello, world!",
-			}
-			Expect(msg.GetStringContent()).To(Equal("Hello, world!"))
-		})
-
-		It("should get string content from array content", func() {
-			msg := schema.AnthropicMessage{
-				Role: "user",
-				Content: []interface{}{
-					map[string]interface{}{"type": "text", "text": "Hello, "},
-					map[string]interface{}{"type": "text", "text": "world!"},
-				},
-			}
-			Expect(msg.GetStringContent()).To(Equal("Hello, world!"))
-		})
-
-		It("should get content blocks from string content", func() {
-			msg := schema.AnthropicMessage{
-				Role:    "user",
-				Content: "Hello, world!",
-			}
-			blocks := msg.GetContentBlocks()
-			Expect(len(blocks)).To(Equal(1))
-			Expect(blocks[0].Type).To(Equal("text"))
-			Expect(blocks[0].Text).To(Equal("Hello, world!"))
-		})
-
-		It("should get content blocks from array content", func() {
-			msg := schema.AnthropicMessage{
-				Role: "user",
-				Content: []interface{}{
-					map[string]interface{}{"type": "text", "text": "Hello"},
-					map[string]interface{}{"type": "image", "source": map[string]interface{}{"type": "base64", "data": "abc123"}},
-				},
-			}
-			blocks := msg.GetContentBlocks()
-			Expect(len(blocks)).To(Equal(2))
-			Expect(blocks[0].Type).To(Equal("text"))
-			Expect(blocks[0].Text).To(Equal("Hello"))
-		})
-	})
-
-	Describe("AnthropicResponse", func() {
-		It("should marshal a valid response", func() {
-			stopReason := "end_turn"
-			resp := schema.AnthropicResponse{
-				ID:         "msg_123",
-				Type:       "message",
-				Role:       "assistant",
-				Model:      "claude-3-sonnet-20240229",
-				StopReason: &stopReason,
-				Content: []schema.AnthropicContentBlock{
-					{Type: "text", Text: "Hello!"},
-				},
-				Usage: schema.AnthropicUsage{
-					InputTokens:  10,
-					OutputTokens: 5,
-				},
-			}
-
-			data, err := json.Marshal(resp)
-			Expect(err).ToNot(HaveOccurred())
-
-			var result map[string]interface{}
-			err = json.Unmarshal(data, &result)
-			Expect(err).ToNot(HaveOccurred())
-
-			Expect(result["id"]).To(Equal("msg_123"))
-			Expect(result["type"]).To(Equal("message"))
-			Expect(result["role"]).To(Equal("assistant"))
-			Expect(result["stop_reason"]).To(Equal("end_turn"))
-		})
-
-		It("should marshal a response with tool use", func() {
-			stopReason := "tool_use"
-			resp := schema.AnthropicResponse{
-				ID:         "msg_123",
-				Type:       "message",
-				Role:       "assistant",
-				Model:      "claude-3-sonnet-20240229",
-				StopReason: &stopReason,
-				Content: []schema.AnthropicContentBlock{
-					{
-						Type: "tool_use",
-						ID:   "toolu_123",
-						Name: "get_weather",
-						Input: map[string]interface{}{
-							"location": "San Francisco",
-						},
-					},
-				},
-				Usage: schema.AnthropicUsage{
-					InputTokens:  10,
-					OutputTokens: 5,
-				},
-			}
-
-			data, err := json.Marshal(resp)
-			Expect(err).ToNot(HaveOccurred())
-
-			var result map[string]interface{}
-			err = json.Unmarshal(data, &result)
-			Expect(err).ToNot(HaveOccurred())
-
-			Expect(result["stop_reason"]).To(Equal("tool_use"))
-			content := result["content"].([]interface{})
-			Expect(len(content)).To(Equal(1))
-			toolUse := content[0].(map[string]interface{})
-			Expect(toolUse["type"]).To(Equal("tool_use"))
-			Expect(toolUse["id"]).To(Equal("toolu_123"))
-			Expect(toolUse["name"]).To(Equal("get_weather"))
-		})
-	})
-
-	Describe("AnthropicErrorResponse", func() {
-		It("should marshal an error response", func() {
-			resp := schema.AnthropicErrorResponse{
-				Type: "error",
-				Error: schema.AnthropicError{
-					Type:    "invalid_request_error",
-					Message: "max_tokens is required",
-				},
-			}
-
-			data, err := json.Marshal(resp)
-			Expect(err).ToNot(HaveOccurred())
-
-			var result map[string]interface{}
-			err = json.Unmarshal(data, &result)
-			Expect(err).ToNot(HaveOccurred())
-
-			Expect(result["type"]).To(Equal("error"))
-			errorObj := result["error"].(map[string]interface{})
-			Expect(errorObj["type"]).To(Equal("invalid_request_error"))
-			Expect(errorObj["message"]).To(Equal("max_tokens is required"))
-		})
-	})
-})

core/schema/gallery-model.schema.json

@@ -1,79 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/mudler/LocalAI/main/schemas/gallery.model.schema.json",
-  "title": "LocalAI Gallery Model Spec",
-  "description": "Schema for LocalAI gallery model YAML files",
-  "type": "object",
-
-  "properties": {
-    "name": {
-      "type": "string",
-      "description": "Model name"
-    },
-    "description": {
-      "type": "string",
-      "description": "Human-readable description of the model"
-    },
-    "icon": {
-      "type": "string",
-      "description": "Optional icon reference or URL"
-    },
-    "license": {
-      "type": "string",
-      "description": "Model license identifier or text"
-    },
-    "urls": {
-      "type": "array",
-      "description": "URLs pointing to remote model configuration",
-      "items": {
-        "type": "string",
-        "format": "uri"
-      }
-    },
-    "config_file": {
-      "type": "string",
-      "description": "Inline YAML configuration that will be written to the model config file"
-    },
-    "files": {
-      "type": "array",
-      "description": "Files to download and install for this model",
-      "items": {
-        "type": "object",
-        "required": ["filename", "uri"],
-        "properties": {
-          "filename": {
-            "type": "string"
-          },
-          "sha256": {
-            "type": "string",
-            "description": "Optional SHA256 checksum for file verification"
-          },
-          "uri": {
-            "type": "string",
-            "format": "uri"
-          }
-        },
-        "additionalProperties": false
-      }
-    },
-    "prompt_templates": {
-      "type": "array",
-      "description": "Prompt templates written as .tmpl files",
-      "items": {
-        "type": "object",
-        "required": ["name", "content"],
-        "properties": {
-          "name": {
-            "type": "string"
-          },
-          "content": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      }
-    }
-  },
-
-  "additionalProperties": false
-}

core/schema/message.go

@@ -27,9 +27,6 @@ type Message struct {
 	FunctionCall interface{} `json:"function_call,omitempty" yaml:"function_call,omitempty"`
 
 	ToolCalls []ToolCall `json:"tool_calls,omitempty" yaml:"tool_call,omitempty"`
-
-	// Reasoning content extracted from <thinking>...</thinking> tags
-	Reasoning *string `json:"reasoning,omitempty" yaml:"reasoning,omitempty"`
 }
 
 type ToolCall struct {
@@ -81,8 +78,8 @@ func (messages Messages) ToProto() []*proto.Message {
 			}
 		}
 
-		// Note: tool_call_id is not in schema.Message yet
-		// Reasoning field is now available in schema.Message but not yet in proto.Message
+		// Note: tool_call_id and reasoning_content are not in schema.Message yet
+		// They may need to be added to schema.Message if needed in the future
 	}
 	return protoMessages
 }

docker-compose.yaml

@@ -11,7 +11,7 @@ services:
       dockerfile: Dockerfile
       args:
       - IMAGE_TYPE=core
-      - BASE_IMAGE=ubuntu:24.04
+      - BASE_IMAGE=ubuntu:22.04
     ports:
       - 8080:8080
     env_file:

docs/content/getting-started/container-images.md

@@ -50,6 +50,16 @@ Standard container images do not have pre-installed models. Use these if you wan
 
 {{% /tab %}}
 
+{{% tab title="GPU Images CUDA 11" %}}
+
+| Description | Quay | Docker Hub                                                  |
+| --- | --- |-------------------------------------------------------------|
+| Latest images from the branch (development) | `quay.io/go-skynet/local-ai:master-gpu-nvidia-cuda-11` | `localai/localai:master-gpu-nvidia-cuda-11`                      |
+| Latest tag | `quay.io/go-skynet/local-ai:latest-gpu-nvidia-cuda-11` | `localai/localai:latest-gpu-nvidia-cuda-11`                      |
+| Versioned image | `quay.io/go-skynet/local-ai:{{< version >}}-gpu-nvidia-cuda-11` | `localai/localai:{{< version >}}-gpu-nvidia-cuda-11`             |
+
+{{% /tab %}}
+
 {{% tab title="GPU Images CUDA 12" %}}
 
 | Description | Quay | Docker Hub                                                  |
@@ -159,9 +169,11 @@ services:
     image: localai/localai:latest-aio-cpu
     # For a specific version:
     # image: localai/localai:{{< version >}}-aio-cpu
-    # For Nvidia GPUs decomment one of the following (cuda12 or cuda13):
+    # For Nvidia GPUs decomment one of the following (cuda11, cuda12, or cuda13):
+    # image: localai/localai:{{< version >}}-aio-gpu-nvidia-cuda-11
     # image: localai/localai:{{< version >}}-aio-gpu-nvidia-cuda-12
     # image: localai/localai:{{< version >}}-aio-gpu-nvidia-cuda-13
+    # image: localai/localai:latest-aio-gpu-nvidia-cuda-11
     # image: localai/localai:latest-aio-gpu-nvidia-cuda-12
     # image: localai/localai:latest-aio-gpu-nvidia-cuda-13
     healthcheck:
@@ -213,6 +225,7 @@ docker run -p 8080:8080 --name local-ai -ti -v localai-models:/models localai/lo
 | --- | --- |-----------------------------------------------|
 | Latest images for CPU | `quay.io/go-skynet/local-ai:latest-aio-cpu` | `localai/localai:latest-aio-cpu`                      |
 | Versioned image (e.g. for CPU) | `quay.io/go-skynet/local-ai:{{< version >}}-aio-cpu` | `localai/localai:{{< version >}}-aio-cpu`             |
+| Latest images for Nvidia GPU (CUDA11) | `quay.io/go-skynet/local-ai:latest-aio-gpu-nvidia-cuda-11` | `localai/localai:latest-aio-gpu-nvidia-cuda-11`                      |
 | Latest images for Nvidia GPU (CUDA12) | `quay.io/go-skynet/local-ai:latest-aio-gpu-nvidia-cuda-12` | `localai/localai:latest-aio-gpu-nvidia-cuda-12`                      |
 | Latest images for Nvidia GPU (CUDA13) | `quay.io/go-skynet/local-ai:latest-aio-gpu-nvidia-cuda-13` | `localai/localai:latest-aio-gpu-nvidia-cuda-13`                      |
 | Latest images for AMD GPU | `quay.io/go-skynet/local-ai:latest-aio-gpu-hipblas` | `localai/localai:latest-aio-gpu-hipblas`                      |

docs/content/getting-started/kubernetes.md

@@ -29,79 +29,3 @@ helm show values go-skynet/local-ai > values.yaml
 
 helm install local-ai go-skynet/local-ai -f values.yaml
 ```
-
-## Security Context Requirements
-
-LocalAI spawns child processes to run model backends (e.g., llama.cpp, diffusers, whisper). To properly stop these processes and free resources like VRAM, LocalAI needs permission to send signals to its child processes.
-
-If you're using restrictive security contexts, ensure the `CAP_KILL` capability is available:
-
-```yaml
-apiVersion: v1
-kind: Pod
-metadata:
-  name: local-ai
-spec:
-  containers:
-  - name: local-ai
-    image: quay.io/go-skynet/local-ai:latest
-    securityContext:
-      allowPrivilegeEscalation: false
-      capabilities:
-        drop:
-          - ALL
-        add:
-          - KILL  # Required for LocalAI to stop backend processes
-      seccompProfile:
-        type: RuntimeDefault
-      runAsNonRoot: true
-      runAsUser: 1000
-```
-
-Without the `KILL` capability, LocalAI cannot terminate backend processes when models are stopped, leading to:
-- VRAM and memory not being freed
-- Orphaned backend processes holding GPU resources
-- Error messages like `error while deleting process error=permission denied`
-
-## Troubleshooting
-
-### Issue: VRAM is not freed when stopping models
-
-**Symptoms:**
-- Models appear to stop but GPU memory remains allocated
-- Logs show `(deleteProcess) error while deleting process error=permission denied`
-- Backend processes remain running after model unload
-
-**Common Causes:**
-- All capabilities are dropped without adding back `CAP_KILL`
-- Using user namespacing (`hostUsers: false`) with certain configurations
-- Overly restrictive seccomp profiles that block signal-related syscalls
-- Pod Security Policies or Pod Security Standards blocking required capabilities
-
-**Solution:**
-
-1. Add the `KILL` capability to your container's security context as shown in the example above.
-
-2. If you're using a Helm chart, configure the security context in your `values.yaml`:
-
-```yaml
-securityContext:
-  allowPrivilegeEscalation: false
-  capabilities:
-    drop:
-      - ALL
-    add:
-      - KILL
-  seccompProfile:
-    type: RuntimeDefault
-```
-
-3. Verify the capability is present in the running pod:
-
-```bash
-kubectl exec -it <pod-name> -- grep CapEff /proc/1/status
-```
-
-4. If running in privileged mode works but the above doesn't, check your cluster's Pod Security Policies or Pod Security Standards. You may need to adjust cluster-level policies to allow the `KILL` capability.
-
-5. Ensure your seccomp profile (if custom) allows the `kill` syscall. The `RuntimeDefault` profile typically includes this.

docs/content/installation/docker.md

@@ -68,6 +68,11 @@ docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gp
 docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gpu-nvidia-cuda-12
 ```
 
+**NVIDIA CUDA 11:**
+```bash
+docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gpu-nvidia-cuda-11
+```
+
 **AMD GPU (ROCm):**
 ```bash
 docker run -ti --name local-ai -p 8080:8080 --device=/dev/kfd --device=/dev/dri --group-add=video localai/localai:latest-gpu-hipblas
@@ -117,6 +122,11 @@ docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-ai
 docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-aio-gpu-nvidia-cuda-12
 ```
 
+**NVIDIA CUDA 11:**
+```bash
+docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-aio-gpu-nvidia-cuda-11
+```
+
 **AMD GPU (ROCm):**
 ```bash
 docker run -ti --name local-ai -p 8080:8080 --device=/dev/kfd --device=/dev/dri --group-add=video localai/localai:latest-aio-gpu-hipblas

docs/content/installation/kubernetes.md

@@ -29,79 +29,3 @@ helm show values go-skynet/local-ai > values.yaml
 
 helm install local-ai go-skynet/local-ai -f values.yaml
 ```
-
-## Security Context Requirements
-
-LocalAI spawns child processes to run model backends (e.g., llama.cpp, diffusers, whisper). To properly stop these processes and free resources like VRAM, LocalAI needs permission to send signals to its child processes.
-
-If you're using restrictive security contexts, ensure the `CAP_KILL` capability is available:
-
-```yaml
-apiVersion: v1
-kind: Pod
-metadata:
-  name: local-ai
-spec:
-  containers:
-  - name: local-ai
-    image: quay.io/go-skynet/local-ai:latest
-    securityContext:
-      allowPrivilegeEscalation: false
-      capabilities:
-        drop:
-          - ALL
-        add:
-          - KILL  # Required for LocalAI to stop backend processes
-      seccompProfile:
-        type: RuntimeDefault
-      runAsNonRoot: true
-      runAsUser: 1000
-```
-
-Without the `KILL` capability, LocalAI cannot terminate backend processes when models are stopped, leading to:
-- VRAM and memory not being freed
-- Orphaned backend processes holding GPU resources
-- Error messages like `error while deleting process error=permission denied`
-
-## Troubleshooting
-
-### Issue: VRAM is not freed when stopping models
-
-**Symptoms:**
-- Models appear to stop but GPU memory remains allocated
-- Logs show `(deleteProcess) error while deleting process error=permission denied`
-- Backend processes remain running after model unload
-
-**Common Causes:**
-- All capabilities are dropped without adding back `CAP_KILL`
-- Using user namespacing (`hostUsers: false`) with certain configurations
-- Overly restrictive seccomp profiles that block signal-related syscalls
-- Pod Security Policies or Pod Security Standards blocking required capabilities
-
-**Solution:**
-
-1. Add the `KILL` capability to your container's security context as shown in the example above.
-
-2. If you're using a Helm chart, configure the security context in your `values.yaml`:
-
-```yaml
-securityContext:
-  allowPrivilegeEscalation: false
-  capabilities:
-    drop:
-      - ALL
-    add:
-      - KILL
-  seccompProfile:
-    type: RuntimeDefault
-```
-
-3. Verify the capability is present in the running pod:
-
-```bash
-kubectl exec -it <pod-name> -- grep CapEff /proc/1/status
-```
-
-4. If running in privileged mode works but the above doesn't, check your cluster's Pod Security Policies or Pod Security Standards. You may need to adjust cluster-level policies to allow the `KILL` capability.
-
-5. Ensure your seccomp profile (if custom) allows the `kill` syscall. The `RuntimeDefault` profile typically includes this.

docs/content/integrations.md

@@ -32,7 +32,6 @@ The list below is a list of software that integrates with LocalAI.
 - [GPTLocalhost (Word Add-in)](https://gptlocalhost.com/demo#LocalAI) - run LocalAI in Microsoft Word locally
 - use LocalAI from Nextcloud with the [integration plugin](https://apps.nextcloud.com/apps/integration_openai) and [AI assistant](https://apps.nextcloud.com/apps/assistant)
 - [Langchain](https://docs.langchain.com/oss/python/integrations/providers/localai) integration package [pypi](https://pypi.org/project/langchain-localai/)
-- [VoxInput](https://github.com/richiejp/VoxInput) - Use voice to control your desktop
 
 Feel free to open up a Pull request (by clicking at the "Edit page" below) to get a page for your project made or if you see a error on one of the pages!
 
@@ -106,36 +105,6 @@ This section provides step-by-step instructions for configuring specific softwar
    After saving the configuration file, restart OpenCode for the changes to take effect.
 
 
-### Charm Crush
-
-You can ask [Charm Crush](https://charm.land/crush) to generate your config by giving it this documentation's URL and your LocalAI instance URL. The configuration will look something like the following and goes in `~/.config/crush/crush.json`:
-```json
-{
-  "$schema": "https://charm.land/crush.json",
-  "providers": {
-    "localai": {
-      "name": "LocalAI",
-      "base_url": "http://localai.lan:8081/v1",
-      "type": "openai-compat",
-      "models": [
-        {
-          "id": "qwen3-coder-480b-a35b-instruct",
-          "name": "Qwen 3 Coder 480b",
-          "context_window": 256000
-        },
-        {
-          "id": "qwen3-30b-a3b",
-          "name": "Qwen 3 30b a3b",
-          "context_window": 32000
-        }
-      ]
-    }
-  }
-}
-```
-
-A list of models can be fetched with `https://<server_address>/v1/models` by crush itself and appropriate models added to the provider list. Crush does not appear to be optimized for smaller models.
-
 ### GitHub Actions
 
 You can use LocalAI in GitHub Actions workflows to perform AI-powered tasks like code review, diff summarization, or automated analysis. The [LocalAI GitHub Action](https://github.com/mudler/localai-github-action) makes it easy to spin up a LocalAI instance in your CI/CD pipeline.

docs/content/reference/compatibility-table.md

@@ -18,9 +18,9 @@ LocalAI will attempt to automatically load models which are not explicitly confi
 
 | Backend and Bindings                                                             | Compatible models     | Completion/Chat endpoint | Capability | Embeddings support                | Token stream support | Acceleration |
 |----------------------------------------------------------------------------------|-----------------------|--------------------------|---------------------------|-----------------------------------|----------------------|--------------|
-| [llama.cpp]({{%relref "features/text-generation#llama.cpp" %}})        | LLama, Mamba, RWKV, Falcon, Starcoder, GPT-2, [and many others](https://github.com/ggerganov/llama.cpp?tab=readme-ov-file#description) | yes                      | GPT and Functions                        | yes | yes                  | CUDA 12/13, ROCm, Intel SYCL, Vulkan, Metal, CPU |
+| [llama.cpp]({{%relref "features/text-generation#llama.cpp" %}})        | LLama, Mamba, RWKV, Falcon, Starcoder, GPT-2, [and many others](https://github.com/ggerganov/llama.cpp?tab=readme-ov-file#description) | yes                      | GPT and Functions                        | yes | yes                  | CUDA 11/12/13, ROCm, Intel SYCL, Vulkan, Metal, CPU |
 | [vLLM](https://github.com/vllm-project/vllm)        | Various GPTs and quantization formats | yes                      | GPT             | no | no                  | CUDA 12/13, ROCm, Intel |
-| [transformers](https://github.com/huggingface/transformers) | Various GPTs and quantization formats  | yes                      | GPT, embeddings, Audio generation            | yes | yes*                  | CUDA 12/13, ROCm, Intel, CPU |
+| [transformers](https://github.com/huggingface/transformers) | Various GPTs and quantization formats  | yes                      | GPT, embeddings, Audio generation            | yes | yes*                  | CUDA 11/12/13, ROCm, Intel, CPU |
 | [exllama2](https://github.com/turboderp-org/exllamav2)  | GPTQ                   | yes                       | GPT only                  | no                               | no                   | CUDA 12/13 |
 | [MLX](https://github.com/ml-explore/mlx-lm)        | Various LLMs               | yes                       | GPT                        | no                                | no                   | Metal (Apple Silicon) |
 | [MLX-VLM](https://github.com/Blaizzy/mlx-vlm)        | Vision-Language Models               | yes                       | Multimodal GPT                        | no                                | no                   | Metal (Apple Silicon) |
@@ -37,7 +37,7 @@ LocalAI will attempt to automatically load models which are not explicitly confi
 | [bark-cpp](https://github.com/PABannier/bark.cpp)        | bark               | no                       | Audio-Only                 | no                                | no                   | CUDA, Metal, CPU |
 | [coqui](https://github.com/idiap/coqui-ai-TTS) | Coqui TTS    | no                       | Audio generation and Voice cloning    | no                               | no                   | CUDA 12/13, ROCm, Intel, CPU |
 | [kokoro](https://github.com/hexgrad/kokoro) | Kokoro TTS    | no                       | Text-to-speech    | no                               | no                   | CUDA 12/13, ROCm, Intel, CPU |
-| [chatterbox](https://github.com/resemble-ai/chatterbox) | Chatterbox TTS    | no                       | Text-to-speech    | no                               | no                   | CUDA 12/13, CPU |
+| [chatterbox](https://github.com/resemble-ai/chatterbox) | Chatterbox TTS    | no                       | Text-to-speech    | no                               | no                   | CUDA 11/12/13, CPU |
 | [kitten-tts](https://github.com/KittenML/KittenTTS) | Kitten TTS    | no                       | Text-to-speech    | no                               | no                   | CPU |
 | [silero-vad](https://github.com/snakers4/silero-vad) with [Golang bindings](https://github.com/streamer45/silero-vad-go) | Silero VAD    | no                       | Voice Activity Detection    | no                               | no                   | CPU |
 | [neutts](https://github.com/neuphonic/neuttsair) | NeuTTSAir    | no                       | Text-to-speech with voice cloning    | no                               | no                   | CUDA 12/13, ROCm, CPU |
@@ -49,7 +49,7 @@ LocalAI will attempt to automatically load models which are not explicitly confi
 | Backend and Bindings                                                             | Compatible models     | Completion/Chat endpoint | Capability | Embeddings support                | Token stream support | Acceleration |
 |----------------------------------------------------------------------------------|-----------------------|--------------------------|---------------------------|-----------------------------------|----------------------|--------------|
 | [stablediffusion.cpp](https://github.com/leejet/stable-diffusion.cpp)         | stablediffusion-1, stablediffusion-2, stablediffusion-3, flux, PhotoMaker               | no                       | Image                 | no                                | no                   | CUDA 12/13, Intel SYCL, Vulkan, CPU |
-| [diffusers](https://github.com/huggingface/diffusers)  | SD, various diffusion models,...                   | no                       | Image/Video generation    | no                               | no                   | CUDA 12/13, ROCm, Intel, Metal, CPU |
+| [diffusers](https://github.com/huggingface/diffusers)  | SD, various diffusion models,...                   | no                       | Image/Video generation    | no                               | no                   | CUDA 11/12/13, ROCm, Intel, Metal, CPU |
 | [transformers-musicgen](https://github.com/huggingface/transformers)  | MusicGen                    | no                       | Audio generation                | no                               | no                   | CUDA, CPU |
 
 ## Specialized AI Tasks
@@ -57,14 +57,14 @@ LocalAI will attempt to automatically load models which are not explicitly confi
 | Backend and Bindings                                                             | Compatible models     | Completion/Chat endpoint | Capability | Embeddings support                | Token stream support | Acceleration |
 |----------------------------------------------------------------------------------|-----------------------|--------------------------|---------------------------|-----------------------------------|----------------------|--------------|
 | [rfdetr](https://github.com/roboflow/rf-detr) | RF-DETR    | no                       | Object Detection    | no                               | no                   | CUDA 12/13, Intel, CPU |
-| [rerankers](https://github.com/AnswerDotAI/rerankers) | Reranking API    | no                       | Reranking   | no                               | no                   | CUDA 12/13, ROCm, Intel, CPU |
+| [rerankers](https://github.com/AnswerDotAI/rerankers) | Reranking API    | no                       | Reranking   | no                               | no                   | CUDA 11/12/13, ROCm, Intel, CPU |
 | [local-store](https://github.com/mudler/LocalAI) | Vector database    | no                       | Vector storage   | yes                               | no                   | CPU |
 | [huggingface](https://huggingface.co/docs/hub/en/api) | HuggingFace API models    | yes                       | Various AI tasks   | yes                               | yes                   | API-based |
 
 ## Acceleration Support Summary
 
 ### GPU Acceleration
-- **NVIDIA CUDA**: CUDA 12.0, CUDA 13.0 support across most backends
+- **NVIDIA CUDA**: CUDA 11.7, CUDA 12.0, CUDA 13.0 support across most backends
 - **AMD ROCm**: HIP-based acceleration for AMD GPUs
 - **Intel oneAPI**: SYCL-based acceleration for Intel GPUs (F16/F32 precision)
 - **Vulkan**: Cross-platform GPU acceleration

gallery/index.yaml

@@ -1,131 +1,4 @@
 ---
-- name: "qwen3-vl-reranker-8b"
-  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
-  urls:
-    - https://huggingface.co/mradermacher/Qwen3-VL-Reranker-8B-GGUF
-  description: |
-    **Model Name:** Qwen3-VL-Reranker-8B
-    **Base Model:** Qwen/Qwen3-VL-Reranker-8B
-
-    **Description:**
-    A high-performance multimodal reranking model for state-of-the-art cross-modal search. It supports 30+ languages and handles text, images, screenshots, videos, and mixed modalities. With 8B parameters and a 32K context length, it refines retrieval results by combining embedding vectors with precise relevance scores. Optimized for efficiency, it supports quantized versions (e.g., Q8_0, Q4_K_M) and is ideal for applications requiring accurate multimodal content matching.
-
-    **Key Features:**
-      - **Multimodal**: Text, images, videos, and mixed content.
-      - **Language Support**: 30+ languages.
-      - **Quantization**: Available in Q8_0 (best quality), Q4_K_M (fast, recommended), and lower-precision options.
-      - **Performance**: Outperforms base models in retrieval tasks (e.g., JinaVDR, ViDoRe v3).
-      - **Use Case**: Enhances search pipelines by refining embeddings with precise relevance scores.
-
-    **Downloads:**
-      - [GGUF Files](https://huggingface.co/mradermacher/Qwen3-VL-Reranker-8B-GGUF) (e.g., `Qwen3-VL-Reranker-8B.Q8_0.gguf`).
-
-    **Usage:**
-      - Requires `transformers`, `qwen-vl-utils`, and `torch`.
-      - Example: `from scripts.qwen3_vl_reranker import Qwen3VLReranker; model = Qwen3VLReranker(...)`
-
-    **Citation:**
-    @article{qwen3vlembedding, ...}
-
-    This description emphasizes its capabilities, efficiency, and versatility for multimodal search tasks.
-  overrides:
-    parameters:
-      model: llama-cpp/models/Qwen3-VL-Reranker-8B.Q4_K_M.gguf
-    name: Qwen3-VL-Reranker-8B-GGUF
-    backend: llama-cpp
-    template:
-      use_tokenizer_template: true
-    known_usecases:
-      - chat
-    function:
-      grammar:
-        disable: true
-    mmproj: llama-cpp/mmproj/Qwen3-VL-Reranker-8B.mmproj-f16.gguf
-    description: Imported from https://huggingface.co/mradermacher/Qwen3-VL-Reranker-8B-GGUF
-    options:
-      - use_jinja:true
-  files:
-    - filename: llama-cpp/models/Qwen3-VL-Reranker-8B.Q4_K_M.gguf
-      sha256: f73e62ea68abf741c3e713af823cfb4d2fd2ca35c8b68277b87b4b3d8570b66d
-      uri: https://huggingface.co/mradermacher/Qwen3-VL-Reranker-8B-GGUF/resolve/main/Qwen3-VL-Reranker-8B.Q4_K_M.gguf
-    - filename: llama-cpp/mmproj/Qwen3-VL-Reranker-8B.mmproj-f16.gguf
-      sha256: 15cd9bd4882dae771344f0ac204fce07de91b47c1438ada3861dfc817403c31e
-      uri: https://huggingface.co/mradermacher/Qwen3-VL-Reranker-8B-GGUF/resolve/main/Qwen3-VL-Reranker-8B.mmproj-f16.gguf
-- name: "liquidai.lfm2-2.6b-transcript"
-  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
-  urls:
-    - https://huggingface.co/DevQuasar/LiquidAI.LFM2-2.6B-Transcript-GGUF
-  description: |
-    This is a large language model (2.6B parameters) designed for text-generation tasks. It is a quantized version of the original model `LiquidAI/LFM2-2.6B-Transcript`, optimized for efficiency while retaining strong performance. The model is built on the foundation of the base model, with additional optimizations for deployment and use cases like transcription or language modeling. It is trained on large-scale text data and supports multiple languages.
-  overrides:
-    parameters:
-      model: llama-cpp/models/LiquidAI.LFM2-2.6B-Transcript.Q4_K_M.gguf
-    name: LiquidAI.LFM2-2.6B-Transcript-GGUF
-    backend: llama-cpp
-    template:
-      use_tokenizer_template: true
-    known_usecases:
-      - chat
-    function:
-      grammar:
-        disable: true
-    description: Imported from https://huggingface.co/DevQuasar/LiquidAI.LFM2-2.6B-Transcript-GGUF
-    options:
-      - use_jinja:true
-  files:
-    - filename: llama-cpp/models/LiquidAI.LFM2-2.6B-Transcript.Q4_K_M.gguf
-      sha256: 301a8467531781909dc7a6263318103a3d8673a375afc4641e358d4174bd15d4
-      uri: https://huggingface.co/DevQuasar/LiquidAI.LFM2-2.6B-Transcript-GGUF/resolve/main/LiquidAI.LFM2-2.6B-Transcript.Q4_K_M.gguf
-- name: "lfm2.5-1.2b-nova-function-calling"
-  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
-  urls:
-    - https://huggingface.co/NovachronoAI/LFM2.5-1.2B-Nova-Function-Calling-GGUF
-  description: |
-    The **LFM2.5-1.2B-Nova-Function-Calling-GGUF** is a quantized version of the original model, optimized for efficiency with **Unsloth**. It supports text and multimodal tasks, using different quantization levels (e.g., Q2_K, Q3_K, Q4_K, etc.) to balance performance and memory usage. The model is designed for function calling and is faster than the original version, making it suitable for tasks like code generation, reasoning, and multi-modal input processing.
-  overrides:
-    parameters:
-      model: llama-cpp/models/LFM2.5-1.2B-Nova-Function-Calling.Q4_K_M.gguf
-    name: LFM2.5-1.2B-Nova-Function-Calling-GGUF
-    backend: llama-cpp
-    template:
-      use_tokenizer_template: true
-    known_usecases:
-      - chat
-    function:
-      grammar:
-        disable: true
-    description: Imported from https://huggingface.co/NovachronoAI/LFM2.5-1.2B-Nova-Function-Calling-GGUF
-    options:
-      - use_jinja:true
-  files:
-    - filename: llama-cpp/models/LFM2.5-1.2B-Nova-Function-Calling.Q4_K_M.gguf
-      sha256: 5d039ad4195447cf4b6dbee8f7fe11f985c01d671a18153084c869077e431fbf
-      uri: https://huggingface.co/NovachronoAI/LFM2.5-1.2B-Nova-Function-Calling-GGUF/resolve/main/LFM2.5-1.2B-Nova-Function-Calling.Q4_K_M.gguf
-- name: "mistral-nemo-instruct-2407-12b-thinking-m-claude-opus-high-reasoning-i1"
-  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
-  urls:
-    - https://huggingface.co/mradermacher/Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning-i1-GGUF
-  description: |
-    The model described in this repository is the **Mistral-Nemo-Instruct-2407-12B** (12 billion parameters), a large language model optimized for instruction tuning and high-level reasoning tasks. It is a **quantized version** of the original model, compressed for efficiency while retaining key capabilities. The model is designed to generate human-like text, perform complex reasoning, and support multi-modal tasks, making it suitable for applications requiring strong language understanding and output.
-  overrides:
-    parameters:
-      model: llama-cpp/models/Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning.i1-Q4_K_M.gguf
-    name: Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning-i1-GGUF
-    backend: llama-cpp
-    template:
-      use_tokenizer_template: true
-    known_usecases:
-      - chat
-    function:
-      grammar:
-        disable: true
-    description: Imported from https://huggingface.co/mradermacher/Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning-i1-GGUF
-    options:
-      - use_jinja:true
-  files:
-    - filename: llama-cpp/models/Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning.i1-Q4_K_M.gguf
-      sha256: 7337216f6d42b0771344328da00d454c0fdc91743ced0a4f5a1c6632f4f4b063
-      uri: https://huggingface.co/mradermacher/Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning-i1-GGUF/resolve/main/Mistral-Nemo-Instruct-2407-12B-Thinking-M-Claude-Opus-High-Reasoning.i1-Q4_K_M.gguf
 - name: "rwkv7-g1c-13.3b"
   url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
   urls:
@@ -6163,7 +6036,6 @@
   tags:
     - embeddings
   overrides:
-    backend: llama-cpp
     embeddings: true
     parameters:
       model: granite-embedding-107m-multilingual-f16.gguf

go.mod

@@ -9,7 +9,6 @@ require (
 	fyne.io/fyne/v2 v2.7.1
 	github.com/Masterminds/sprig/v3 v3.3.0
 	github.com/alecthomas/kong v1.13.0
-	github.com/anthropics/anthropic-sdk-go v1.19.0
 	github.com/charmbracelet/glamour v0.10.0
 	github.com/containerd/containerd v1.7.30
 	github.com/ebitengine/purego v0.9.1
@@ -26,7 +25,7 @@ require (
 	github.com/jaypipes/ghw v0.21.2
 	github.com/joho/godotenv v1.5.1
 	github.com/klauspost/cpuid/v2 v2.3.0
-	github.com/labstack/echo/v4 v4.15.0
+	github.com/labstack/echo/v4 v4.14.0
 	github.com/libp2p/go-libp2p v0.43.0
 	github.com/lithammer/fuzzysearch v1.1.8
 	github.com/mholt/archiver/v3 v3.5.1
@@ -59,7 +58,6 @@ require (
 	go.opentelemetry.io/otel/metric v1.39.0
 	go.opentelemetry.io/otel/sdk/metric v1.39.0
 	google.golang.org/grpc v1.78.0
-	google.golang.org/protobuf v1.36.10
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
 	oras.land/oras-go/v2 v2.6.0
@@ -69,11 +67,8 @@ require (
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/labstack/gommon v0.4.2 // indirect
 	github.com/swaggo/files/v2 v2.0.2 // indirect
-	github.com/tidwall/gjson v1.18.0 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.1 // indirect
-	github.com/tidwall/sjson v1.2.5 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 )
 
 require (

go.sum

@@ -44,8 +44,6 @@ github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu
 github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
 github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
-github.com/anthropics/anthropic-sdk-go v1.19.0 h1:mO6E+ffSzLRvR/YUH9KJC0uGw0uV8GjISIuzem//3KE=
-github.com/anthropics/anthropic-sdk-go v1.19.0/go.mod h1:WTz31rIUHUHqai2UslPpw5CwXrQP3geYBioRV4WOLvE=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
@@ -388,8 +386,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/labstack/echo/v4 v4.15.0 h1:hoRTKWcnR5STXZFe9BmYun9AMTNeSbjHi2vtDuADJ24=
-github.com/labstack/echo/v4 v4.15.0/go.mod h1:xmw1clThob0BSVRX1CRQkGQ/vjwcpOMjQZSZa9fKA/c=
+github.com/labstack/echo/v4 v4.14.0 h1:+tiMrDLxwv6u0oKtD03mv+V1vXXB3wCqPHJqPuIe+7M=
+github.com/labstack/echo/v4 v4.14.0/go.mod h1:xmw1clThob0BSVRX1CRQkGQ/vjwcpOMjQZSZa9fKA/c=
 github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
 github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
 github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8=
@@ -764,12 +762,10 @@ github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4
 github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
 github.com/testcontainers/testcontainers-go v0.40.0 h1:pSdJYLOVgLE8YdUY2FHQ1Fxu+aMnb6JfVz1mxk7OeMU=
 github.com/testcontainers/testcontainers-go v0.40.0/go.mod h1:FSXV5KQtX2HAMlm7U3APNyLkkap35zNLxukw9oBi/MY=
-github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
 github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
 github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
 github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=

pkg/functions/functions.go

@@ -2,6 +2,7 @@ package functions
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"github.com/mudler/xlog"
 )
@@ -102,3 +103,91 @@ func (f Functions) Select(name string) Functions {
 
 	return funcs
 }
+
+// sanitizeValue recursively sanitizes null values in a JSON structure, converting them to empty objects.
+// It handles maps, slices, and nested structures.
+func sanitizeValue(value interface{}, path string) interface{} {
+	if value == nil {
+		// Convert null to empty object
+		xlog.Debug("SanitizeTools: found null value, converting to empty object", "path", path)
+		return map[string]interface{}{}
+	}
+
+	switch v := value.(type) {
+	case map[string]interface{}:
+		// Recursively sanitize map values
+		sanitized := make(map[string]interface{})
+		for key, val := range v {
+			newPath := path
+			if newPath != "" {
+				newPath += "."
+			}
+			newPath += key
+			sanitized[key] = sanitizeValue(val, newPath)
+		}
+		return sanitized
+
+	case []interface{}:
+		// Recursively sanitize slice elements
+		sanitized := make([]interface{}, len(v))
+		for i, val := range v {
+			newPath := fmt.Sprintf("%s[%d]", path, i)
+			sanitized[i] = sanitizeValue(val, newPath)
+		}
+		return sanitized
+
+	default:
+		// For primitive types (string, number, bool), return as-is
+		return value
+	}
+}
+
+// SanitizeTools removes null values from tool.parameters.properties and converts them to empty objects.
+// This prevents Jinja template errors when processing tools with malformed parameter schemas.
+// It works by marshaling to JSON, recursively sanitizing the JSON structure, and unmarshaling back.
+func SanitizeTools(tools Tools) Tools {
+	if len(tools) == 0 {
+		return tools
+	}
+
+	xlog.Debug("SanitizeTools: processing tools", "count", len(tools))
+
+	// Marshal to JSON to work with the actual JSON representation
+	toolsJSON, err := json.Marshal(tools)
+	if err != nil {
+		xlog.Warn("SanitizeTools: failed to marshal tools to JSON", "error", err)
+		return tools
+	}
+
+	// Parse JSON into a generic structure
+	var toolsData []map[string]interface{}
+	if err := json.Unmarshal(toolsJSON, &toolsData); err != nil {
+		xlog.Warn("SanitizeTools: failed to unmarshal tools JSON", "error", err)
+		return tools
+	}
+
+	// Recursively sanitize the JSON structure
+	for i, tool := range toolsData {
+		if function, ok := tool["function"].(map[string]interface{}); ok {
+			// Recursively sanitize the entire tool structure
+			tool["function"] = sanitizeValue(function, fmt.Sprintf("tools[%d].function", i))
+		}
+		toolsData[i] = tool
+	}
+
+	// Marshal back to JSON
+	sanitizedJSON, err := json.Marshal(toolsData)
+	if err != nil {
+		xlog.Warn("SanitizeTools: failed to marshal sanitized tools", "error", err)
+		return tools
+	}
+
+	// Unmarshal back into Tools structure
+	var sanitized Tools
+	if err := json.Unmarshal(sanitizedJSON, &sanitized); err != nil {
+		xlog.Warn("SanitizeTools: failed to unmarshal sanitized tools", "error", err)
+		return tools
+	}
+
+	return sanitized
+}

pkg/functions/functions_test.go

@@ -82,4 +82,202 @@ var _ = Describe("LocalAI grammar functions", func() {
 			Expect(functions[0].Name).To(Equal("create_event"))
 		})
 	})
+	Context("SanitizeTools()", func() {
+		It("returns empty slice when input is empty", func() {
+			tools := Tools{}
+			sanitized := SanitizeTools(tools)
+			Expect(len(sanitized)).To(Equal(0))
+		})
+
+		It("converts null values in parameters.properties to empty objects", func() {
+			tools := Tools{
+				{
+					Type: "function",
+					Function: Function{
+						Name:        "test_function",
+						Description: "A test function",
+						Parameters: map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"valid_param": map[string]interface{}{
+									"type": "string",
+								},
+								"null_param": nil,
+								"another_valid": map[string]interface{}{
+									"type": "integer",
+								},
+							},
+						},
+					},
+				},
+			}
+
+			sanitized := SanitizeTools(tools)
+			Expect(len(sanitized)).To(Equal(1))
+			Expect(sanitized[0].Function.Name).To(Equal("test_function"))
+
+			properties := sanitized[0].Function.Parameters["properties"].(map[string]interface{})
+			Expect(properties["valid_param"]).NotTo(BeNil())
+			Expect(properties["null_param"]).NotTo(BeNil())
+			Expect(properties["null_param"]).To(Equal(map[string]interface{}{}))
+			Expect(properties["another_valid"]).NotTo(BeNil())
+		})
+
+		It("preserves valid parameter structures unchanged", func() {
+			tools := Tools{
+				{
+					Type: "function",
+					Function: Function{
+						Name:        "valid_function",
+						Description: "A function with valid parameters",
+						Parameters: map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"param1": map[string]interface{}{
+									"type":        "string",
+									"description": "First parameter",
+								},
+								"param2": map[string]interface{}{
+									"type": "integer",
+								},
+							},
+						},
+					},
+				},
+			}
+
+			sanitized := SanitizeTools(tools)
+			Expect(len(sanitized)).To(Equal(1))
+			Expect(sanitized[0].Function.Name).To(Equal("valid_function"))
+
+			properties := sanitized[0].Function.Parameters["properties"].(map[string]interface{})
+			Expect(properties["param1"].(map[string]interface{})["type"]).To(Equal("string"))
+			Expect(properties["param1"].(map[string]interface{})["description"]).To(Equal("First parameter"))
+			Expect(properties["param2"].(map[string]interface{})["type"]).To(Equal("integer"))
+		})
+
+		It("handles tools without parameters field", func() {
+			tools := Tools{
+				{
+					Type: "function",
+					Function: Function{
+						Name:        "no_params_function",
+						Description: "A function without parameters",
+					},
+				},
+			}
+
+			sanitized := SanitizeTools(tools)
+			Expect(len(sanitized)).To(Equal(1))
+			Expect(sanitized[0].Function.Name).To(Equal("no_params_function"))
+			Expect(sanitized[0].Function.Parameters).To(BeNil())
+		})
+
+		It("handles tools without properties field", func() {
+			tools := Tools{
+				{
+					Type: "function",
+					Function: Function{
+						Name:        "no_properties_function",
+						Description: "A function without properties",
+						Parameters: map[string]interface{}{
+							"type": "object",
+						},
+					},
+				},
+			}
+
+			sanitized := SanitizeTools(tools)
+			Expect(len(sanitized)).To(Equal(1))
+			Expect(sanitized[0].Function.Name).To(Equal("no_properties_function"))
+			Expect(sanitized[0].Function.Parameters["type"]).To(Equal("object"))
+		})
+
+		It("handles multiple tools with mixed valid and null values", func() {
+			tools := Tools{
+				{
+					Type: "function",
+					Function: Function{
+						Name: "function_with_nulls",
+						Parameters: map[string]interface{}{
+							"properties": map[string]interface{}{
+								"valid": map[string]interface{}{
+									"type": "string",
+								},
+								"null1": nil,
+								"null2": nil,
+							},
+						},
+					},
+				},
+				{
+					Type: "function",
+					Function: Function{
+						Name: "function_all_valid",
+						Parameters: map[string]interface{}{
+							"properties": map[string]interface{}{
+								"param1": map[string]interface{}{
+									"type": "string",
+								},
+								"param2": map[string]interface{}{
+									"type": "integer",
+								},
+							},
+						},
+					},
+				},
+				{
+					Type: "function",
+					Function: Function{
+						Name: "function_no_params",
+					},
+				},
+			}
+
+			sanitized := SanitizeTools(tools)
+			Expect(len(sanitized)).To(Equal(3))
+
+			// First tool should have nulls converted to empty objects
+			props1 := sanitized[0].Function.Parameters["properties"].(map[string]interface{})
+			Expect(props1["valid"]).NotTo(BeNil())
+			Expect(props1["null1"]).To(Equal(map[string]interface{}{}))
+			Expect(props1["null2"]).To(Equal(map[string]interface{}{}))
+
+			// Second tool should remain unchanged
+			props2 := sanitized[1].Function.Parameters["properties"].(map[string]interface{})
+			Expect(props2["param1"].(map[string]interface{})["type"]).To(Equal("string"))
+			Expect(props2["param2"].(map[string]interface{})["type"]).To(Equal("integer"))
+
+			// Third tool should remain unchanged
+			Expect(sanitized[2].Function.Parameters).To(BeNil())
+		})
+
+		It("does not modify the original tools slice", func() {
+			tools := Tools{
+				{
+					Type: "function",
+					Function: Function{
+						Name: "test_function",
+						Parameters: map[string]interface{}{
+							"properties": map[string]interface{}{
+								"null_param": nil,
+							},
+						},
+					},
+				},
+			}
+
+			originalProperties := tools[0].Function.Parameters["properties"].(map[string]interface{})
+			originalNullValue := originalProperties["null_param"]
+
+			sanitized := SanitizeTools(tools)
+
+			// Original should still have nil
+			Expect(originalNullValue).To(BeNil())
+
+			// Sanitized should have empty object
+			sanitizedProperties := sanitized[0].Function.Parameters["properties"].(map[string]interface{})
+			Expect(sanitizedProperties["null_param"]).To(Equal(map[string]interface{}{}))
+		})
+	})
 })

pkg/functions/json_stack_parser.go

@@ -1,431 +0,0 @@
-package functions
-
-import (
-	"encoding/json"
-	"errors"
-	"regexp"
-	"strings"
-	"unicode"
-)
-
-// JSONStackElementType represents the type of JSON stack element
-type JSONStackElementType int
-
-const (
-	JSONStackElementObject JSONStackElementType = iota
-	JSONStackElementKey
-	JSONStackElementArray
-)
-
-// JSONStackElement represents an element in the JSON parsing stack
-type JSONStackElement struct {
-	Type JSONStackElementType
-	Key  string
-}
-
-// JSONErrorLocator tracks JSON parsing state and errors
-type JSONErrorLocator struct {
-	position         int
-	foundError       bool
-	lastToken        string
-	exceptionMessage string
-	stack            []JSONStackElement
-}
-
-// parseJSONWithStack parses JSON with stack tracking, matching llama.cpp's common_json_parse
-// Returns the parsed JSON value, whether it was healed, and any error
-func parseJSONWithStack(input string, healingMarker string) (any, bool, string, error) {
-	if healingMarker == "" {
-		// No healing marker, just try to parse normally
-		var result any
-		if err := json.Unmarshal([]byte(input), &result); err != nil {
-			return nil, false, "", err
-		}
-		return result, false, "", nil
-	}
-
-	// Try to parse complete JSON first
-	var result any
-	if err := json.Unmarshal([]byte(input), &result); err == nil {
-		return result, false, "", nil
-	}
-
-	// Parsing failed, need to track stack and heal
-	errLoc := &JSONErrorLocator{
-		position:   0,
-		foundError: false,
-		stack:      make([]JSONStackElement, 0),
-	}
-
-	// Parse with stack tracking to find where error occurs
-	errorPos, err := parseJSONWithStackTracking(input, errLoc)
-	if err == nil && !errLoc.foundError {
-		// No error found, should have parsed successfully
-		var result any
-		if err := json.Unmarshal([]byte(input), &result); err != nil {
-			return nil, false, "", err
-		}
-		return result, false, "", nil
-	}
-
-	if !errLoc.foundError || len(errLoc.stack) == 0 {
-		// Can't heal without stack information
-		return nil, false, "", errors.New("incomplete JSON")
-	}
-
-	// Build closing braces/brackets from stack
-	closing := ""
-	for i := len(errLoc.stack) - 1; i >= 0; i-- {
-		el := errLoc.stack[i]
-		if el.Type == JSONStackElementObject {
-			closing += "}"
-		} else if el.Type == JSONStackElementArray {
-			closing += "]"
-		}
-		// Keys don't add closing characters
-	}
-
-	// Get the partial input up to error position
-	partialInput := input
-	if errorPos > 0 && errorPos < len(input) {
-		partialInput = input[:errorPos]
-	}
-
-	// Find last non-space character
-	lastNonSpacePos := strings.LastIndexFunc(partialInput, func(r rune) bool {
-		return !unicode.IsSpace(r)
-	})
-	if lastNonSpacePos == -1 {
-		return nil, false, "", errors.New("cannot heal a truncated JSON that stopped in an unknown location")
-	}
-	lastNonSpaceChar := rune(partialInput[lastNonSpacePos])
-
-	// Check if we stopped on a number
-	wasMaybeNumber := func() bool {
-		if len(partialInput) > 0 && unicode.IsSpace(rune(partialInput[len(partialInput)-1])) {
-			return false
-		}
-		return unicode.IsDigit(lastNonSpaceChar) ||
-			lastNonSpaceChar == '.' ||
-			lastNonSpaceChar == 'e' ||
-			lastNonSpaceChar == 'E' ||
-			lastNonSpaceChar == '-'
-	}
-
-	// Check for partial unicode escape sequences
-	partialUnicodeRegex := regexp.MustCompile(`\\u(?:[0-9a-fA-F](?:[0-9a-fA-F](?:[0-9a-fA-F](?:[0-9a-fA-F])?)?)?)?$`)
-	unicodeMarkerPadding := "udc00"
-	lastUnicodeMatch := partialUnicodeRegex.FindStringSubmatch(partialInput)
-	if lastUnicodeMatch != nil {
-		// Pad the escape sequence
-		unicodeMarkerPadding = strings.Repeat("0", 6-len(lastUnicodeMatch[0]))
-		// Check if it's a high surrogate
-		if len(lastUnicodeMatch[0]) >= 4 {
-			seq := lastUnicodeMatch[0]
-			if seq[0] == '\\' && seq[1] == 'u' {
-				third := strings.ToLower(string(seq[2]))
-				if third == "d" {
-					fourth := strings.ToLower(string(seq[3]))
-					if fourth == "8" || fourth == "9" || fourth == "a" || fourth == "b" {
-						// High surrogate, add low surrogate
-						unicodeMarkerPadding += "\\udc00"
-					}
-				}
-			}
-		}
-	}
-
-	canParse := func(str string) bool {
-		var test any
-		return json.Unmarshal([]byte(str), &test) == nil
-	}
-
-	// Heal based on stack top element type
-	healedJSON := partialInput
-	jsonDumpMarker := ""
-	topElement := errLoc.stack[len(errLoc.stack)-1]
-
-	if topElement.Type == JSONStackElementKey {
-		// We're inside an object value
-		if lastNonSpaceChar == ':' && canParse(healedJSON+"1"+closing) {
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if canParse(healedJSON + ": 1" + closing) {
-			jsonDumpMarker = ":\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if lastNonSpaceChar == '{' && canParse(healedJSON+closing) {
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\": 1" + closing
-		} else if canParse(healedJSON + "\"" + closing) {
-			jsonDumpMarker = healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if len(healedJSON) > 0 && healedJSON[len(healedJSON)-1] == '\\' && canParse(healedJSON+"\\\""+closing) {
-			jsonDumpMarker = "\\" + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if canParse(healedJSON + unicodeMarkerPadding + "\"" + closing) {
-			jsonDumpMarker = unicodeMarkerPadding + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else {
-			// Find last colon and cut back
-			lastColon := strings.LastIndex(healedJSON, ":")
-			if lastColon == -1 {
-				return nil, false, "", errors.New("cannot heal a truncated JSON that stopped in an unknown location")
-			}
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON = healedJSON[:lastColon+1] + jsonDumpMarker + "\"" + closing
-		}
-	} else if topElement.Type == JSONStackElementArray {
-		// We're inside an array
-		if (lastNonSpaceChar == ',' || lastNonSpaceChar == '[') && canParse(healedJSON+"1"+closing) {
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if canParse(healedJSON + "\"" + closing) {
-			jsonDumpMarker = healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if len(healedJSON) > 0 && healedJSON[len(healedJSON)-1] == '\\' && canParse(healedJSON+"\\\""+closing) {
-			jsonDumpMarker = "\\" + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if canParse(healedJSON + unicodeMarkerPadding + "\"" + closing) {
-			jsonDumpMarker = unicodeMarkerPadding + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else if !wasMaybeNumber() && canParse(healedJSON+", 1"+closing) {
-			jsonDumpMarker = ",\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\"" + closing
-		} else {
-			lastBracketOrComma := strings.LastIndexAny(healedJSON, "[,")
-			if lastBracketOrComma == -1 {
-				return nil, false, "", errors.New("cannot heal a truncated JSON array stopped in an unknown location")
-			}
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON = healedJSON[:lastBracketOrComma+1] + jsonDumpMarker + "\"" + closing
-		}
-	} else if topElement.Type == JSONStackElementObject {
-		// We're inside an object (expecting a key)
-		if (lastNonSpaceChar == '{' && canParse(healedJSON+closing)) ||
-			(lastNonSpaceChar == ',' && canParse(healedJSON+"\"\": 1"+closing)) {
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\": 1" + closing
-		} else if !wasMaybeNumber() && canParse(healedJSON+",\"\": 1"+closing) {
-			jsonDumpMarker = ",\"" + healingMarker
-			healedJSON += jsonDumpMarker + "\": 1" + closing
-		} else if canParse(healedJSON + "\": 1" + closing) {
-			jsonDumpMarker = healingMarker
-			healedJSON += jsonDumpMarker + "\": 1" + closing
-		} else if len(healedJSON) > 0 && healedJSON[len(healedJSON)-1] == '\\' && canParse(healedJSON+"\\\": 1"+closing) {
-			jsonDumpMarker = "\\" + healingMarker
-			healedJSON += jsonDumpMarker + "\": 1" + closing
-		} else if canParse(healedJSON + unicodeMarkerPadding + "\": 1" + closing) {
-			jsonDumpMarker = unicodeMarkerPadding + healingMarker
-			healedJSON += jsonDumpMarker + "\": 1" + closing
-		} else {
-			lastColon := strings.LastIndex(healedJSON, ":")
-			if lastColon == -1 {
-				return nil, false, "", errors.New("cannot heal a truncated JSON object stopped in an unknown location")
-			}
-			jsonDumpMarker = "\"" + healingMarker
-			healedJSON = healedJSON[:lastColon+1] + jsonDumpMarker + "\"" + closing
-		}
-	} else {
-		return nil, false, "", errors.New("cannot heal a truncated JSON object stopped in an unknown location")
-	}
-
-	// Try to parse the healed JSON
-	var healedValue any
-	if err := json.Unmarshal([]byte(healedJSON), &healedValue); err != nil {
-		return nil, false, "", err
-	}
-
-	// Remove healing marker from result
-	cleaned := removeHealingMarkerFromJSONAny(healedValue, healingMarker)
-	return cleaned, true, jsonDumpMarker, nil
-}
-
-// parseJSONWithStackTracking parses JSON while tracking the stack structure
-// Returns the error position and any error encountered
-// This implements stack tracking similar to llama.cpp's json_error_locator
-func parseJSONWithStackTracking(input string, errLoc *JSONErrorLocator) (int, error) {
-	// First, try to parse to get exact error position
-	decoder := json.NewDecoder(strings.NewReader(input))
-	var test any
-	err := decoder.Decode(&test)
-	if err != nil {
-		errLoc.foundError = true
-		errLoc.exceptionMessage = err.Error()
-
-		var errorPos int
-		if syntaxErr, ok := err.(*json.SyntaxError); ok {
-			errorPos = int(syntaxErr.Offset)
-			errLoc.position = errorPos
-		} else {
-			// Fallback: use end of input
-			errorPos = len(input)
-			errLoc.position = errorPos
-		}
-
-		// Now build the stack by parsing up to the error position
-		// This matches llama.cpp's approach of tracking stack during SAX parsing
-		partialInput := input
-		if errorPos > 0 && errorPos < len(input) {
-			partialInput = input[:errorPos]
-		}
-
-		// Track stack by parsing character by character up to error
-		pos := 0
-		inString := false
-		escape := false
-		keyStart := -1
-		keyEnd := -1
-
-		for pos < len(partialInput) {
-			ch := partialInput[pos]
-
-			if escape {
-				escape = false
-				pos++
-				continue
-			}
-
-			if ch == '\\' {
-				escape = true
-				pos++
-				continue
-			}
-
-			if ch == '"' {
-				if !inString {
-					// Starting a string
-					inString = true
-					// Check if we're in an object context (expecting a key)
-					if len(errLoc.stack) > 0 {
-						top := errLoc.stack[len(errLoc.stack)-1]
-						if top.Type == JSONStackElementObject {
-							// This could be a key
-							keyStart = pos + 1 // Start after quote
-						}
-					}
-				} else {
-					// Ending a string
-					inString = false
-					if keyStart != -1 {
-						// This was potentially a key, extract it
-						keyEnd = pos
-						key := partialInput[keyStart:keyEnd]
-
-						// Look ahead to see if next non-whitespace is ':'
-						nextPos := pos + 1
-						for nextPos < len(partialInput) && unicode.IsSpace(rune(partialInput[nextPos])) {
-							nextPos++
-						}
-						if nextPos < len(partialInput) && partialInput[nextPos] == ':' {
-							// This is a key, add it to stack
-							errLoc.stack = append(errLoc.stack, JSONStackElement{Type: JSONStackElementKey, Key: key})
-						}
-						keyStart = -1
-						keyEnd = -1
-					}
-				}
-				pos++
-				continue
-			}
-
-			if inString {
-				pos++
-				continue
-			}
-
-			// Handle stack operations (outside strings)
-			if ch == '{' {
-				errLoc.stack = append(errLoc.stack, JSONStackElement{Type: JSONStackElementObject})
-			} else if ch == '}' {
-				// Pop object and any key on top (keys are popped when value starts, but handle here too)
-				for len(errLoc.stack) > 0 {
-					top := errLoc.stack[len(errLoc.stack)-1]
-					errLoc.stack = errLoc.stack[:len(errLoc.stack)-1]
-					if top.Type == JSONStackElementObject {
-						break
-					}
-				}
-			} else if ch == '[' {
-				errLoc.stack = append(errLoc.stack, JSONStackElement{Type: JSONStackElementArray})
-			} else if ch == ']' {
-				// Pop array
-				for len(errLoc.stack) > 0 {
-					top := errLoc.stack[len(errLoc.stack)-1]
-					errLoc.stack = errLoc.stack[:len(errLoc.stack)-1]
-					if top.Type == JSONStackElementArray {
-						break
-					}
-				}
-			} else if ch == ':' {
-				// Colon means we're starting a value, pop the key if it's on stack
-				if len(errLoc.stack) > 0 && errLoc.stack[len(errLoc.stack)-1].Type == JSONStackElementKey {
-					errLoc.stack = errLoc.stack[:len(errLoc.stack)-1]
-				}
-			}
-			// Note: commas and whitespace don't affect stack structure
-
-			pos++
-		}
-
-		return errorPos, err
-	}
-
-	// No error, parse was successful - build stack anyway for completeness
-	// (though we shouldn't need healing in this case)
-	pos := 0
-	inString := false
-	escape := false
-
-	for pos < len(input) {
-		ch := input[pos]
-
-		if escape {
-			escape = false
-			pos++
-			continue
-		}
-
-		if ch == '\\' {
-			escape = true
-			pos++
-			continue
-		}
-
-		if ch == '"' {
-			inString = !inString
-			pos++
-			continue
-		}
-
-		if inString {
-			pos++
-			continue
-		}
-
-		if ch == '{' {
-			errLoc.stack = append(errLoc.stack, JSONStackElement{Type: JSONStackElementObject})
-		} else if ch == '}' {
-			for len(errLoc.stack) > 0 {
-				top := errLoc.stack[len(errLoc.stack)-1]
-				errLoc.stack = errLoc.stack[:len(errLoc.stack)-1]
-				if top.Type == JSONStackElementObject {
-					break
-				}
-			}
-		} else if ch == '[' {
-			errLoc.stack = append(errLoc.stack, JSONStackElement{Type: JSONStackElementArray})
-		} else if ch == ']' {
-			for len(errLoc.stack) > 0 {
-				top := errLoc.stack[len(errLoc.stack)-1]
-				errLoc.stack = errLoc.stack[:len(errLoc.stack)-1]
-				if top.Type == JSONStackElementArray {
-					break
-				}
-			}
-		}
-
-		pos++
-	}
-
-	return len(input), nil
-}

pkg/functions/reasoning.go

@@ -1,114 +0,0 @@
-package functions
-
-import (
-	"strings"
-)
-
-// ExtractReasoning extracts reasoning content from thinking tags and returns
-// both the extracted reasoning and the cleaned content (with tags removed).
-// It handles <thinking>...</thinking> and <think>...</think> tags.
-// Multiple reasoning blocks are concatenated with newlines.
-func ExtractReasoning(content string) (reasoning string, cleanedContent string) {
-	if content == "" {
-		return "", content
-	}
-
-	var reasoningParts []string
-	var cleanedParts []string
-	remaining := content
-
-	// Define tag pairs to look for
-	tagPairs := []struct {
-		start string
-		end   string
-	}{
-		{"<thinking>", "</thinking>"},
-		{"<think>", "</think>"},
-	}
-
-	// Track the last position we've processed
-	lastPos := 0
-
-	for {
-		// Find the earliest tag start
-		earliestStart := -1
-		earliestEnd := -1
-		isUnclosed := false
-		var matchedTag struct {
-			start string
-			end   string
-		}
-
-		for _, tagPair := range tagPairs {
-			startIdx := strings.Index(remaining[lastPos:], tagPair.start)
-			if startIdx == -1 {
-				continue
-			}
-			startIdx += lastPos
-
-			// Find the corresponding end tag
-			endIdx := strings.Index(remaining[startIdx+len(tagPair.start):], tagPair.end)
-			if endIdx == -1 {
-				// Unclosed tag - extract what we have
-				if earliestStart == -1 || startIdx < earliestStart {
-					earliestStart = startIdx
-					earliestEnd = len(remaining)
-					isUnclosed = true
-					matchedTag = tagPair
-				}
-				continue
-			}
-			endIdx += startIdx + len(tagPair.start)
-
-			// Found a complete tag pair
-			if earliestStart == -1 || startIdx < earliestStart {
-				earliestStart = startIdx
-				earliestEnd = endIdx + len(tagPair.end)
-				isUnclosed = false
-				matchedTag = tagPair
-			}
-		}
-
-		if earliestStart == -1 {
-			// No more tags found, add remaining content
-			if lastPos < len(remaining) {
-				cleanedParts = append(cleanedParts, remaining[lastPos:])
-			}
-			break
-		}
-
-		// Add content before the tag
-		if earliestStart > lastPos {
-			cleanedParts = append(cleanedParts, remaining[lastPos:earliestStart])
-		}
-
-		// Extract reasoning content
-		reasoningStart := earliestStart + len(matchedTag.start)
-		// For unclosed tags, earliestEnd is already at the end of the string
-		// For closed tags, earliestEnd points to after the closing tag, so we subtract the end tag length
-		var reasoningEnd int
-		if isUnclosed {
-			// Unclosed tag - extract everything to the end
-			reasoningEnd = len(remaining)
-		} else {
-			// Closed tag - exclude the end tag
-			reasoningEnd = earliestEnd - len(matchedTag.end)
-		}
-		if reasoningEnd > reasoningStart {
-			reasoningContent := strings.TrimSpace(remaining[reasoningStart:reasoningEnd])
-			if reasoningContent != "" {
-				reasoningParts = append(reasoningParts, reasoningContent)
-			}
-		}
-
-		// Move past this tag
-		lastPos = earliestEnd
-	}
-
-	// Combine reasoning parts
-	reasoning = strings.Join(reasoningParts, "\n\n")
-	// Combine cleaned content parts
-	cleanedContent = strings.Join(cleanedParts, "")
-
-	return reasoning, cleanedContent
-}

pkg/functions/reasoning_test.go

@@ -1,261 +0,0 @@
-package functions_test
-
-import (
-	"strings"
-
-	. "github.com/mudler/LocalAI/pkg/functions"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("ExtractReasoning", func() {
-	Context("when content has no reasoning tags", func() {
-		It("should return empty reasoning and original content", func() {
-			content := "This is regular content without any tags."
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(Equal(content))
-		})
-
-		It("should handle empty string", func() {
-			content := ""
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(BeEmpty())
-		})
-
-		It("should handle content with only whitespace", func() {
-			content := "   \n\t  "
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(Equal(content))
-		})
-	})
-
-	Context("when content has <thinking> tags", func() {
-		It("should extract reasoning from single thinking block", func() {
-			content := "Some text <thinking>This is my reasoning</thinking> More text"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("This is my reasoning"))
-			Expect(cleaned).To(Equal("Some text  More text"))
-		})
-
-		It("should extract reasoning and preserve surrounding content", func() {
-			content := "Before <thinking>Reasoning here</thinking> After"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Reasoning here"))
-			Expect(cleaned).To(Equal("Before  After"))
-		})
-
-		It("should handle thinking block at the start", func() {
-			content := "<thinking>Start reasoning</thinking> Regular content"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Start reasoning"))
-			Expect(cleaned).To(Equal(" Regular content"))
-		})
-
-		It("should handle thinking block at the end", func() {
-			content := "Regular content <thinking>End reasoning</thinking>"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("End reasoning"))
-			Expect(cleaned).To(Equal("Regular content "))
-		})
-
-		It("should handle only thinking block", func() {
-			content := "<thinking>Only reasoning</thinking>"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Only reasoning"))
-			Expect(cleaned).To(BeEmpty())
-		})
-
-		It("should trim whitespace from reasoning content", func() {
-			content := "Text <thinking>  \n  Reasoning with spaces  \n  </thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Reasoning with spaces"))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-	})
-
-	Context("when content has <think> tags", func() {
-		It("should extract reasoning from redacted_reasoning block", func() {
-			content := "Text <think>Redacted reasoning</think> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Redacted reasoning"))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-
-		It("should handle redacted_reasoning with multiline content", func() {
-			content := "Before <think>Line 1\nLine 2\nLine 3</think> After"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Line 1\nLine 2\nLine 3"))
-			Expect(cleaned).To(Equal("Before  After"))
-		})
-
-		It("should handle redacted_reasoning with complex content", func() {
-			content := "Start <think>Complex reasoning\nwith\nmultiple\nlines</think> End"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Complex reasoning\nwith\nmultiple\nlines"))
-			Expect(cleaned).To(Equal("Start  End"))
-		})
-	})
-
-	Context("when content has multiple reasoning blocks", func() {
-		It("should concatenate multiple thinking blocks with newlines", func() {
-			content := "Text <thinking>First</thinking> Middle <thinking>Second</thinking> End"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("First\n\nSecond"))
-			Expect(cleaned).To(Equal("Text  Middle  End"))
-		})
-
-		It("should handle multiple different tag types", func() {
-			content := "A <thinking>One</thinking> B <think>Two</think> C <think>Three</think> D"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(ContainSubstring("One"))
-			Expect(reasoning).To(ContainSubstring("Two"))
-			Expect(reasoning).To(ContainSubstring("Three"))
-			Expect(cleaned).To(Equal("A  B  C  D"))
-		})
-
-		It("should handle nested tags correctly (extracts first match)", func() {
-			content := "Text <thinking>Outer <think>Inner</think></thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			// Should extract the outer thinking block
-			Expect(reasoning).To(ContainSubstring("Outer"))
-			Expect(reasoning).To(ContainSubstring("Inner"))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-	})
-
-	Context("when content has unclosed reasoning tags", func() {
-		It("should extract unclosed thinking block", func() {
-			content := "Text <thinking>Unclosed reasoning"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Unclosed reasoning"))
-			Expect(cleaned).To(Equal("Text "))
-		})
-
-		It("should extract unclosed think block", func() {
-			content := "Before <think>Incomplete"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Incomplete"))
-			Expect(cleaned).To(Equal("Before "))
-		})
-
-		It("should extract unclosed redacted_reasoning block", func() {
-			content := "Start <think>Partial reasoning content"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Partial reasoning content"))
-			Expect(cleaned).To(Equal("Start "))
-		})
-
-		It("should handle unclosed tag at the end", func() {
-			content := "Regular content <thinking>Unclosed at end"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Unclosed at end"))
-			Expect(cleaned).To(Equal("Regular content "))
-		})
-	})
-
-	Context("when content has empty reasoning blocks", func() {
-		It("should ignore empty thinking block", func() {
-			content := "Text <thinking></thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-
-		It("should ignore thinking block with only whitespace", func() {
-			content := "Text <thinking>   \n\t  </thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-	})
-
-	Context("when content has reasoning tags with special characters", func() {
-		It("should handle reasoning with newlines", func() {
-			content := "Before <thinking>Line 1\nLine 2\nLine 3</thinking> After"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Line 1\nLine 2\nLine 3"))
-			Expect(cleaned).To(Equal("Before  After"))
-		})
-
-		It("should handle reasoning with code blocks", func() {
-			content := "Text <thinking>Reasoning with ```code``` blocks</thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Reasoning with ```code``` blocks"))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-
-		It("should handle reasoning with JSON", func() {
-			content := "Before <think>{\"key\": \"value\"}</think> After"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("{\"key\": \"value\"}"))
-			Expect(cleaned).To(Equal("Before  After"))
-		})
-
-		It("should handle reasoning with HTML-like content", func() {
-			content := "Text <thinking>Reasoning with <tags> inside</thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Reasoning with <tags> inside"))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-	})
-
-	Context("when content has reasoning mixed with regular content", func() {
-		It("should preserve content order correctly", func() {
-			content := "Start <thinking>Reasoning</thinking> Middle <think>More reasoning</think> End"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(ContainSubstring("Reasoning"))
-			Expect(reasoning).To(ContainSubstring("More reasoning"))
-			Expect(cleaned).To(Equal("Start  Middle  End"))
-		})
-
-		It("should handle reasoning in the middle of a sentence", func() {
-			content := "This is a <thinking>reasoning</thinking> sentence."
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("reasoning"))
-			Expect(cleaned).To(Equal("This is a  sentence."))
-		})
-	})
-
-	Context("edge cases", func() {
-		It("should handle content with only opening tag", func() {
-			content := "<thinking>"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(Equal(""))
-		})
-
-		It("should handle content with only closing tag", func() {
-			content := "</thinking>"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(BeEmpty())
-			Expect(cleaned).To(Equal("</thinking>"))
-		})
-
-		It("should handle mismatched tags", func() {
-			content := "<thinking>Content</think>"
-			reasoning, cleaned := ExtractReasoning(content)
-			// Should extract unclosed thinking block
-			Expect(reasoning).To(ContainSubstring("Content"))
-			Expect(cleaned).To(Equal(""))
-		})
-
-		It("should handle very long reasoning content", func() {
-			longReasoning := strings.Repeat("This is reasoning content. ", 100)
-			content := "Text <thinking>" + longReasoning + "</thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			// TrimSpace is applied, so we need to account for that
-			Expect(reasoning).To(Equal(strings.TrimSpace(longReasoning)))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-
-		It("should handle reasoning with unicode characters", func() {
-			content := "Text <thinking>Reasoning with 中文 and emoji 🧠</thinking> More"
-			reasoning, cleaned := ExtractReasoning(content)
-			Expect(reasoning).To(Equal("Reasoning with 中文 and emoji 🧠"))
-			Expect(cleaned).To(Equal("Text  More"))
-		})
-	})
-})

pkg/system/capabilities.go

@@ -8,6 +8,7 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/jaypipes/ghw/pkg/gpu"
 	"github.com/mudler/xlog"
 )
 
@@ -18,9 +19,8 @@ const (
 	metal             = "metal"
 	nvidia            = "nvidia"
 
-	amd    = "amd"
-	intel  = "intel"
-	vulkan = "vulkan"
+	amd   = "amd"
+	intel = "intel"
 
 	nvidiaCuda13    = "nvidia-cuda-13"
 	nvidiaCuda12    = "nvidia-cuda-12"
@@ -131,6 +131,26 @@ func (s *SystemState) getSystemCapabilities() string {
 	return s.GPUVendor
 }
 
+func detectGPUVendor(gpus []*gpu.GraphicsCard) (string, error) {
+	for _, gpu := range gpus {
+		if gpu.DeviceInfo != nil {
+			if gpu.DeviceInfo.Vendor != nil {
+				gpuVendorName := strings.ToUpper(gpu.DeviceInfo.Vendor.Name)
+				if strings.Contains(gpuVendorName, strings.ToUpper(nvidia)) {
+					return nvidia, nil
+				}
+				if strings.Contains(gpuVendorName, strings.ToUpper(amd)) {
+					return amd, nil
+				}
+				if strings.Contains(gpuVendorName, strings.ToUpper(intel)) {
+					return intel, nil
+				}
+			}
+		}
+	}
+
+	return "", nil
+}
 
 // BackendPreferenceTokens returns a list of substrings that represent the preferred
 // backend implementation order for the current system capability. Callers can use
@@ -149,8 +169,6 @@ func (s *SystemState) BackendPreferenceTokens() []string {
 		return []string{"metal", "cpu"}
 	case strings.HasPrefix(capStr, darwinX86):
 		return []string{"darwin-x86", "cpu"}
-	case strings.HasPrefix(capStr, vulkan):
-		return []string{"vulkan", "cpu"}
 	default:
 		return []string{"cpu"}
 	}

pkg/system/state.go

@@ -1,6 +1,7 @@
 package system
 
 import (
+	"github.com/jaypipes/ghw/pkg/gpu"
 	"github.com/mudler/LocalAI/pkg/xsysinfo"
 	"github.com/mudler/xlog"
 )
@@ -18,6 +19,7 @@ type SystemState struct {
 	GPUVendor string
 	Backend   Backend
 	Model     Model
+	gpus      []*gpu.GraphicsCard
 	VRAM      uint64
 }
 
@@ -48,7 +50,9 @@ func GetSystemState(opts ...SystemStateOptions) (*SystemState, error) {
 	}
 
 	// Detection is best-effort here, we don't want to fail if it fails
-	state.GPUVendor, _ = xsysinfo.DetectGPUVendor()
+	state.gpus, _ = xsysinfo.GPUs()
+	xlog.Debug("GPUs", "gpus", state.gpus)
+	state.GPUVendor, _ = detectGPUVendor(state.gpus)
 	xlog.Debug("GPU vendor", "gpuVendor", state.GPUVendor)
 	state.VRAM, _ = xsysinfo.TotalAvailableVRAM()
 	xlog.Debug("Total available VRAM", "vram", state.VRAM)